diff --git a/.circleci/config.yml b/.circleci/config.yml
index b86b39f752a38aee24f50bb260f7b6b45d8b722f..9cf3c2a4e36338e88a9f08201a4df200395fdcf9 100644
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -7,6 +7,7 @@ jobs:
environment:
CC: ccache gcc
CCACHE_COMPRESS: true
+ CFLAGS: -Wno-error=unused-result
#- image: ubuntu:trusty
# environment:
# CC: ccache gcc -m32
@@ -49,12 +50,15 @@ jobs:
paths:
- /home/circleci/.cache/apt
- checkout
+ - run:
+ name: Create deps folder as needed
+ command: mkdir -p make/linux/64/SDL/deps/
- run:
name: make master depend file
- command: find make/linux64/SDL/deps/ -type f -print0 | sort -z | xargs -r0 cat > make/linux64/SDL.deps
+ command: find make/linux/64/SDL/deps/ -type f -print0 | sort -z | xargs -r0 cat > make/linux/64/SDL.deps
- restore_cache:
keys:
- - v1-SRB2-{{ .Branch }}-{{ checksum "make/linux64/SDL.deps" }}
+ - v1-SRB2-{{ .Branch }}-{{ checksum "make/linux/64/SDL.deps" }}
- run:
name: Compile
command: make -C src LINUX64=1 ERRORMODE=1 -k -j4
@@ -62,6 +66,6 @@ jobs:
path: /home/circleci/SRB2/bin/
destination: bin
- save_cache:
- key: v1-SRB2-{{ .Branch }}-{{ checksum "make/linux64/SDL.deps" }}
+ key: v1-SRB2-{{ .Branch }}-{{ checksum "make/linux/64/SDL.deps" }}
paths:
- /home/circleci/.ccache
diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index 29f5ef5fff9f1bc4afb83006c65f54088762e6dc..14c36213e051f0af306b2d392af1f8da491ce289 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -12,6 +12,7 @@ variables:
stages:
- build
+ - osxcross
default:
interruptible: true
diff --git a/.gitlab/ci/jobs/alpine-3-gcc-dedicated.yml b/.gitlab/ci/jobs/alpine-3-gcc-dedicated-makefile.yml
similarity index 86%
rename from .gitlab/ci/jobs/alpine-3-gcc-dedicated.yml
rename to .gitlab/ci/jobs/alpine-3-gcc-dedicated-makefile.yml
index 242ddd0eaa3f0e45504fa0fe258e08c63e0845df..5d875d8657694b4899a31f33ba3440a2cd47e314 100644
--- a/.gitlab/ci/jobs/alpine-3-gcc-dedicated.yml
+++ b/.gitlab/ci/jobs/alpine-3-gcc-dedicated-makefile.yml
@@ -1,18 +1,18 @@
-Alpine 3 GCC Dedicated:
- extends: Alpine 3 GCC
+Alpine 3 GCC Dedicated Makefile:
+ extends: Alpine 3 GCC Makefile
artifacts:
paths:
- "bin/"
- "src/comptime.h"
- expose_as: "Apline-3-Dedicated"
- name: "$CI_PROJECT_PATH_SLUG-$CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA-Apline-3-Dedicated"
+ expose_as: "Apline-3-Dedicated-makefile"
+ name: "$CI_PROJECT_PATH_SLUG-$CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA-Apline-3-Dedicated-makefile"
script:
- - |
# apk_toolchain
echo -e "\e[0Ksection_start:`date +%s`:apk_toolchain[collapsed=true]\r\e[0KInstalling toolchain packages"
- - apk add gcc
+ - apk add g++
- |
# apk_toolchain
echo -e "\e[0Ksection_end:`date +%s`:apk_toolchain\r\e[0K"
diff --git a/.gitlab/ci/jobs/alpine-3-gcc-makefile.yml b/.gitlab/ci/jobs/alpine-3-gcc-makefile.yml
new file mode 100644
index 0000000000000000000000000000000000000000..6b0b6a06f5b01dde129a3ecd75b92e9c06e3bbbb
--- /dev/null
+++ b/.gitlab/ci/jobs/alpine-3-gcc-makefile.yml
@@ -0,0 +1,135 @@
+Alpine 3 GCC Makefile:
+ stage: build
+
+ when: manual
+
+ image: alpine:3
+
+ allow_failure: true
+
+ cache:
+ - key: apk-$CI_JOB_IMAGE-makefile
+ paths:
+ - apk-cache
+ unprotect: true
+
+ artifacts:
+ paths:
+ - "bin/"
+ - "src/comptime.h"
+ expose_as: "Apline-3-makefile"
+ name: "$CI_PROJECT_PATH_SLUG-$CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA-Apline-3-makefile"
+
+ before_script:
+ - - |
+ # apk_cache
+ echo -e "\e[0Ksection_start:`date +%s`:apk_cache[collapsed=true]\r\e[0KUpdating APK listing"
+ - export APK_CACHE_DIR=`pwd`/apk-cache
+ - mkdir --parents --verbose $APK_CACHE_DIR/
+ - ln -sf /etc/apk/cache $APK_CACHE_DIR
+ - |
+ # apk_cache
+ echo -e "\e[0Ksection_end:`date +%s`:apk_cache\r\e[0K"
+
+ - - |
+ # apk_update
+ echo -e "\e[0Ksection_start:`date +%s`:apk_update[collapsed=true]\r\e[0KUpdating APK listing"
+ - apk update
+ - |
+ # apk_update
+ echo -e "\e[0Ksection_end:`date +%s`:apk_update\r\e[0K"
+
+ - - |
+ # apk_upgrade
+ echo -e "\e[0Ksection_start:`date +%s`:apk_upgrade[collapsed=true]\r\e[0KUpdating existing packages"
+ - apk upgrade
+ - |
+ # apk_update
+ echo -e "\e[0Ksection_end:`date +%s`:apk_upgrade\r\e[0K"
+
+ - - |
+ # apk_common
+ echo -e "\e[0Ksection_start:`date +%s`:apk_common[collapsed=true]\r\e[0KInstalling common packages"
+ - apk add make git ccache nasm
+ - |
+ # apk_common
+ echo -e "\e[0Ksection_end:`date +%s`:apk_common\r\e[0K"
+
+ - - |
+ # ccache_config
+ echo -e "\e[0Ksection_start:`date +%s`:ccache_config[collapsed=true]\r\e[0KSetting up ccache config"
+ - mkdir --parents --verbose ~/.ccache/
+ - touch ~/.ccache/ccache.conf
+ - |
+ # cache.conf
+ echo Adding ccache configution option
+ - |
+ # base_dir
+ echo base_dir = $PWD | tee -a ~/.ccache/ccache.conf
+ - |
+ # cache_dir
+ echo cache_dir = $PWD/ccache | tee -a ~/.ccache/ccache.conf
+ - |
+ # compiler_check
+ echo compiler_check = content | tee -a ~/.ccache/ccache.conf
+ - |
+ # stats_log
+ echo stats_log = $PWD/ccache_statslog | tee -a ~/.ccache/ccache.conf
+ - |
+ # max_size
+ echo max_size = 50M | tee -a ~/.ccache/ccache.conf
+ - |
+ # ccache_config
+ echo -e "\e[0Ksection_end:`date +%s`:ccache_config\r\e[0K"
+
+ - - |
+ # cache_reset
+ echo -e "\e[0Ksection_start:`date +%s`:ccache_reset[collapsed=true]\r\e[0KResetting ccache statistics"
+ - ccache --zero-stats
+ - ccache --show-stats
+ - |
+ # ccache_reset
+ echo -e "\e[0Ksection_end:`date +%s`:ccache_reset\r\e[0K"
+
+ script:
+ - - |
+ # apk_toolchain
+ echo -e "\e[0Ksection_start:`date +%s`:apk_toolchain[collapsed=true]\r\e[0KInstalling toolchain packages"
+ - apk add g++
+ - |
+ # apk_toolchain
+ echo -e "\e[0Ksection_end:`date +%s`:apk_toolchain\r\e[0K"
+
+ - - |
+ # apk_development
+ echo -e "\e[0Ksection_start:`date +%s`:apk_development[collapsed=true]\r\e[0KInstalling development packages"
+ - apk add cmake musl-dev sdl2_mixer-dev libpng-dev curl-dev libgme-dev libopenmpt-dev miniupnpc-dev elfutils-dev
+ - |
+ # apk_development
+ echo -e "\e[0Ksection_end:`date +%s`:apk_development\r\e[0K"
+
+ - - |
+ # make
+ echo -e "\e[0Ksection_start:`date +%s`:make[collapsed=false]\r\e[0KCompiling SRB2"
+ - make --directory=src --keep-going CCACHE=1 ERRORMODE=1 NONX86=1 NOEXECINFO=1 || make --directory=src --keep-going CCACHE=1 ERRORMODE=1 NONX86=1 NOEXECINFO=1
+ - |
+ # make
+ echo -e "\e[0Ksection_end:`date +%s`:make\r\e[0K"
+
+ after_script:
+ - - |
+ # apk_clean
+ echo -e "\e[0Ksection_start:`date +%s`:apk_clean[collapsed=true]\r\e[0KCleaning of unneeded APK packages"
+ - apk cache clean
+ - |
+ # apk_clean
+ echo -e "\e[0Ksection_end:`date +%s`:apk_clean\r\e[0K"
+
+ - - |
+ # ccache_stats
+ echo -e "\e[0Ksection_start:`date +%s`:ccache_stats[collapsed=true]\r\e[0Kccache statistics:"
+ - ccache --show-stats --verbose
+ - ccache --show-log-stats --verbose
+ - |
+ # ccahe_stats
+ echo -e "\e[0Ksection_end:`date +%s`:ccache_stats\r\e[0K"
diff --git a/.gitlab/ci/jobs/alpine-3-gcc.yml b/.gitlab/ci/jobs/alpine-3-gcc.yml
index b3b12e40167a568e3ced2abc7a09ed0045e0cc99..72994d405b3dc36e6545fd33b210fb5246971c6d 100644
--- a/.gitlab/ci/jobs/alpine-3-gcc.yml
+++ b/.gitlab/ci/jobs/alpine-3-gcc.yml
@@ -15,8 +15,8 @@ Alpine 3 GCC:
artifacts:
paths:
- - "bin/"
- - "src/comptime.h"
+ - "build.cmake/bin/"
+ - "build.cmake/src/config.h"
expose_as: "Apline-3"
name: "$CI_PROJECT_PATH_SLUG-$CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA-Apline-3"
@@ -50,7 +50,7 @@ Alpine 3 GCC:
- - |
# apk_common
echo -e "\e[0Ksection_start:`date +%s`:apk_common[collapsed=true]\r\e[0KInstalling common packages"
- - apk add make git ccache nasm
+ - apk add cmake make git ccache nasm
- |
# apk_common
echo -e "\e[0Ksection_end:`date +%s`:apk_common\r\e[0K"
@@ -95,7 +95,7 @@ Alpine 3 GCC:
- - |
# apk_toolchain
echo -e "\e[0Ksection_start:`date +%s`:apk_toolchain[collapsed=true]\r\e[0KInstalling toolchain packages"
- - apk add gcc
+ - apk add g++
- |
# apk_toolchain
echo -e "\e[0Ksection_end:`date +%s`:apk_toolchain\r\e[0K"
@@ -103,15 +103,23 @@ Alpine 3 GCC:
- - |
# apk_development
echo -e "\e[0Ksection_start:`date +%s`:apk_development[collapsed=true]\r\e[0KInstalling development packages"
- - apk add musl-dev sdl2_mixer-dev libpng-dev curl-dev libgme-dev libopenmpt-dev miniupnpc-dev
+ - apk add cmake musl-dev sdl2_mixer-dev libpng-dev curl-dev libgme-dev libopenmpt-dev miniupnpc-dev elfutils-dev
- |
# apk_development
echo -e "\e[0Ksection_end:`date +%s`:apk_development\r\e[0K"
+ - - |
+ # cmake
+ echo -e "\e[0Ksection_start:`date +%s`:cmake[collapsed=false]\r\e[0KBuilding Makefiles"
+ - cmake -B build.cmake -DSRB2_USE_CCACHE=YES -DSRB2_CONFIG_ERRORMODE=ON -DSRB2_CONFIG_EXECINFO=NO -DSRB2_CONFIG_USE_GME:BOOL=ON
+ - |
+ # cmake
+ echo -e "\e[0Ksection_end:`date +%s`:cmake\r\e[0K"
+
- - |
# make
echo -e "\e[0Ksection_start:`date +%s`:make[collapsed=false]\r\e[0KCompiling SRB2"
- - make --directory=src --keep-going CCACHE=1 ERRORMODE=1 NONX86=1 NOEXECINFO=1 || make --directory=src --keep-going CCACHE=1 ERRORMODE=1 NONX86=1 NOEXECINFO=1
+ - cmake --build build.cmake --parallel 1 --verbose
- |
# make
echo -e "\e[0Ksection_end:`date +%s`:make\r\e[0K"
diff --git a/.gitlab/ci/jobs/batocera-arm64-makefile.yml b/.gitlab/ci/jobs/batocera-arm64-makefile.yml
new file mode 100644
index 0000000000000000000000000000000000000000..e02497d40d7e190cac34bde6f7cb12c3cf755647
--- /dev/null
+++ b/.gitlab/ci/jobs/batocera-arm64-makefile.yml
@@ -0,0 +1,38 @@
+batocera:arm64 Makefile:
+ extends: Debian stable:arm64 Makefile
+
+ when: manual
+
+ allow_failure: true
+
+ artifacts:
+ paths:
+ - "bin/"
+ - "src/comptime.h"
+ expose_as: "Debian old arm64 makefile"
+ name: "$CI_PROJECT_PATH_SLUG-$CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA-batocera-aarch64-makefile"
+
+ script:
+ - - |
+ # apt_toolchain
+ echo -e "\e[0Ksection_start:`date +%s`:apt_toolchain[collapsed=true]\r\e[0KInstalling toolchain packages"
+ - apt-get install g++-aarch64-linux-gnu || apt-get install g++
+ - |
+ # apt_toolchain
+ echo -e "\e[0Ksection_end:`date +%s`:apt_toolchain\r\e[0K"
+
+ - - |
+ # apt_development
+ echo -e "\e[0Ksection_start:`date +%s`:apt_development[collapsed=true]\r\e[0KInstalling development packages"
+ - apt-get install libsdl2-mixer-dev:arm64 libpng-dev:arm64 libcurl4-openssl-dev:arm64 libopenmpt-dev:arm64 libminiupnpc-dev:arm64
+ - |
+ # apt_development
+ echo -e "\e[0Ksection_end:`date +%s`:apt_development\r\e[0K"
+
+ - - |
+ # make
+ echo -e "\e[0Ksection_start:`date +%s`:make[collapsed=false]\r\e[0KCompiling SRB2"
+ - make --directory=src --keep-going CCACHE=1 ERRORMODE=1 LINUX64=1 ERRORMODE=1 NONX86=1 ARM64=1 NOGME=1 || make --directory=src --keep-going CCACHE=1 ERRORMODE=1 LINUX64=1 NONX86=1 ARM64=1 NOGME=1
+ - |
+ # make
+ echo -e "\e[0Ksection_end:`date +%s`:make\r\e[0K"
diff --git a/.gitlab/ci/jobs/batocera-arm64.yml b/.gitlab/ci/jobs/batocera-arm64.yml
index 3e43aa8753a0a1500abdc52e9f594863bd4b3691..3dcd73a0e2f422e84b5601a584d987a4bd0f2ed9 100644
--- a/.gitlab/ci/jobs/batocera-arm64.yml
+++ b/.gitlab/ci/jobs/batocera-arm64.yml
@@ -7,8 +7,8 @@ batocera:arm64:
artifacts:
paths:
- - "bin/"
- - "src/comptime.h"
+ - "build.cmake/bin/"
+ - "build.cmake/src/config.h"
expose_as: "Debian old arm64"
name: "$CI_PROJECT_PATH_SLUG-$CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA-batocera-aarch64"
@@ -16,7 +16,7 @@ batocera:arm64:
- - |
# apt_toolchain
echo -e "\e[0Ksection_start:`date +%s`:apt_toolchain[collapsed=true]\r\e[0KInstalling toolchain packages"
- - apt-get install gcc-aarch64-linux-gnu || apt-get install gcc
+ - apt-get install g++-aarch64-linux-gnu || apt-get install g++
- |
# apt_toolchain
echo -e "\e[0Ksection_end:`date +%s`:apt_toolchain\r\e[0K"
@@ -29,10 +29,18 @@ batocera:arm64:
# apt_development
echo -e "\e[0Ksection_end:`date +%s`:apt_development\r\e[0K"
+ - - |
+ # cmake
+ echo -e "\e[0Ksection_start:`date +%s`:cmake[collapsed=false]\r\e[0KBuilding Makefiles"
+ - cmake -B build.cmake -DSRB2_USE_CCACHE=YES -DSRB2_CONFIG_ERRORMODE=ON -DSRB2_CONFIG_FORCE_NO_MS_BITFIELDS=ON -DSRB2_CONFIG_USE_GME:BOOL=OFF
+ - |
+ # cmake
+ echo -e "\e[0Ksection_end:`date +%s`:cmake\r\e[0K"
+
- - |
# make
echo -e "\e[0Ksection_start:`date +%s`:make[collapsed=false]\r\e[0KCompiling SRB2"
- - make --directory=src --keep-going CCACHE=1 ERRORMODE=1 LINUX64=1 ERRORMODE=1 NONX86=1 ARM64=1 NOGME=1 || make --directory=src --keep-going CCACHE=1 ERRORMODE=1 LINUX64=1 NONX86=1 ARM64=1 NOGME=1
+ - cmake --build build.cmake --parallel 1 --verbose
- |
# make
echo -e "\e[0Ksection_end:`date +%s`:make\r\e[0K"
diff --git a/.gitlab/ci/jobs/debian-oldstable-amd64-makefile.yml b/.gitlab/ci/jobs/debian-oldstable-amd64-makefile.yml
new file mode 100644
index 0000000000000000000000000000000000000000..bd4a927419ad65ce51745214b44500f84751209a
--- /dev/null
+++ b/.gitlab/ci/jobs/debian-oldstable-amd64-makefile.yml
@@ -0,0 +1,40 @@
+Debian oldstable:amd64 Makefile:
+ extends: Debian stable:amd64 Makefile
+
+ when: manual
+
+ image: git.do.srb2.org:5050/stjr/srb2ci/srb2ci:oldstable
+
+ allow_failure: true
+
+ artifacts:
+ paths:
+ - "bin/"
+ - "src/comptime.h"
+ expose_as: "Debian old amd64 makefile"
+ name: "$CI_PROJECT_PATH_SLUG-$CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA-old-x86-64-makefile"
+
+ script:
+ - - |
+ # apt_toolchain
+ echo -e "\e[0Ksection_start:`date +%s`:apt_toolchain[collapsed=true]\r\e[0KInstalling toolchain packages"
+ - apt-get install g++-x86-64-linux-gnu || apt-get install g++
+ - |
+ # apt_toolchain
+ echo -e "\e[0Ksection_end:`date +%s`:apt_toolchain\r\e[0K"
+
+ - - |
+ # apt_development
+ echo -e "\e[0Ksection_start:`date +%s`:apt_development[collapsed=true]\r\e[0KInstalling development packages"
+ - apt-get install libsdl2-mixer-dev:amd64 libpng-dev:amd64 libcurl4-openssl-dev:amd64 libopenmpt-dev:amd64 libminiupnpc-dev:amd64
+ - |
+ # apt_development
+ echo -e "\e[0Ksection_end:`date +%s`:apt_development\r\e[0K"
+
+ - - |
+ # make
+ echo -e "\e[0Ksection_start:`date +%s`:make[collapsed=false]\r\e[0KCompiling SRB2"
+ - make --directory=src --keep-going CCACHE=1 ERRORMODE=1 LINUX64=1 NOGME=1 || make --directory=src --keep-going CCACHE=1 ERRORMODE=1 LINUX64=1 NOGME=1
+ - |
+ # make
+ echo -e "\e[0Ksection_end:`date +%s`:make\r\e[0K"
diff --git a/.gitlab/ci/jobs/debian-oldstable-amd64.yml b/.gitlab/ci/jobs/debian-oldstable-amd64.yml
index 3929ecdcd10f8f448072d2c859de6a7dd31d94c7..231e8485d71d5a50e94c1ecc08fb140549595e5e 100644
--- a/.gitlab/ci/jobs/debian-oldstable-amd64.yml
+++ b/.gitlab/ci/jobs/debian-oldstable-amd64.yml
@@ -9,8 +9,8 @@ Debian oldstable:amd64:
artifacts:
paths:
- - "bin/"
- - "src/comptime.h"
+ - "build.cmake/bin/"
+ - "build.cmake/src/config.h"
expose_as: "Debian old amd64"
name: "$CI_PROJECT_PATH_SLUG-$CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA-old-x86-64"
@@ -18,7 +18,7 @@ Debian oldstable:amd64:
- - |
# apt_toolchain
echo -e "\e[0Ksection_start:`date +%s`:apt_toolchain[collapsed=true]\r\e[0KInstalling toolchain packages"
- - apt-get install gcc-x86-64-linux-gnu || apt-get install gcc
+ - apt-get install ++-x86-64-linux-gnu || apt-get install g++
- |
# apt_toolchain
echo -e "\e[0Ksection_end:`date +%s`:apt_toolchain\r\e[0K"
@@ -31,10 +31,18 @@ Debian oldstable:amd64:
# apt_development
echo -e "\e[0Ksection_end:`date +%s`:apt_development\r\e[0K"
+ - - |
+ # cmake
+ echo -e "\e[0Ksection_start:`date +%s`:cmake[collapsed=false]\r\e[0KBuilding Makefiles"
+ - cmake -B build.cmake -DSRB2_USE_CCACHE=YES -DSRB2_CONFIG_ERRORMODE=ON -DSRB2_CONFIG_USE_GME:BOOL=ON
+ - |
+ # cmake
+ echo -e "\e[0Ksection_end:`date +%s`:cmake\r\e[0K"
+
- - |
# make
echo -e "\e[0Ksection_start:`date +%s`:make[collapsed=false]\r\e[0KCompiling SRB2"
- - make --directory=src --keep-going CCACHE=1 ERRORMODE=1 LINUX64=1 NOGME=1 || make --directory=src --keep-going CCACHE=1 ERRORMODE=1 LINUX64=1 NOGME=1
+ - cmake --build build.cmake --parallel 1 --verbose
- |
# make
echo -e "\e[0Ksection_end:`date +%s`:make\r\e[0K"
diff --git a/.gitlab/ci/jobs/debian-oldstable-arm64-makefile.yml b/.gitlab/ci/jobs/debian-oldstable-arm64-makefile.yml
new file mode 100644
index 0000000000000000000000000000000000000000..426934bf97d9cae2875ec1bd4ed8dff7ad58af68
--- /dev/null
+++ b/.gitlab/ci/jobs/debian-oldstable-arm64-makefile.yml
@@ -0,0 +1,40 @@
+Debian oldstable:arm64 Makefile:
+ extends: Debian stable:arm64 Makefile
+
+ when: manual
+
+ image: git.do.srb2.org:5050/stjr/srb2ci/srb2ci:oldstable
+
+ allow_failure: true
+
+ artifacts:
+ paths:
+ - "bin/"
+ - "src/comptime.h"
+ expose_as: "Debian old arm64 makefile"
+ name: "$CI_PROJECT_PATH_SLUG-$CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA-old-aarch64-makefile"
+
+ script:
+ - - |
+ # apt_toolchain
+ echo -e "\e[0Ksection_start:`date +%s`:apt_toolchain[collapsed=true]\r\e[0KInstalling toolchain packages"
+ - apt-get install g++-aarch64-linux-gnu || apt-get install g++
+ - |
+ # apt_toolchain
+ echo -e "\e[0Ksection_end:`date +%s`:apt_toolchain\r\e[0K"
+
+ - - |
+ # apt_development
+ echo -e "\e[0Ksection_start:`date +%s`:apt_development[collapsed=true]\r\e[0KInstalling development packages"
+ - apt-get install libsdl2-mixer-dev:arm64 libpng-dev:arm64 libcurl4-openssl-dev:arm64 libopenmpt-dev:arm64 libminiupnpc-dev:arm64
+ - |
+ # apt_development
+ echo -e "\e[0Ksection_end:`date +%s`:apt_development\r\e[0K"
+
+ - - |
+ # make
+ echo -e "\e[0Ksection_start:`date +%s`:make[collapsed=false]\r\e[0KCompiling SRB2"
+ - make --directory=src --keep-going CCACHE=1 ERRORMODE=1 LINUX64=1 ERRORMODE=1 NONX86=1 ARM64=1 NOGME=1 || make --directory=src --keep-going CCACHE=1 ERRORMODE=1 LINUX64=1 NONX86=1 ARM64=1 NOGME=1
+ - |
+ # make
+ echo -e "\e[0Ksection_end:`date +%s`:make\r\e[0K"
diff --git a/.gitlab/ci/jobs/debian-oldstable-arm64.yml b/.gitlab/ci/jobs/debian-oldstable-arm64.yml
index b18d538cd0824041650f3f8a5361b7b07c85f206..76d401309d07df3ee312b85488c09a9dd0fd28fb 100644
--- a/.gitlab/ci/jobs/debian-oldstable-arm64.yml
+++ b/.gitlab/ci/jobs/debian-oldstable-arm64.yml
@@ -9,8 +9,8 @@ Debian oldstable:arm64:
artifacts:
paths:
- - "bin/"
- - "src/comptime.h"
+ - "build.cmake/bin/"
+ - "build.cmake/src/config.h"
expose_as: "Debian old arm64"
name: "$CI_PROJECT_PATH_SLUG-$CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA-old-aarch64"
@@ -18,7 +18,7 @@ Debian oldstable:arm64:
- - |
# apt_toolchain
echo -e "\e[0Ksection_start:`date +%s`:apt_toolchain[collapsed=true]\r\e[0KInstalling toolchain packages"
- - apt-get install gcc-aarch64-linux-gnu || apt-get install gcc
+ - apt-get install g++-aarch64-linux-gnu || apt-get install g++
- |
# apt_toolchain
echo -e "\e[0Ksection_end:`date +%s`:apt_toolchain\r\e[0K"
@@ -31,10 +31,18 @@ Debian oldstable:arm64:
# apt_development
echo -e "\e[0Ksection_end:`date +%s`:apt_development\r\e[0K"
+ - - |
+ # cmake
+ echo -e "\e[0Ksection_start:`date +%s`:cmake[collapsed=false]\r\e[0KBuilding Makefiles"
+ - cmake -B build.cmake -DSRB2_USE_CCACHE=YES -DSRB2_CONFIG_ERRORMODE=ON -DSRB2_CONFIG_FORCE_NO_MS_BITFIELDS=ON -DSRB2_CONFIG_USE_GME:BOOL=ON
+ - |
+ # cmake
+ echo -e "\e[0Ksection_end:`date +%s`:cmake\r\e[0K"
+
- - |
# make
echo -e "\e[0Ksection_start:`date +%s`:make[collapsed=false]\r\e[0KCompiling SRB2"
- - make --directory=src --keep-going CCACHE=1 ERRORMODE=1 LINUX64=1 ERRORMODE=1 NONX86=1 ARM64=1 NOGME=1 || make --directory=src --keep-going CCACHE=1 ERRORMODE=1 LINUX64=1 NONX86=1 ARM64=1 NOGME=1
+ - cmake --build build.cmake --parallel 1 --verbose
- |
# make
echo -e "\e[0Ksection_end:`date +%s`:make\r\e[0K"
diff --git a/.gitlab/ci/jobs/debian-stable-amd64-makefile.yml b/.gitlab/ci/jobs/debian-stable-amd64-makefile.yml
new file mode 100644
index 0000000000000000000000000000000000000000..a6aebfac34bf1ad1e99380b167f16f56a5686f12
--- /dev/null
+++ b/.gitlab/ci/jobs/debian-stable-amd64-makefile.yml
@@ -0,0 +1,46 @@
+Debian stable:amd64 Makefile:
+ extends: .srb2ci
+
+ stage: build
+
+ artifacts:
+ paths:
+ - "bin/"
+ - "src/comptime.h"
+ expose_as: "Debian amd64 makefile"
+ name: "$CI_PROJECT_PATH_SLUG-$CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA-x86-64-makefile"
+
+ variables:
+ CC: x86_64-linux-gnu-gcc
+ CXX: x86_64-linux-gnu-g++
+ LDFLAGS: -Wl,-fuse-ld=gold
+ OBJCOPY: x86_64-linux-gnu-objcopy
+ OBJDUMP: x86_64-linux-gnu-objdump
+ PKG_CONFIG_PATH: /usr/lib/x86_64-linux-gnu/pkgconfig
+
+ when: on_success
+
+ script:
+ - - |
+ # apt_toolchain
+ echo -e "\e[0Ksection_start:`date +%s`:apt_toolchain[collapsed=true]\r\e[0KInstalling toolchain packages"
+ - apt-get install g++-x86-64-linux-gnu || apt-get install g++
+ - |
+ # apt_toolchain
+ echo -e "\e[0Ksection_end:`date +%s`:apt_toolchain\r\e[0K"
+
+ - - |
+ # apt_development
+ echo -e "\e[0Ksection_start:`date +%s`:apt_development[collapsed=true]\r\e[0KInstalling development packages"
+ - apt-get install libsdl2-mixer-dev:amd64 libpng-dev:amd64 libcurl4-openssl-dev:amd64 libgme-dev:amd64 libopenmpt-dev:amd64 libminiupnpc-dev:amd64
+ - |
+ # apt_development
+ echo -e "\e[0Ksection_end:`date +%s`:apt_development\r\e[0K"
+
+ - - |
+ # make
+ echo -e "\e[0Ksection_start:`date +%s`:make[collapsed=false]\r\e[0KCompiling SRB2"
+ - make --directory=src --keep-going CCACHE=1 ERRORMODE=1 LINUX64=1 || make --directory=src --keep-going CCACHE=1 ERRORMODE=1 LINUX64=1
+ - |
+ # make
+ echo -e "\e[0Ksection_end:`date +%s`:make\r\e[0K"
diff --git a/.gitlab/ci/jobs/debian-stable-amd64.yml b/.gitlab/ci/jobs/debian-stable-amd64.yml
index 4a757afe0d519f268bb4541cda49ba03a3181600..ed1f5ce23e0ff88a96ed73ddc82f5371a7b13656 100644
--- a/.gitlab/ci/jobs/debian-stable-amd64.yml
+++ b/.gitlab/ci/jobs/debian-stable-amd64.yml
@@ -5,13 +5,14 @@ Debian stable:amd64:
artifacts:
paths:
- - "bin/"
- - "src/comptime.h"
+ - "build.cmake/bin/"
+ - "build.cmake/src/config.h"
expose_as: "Debian amd64"
name: "$CI_PROJECT_PATH_SLUG-$CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA-x86-64"
variables:
CC: x86_64-linux-gnu-gcc
+ CXX: x86_64-linux-gnu-g++
LDFLAGS: -Wl,-fuse-ld=gold
OBJCOPY: x86_64-linux-gnu-objcopy
OBJDUMP: x86_64-linux-gnu-objdump
@@ -23,7 +24,7 @@ Debian stable:amd64:
- - |
# apt_toolchain
echo -e "\e[0Ksection_start:`date +%s`:apt_toolchain[collapsed=true]\r\e[0KInstalling toolchain packages"
- - apt-get install gcc-x86-64-linux-gnu || apt-get install gcc
+ - apt-get install g++-x86-64-linux-gnu || apt-get install g++
- |
# apt_toolchain
echo -e "\e[0Ksection_end:`date +%s`:apt_toolchain\r\e[0K"
@@ -36,10 +37,18 @@ Debian stable:amd64:
# apt_development
echo -e "\e[0Ksection_end:`date +%s`:apt_development\r\e[0K"
+ - - |
+ # cmake
+ echo -e "\e[0Ksection_start:`date +%s`:cmake[collapsed=false]\r\e[0KBuilding Makefiles"
+ - cmake -B build.cmake -DSRB2_USE_CCACHE=YES -DSRB2_CONFIG_ERRORMODE=ON -DSRB2_CONFIG_USE_GME:BOOL=ON
+ - |
+ # cmake
+ echo -e "\e[0Ksection_end:`date +%s`:cmake\r\e[0K"
+
- - |
# make
echo -e "\e[0Ksection_start:`date +%s`:make[collapsed=false]\r\e[0KCompiling SRB2"
- - make --directory=src --keep-going CCACHE=1 ERRORMODE=1 LINUX64=1 || make --directory=src --keep-going CCACHE=1 ERRORMODE=1 LINUX64=1
+ - cmake --build build.cmake --parallel 1 --verbose
- |
# make
echo -e "\e[0Ksection_end:`date +%s`:make\r\e[0K"
diff --git a/.gitlab/ci/jobs/debian-stable-arm64-makefile.yml b/.gitlab/ci/jobs/debian-stable-arm64-makefile.yml
new file mode 100644
index 0000000000000000000000000000000000000000..53625138abe3c56dc23612b9abca129f461f8b68
--- /dev/null
+++ b/.gitlab/ci/jobs/debian-stable-arm64-makefile.yml
@@ -0,0 +1,47 @@
+Debian stable:arm64 Makefile:
+ extends: .srb2ci
+
+ stage: build
+
+ when: manual
+
+ artifacts:
+ paths:
+ - "bin/"
+ - "src/comptime.h"
+ expose_as: "Debian arm64 makefile"
+ name: "$CI_PROJECT_PATH_SLUG-$CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA-aarch64-makefile"
+
+ variables:
+ CC: aarch64-linux-gnu-gcc
+ CXX: aarch64-linux-gnu-g++
+ LDFLAGS: -Wl,-fuse-ld=gold
+ OBJCOPY: aarch64-linux-gnu-objcopy
+ OBJDUMP: aarch64-linux-gnu-objdump
+ LD: aarch64-linux-gnu-ld
+ PKG_CONFIG_PATH: /usr/lib/aarch64-linux-gnu/pkgconfig
+
+ script:
+ - - |
+ # apt_toolchain
+ echo -e "\e[0Ksection_start:`date +%s`:apt_toolchain[collapsed=true]\r\e[0KInstalling toolchain packages"
+ - apt-get install gg++-aarch64-linux-gnu || apt-get install g++
+ - |
+ # apt_toolchain
+ echo -e "\e[0Ksection_end:`date +%s`:apt_toolchain\r\e[0K"
+
+ - - |
+ # apt_development
+ echo -e "\e[0Ksection_start:`date +%s`:apt_development[collapsed=true]\r\e[0KInstalling development packages"
+ - apt-get install libsdl2-mixer-dev:arm64 libpng-dev:arm64 libcurl4-openssl-dev:arm64 libgme-dev:arm64 libopenmpt-dev:arm64 libminiupnpc-dev:arm64
+ - |
+ # apt_development
+ echo -e "\e[0Ksection_end:`date +%s`:apt_development\r\e[0K"
+
+ - - |
+ # make
+ echo -e "\e[0Ksection_start:`date +%s`:make[collapsed=false]\r\e[0KCompiling SRB2"
+ - make --directory=src --keep-going CCACHE=1 ERRORMODE=1 LINUX64=1 ERRORMODE=1 NONX86=1 ARM64=1 || make --directory=src --keep-going CCACHE=1 ERRORMODE=1 LINUX64=1 NONX86=1 ARM64=1
+ - |
+ # make
+ echo -e "\e[0Ksection_end:`date +%s`:make\r\e[0K"
diff --git a/.gitlab/ci/jobs/debian-stable-arm64.yml b/.gitlab/ci/jobs/debian-stable-arm64.yml
index 879391affebe7586e019e7bb7f8d77a0599983e2..b0f02dd391b181a3c3f42f3fc7a71233913d4b5d 100644
--- a/.gitlab/ci/jobs/debian-stable-arm64.yml
+++ b/.gitlab/ci/jobs/debian-stable-arm64.yml
@@ -7,23 +7,25 @@ Debian stable:arm64:
artifacts:
paths:
- - "bin/"
- - "src/comptime.h"
+ - "build.cmake/bin/"
+ - "build.cmake/src/config.h"
expose_as: "Debian arm64"
name: "$CI_PROJECT_PATH_SLUG-$CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA-aarch64"
variables:
CC: aarch64-linux-gnu-gcc
+ CXX: aarch64-linux-gnu-g++
LDFLAGS: -Wl,-fuse-ld=gold
OBJCOPY: aarch64-linux-gnu-objcopy
OBJDUMP: aarch64-linux-gnu-objdump
+ LD: aarch64-linux-gnu-ld
PKG_CONFIG_PATH: /usr/lib/aarch64-linux-gnu/pkgconfig
script:
- - |
# apt_toolchain
echo -e "\e[0Ksection_start:`date +%s`:apt_toolchain[collapsed=true]\r\e[0KInstalling toolchain packages"
- - apt-get install gcc-aarch64-linux-gnu || apt-get install gcc
+ - apt-get install g++-aarch64-linux-gnu || apt-get install g++
- |
# apt_toolchain
echo -e "\e[0Ksection_end:`date +%s`:apt_toolchain\r\e[0K"
@@ -36,10 +38,18 @@ Debian stable:arm64:
# apt_development
echo -e "\e[0Ksection_end:`date +%s`:apt_development\r\e[0K"
+ - - |
+ # cmake
+ echo -e "\e[0Ksection_start:`date +%s`:cmake[collapsed=false]\r\e[0KBuilding Makefiles"
+ - cmake -B build.cmake -DSRB2_USE_CCACHE=YES -DSRB2_CONFIG_ERRORMODE=ON -DSRB2_CONFIG_FORCE_NO_MS_BITFIELDS=ON -DSRB2_CONFIG_USE_GME:BOOL=ON
+ - |
+ # cmake
+ echo -e "\e[0Ksection_end:`date +%s`:cmake\r\e[0K"
+
- - |
# make
echo -e "\e[0Ksection_start:`date +%s`:make[collapsed=false]\r\e[0KCompiling SRB2"
- - make --directory=src --keep-going CCACHE=1 ERRORMODE=1 LINUX64=1 ERRORMODE=1 NONX86=1 ARM64=1 || make --directory=src --keep-going CCACHE=1 ERRORMODE=1 LINUX64=1 NONX86=1 ARM64=1
+ - cmake --build build.cmake --parallel 1 --verbose
- |
# make
echo -e "\e[0Ksection_end:`date +%s`:make\r\e[0K"
diff --git a/.gitlab/ci/jobs/debian-stable-clang-amd64.yml b/.gitlab/ci/jobs/debian-stable-clang-amd64.yml
index 4686c1849196d3be6cbee936c1ad910c0f93627c..c40998e17af3157856f92fbb0121c409655900bc 100644
--- a/.gitlab/ci/jobs/debian-stable-clang-amd64.yml
+++ b/.gitlab/ci/jobs/debian-stable-clang-amd64.yml
@@ -9,8 +9,8 @@ Debian stable Clang:
artifacts:
paths:
- - "build.clang/bin/"
- - "build.clang/src/config.h"
+ - "build.cmake/bin/"
+ - "build.cmake/src/config.h"
expose_as: "clang"
name: "$CI_PROJECT_PATH_SLUG-$CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA-clang"
@@ -41,7 +41,7 @@ Debian stable Clang:
- - |
# cmake
echo -e "\e[0Ksection_start:`date +%s`:cmake[collapsed=false]\r\e[0KBuilding Makefiles"
- - cmake -B build.clang -DCPM_USE_LOCAL_PACKAGES:BOOL=ON -DSRB2_CONFIG_ENABLE_TESTS:BOOL=OFF -DSRB2_CONFIG_SYSTEM_LIBRARIES:BOOL=ON -DSRB2_USE_LIBGME:BOOL=OFF -G "Unix Makefiles"
+ - cmake -B build.cmake -DCPM_USE_LOCAL_PACKAGES:BOOL=ON -DSRB2_CONFIG_ENABLE_TESTS:BOOL=OFF -DSRB2_CONFIG_SYSTEM_LIBRARIES:BOOL=ON -DSRB2_USE_LIBGME:BOOL=OFF -DSRB2_CONFIG_USE_GME:BOOL=ON
- |
# cmake
echo -e "\e[0Ksection_end:`date +%s`:cmake\r\e[0K"
@@ -49,7 +49,7 @@ Debian stable Clang:
- - |
# make
echo -e "\e[0Ksection_start:`date +%s`:make[collapsed=false]\r\e[0KCompiling SRB2"
- - make --directory=build.clang --keep-going || make --directory=build.clang --keep-going
+ - cmake --build build.cmake --parallel 1 --verbose
- |
# make
echo -e "\e[0Ksection_end:`date +%s`:make\r\e[0K"
diff --git a/.gitlab/ci/jobs/debian-stable-i386-makefile.yml b/.gitlab/ci/jobs/debian-stable-i386-makefile.yml
new file mode 100644
index 0000000000000000000000000000000000000000..dd572ec383c489d3414a312348806f47c65f3cbc
--- /dev/null
+++ b/.gitlab/ci/jobs/debian-stable-i386-makefile.yml
@@ -0,0 +1,46 @@
+Debian stable:i386 Makefile:
+ extends: .srb2ci
+
+ stage: build
+
+ when: manual
+
+ artifacts:
+ paths:
+ - "bin/"
+ - "src/comptime.h"
+ expose_as: "Debian i386 makefile"
+ name: "$CI_PROJECT_PATH_SLUG-$CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA-i686-makefile"
+
+ variables:
+ CC: i686-linux-gnu-gcc
+ CXX: i686-linux-gnu-g++
+ OBJCOPY: i686-linux-gnu-objcopy
+ OBJDUMP: i686-linux-gnu-objdump
+ LD: i686-linux-gnu-ld
+ PKG_CONFIG_PATH: /usr/lib/i386-linux-gnu/pkgconfig
+
+ script:
+ - - |
+ # apt_toolchain
+ echo -e "\e[0Ksection_start:`date +%s`:apt_toolchain[collapsed=true]\r\e[0KInstalling toolchain packages"
+ - apt-get install g++-i686-linux-gnu || apt-get install g++
+ - |
+ # apt_toolchain
+ echo -e "\e[0Ksection_end:`date +%s`:apt_toolchain\r\e[0K"
+
+ - - |
+ # apt_development
+ echo -e "\e[0Ksection_start:`date +%s`:apt_development[collapsed=true]\r\e[0KInstalling development packages"
+ - apt-get install libsdl2-mixer-dev:i386 libpng-dev:i386 libcurl4-openssl-dev:i386 libgme-dev:i386 libopenmpt-dev:i386 libminiupnpc-dev:i386
+ - |
+ # apt_development
+ echo -e "\e[0Ksection_end:`date +%s`:apt_development\r\e[0K"
+
+ - - |
+ # make
+ echo -e "\e[0Ksection_start:`date +%s`:make[collapsed=false]\r\e[0KCompiling SRB2"
+ - make --directory=src --keep-going CCACHE=1 ERRORMODE=1 LINUX=1 || make --directory=src --keep-going CCACHE=1 ERRORMODE=1 LINUX=1
+ - |
+ # make
+ echo -e "\e[0Ksection_end:`date +%s`:make\r\e[0K"
diff --git a/.gitlab/ci/jobs/debian-stable-i386.yml b/.gitlab/ci/jobs/debian-stable-i386.yml
index cd6206e55e9a497d7065d3ea652c1ed3c6bd8d23..970b92a69c6f00ff508a0126bd1b82962f8e5c48 100644
--- a/.gitlab/ci/jobs/debian-stable-i386.yml
+++ b/.gitlab/ci/jobs/debian-stable-i386.yml
@@ -7,22 +7,24 @@ Debian stable:i386:
artifacts:
paths:
- - "bin/"
- - "src/comptime.h"
+ - "build.cmake/bin/"
+ - "build.cmake/src/config.h"
expose_as: "Debian i386"
name: "$CI_PROJECT_PATH_SLUG-$CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA-i686"
variables:
CC: i686-linux-gnu-gcc
+ CXX: i686-linux-gnu-g++
OBJCOPY: i686-linux-gnu-objcopy
OBJDUMP: i686-linux-gnu-objdump
+ LD: i686-linux-gnu-ld
PKG_CONFIG_PATH: /usr/lib/i386-linux-gnu/pkgconfig
script:
- - |
# apt_toolchain
echo -e "\e[0Ksection_start:`date +%s`:apt_toolchain[collapsed=true]\r\e[0KInstalling toolchain packages"
- - apt-get install gcc-i686-linux-gnu || apt-get install gcc
+ - apt-get install g++-i686-linux-gnu || apt-get install g++
- |
# apt_toolchain
echo -e "\e[0Ksection_end:`date +%s`:apt_toolchain\r\e[0K"
@@ -35,10 +37,18 @@ Debian stable:i386:
# apt_development
echo -e "\e[0Ksection_end:`date +%s`:apt_development\r\e[0K"
+ - - |
+ # cmake
+ echo -e "\e[0Ksection_start:`date +%s`:cmake[collapsed=false]\r\e[0KBuilding Makefiles"
+ - cmake -B build.cmake -DSRB2_USE_CCACHE=YES -DSRB2_CONFIG_ERRORMODE=ON -DSRB2_CONFIG_USE_GME:BOOL=ON
+ - |
+ # cmake
+ echo -e "\e[0Ksection_end:`date +%s`:cmake\r\e[0K"
+
- - |
# make
echo -e "\e[0Ksection_start:`date +%s`:make[collapsed=false]\r\e[0KCompiling SRB2"
- - make --directory=src --keep-going CCACHE=1 ERRORMODE=1 LINUX=1 || make --directory=src --keep-going CCACHE=1 ERRORMODE=1 LINUX=1
+ - cmake --build build.cmake --parallel 1 --verbose
- |
# make
echo -e "\e[0Ksection_end:`date +%s`:make\r\e[0K"
diff --git a/.gitlab/ci/jobs/debian-testing-gcc-amd64-makefile.yml b/.gitlab/ci/jobs/debian-testing-gcc-amd64-makefile.yml
new file mode 100644
index 0000000000000000000000000000000000000000..70d71b537703e6ef07dcd572dec0d318d86e9d93
--- /dev/null
+++ b/.gitlab/ci/jobs/debian-testing-gcc-amd64-makefile.yml
@@ -0,0 +1,47 @@
+Debian testing GCC Makefile:
+ extends: .srb2ci
+
+ stage: build
+
+ when: manual
+
+ image: debian:testing-slim
+
+ allow_failure: true
+
+ artifacts:
+ paths:
+ - "bin/"
+ - "src/comptime.h"
+ expose_as: "testing-gcc-makefile"
+ name: "$CI_PROJECT_PATH_SLUG-$CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA-testing-gcc-makefile"
+
+ variables:
+ CC: gcc
+ CXX: g++
+ LDFLAGS: -Wl,-fuse-ld=gold
+
+ script:
+ - - |
+ # apt_toolchain
+ echo -e "\e[0Ksection_start:`date +%s`:apt_toolchain[collapsed=true]\r\e[0KInstalling toolchain packages"
+ - apt-get install g++
+ - |
+ # apt_toolchain
+ echo -e "\e[0Ksection_end:`date +%s`:apt_toolchain\r\e[0K"
+
+ - - |
+ # apt_development
+ echo -e "\e[0Ksection_start:`date +%s`:apt_development[collapsed=true]\r\e[0KInstalling development packages"
+ - apt-get install libsdl2-mixer-dev libpng-dev libcurl4-openssl-dev libgme-dev libopenmpt-dev libminiupnpc-dev
+ - |
+ # apt_development
+ echo -e "\e[0Ksection_end:`date +%s`:apt_development\r\e[0K"
+
+ - - |
+ # make
+ echo -e "\e[0Ksection_start:`date +%s`:make[collapsed=false]\r\e[0KCompiling SRB2"
+ - make --directory=src --keep-going CCACHE=1 ERRORMODE=1 NONX86=1 || make --directory=src --keep-going CCACHE=1 ERRORMODE=1 NONX86=1
+ - |
+ # make
+ echo -e "\e[0Ksection_end:`date +%s`:make\r\e[0K"
diff --git a/.gitlab/ci/jobs/debian-testing-gcc-amd64.yml b/.gitlab/ci/jobs/debian-testing-gcc-amd64.yml
index 10799b3053e45a3d98fcfa1f63281e36ebadae9d..72bfdc3e3a7e24884ce031d01fcab86f0baa48c8 100644
--- a/.gitlab/ci/jobs/debian-testing-gcc-amd64.yml
+++ b/.gitlab/ci/jobs/debian-testing-gcc-amd64.yml
@@ -11,20 +11,21 @@ Debian testing GCC:
artifacts:
paths:
- - "bin/"
- - "src/comptime.h"
+ - "build.cmake/bin/"
+ - "build.cmake/src/config.h"
expose_as: "testing-gcc"
name: "$CI_PROJECT_PATH_SLUG-$CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA-testing-gcc"
variables:
CC: gcc
+ CXX: g++
LDFLAGS: -Wl,-fuse-ld=gold
script:
- - |
# apt_toolchain
echo -e "\e[0Ksection_start:`date +%s`:apt_toolchain[collapsed=true]\r\e[0KInstalling toolchain packages"
- - apt-get install gcc
+ - apt-get install g++
- |
# apt_toolchain
echo -e "\e[0Ksection_end:`date +%s`:apt_toolchain\r\e[0K"
@@ -37,10 +38,18 @@ Debian testing GCC:
# apt_development
echo -e "\e[0Ksection_end:`date +%s`:apt_development\r\e[0K"
+ - - |
+ # cmake
+ echo -e "\e[0Ksection_start:`date +%s`:cmake[collapsed=false]\r\e[0KBuilding Makefiles"
+ - cmake -B build.cmake -DSRB2_USE_CCACHE=YES -DSRB2_CONFIG_ERRORMODE=ON -DSRB2_CONFIG_USE_GME:BOOL=ON
+ - |
+ # cmake
+ echo -e "\e[0Ksection_end:`date +%s`:cmake\r\e[0K"
+
- - |
# make
echo -e "\e[0Ksection_start:`date +%s`:make[collapsed=false]\r\e[0KCompiling SRB2"
- - make --directory=src --keep-going CCACHE=1 ERRORMODE=1 NONX86=1 || make --directory=src --keep-going CCACHE=1 ERRORMODE=1 NONX86=1
+ - cmake --build build.cmake --parallel 1 --verbose
- |
# make
echo -e "\e[0Ksection_end:`date +%s`:make\r\e[0K"
diff --git a/.gitlab/ci/jobs/macos-arm64.yml b/.gitlab/ci/jobs/macos-arm64.yml
index 3928413610a048460dfe05d0dfc8f92e9da76848..1c89000c2f540bc1b1251f66aba833a6557ad9f9 100644
--- a/.gitlab/ci/jobs/macos-arm64.yml
+++ b/.gitlab/ci/jobs/macos-arm64.yml
@@ -3,16 +3,13 @@ osxcross arm64:
stage: build
- when: manual
-
- allow_failure: true
-
artifacts:
paths:
- - "build.osxcross/bin/"
- - "build.osxcross/src/config.h"
+ - "build.arm64/bin/"
+ - "build.arm64/dist/arm64.h"
+ - "build.arm64/src/config.h"
expose_as: "Mac arm64"
- name: "$CI_PROJECT_PATH_SLUG-$CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA-clang"
+ name: "$CI_PROJECT_PATH_SLUG-$CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA-arm64-apple-darwin21.4"
variables:
OSXCROSS_HOST: arm64-apple-darwin21.4
@@ -22,7 +19,8 @@ osxcross arm64:
- - |
# apt_development
echo -e "\e[0Ksection_start:`date +%s`:macports_development[collapsed=true]\r\e[0KInstalling development packages"
- - osxcross-macports install --arm64 curl libopenmpt libsdl2_mixer
+ - osxcross-macports install --arm64 libxmp wavpack libopenmpt opusfile || osxcross-macports install --arm64 libxmp wavpack libopenmpt opusfile
+ - osxcross-macports install --static --arm64 curl libsdl2_mixer libpng || osxcross-macports install --static --arm64 curl libsdl2_mixer libpng
- |
# apt_development
echo -e "\e[0Ksection_end:`date +%s`:macports_development\r\e[0K"
@@ -30,7 +28,7 @@ osxcross arm64:
- - |
# cmake
echo -e "\e[0Ksection_start:`date +%s`:cmake[collapsed=false]\r\e[0KBuilding Makefiles"
- - cmake -B build.osxcross --toolchain /osxcross/toolchain.cmake -DCPM_USE_LOCAL_PACKAGES:BOOL=ON -DOPENMPT_INCLUDE_DIR:PATH="/osxcross/macports/pkgs/opt/local/include" -DSDL2_INCLUDE_DIR:PATH="/osxcross/macports/pkgs/opt/local/lib" -DSRB2_CONFIG_ENABLE_TESTS:BOOL=OFF -DSRB2_CONFIG_SYSTEM_LIBRARIES:BOOL=ON -DSRB2_CONFIG_USE_GME:BOOL=OFF -G "Unix Makefiles"
+ - cmake -B build.arm64 --toolchain /osxcross/toolchain.cmake -DCPM_USE_LOCAL_PACKAGES:BOOL=ON -DOPENMPT_INCLUDE_DIR:PATH="/osxcross/macports/pkgs/opt/local/include" -DSDL2_INCLUDE_DIR:PATH="/osxcross/macports/pkgs/opt/local/lib" -DSRB2_CONFIG_ENABLE_TESTS:BOOL=OFF -DSRB2_CONFIG_SYSTEM_LIBRARIES:BOOL=ON -DSRB2_CONFIG_FORCE_NO_MS_BITFIELDS:BOOL=ON -DSRB2_CONFIG_USE_GME:BOOL=OFF -DSRB2_SDL2_EXE_NAME=srb2_$CI_PIPELINE_ID
- |
# make
echo -e "\e[0Ksection_end:`date +%s`:make\r\e[0K"
@@ -38,7 +36,16 @@ osxcross arm64:
- - |
# make
echo -e "\e[0Ksection_start:`date +%s`:make[collapsed=false]\r\e[0KCompiling SRB2"
- - make --directory=build.osxcross --keep-going || make --directory=build.osxcross --keep-going
+ - cmake --build build.arm64 --parallel 1 --verbose
- |
# make
echo -e "\e[0Ksection_end:`date +%s`:make\r\e[0K"
+
+ - - |
+ # copy config.h
+ echo -e "\e[0Ksection_start:`date +%s`:copy[collapsed=false]\r\e[0KCopying config.h"
+ - mkdir --parents --verbose build.arm64/dist
+ - cp --reflink=auto --sparse=always --verbose build.arm64/src/config.h build.arm64/dist/arm64.h
+ - |
+ # make
+ echo -e "\e[0Ksection_end:`date +%s`:copy\r\e[0K"
diff --git a/.gitlab/ci/jobs/macos-x86_64.yml b/.gitlab/ci/jobs/macos-x86_64.yml
index 818028e49a43624f3e29a357d7d7614ef4dd5118..d40ae65f6c7729bf82d005c9024627da0fd36274 100644
--- a/.gitlab/ci/jobs/macos-x86_64.yml
+++ b/.gitlab/ci/jobs/macos-x86_64.yml
@@ -3,22 +3,69 @@ osxcross x86_64:
stage: build
+ cache:
+ - key: ccache-$CI_JOB_NAME_SLUG-$CI_COMMIT_REF_SLUG
+ fallback_keys:
+ - ccache-$CI_JOB_NAME_SLUG-$CI_DEFAULT_BRANCH
+ - ccache-$CI_JOB_NAME_SLUG-master
+ paths:
+ - build/ccache
+ - build/ccache_statslog
+
+ - key: apt-$CI_JOB_IMAGE
+ paths:
+ - build/apt-cache
+ unprotect: true
+
+ - key: vcpkg-root
+ paths:
+ - build/vcpkg-root
+ unprotect: true
+
+ - key: vcpkg-binary-cache-x64-osx
+ paths:
+ - build/vcpkg-binary-cache
+ unprotect: true
+
artifacts:
paths:
- - "build.osxcross/bin/"
- - "build.osxcross/src/config.h"
+ - "build.x86_64/bin/"
+ - "build.x86_64/dist/x86_64.h"
+ - "build.x86_64/src/config.h"
expose_as: "Mac x86_64"
- name: "$CI_PROJECT_PATH_SLUG-$CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA-clang"
+ name: "$CI_PROJECT_PATH_SLUG-$CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA-x86_64-apple-darwin21.4"
variables:
OSXCROSS_HOST: x86_64-apple-darwin21.4
LD: x86_64-apple-darwin21.4-ld
script:
+ - |
+ # vcpkg
+ echo -e "\e[0Ksection_start:`date +%s`:vcpkg-root[collapsed=true]\r\e[0KUpdating vcpkg"
+
+ if [ -d "build/vcpkg-root" ]; then
+ pushd build/vcpkg-root
+ git fetch https://github.com/Microsoft/vcpkg master
+ git reset --hard FETCH_HEAD
+ popd
+ else
+ mkdir -p build
+ git clone https://github.com/Microsoft/vcpkg build/vcpkg-root
+ fi
+
+ export VCPKG_ROOT=$(pwd)/build/vcpkg-root
+ export VCPKG_BINARY_SOURCES="clear;files,$(pwd)/build/vcpkg-binary-cache,readwrite"
+
+ mkdir -p "build/vcpkg-binary-cache"
+
+ echo -e "\e[0Ksection_end:`date +%s`:vcpkg-root\r\e[0K"
+
- - |
# apt_development
echo -e "\e[0Ksection_start:`date +%s`:macports_development[collapsed=true]\r\e[0KInstalling development packages"
- - osxcross-macports install curl libopenmpt libsdl2_mixer
+ - osxcross-macports install libxmp wavpack libopenmpt opusfile || osxcross-macports install libxmp wavpack libopenmpt opusfile
+ - osxcross-macports install --static curl libsdl2_mixer libpng || osxcross-macports install --static curl libsdl2_mixer libpng
- |
# apt_development
echo -e "\e[0Ksection_end:`date +%s`:macports_development\r\e[0K"
@@ -26,7 +73,7 @@ osxcross x86_64:
- - |
# cmake
echo -e "\e[0Ksection_start:`date +%s`:cmake[collapsed=false]\r\e[0KBuilding Makefiles"
- - cmake -B build.osxcross --toolchain /osxcross/toolchain.cmake -DCPM_USE_LOCAL_PACKAGES:BOOL=ON -DOPENMPT_INCLUDE_DIR:PATH="/osxcross/macports/pkgs/opt/local/include" -DSDL2_INCLUDE_DIR:PATH="/osxcross/macports/pkgs/opt/local/lib" -DSRB2_CONFIG_ENABLE_TESTS:BOOL=OFF -DSRB2_CONFIG_SYSTEM_LIBRARIES:BOOL=ON -DSRB2_CONFIG_USE_GME:BOOL=OFF -G "Unix Makefiles"
+ - cmake -B build.x86_64 --toolchain /osxcross/toolchain.cmake -DCPM_USE_LOCAL_PACKAGES:BOOL=ON -DOPENMPT_INCLUDE_DIR:PATH="/osxcross/macports/pkgs/opt/local/include" -DSDL2_INCLUDE_DIR:PATH="/osxcross/macports/pkgs/opt/local/lib" -DSRB2_CONFIG_ENABLE_TESTS:BOOL=OFF -DSRB2_CONFIG_SYSTEM_LIBRARIES:BOOL=ON -DSRB2_CONFIG_USE_GME:BOOL=OFF -DSRB2_SDL2_EXE_NAME=srb2_$CI_PIPELINE_ID
- |
# make
echo -e "\e[0Ksection_end:`date +%s`:make\r\e[0K"
@@ -34,7 +81,47 @@ osxcross x86_64:
- - |
# make
echo -e "\e[0Ksection_start:`date +%s`:make[collapsed=false]\r\e[0KCompiling SRB2"
- - make --directory=build.osxcross --keep-going || make --directory=build.osxcross --keep-going
+ - cmake --build build.x86_64 --parallel 1 --verbose
- |
# make
echo -e "\e[0Ksection_end:`date +%s`:make\r\e[0K"
+
+ - - |
+ # copy config.h
+ echo -e "\e[0Ksection_start:`date +%s`:copy[collapsed=false]\r\e[0KCopying config.h"
+ - mkdir --parents --verbose build.x86_64/dist
+ - cp --reflink=auto --sparse=always --verbose build.x86_64/src/config.h build.x86_64/dist/x86_64.h
+ - |
+ # make
+ echo -e "\e[0Ksection_end:`date +%s`:copy\r\e[0K"
+
+
+ after_script:
+ - - |
+ # apt_clean
+ echo -e "\e[0Ksection_start:`date +%s`:apt_clean[collapsed=true]\r\e[0KCleaning of unneeded APT packages"
+ - apt-get autoclean
+ - |
+ # apt_clean
+ echo -e "\e[0Ksection_end:`date +%s`:apt_clean\r\e[0K"
+
+ - - |
+ # vcpkg_clean
+ echo -e "\e[0Ksection_start:`date +%s`:vcpkg_clean[collapsed=true]\r\e[0KCleaning vcpkg-root"
+
+ if [ -d "build/vcpkg-root" ]; then
+ pushd "build/vcpkg-root"
+ git clean
+ popd
+ fi
+
+ echo -e "\e[0Ksection_end:`date +%s`:vcpkg_clean\r\e[0K"
+
+ - - |
+ # ccache_stats
+ echo -e "\e[0Ksection_start:`date +%s`:ccache_stats[collapsed=true]\r\e[0Kccache statistics:"
+ - ccache --show-stats
+ - ccache --show-log-stats || true
+ - |
+ # ccahe_stats
+ echo -e "\e[0Ksection_end:`date +%s`:ccache_stats\r\e[0K"
diff --git a/.gitlab/ci/jobs/osxccross-universal.yml b/.gitlab/ci/jobs/osxccross-universal.yml
new file mode 100644
index 0000000000000000000000000000000000000000..841151f60895c9ea966068a541fa74251dc3964e
--- /dev/null
+++ b/.gitlab/ci/jobs/osxccross-universal.yml
@@ -0,0 +1,67 @@
+osxcross universal:
+ image: git.do.srb2.org:5050/stjr/srb2ci/srb2ci:stable
+
+ dependencies:
+ - osxcross arm64
+ - osxcross x86_64
+ needs:
+ - job: osxcross arm64
+ - job: osxcross x86_64
+
+ stage: osxcross
+
+ artifacts:
+ paths:
+ - "dist/bin"
+ - "dist/src"
+ expose_as: "Mac Universal"
+ name: "$CI_PROJECT_PATH_SLUG-$CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA-lipo-apple-darwin21.4"
+
+ script:
+ - - |
+ # mkdir
+ echo -e "\e[0Ksection_start:`date +%s`:mkdir[collapsed=true]\r\e[0KMaking dist folder"
+ mkdir --parents --verbose dist/src dist/bin
+ - |
+ # mkdir
+ echo -e "\e[0Ksection_end:`date +%s`:mkdir\r\e[0K"
+
+ - - |
+ # copy-config
+ echo -e "\e[0Ksection_start:`date +%s`:x86_64-config[collapsed=true]\r\e[0KCopying x86_64 config"
+ - cp --reflink=auto --sparse=always --verbose --target-directory=dist/src/ build.*/dist/*.h
+ - |
+ # x86_64-config
+ echo -e "\e[0Ksection_end:`date +%s`:x86_64-config\r\e[0K"
+
+ - - |
+ # copy-build
+ echo -e "\e[0Ksection_start:`date +%s`:copy-build[collapsed=true]\r\e[0KCopying ALL build"
+ - cp --reflink=auto --sparse=always --recursive --verbose --target-directory=dist/ build.*/bin/
+ - |
+ # copy-build
+ echo -e "\e[0Ksection_end:`date +%s`:copy-build\r\e[0K"
+
+ - - |
+ # link-build
+ echo -e "\e[0Ksection_start:`date +%s`:link-build[collapsed=true]\r\e[0KLinking universal build"
+ - lipo -create -output dist/bin/srb2_$CI_PIPELINE_ID.app/Contents/MacOS/srb2_$CI_PIPELINE_ID build.*/bin/srb2_$CI_PIPELINE_ID.app/Contents/MacOS/srb2_$CI_PIPELINE_ID
+ - |
+ # universal-build
+ echo -e "\e[0Ksection_end:`date +%s`:link-build\r\e[0K"
+
+ - - |
+ # arm64-verify
+ echo -e "\e[0Ksection_start:`date +%s`:arm64-verify[collapsed=true]\r\e[0KVerifying arm64"
+ - lipo dist/bin/srb2_$CI_PIPELINE_ID.app/Contents/MacOS/srb2_$CI_PIPELINE_ID -verify_arch arm64
+ - |
+ # arm64-verify
+ echo -e "\e[0Ksection_end:`date +%s`:arm64-verify\r\e[0K"
+
+ - - |
+ # x86_64-verify
+ echo -e "\e[0Ksection_start:`date +%s`:x86_64-verify[collapsed=true]\r\e[0KVerifying x86_64"
+ - lipo dist/bin/srb2_$CI_PIPELINE_ID.app/Contents/MacOS/srb2_$CI_PIPELINE_ID -verify_arch x86_64
+ - |
+ # x86_64-verify
+ echo -e "\e[0Ksection_end:`date +%s`:x86_64-verify\r\e[0K"
diff --git a/.gitlab/ci/jobs/windows-x64-makefile.yml b/.gitlab/ci/jobs/windows-x64-makefile.yml
new file mode 100644
index 0000000000000000000000000000000000000000..8da30d2b9822fd42c90f00df2d061284d1c753ef
--- /dev/null
+++ b/.gitlab/ci/jobs/windows-x64-makefile.yml
@@ -0,0 +1,35 @@
+Windows x64 Makefile:
+ extends: .srb2ci
+
+ stage: build
+
+ when: manual
+
+ allow_failure: true
+
+ artifacts:
+ paths:
+ - "bin/"
+ - "src/comptime.h"
+ expose_as: "Win64-makefile"
+ name: "$CI_PROJECT_PATH_SLUG-$CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA-Win64-makefile"
+
+ variables:
+ PREFIX: x86_64-w64-mingw32
+
+ script:
+ - - |
+ # apt_toolchain
+ echo -e "\e[0Ksection_start:`date +%s`:apt_toolchain[collapsed=true]\r\e[0KInstalling toolchain packages"
+ - apt-get install g++-mingw-w64-x86-64-win32
+ - |
+ # apt_toolchain
+ echo -e "\e[0Ksection_end:`date +%s`:apt_toolchain\r\e[0K"
+
+ - - |
+ # make
+ echo -e "\e[0Ksection_start:`date +%s`:make[collapsed=false]\r\e[0KCompiling SRB2"
+ - make --directory=src --keep-going CCACHE=1 ERRORMODE=1 MINGW64=1 SDL=1 || make --directory=src --keep-going CCACHE=1 ERRORMODE=1 MINGW64=1 SDL=1
+ - |
+ # make
+ echo -e "\e[0Ksection_end:`date +%s`:make\r\e[0K"
diff --git a/.gitlab/ci/jobs/windows-x64.yml b/.gitlab/ci/jobs/windows-x64.yml
index da8d960bd1330229a2265ed9b015a487f1040e75..73791e82a202d91f1b0bc4c28e764bb0a846941a 100644
--- a/.gitlab/ci/jobs/windows-x64.yml
+++ b/.gitlab/ci/jobs/windows-x64.yml
@@ -7,29 +7,122 @@ Windows x64:
allow_failure: true
+ cache:
+ - key: ccache-$CI_JOB_NAME_SLUG-$CI_COMMIT_REF_SLUG
+ fallback_keys:
+ - ccache-$CI_JOB_NAME_SLUG-$CI_DEFAULT_BRANCH
+ - ccache-$CI_JOB_NAME_SLUG-master
+ paths:
+ - build/ccache
+ - build/ccache_statslog
+
+ - key: apt-$CI_JOB_IMAGE
+ paths:
+ - build/apt-cache
+ unprotect: true
+
+ - key: vcpkg-root
+ paths:
+ - build/vcpkg-root
+ unprotect: true
+
+ - key: vcpkg-binary-cache-x64-mingw-static
+ paths:
+ - build/vcpkg-binary-cache
+ unprotect: true
+
artifacts:
paths:
- - "bin/"
- - "src/comptime.h"
+ - "build.cmake/bin/"
+ - "build.cmake/src/config.h"
expose_as: "Win64"
name: "$CI_PROJECT_PATH_SLUG-$CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA-Win64"
variables:
PREFIX: x86_64-w64-mingw32
+ CC: /usr/lib/ccache/x86_64-w64-mingw32-gcc
+ CXX: /usr/lib/ccache/x86_64-w64-mingw32-g++
script:
+ - |
+ # vcpkg
+ echo -e "\e[0Ksection_start:`date +%s`:vcpkg-root[collapsed=true]\r\e[0KUpdating vcpkg"
+
+ if [ -d "build/vcpkg-root" ]; then
+ pushd build/vcpkg-root
+ git fetch https://github.com/Microsoft/vcpkg master
+ git reset --hard FETCH_HEAD
+ popd
+ else
+ mkdir -p build
+ git clone https://github.com/Microsoft/vcpkg build/vcpkg-root
+ fi
+
+ export VCPKG_ROOT=$(pwd)/build/vcpkg-root
+ export VCPKG_BINARY_SOURCES="clear;files,/opt/vcpkg.bsources,read;files,$(pwd)/build/vcpkg-binary-cache,readwrite"
+
+ mkdir -p "build/vcpkg-binary-cache"
+
+ echo -e "\e[0Ksection_end:`date +%s`:vcpkg-root\r\e[0K"
+
- - |
# apt_toolchain
echo -e "\e[0Ksection_start:`date +%s`:apt_toolchain[collapsed=true]\r\e[0KInstalling toolchain packages"
- - apt-get install gcc-mingw-w64-x86-64-win32
+ - apt-get install g++-mingw-w64-x86-64-win32
- |
# apt_toolchain
echo -e "\e[0Ksection_end:`date +%s`:apt_toolchain\r\e[0K"
+ - - |
+ # apt_development
+ echo -e "\e[0Ksection_start:`date +%s`:apt_development[collapsed=true]\r\e[0KInstalling development packages"
+ - apt-get install ninja-build
+ - |
+ # apt_development
+ echo -e "\e[0Ksection_end:`date +%s`:apt_development\r\e[0K"
+
+ - - |
+ # cmake
+ echo -e "\e[0Ksection_start:`date +%s`:cmake[collapsed=false]\r\e[0KBuilding Makefiles"
+ - cmake -B build.cmake -DSRB2_USE_CCACHE=NO -DSRB2_CONFIG_ERRORMODE=ON -DCMAKE_TOOLCHAIN_FILE=$VCPKG_ROOT/scripts/buildsystems/vcpkg.cmake -DVCPKG_TARGET_TRIPLET=x64-mingw-static -DVCPKG_CHAINLOAD_TOOLCHAIN_FILE=$VCPKG_ROOT/scripts/toolchains/mingw.cmake -G "Unix Makefiles"
+ - |
+ # cmake
+ echo -e "\e[0Ksection_end:`date +%s`:cmake\r\e[0K"
+
- - |
# make
echo -e "\e[0Ksection_start:`date +%s`:make[collapsed=false]\r\e[0KCompiling SRB2"
- - make --directory=src --keep-going CCACHE=1 ERRORMODE=1 MINGW64=1 SDL=1 || make --directory=src --keep-going CCACHE=1 ERRORMODE=1 MINGW64=1 SDL=1
+ - cmake --build build.cmake --parallel 1 --verbose
- |
# make
echo -e "\e[0Ksection_end:`date +%s`:make\r\e[0K"
+
+ after_script:
+ - - |
+ # apt_clean
+ echo -e "\e[0Ksection_start:`date +%s`:apt_clean[collapsed=true]\r\e[0KCleaning of unneeded APT packages"
+ - apt-get autoclean
+ - |
+ # apt_clean
+ echo -e "\e[0Ksection_end:`date +%s`:apt_clean\r\e[0K"
+
+ - - |
+ # vcpkg_clean
+ echo -e "\e[0Ksection_start:`date +%s`:vcpkg_clean[collapsed=true]\r\e[0KCleaning vcpkg-root"
+
+ if [ -d "build/vcpkg-root" ]; then
+ pushd "build/vcpkg-root"
+ git clean -f
+ popd
+ fi
+
+ echo -e "\e[0Ksection_end:`date +%s`:vcpkg_clean\r\e[0K"
+
+ - - |
+ # ccache_stats
+ echo -e "\e[0Ksection_start:`date +%s`:ccache_stats[collapsed=true]\r\e[0Kccache statistics:"
+ - ccache --show-stats
+ - ccache --show-log-stats || true
+ - |
+ # ccahe_stats
+ echo -e "\e[0Ksection_end:`date +%s`:ccache_stats\r\e[0K"
diff --git a/.gitlab/ci/jobs/windows-x86-makefile.yml b/.gitlab/ci/jobs/windows-x86-makefile.yml
new file mode 100644
index 0000000000000000000000000000000000000000..213342cda81e119827937a79df8b1f74242d7ef2
--- /dev/null
+++ b/.gitlab/ci/jobs/windows-x86-makefile.yml
@@ -0,0 +1,35 @@
+Windows x86 Makefile:
+ extends: .srb2ci
+
+ stage: build
+
+ when: on_success
+
+ artifacts:
+ paths:
+ - "bin/"
+ - "src/comptime.h"
+ expose_as: "Win32-makefile"
+ name: "$CI_PROJECT_PATH_SLUG-$CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA-Win32-makefile"
+
+ variables:
+ PREFIX: i686-w64-mingw32
+ CC: /usr/bin/i686-w64-mingw32-gcc-posix
+ CXX: /usr/bin/i686-w64-mingw32-g++-posix
+
+ script:
+ - - |
+ # apt_toolchain
+ echo -e "\e[0Ksection_start:`date +%s`:apt_toolchain[collapsed=true]\r\e[0KInstalling toolchain packages"
+ - apt-get install g++-mingw-w64-i686-win32
+ - |
+ # apt_toolchain
+ echo -e "\e[0Ksection_end:`date +%s`:apt_toolchain\r\e[0K"
+
+ - - |
+ # make
+ echo -e "\e[0Ksection_start:`date +%s`:make[collapsed=false]\r\e[0KCompiling SRB2"
+ - make --directory=src --keep-going CCACHE=1 ERRORMODE=1 MINGW=1 SDL=1 || make --directory=src --keep-going CCACHE=1 ERRORMODE=1 MINGW=1 SDL=1
+ - |
+ # make
+ echo -e "\e[0Ksection_end:`date +%s`:make\r\e[0K"
diff --git a/.gitlab/ci/jobs/windows-x86.yml b/.gitlab/ci/jobs/windows-x86.yml
index 311c767bbd9cd31d1063a248f68c0a6793dd47d5..9a33364b2830df79055838037563a2711fd51d04 100644
--- a/.gitlab/ci/jobs/windows-x86.yml
+++ b/.gitlab/ci/jobs/windows-x86.yml
@@ -3,33 +3,122 @@ Windows x86:
stage: build
- when: on_success
+ cache:
+ - key: ccache-$CI_JOB_NAME_SLUG-$CI_COMMIT_REF_SLUG
+ fallback_keys:
+ - ccache-$CI_JOB_NAME_SLUG-$CI_DEFAULT_BRANCH
+ - ccache-$CI_JOB_NAME_SLUG-master
+ paths:
+ - build/ccache
+ - build/ccache_statslog
+
+ - key: apt-$CI_JOB_IMAGE
+ paths:
+ - build/apt-cache
+ unprotect: true
+
+ - key: vcpkg-root
+ paths:
+ - build/vcpkg-root
+ unprotect: true
+
+ - key: vcpkg-binary-cache-x86-mingw-static
+ paths:
+ - build/vcpkg-binary-cache
+ unprotect: true
artifacts:
paths:
- - "bin/"
- - "src/comptime.h"
+ - "build.cmake/bin/"
+ - "build.cmake/src/config.h"
expose_as: "Win32"
name: "$CI_PROJECT_PATH_SLUG-$CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA-Win32"
variables:
PREFIX: i686-w64-mingw32
- CC: /usr/bin/i686-w64-mingw32-gcc-posix
- CXX: /usr/bin/i686-w64-mingw32-g++-posix
+ CC: /usr/lib/ccache/i686-w64-mingw32-gcc
+ CXX: /usr/lib/ccache/i686-w64-mingw32-g++
script:
+ - |
+ # vcpkg
+ echo -e "\e[0Ksection_start:`date +%s`:vcpkg-root[collapsed=true]\r\e[0KUpdating vcpkg"
+
+ if [ -d "build/vcpkg-root" ]; then
+ pushd build/vcpkg-root
+ git fetch https://github.com/Microsoft/vcpkg master
+ git reset --hard FETCH_HEAD
+ popd
+ else
+ mkdir -p build
+ git clone https://github.com/Microsoft/vcpkg build/vcpkg-root
+ fi
+
+ export VCPKG_ROOT=$(pwd)/build/vcpkg-root
+ export VCPKG_BINARY_SOURCES="clear;files,/opt/vcpkg.bsources,read;files,$(pwd)/build/vcpkg-binary-cache,readwrite"
+
+ mkdir -p "build/vcpkg-binary-cache"
+
+ echo -e "\e[0Ksection_end:`date +%s`:vcpkg-root\r\e[0K"
+
- - |
# apt_toolchain
echo -e "\e[0Ksection_start:`date +%s`:apt_toolchain[collapsed=true]\r\e[0KInstalling toolchain packages"
- - apt-get install gcc-mingw-w64-i686-win32
+ - apt-get install g++-mingw-w64-i686-win32
- |
# apt_toolchain
echo -e "\e[0Ksection_end:`date +%s`:apt_toolchain\r\e[0K"
+ - - |
+ # apt_development
+ echo -e "\e[0Ksection_start:`date +%s`:apt_development[collapsed=true]\r\e[0KInstalling development packages"
+ - apt-get install ninja-build
+ - |
+ # apt_development
+ echo -e "\e[0Ksection_end:`date +%s`:apt_development\r\e[0K"
+
+ - - |
+ # cmake
+ echo -e "\e[0Ksection_start:`date +%s`:cmake[collapsed=false]\r\e[0KBuilding Makefiles"
+ - cmake -B build.cmake -DSRB2_USE_CCACHE=NO -DSRB2_CONFIG_ERRORMODE=ON -DCMAKE_TOOLCHAIN_FILE=$VCPKG_ROOT/scripts/buildsystems/vcpkg.cmake -DVCPKG_TARGET_TRIPLET=x86-mingw-static -DVCPKG_CHAINLOAD_TOOLCHAIN_FILE=$VCPKG_ROOT/scripts/toolchains/mingw.cmake -G "Unix Makefiles"
+ - |
+ # cmake
+ echo -e "\e[0Ksection_end:`date +%s`:cmake\r\e[0K"
+
- - |
# make
echo -e "\e[0Ksection_start:`date +%s`:make[collapsed=false]\r\e[0KCompiling SRB2"
- - make --directory=src --keep-going CCACHE=1 ERRORMODE=1 MINGW=1 SDL=1 || make --directory=src --keep-going CCACHE=1 ERRORMODE=1 MINGW=1 SDL=1
+ - cmake --build build.cmake --parallel 1 --verbose
- |
# make
echo -e "\e[0Ksection_end:`date +%s`:make\r\e[0K"
+
+ after_script:
+ - - |
+ # apt_clean
+ echo -e "\e[0Ksection_start:`date +%s`:apt_clean[collapsed=true]\r\e[0KCleaning of unneeded APT packages"
+ - apt-get autoclean
+ - |
+ # apt_clean
+ echo -e "\e[0Ksection_end:`date +%s`:apt_clean\r\e[0K"
+
+ - - |
+ # vcpkg_clean
+ echo -e "\e[0Ksection_start:`date +%s`:vcpkg_clean[collapsed=true]\r\e[0KCleaning vcpkg-root"
+
+ if [ -d "build/vcpkg-root" ]; then
+ pushd "build/vcpkg-root"
+ git clean -f
+ popd
+ fi
+
+ echo -e "\e[0Ksection_end:`date +%s`:vcpkg_clean\r\e[0K"
+
+ - - |
+ # ccache_stats
+ echo -e "\e[0Ksection_start:`date +%s`:ccache_stats[collapsed=true]\r\e[0Kccache statistics:"
+ - ccache --show-stats
+ - ccache --show-log-stats || true
+ - |
+ # ccahe_stats
+ echo -e "\e[0Ksection_end:`date +%s`:ccache_stats\r\e[0K"
diff --git a/.gitlab/ci/templates/srb2ci.yml b/.gitlab/ci/templates/srb2ci.yml
index 3716d9df921407cb29081af301a5b6a3d92db459..bdf8a3ed66d8126559c25e5563da432da41932e0 100644
--- a/.gitlab/ci/templates/srb2ci.yml
+++ b/.gitlab/ci/templates/srb2ci.yml
@@ -61,7 +61,7 @@
- - |
# apt_update
echo -e "\e[0Ksection_start:`date +%s`:apt_update[collapsed=true]\r\e[0KUpdating APT listing"
- - apt-get update
+ - timeout 2m apt-get update || timeout 2m apt-get update
- |
# apt_update
echo -e "\e[0Ksection_end:`date +%s`:apt_update\r\e[0K"
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 3b08a9facc348aad76f77b55a5700b8929859333..a4c631102606ee3177c94f1bb7a35b100694bf4c 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -8,6 +8,7 @@ endif()
set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake/Modules/")
include(CMakeDependentOption)
+include(CheckCXXCompilerFlag)
file(STRINGS src/version.h SRB2_VERSION)
string(REGEX MATCH "[0-9]+\\.[0-9.]+" SRB2_VERSION ${SRB2_VERSION})
@@ -72,6 +73,7 @@ option(SRB2_CONFIG_MOBJCONSISTANCY "Compile with MOBJCONSISTANCY defined." OFF)
option(SRB2_CONFIG_PACKETDROP "Compile with PACKETDROP defined." OFF)
option(SRB2_CONFIG_EXECINFO "Enable stack trace dump support." ON)
option(SRB2_CONFIG_ZDEBUG "Compile with ZDEBUG defined." OFF)
+option(SRB2_CONFIG_FORCE_NO_MS_BITFIELDS "Compile without -mno-ms-bitfields compiler flag" OFF)
# SRB2_CONFIG_PROFILEMODE is probably superceded by some CMake setting.
option(SRB2_CONFIG_PROFILEMODE "Compile for profiling (GCC only)." OFF)
set(SRB2_CONFIG_ASSET_DIRECTORY "" CACHE PATH "Path to directory that contains all asset files for the installer. If set, assets will be part of installation and cpack.")
diff --git a/assets/CMakeLists.txt b/assets/CMakeLists.txt
index dfb2f4180db7dbbae9a454a6f939aeda9e6f26a4..68c84819513075a90e21917ce797acf893c2a40d 100644
--- a/assets/CMakeLists.txt
+++ b/assets/CMakeLists.txt
@@ -27,10 +27,10 @@ list(TRANSFORM SRB2_ASSETS_DOCS PREPEND "${SRB2_ASSET_DIRECTORY_ABSOLUTE}")
set(SRB2_ASSETS_GAME
"srb2.pk3"
- "player.dta"
+ "characters.pk3"
"zones.pk3"
"patch.pk3"
- "music.dta"
+ "music.pk3"
"models.dat"
)
list(TRANSFORM SRB2_ASSETS_GAME PREPEND "/")
diff --git a/assets/README.txt b/assets/README.txt
index e384333ed762459cd140fff13fdb777036d3d698..1ddacc999d7bde07f18e9c4fbb9041467dbda619 100644
--- a/assets/README.txt
+++ b/assets/README.txt
@@ -33,13 +33,10 @@ https://discord.gg/b3BGb8A
Twitter:
https://twitter.com/SonicTeamJr
-Facebook:
-https://facebook.com/SonicRoboBlast2
-
COPYRIGHT AND DISCLAIMER
-Design and content in Sonic Robo Blast 2 is copyright 1998-2023 by Sonic Team Jr.
+Design and content in Sonic Robo Blast 2 is copyright 1998-2025 by Sonic Team Jr.
All original material in this game is copyrighted by their respective owners, and no copyright infringement is intended. Sonic Team Jr. is in no way affiliated with SEGA or Sonic Team, and we do not claim ownership of any of SEGA's intellectual property used in SRB2.
diff --git a/assets/debian-template/copyright b/assets/debian-template/copyright
index cc47c453bf2b0ccc6db34c57a03dfe1ce2fc75a7..71d2cf583d6e6e624ad7a12638ea65df775f4223 100644
--- a/assets/debian-template/copyright
+++ b/assets/debian-template/copyright
@@ -12,7 +12,7 @@ Upstream Author(s):
Copyright:
- Copyright (C) 1998-2018 by Sonic Team Junior
+ Copyright (C) 1998-2025 by Sonic Team Junior
License:
@@ -21,7 +21,7 @@ License:
The Debian packaging is:
Copyright (C) 2010 Callum Dickinson <gcfreak_ag20@hotmail.com>
- Copyright (C) 2010-2018 by Sonic Team Junior <stjr@srb2.org>
+ Copyright (C) 2010-2025 by Sonic Team Junior <stjr@srb2.org>
and is licensed under the GPL version 2,
see "/usr/share/common-licenses/GPL-2".
diff --git a/cmake/Modules/Findlibopenmpt.cmake b/cmake/Modules/Findlibopenmpt.cmake
index d7de22134831c1e0edc8b3b6e62ed42abd69287f..96cc3102677c0639bed76fe28cf60efd13e63429 100644
--- a/cmake/Modules/Findlibopenmpt.cmake
+++ b/cmake/Modules/Findlibopenmpt.cmake
@@ -1,14 +1,16 @@
include(LibFindMacros)
-libfind_pkg_check_modules(libopenmpt_PKGCONF openmpt)
+libfind_pkg_check_modules(libopenmpt_PKGCONF openmpt libopenmpt)
find_path(libopenmpt_INCLUDE_DIR
NAMES libopenmpt.h
PATHS
${libopenmpt_PKGCONF_INCLUDE_DIRS}
- "${VCPKG_INSTALLED_DIR}/${VCPKG_TARGET_TRIPLET}/include/libopenmpt"
- "/usr/include/libopenmpt"
- "/usr/local/include/libopenmpt"
+ "${VCPKG_INSTALLED_DIR}/${VCPKG_TARGET_TRIPLET}/include"
+ "/usr/include"
+ "/usr/local/include"
+ PATH_SUFFIXES
++ libopenmpt
)
find_library(libopenmpt_LIBRARY
diff --git a/debian-template/copyright b/debian-template/copyright
index cc47c453bf2b0ccc6db34c57a03dfe1ce2fc75a7..71d2cf583d6e6e624ad7a12638ea65df775f4223 100644
--- a/debian-template/copyright
+++ b/debian-template/copyright
@@ -12,7 +12,7 @@ Upstream Author(s):
Copyright:
- Copyright (C) 1998-2018 by Sonic Team Junior
+ Copyright (C) 1998-2025 by Sonic Team Junior
License:
@@ -21,7 +21,7 @@ License:
The Debian packaging is:
Copyright (C) 2010 Callum Dickinson <gcfreak_ag20@hotmail.com>
- Copyright (C) 2010-2018 by Sonic Team Junior <stjr@srb2.org>
+ Copyright (C) 2010-2025 by Sonic Team Junior <stjr@srb2.org>
and is licensed under the GPL version 2,
see "/usr/share/common-licenses/GPL-2".
diff --git a/extras/conf/SRB2-22.cfg b/extras/conf/SRB2-22.cfg
index 41ad998891154f56fe850cdfe457a48189dd648f..7ef5ab1e170dcb00041a0a341a8d7a82da0072d2 100644
--- a/extras/conf/SRB2-22.cfg
+++ b/extras/conf/SRB2-22.cfg
@@ -41,7 +41,7 @@ linetagindicatesectors = true;
// The format interface handles the map data format - DoomMapSetIO for SRB2DB2, SRB2MapSetIO for Zone Builder
formatinterface = "SRB2MapSetIO";
-
+
//Maximum safe map size check (0 means skip check)
safeboundary = 0;
@@ -502,7 +502,7 @@ gen_sectortypes
{
0 = "Normal";
512 = "Wind/Current <deprecated>";
- 1024 = "Conveyor Belt <deprecated>";
+ 1024 = "Conveyor Belt <deprecated>";
1280 = "Speed Pad";
1536 = "Flip Gravity on Jump";
}
@@ -3730,7 +3730,7 @@ thingtypes
3328 = "3D Mode Start";
}
-
+
starts
{
color = 1; // Blue
diff --git a/extras/conf/udb/Includes/SRB222_common.cfg b/extras/conf/udb/Includes/SRB222_common.cfg
index e5cafead431c0d79eaaef734eee008eeab89dd15..9bf882f56a11346709b7c7c263e37dd86ffad173 100644
--- a/extras/conf/udb/Includes/SRB222_common.cfg
+++ b/extras/conf/udb/Includes/SRB222_common.cfg
@@ -96,7 +96,7 @@ mapformat_udmf
{
include("SRB222_misc.cfg", "universalfields");
}
-
+
// Disable Doom-related modes that don't make sense for SRB2
soundsupport = false;
automapsupport = false;
@@ -195,4 +195,4 @@ mapformat_udmf
{
include("SRB222_linedefs.cfg", "udmf");
}
-}
\ No newline at end of file
+}
diff --git a/extras/conf/udb/Includes/SRB222_linedefs.cfg b/extras/conf/udb/Includes/SRB222_linedefs.cfg
index fc505fb6025b02782d1a309b247f569a63dd96fd..ce1979581fb7e1251ad76882154eab80ec204f06 100644
--- a/extras/conf/udb/Includes/SRB222_linedefs.cfg
+++ b/extras/conf/udb/Includes/SRB222_linedefs.cfg
@@ -8,7 +8,7 @@ udmf
{
title = "None";
}
-
+
6
{
title = "Sector Set Portal";
@@ -897,7 +897,7 @@ udmf
}
}
}
-
+
190
{
title = "Rising";
diff --git a/extras/conf/udb/Includes/SRB222_misc.cfg b/extras/conf/udb/Includes/SRB222_misc.cfg
index c37c29ce0def1f471565d7d4494ac7ab833eb054..e5786977bd4e9c3a543c2113d0f20fa8b84939a1 100644
--- a/extras/conf/udb/Includes/SRB222_misc.cfg
+++ b/extras/conf/udb/Includes/SRB222_misc.cfg
@@ -240,7 +240,7 @@ universalfields
type = 1;
default = 1.0;
}
-
+
comment
{
type = 2;
@@ -252,19 +252,19 @@ universalfields
type = 2;
default = "";
}
-
+
stringarg0
{
type = 2;
default = "";
}
-
+
stringarg1
{
type = 2;
default = "";
}
-
+
executordelay
{
type = 0;
@@ -279,19 +279,19 @@ universalfields
type = 2;
default = "";
}
-
+
light
{
type = 0;
default = 0;
}
-
+
lightabsolute
{
type = 3;
default = false;
}
-
+
//light_top
//{
// type = 0;
@@ -326,8 +326,8 @@ universalfields
//{
// type = 3;
// default = false;
- //}
-
+ //}
+
offsetx_bottom
{
type = 1;
@@ -339,7 +339,7 @@ universalfields
type = 1;
default = 0.0;
}
-
+
offsetx_top
{
type = 1;
@@ -357,43 +357,43 @@ universalfields
type = 1;
default = 0.0;
}
-
+
offsety_top
{
type = 1;
default = 0.0;
}
-
+
scalex_bottom
{
type = 1;
default = 1.0;
}
-
+
scalex_mid
{
type = 1;
default = 1.0;
}
-
+
scalex_top
{
type = 1;
default = 1.0;
}
-
+
scaley_bottom
{
type = 1;
default = 1.0;
}
-
+
scaley_mid
{
type = 1;
default = 1.0;
}
-
+
scaley_top
{
type = 1;
@@ -408,41 +408,41 @@ universalfields
type = 2;
default = "";
}
-
+
pitch
{
type = 0;
}
-
+
roll
{
type = 0;
}
-
+
scalex
{
type = 1;
default = 1.0;
}
-
+
scaley
{
type = 1;
default = 1.0;
}
-
+
stringarg0
{
type = 2;
default = "";
}
-
+
stringarg1
{
type = 2;
default = "";
}
-
+
mobjscale
{
type = 1;
@@ -450,7 +450,7 @@ universalfields
managed = false;
}
}
-
+
sector
{
comment
@@ -530,7 +530,7 @@ universalfields
type = 1;
default = 1.0;
}
-
+
yscalefloor
{
type = 1;
@@ -542,7 +542,7 @@ universalfields
type = 0;
default = 0;
}
-
+
lightfloorabsolute
{
type = 3;
@@ -572,7 +572,7 @@ universalfields
type = 1;
default = 1.0;
}
-
+
yscaleceiling
{
type = 1;
@@ -584,7 +584,7 @@ universalfields
type = 0;
default = 0;
}
-
+
lightceilingabsolute
{
type = 3;
diff --git a/extras/conf/udb/Includes/SRB222_things.cfg b/extras/conf/udb/Includes/SRB222_things.cfg
index c028f9439c493d156e1ded87f7a116cc4b14d9d7..8b1e29751b7bb4b3e771813b414d80f9017a4f68 100644
--- a/extras/conf/udb/Includes/SRB222_things.cfg
+++ b/extras/conf/udb/Includes/SRB222_things.cfg
@@ -1127,12 +1127,12 @@ udmf
}
}
}
-
+
bossinvisibles
{
title = "Misc. Invisible";
color = 15; // White
-
+
290
{
arrow = 0;
@@ -2021,7 +2021,7 @@ udmf
}
}
}
-
+
hazards
{
color = 17; // Orange
@@ -2983,7 +2983,7 @@ udmf
{
title = "Mace Spawnpoints";
color = 11;
-
+
1104
{
title = "Mace Spawn";
@@ -3188,7 +3188,7 @@ udmf
title = "Flags";
type = 12;
enum = "maceflags";
-
+
}
}
1108
@@ -3320,7 +3320,7 @@ udmf
}
}
}
-
+
1100
{
title = "Chain (Decorative)";
@@ -3570,12 +3570,12 @@ udmf
color = 2; // Green
title = "Arid Canyon";
-
+
cacti
{
title = "Cacti";
color = 17;
-
+
1203
{
title = "Tiny Red Flower Cactus";
@@ -3654,12 +3654,12 @@ udmf
height = 60;
}
}
-
+
minecarts
{
title = "Minecart";
color = 11;
-
+
1219
{
title = "Minecart Spawner";
@@ -3706,7 +3706,7 @@ udmf
}
}
}
-
+
1200
{
title = "Tumbleweed (Big)";
@@ -4611,7 +4611,7 @@ udmf
title = "Botanic Serenity";
width = 16;
height = 32;
-
+
flowers
{
title = "Flowers";
@@ -4706,7 +4706,7 @@ udmf
sprite = "BSZ3F0";
}
}
-
+
tulips
{
title = "Tulips";
@@ -4771,7 +4771,7 @@ udmf
sprite = "BSZ5F0";
}
}
-
+
bushes
{
title = "Bushes";
@@ -4806,7 +4806,7 @@ udmf
sprite = "BSZ6F0";
}
}
-
+
vines
{
title = "Vines";
@@ -5063,7 +5063,7 @@ udmf
}
}
}
-
+
mario
{
color = 2; // Green
@@ -5574,7 +5574,7 @@ udmf
}
}
}
-
+
editor
{
color = 15; // White
@@ -5587,4 +5587,4 @@ udmf
3328 = "3D Mode Start";
}
-}
\ No newline at end of file
+}
diff --git a/extras/conf/udb/SRB2-22binary.cfg b/extras/conf/udb/SRB2-22binary.cfg
index 3073b76c4570cb9a8f7f62a3e675cbffc7814614..2144ff7a61591b1c9a6865013cd44499179f2183 100644
--- a/extras/conf/udb/SRB2-22binary.cfg
+++ b/extras/conf/udb/SRB2-22binary.cfg
@@ -41,7 +41,7 @@ linetagindicatesectors = true;
// The format interface handles the map data format - DoomMapSetIO for SRB2DB2, SRB2MapSetIO for Zone Builder
formatinterface = "DoomMapSetIO";
-
+
//Maximum safe map size check (0 means skip check)
safeboundary = 0;
@@ -502,7 +502,7 @@ gen_sectortypes
{
0 = "Normal";
512 = "Wind/Current <deprecated>";
- 1024 = "Conveyor Belt <deprecated>";
+ 1024 = "Conveyor Belt <deprecated>";
1280 = "Speed Pad";
1536 = "Flip Gravity on Jump";
}
@@ -3636,7 +3636,7 @@ thingtypes
3328 = "3D Mode Start";
}
-
+
starts
{
color = 1; // Blue
diff --git a/scripts/arm64-osx-1015.cmake b/scripts/arm64-osx-1015.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..224430bc1fe787c70db8480cf86e84f1e8bcb637
--- /dev/null
+++ b/scripts/arm64-osx-1015.cmake
@@ -0,0 +1,7 @@
+set(VCPKG_TARGET_ARCHITECTURE arm64)
+set(VCPKG_OSX_DEPLOYMENT_TARGET 10.15)
+set(VCPKG_CRT_LINKAGE dynamic)
+set(VCPKG_LIBRARY_LINKAGE static)
+
+set(VCPKG_CMAKE_SYSTEM_NAME Darwin)
+set(VCPKG_OSX_ARCHITECTURES arm64)
diff --git a/scripts/make-macos-universal.sh b/scripts/make-macos-universal.sh
new file mode 100755
index 0000000000000000000000000000000000000000..f1b17516c16fec2d333e5bfc9e3cc9fbfadb0499
--- /dev/null
+++ b/scripts/make-macos-universal.sh
@@ -0,0 +1,25 @@
+#!/usr/bin/env bash
+
+# Makes a fused macOS Universal app bundle in the arm64 release preset dir
+# Only works if in master branch or in source tarball
+
+set -e
+
+rm -rf "build/ninja-x64_osx_vcpkg-release"
+rm -rf "build/ninja-arm64_osx_vcpkg-release"
+cmake --preset ninja-x64_osx_vcpkg-release -DVCPKG_OVERLAY_TRIPLETS=scripts/ -DVCPKG_TARGET_TRIPLET=x64-osx-1015 -DCMAKE_OSX_ARCHITECTURES=x86_64 -DCMAKE_OSX_DEPLOYMENT_TARGET=10.15 "-DSRB2_SDL2_EXE_NAME=srb2"
+cmake --build --preset ninja-x64_osx_vcpkg-release
+cmake --preset ninja-arm64_osx_vcpkg-release -DVCPKG_OVERLAY_TRIPLETS=scripts/ -DVCPKG_TARGET_TRIPLET=arm64-osx-1015 -DCMAKE_OSX_ARCHITECTURES=arm64 -DCMAKE_OSX_DEPLOYMENT_TARGET=10.15 "-DSRB2_SDL2_EXE_NAME=srb2"
+cmake --build --preset ninja-arm64_osx_vcpkg-release
+
+mkdir -p build/dist
+rm -rf "build/dist/Sonic Robo Blast 2.app" "build/dist/srb2.app"
+
+cp -r build/ninja-arm64_osx_vcpkg-release/bin/srb2.app build/dist/
+
+lipo -create \
+ -output "build/dist/srb2.app/Contents/MacOS/srb2" \
+ build/ninja-x64_osx_vcpkg-release/bin/srb2.app/Contents/MacOS/srb2 \
+ build/ninja-arm64_osx_vcpkg-release/bin/srb2.app/Contents/MacOS/srb2
+
+mv build/dist/srb2.app "build/dist/Sonic Robo Blast 2.app"
diff --git a/scripts/x64-osx-1015.cmake b/scripts/x64-osx-1015.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..5f0c7b66e0e4c1c9969ed6963ddcc99cef9db64c
--- /dev/null
+++ b/scripts/x64-osx-1015.cmake
@@ -0,0 +1,7 @@
+set(VCPKG_TARGET_ARCHITECTURE x64)
+set(VCPKG_OSX_DEPLOYMENT_TARGET 10.15)
+set(VCPKG_CRT_LINKAGE dynamic)
+set(VCPKG_LIBRARY_LINKAGE static)
+
+set(VCPKG_CMAKE_SYSTEM_NAME Darwin)
+set(VCPKG_OSX_ARCHITECTURES x86_64)
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 20caecf7bd6a65a20631318799016da319d3f13d..fbc34173390a1be01be3058772629779558f5c4a 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -172,6 +172,11 @@ if("${CMAKE_SYSTEM_NAME}" MATCHES "Linux")
endif()
endif()
+if("${CMAKE_SYSTEM_NAME}" MATCHES "Haiku")
+ target_compile_definitions(SRB2SDL2 PRIVATE -DNOEXECINFO)
+ target_link_libraries(SRB2SDL2 PRIVATE network)
+endif()
+
if("${CMAKE_SYSTEM_NAME}" MATCHES "Darwin")
target_compile_definitions(SRB2SDL2 PRIVATE -DMACOSX)
endif()
@@ -229,9 +234,12 @@ endif()
# Compatibility flag with later versions of GCC
# We should really fix our code to not need this
-if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
- if (CMAKE_SYSTEM_PROCESSOR MATCHES "^(x86_64|x64|amd64|AMD64|em64t|EM64T)")
- target_compile_options(SRB2SDL2 PRIVATE -mno-ms-bitfields)
+if (NOT SRB2_CONFIG_FORCE_NO_MS_BITFIELDS)
+ if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+ check_cxx_compiler_flag("-mno-ms-bitfields" HAS_NO_MS_BITFIELDS)
+ if(HAS_NO_MS_BITFIELDS)
+ target_compile_options(SRB2SDL2 PRIVATE -mno-ms-bitfields)
+ endif()
endif()
endif()
@@ -456,8 +464,13 @@ else()
endif()
if(TARGET miniupnpc::miniupnpc)
- target_compile_definitions(SRB2SDL2 PRIVATE -DHAVE_MINIUPNPC)
- target_link_libraries(SRB2SDL2 PRIVATE miniupnpc::miniupnpc)
+ if("${VCPKG_TARGET_TRIPLET}" MATCHES "-mingw-static$")
+ target_compile_definitions(SRB2SDL2 PRIVATE -DHAVE_MINIUPNPC -DMINIUPNP_STATICLIB)
+ target_link_libraries(SRB2SDL2 PRIVATE miniupnpc::miniupnpc -liphlpapi)
+ else()
+ target_compile_definitions(SRB2SDL2 PRIVATE -DHAVE_MINIUPNPC)
+ target_link_libraries(SRB2SDL2 PRIVATE miniupnpc::miniupnpc)
+ endif()
message(STATUS "miniupnpc Found")
else()
message(STATUS "No miniupnpc Found")
diff --git a/src/Makefile.d/detect.mk b/src/Makefile.d/detect.mk
index 9e27369462b00c407f02cb95dbda22ef284a91d1..853ad3d6df728d7c69ea64b204cf099547f59e45 100644
--- a/src/Makefile.d/detect.mk
+++ b/src/Makefile.d/detect.mk
@@ -4,7 +4,6 @@
# Previously featured:\
PANDORA\
- HAIKU\
DUMMY\
DJGPPDOS\
SOLARIS\
@@ -17,6 +16,7 @@ all_systems:=\
UNIX\
LINUX\
FREEBSD\
+ HAIKU\
# check for user specified system
ifeq (,$(filter $(all_systems),$(.VARIABLES)))
@@ -35,6 +35,8 @@ system:=$(shell uname -s)
ifeq ($(system),Linux)
new_system:=LINUX
+else ifeq ($(system),Haiku)
+new_system:=HAIKU
else
$(error \
diff --git a/src/Makefile.d/haiku.mk b/src/Makefile.d/haiku.mk
new file mode 100644
index 0000000000000000000000000000000000000000..6742ec75b58f992a916a99752c72ca827f4dab5e
--- /dev/null
+++ b/src/Makefile.d/haiku.mk
@@ -0,0 +1,71 @@
+#
+# Makefile options for Haiku
+#
+
+opts+=-DUNIXCOMMON -DLUA_USE_POSIX
+
+ifndef DEDICATED
+ifndef DUMMY
+SDL?=1
+DEDICATED?=0
+endif
+endif
+
+NOEXECINFO=1
+
+ifeq (${SDL},1)
+EXENAME?=srb2haiku
+else ifeq (${DEDICATED},1)
+EXENAME?=srb2haikud
+endif
+
+ifndef NONET
+libs+=-lnetwork
+endif
+
+define _set =
+$(1)_CFLAGS?=$($(1)_opts)
+$(1)_LDFLAGS?=$($(1)_libs)
+endef
+
+lib:=../libs/gme
+LIBGME_opts:=-I$(lib)/include
+LIBGME_libs:=-l:libgme.so.0
+$(eval $(call _set,LIBGME))
+
+lib:=../libs/libopenmpt
+LIBOPENMPT_opts:=-I$(lib)/inc
+LIBOPENMPT_libs:=-l:libopenmpt.so.0
+$(eval $(call _set,LIBOPENMPT))
+
+ifdef SDL
+lib:=../libs/SDL2_mixer
+mixer_opts:=-I$(lib)/include
+mixer_libs:=-l:libSDL2_mixer-2.0.so.0
+
+lib:=../libs/SDL2
+SDL_opts:=-I$(lib)/include $(mixer_opts)
+SDL_libs:=$(mixer_libs) -l:libSDL2-2.0.so.0
+$(eval $(call _set,SDL))
+endif
+
+lib:=../libs/zlib
+ZLIB_opts:=-I$(lib)
+ZLIB_libs:=-l:libz.so.1
+$(eval $(call _set,ZLIB))
+
+ifndef PNG_CONFIG
+PNG_opts:=
+PNG_libs:=-l:libpng16.so.16
+$(eval $(call _set,PNG))
+endif
+
+lib:=../libs/curl
+CURL_opts:=-I$(lib)/include
+CURL_libs:=-l:libcurl.so.4
+$(eval $(call _set,CURL))
+
+lib:=../libs/miniupnpc
+MINIUPNPC_opts:=-I$(lib)/include
+MINIUPNPC_libs:=-l:libminiupnpc.so.17
+$(eval $(call _set,MINIUPNPC))
diff --git a/src/Makefile.d/platform.mk b/src/Makefile.d/platform.mk
index d9a2954f60c54b30c121c0467022c1707f720fc0..d5423a397384922689260546b71948447846f3e1 100644
--- a/src/Makefile.d/platform.mk
+++ b/src/Makefile.d/platform.mk
@@ -35,6 +35,10 @@ endif
else ifdef FREEBSD
UNIX=1
platform=freebsd
+else ifdef HAIKU
+# Give Haiku its own configuration, since it
+# isn't actually UNIX.
+include Makefile.d/haiku.mk
else ifdef SOLARIS # FIXME: UNTESTED
UNIX=1
platform=solaris
diff --git a/src/Makefile.d/sdl.mk b/src/Makefile.d/sdl.mk
index a1bfa33038bbacebada85790a7565fceb9440985..d5e83989c2d1955146a8c228c15034d9f2b9e091 100644
--- a/src/Makefile.d/sdl.mk
+++ b/src/Makefile.d/sdl.mk
@@ -33,11 +33,13 @@ else
opts+=-DHAVE_MIXER
sources+=sdl/mixer_sound.c
- ifdef HAVE_MIXERX
- opts+=-DHAVE_MIXERX
- libs+=-lSDL2_mixer_ext
- else
- libs+=-lSDL2_mixer
+ ifndef HAIKU # Haiku has a special import path
+ ifdef HAVE_MIXERX
+ opts+=-DHAVE_MIXERX
+ libs+=-lSDL2_mixer_ext
+ else
+ libs+=-lSDL2_mixer
+ endif
endif
endif
diff --git a/src/am_map.c b/src/am_map.c
index df3a45cfff504e046ddaa6ecc03cf9f9d548e45f..36b62f2f9b0157c58a2becd8b55624302d29ae0b 100644
--- a/src/am_map.c
+++ b/src/am_map.c
@@ -1076,6 +1076,9 @@ static inline void AM_drawPlayers(void)
if (!playeringame[i] || players[i].spectator)
continue;
+ if (!players[i].mo)
+ continue;
+
p = &players[i];
if (p->skincolor > 0)
color = R_GetTranslationColormap(TC_DEFAULT, p->skincolor, GTC_CACHE)[GREENS + 8];
diff --git a/src/b_bot.c b/src/b_bot.c
index 6229cb1d61893b328e667ba357fbbefe333e51f4..97dcd1078dfd91f9c5caf03c352420cbc98198de 100644
--- a/src/b_bot.c
+++ b/src/b_bot.c
@@ -1,7 +1,7 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
// Copyright (C) 2007-2016 by John "JTE" Muniz.
-// Copyright (C) 2011-2023 by Sonic Team Junior.
+// Copyright (C) 2011-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
diff --git a/src/blua/CMakeLists.txt b/src/blua/CMakeLists.txt
index 892bf534addc810434bdd00960ebe7a92ef7bde4..21278f2bbb1dc75b1e004d6b234d757776f07904 100644
--- a/src/blua/CMakeLists.txt
+++ b/src/blua/CMakeLists.txt
@@ -1,6 +1,7 @@
target_sources(SRB2SDL2 PRIVATE
lapi.c
lbaselib.c
+ ldblib.c
ldo.c
lfunc.c
linit.c
diff --git a/src/blua/Sourcefile b/src/blua/Sourcefile
index dae94310981fce03d6aefd30b6e7e5781a4a4eae..2b6b9636604844687b3837cf18b30781512f184b 100644
--- a/src/blua/Sourcefile
+++ b/src/blua/Sourcefile
@@ -1,6 +1,7 @@
lapi.c
lbaselib.c
ldo.c
+ldblib.c
lfunc.c
linit.c
liolib.c
diff --git a/src/blua/ldblib.c b/src/blua/ldblib.c
new file mode 100644
index 0000000000000000000000000000000000000000..2eacef929bedd4e3e034158542a09dc13431f10d
--- /dev/null
+++ b/src/blua/ldblib.c
@@ -0,0 +1,310 @@
+/*
+** $Id: ldblib.c,v 1.104.1.4 2009/08/04 18:50:18 roberto Exp $
+** Interface from Lua to its debug API
+** See Copyright Notice in lua.h
+*/
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define ldblib_c
+#define LUA_LIB
+
+#include "lua.h"
+
+#include "lauxlib.h"
+#include "lualib.h"
+
+
+
+static void settabss (lua_State *L, const char *i, const char *v) {
+ lua_pushstring(L, v);
+ lua_setfield(L, -2, i);
+}
+
+
+static void settabsi (lua_State *L, const char *i, int v) {
+ lua_pushinteger(L, v);
+ lua_setfield(L, -2, i);
+}
+
+
+static lua_State *getthread (lua_State *L, int *arg) {
+ if (lua_isthread(L, 1)) {
+ *arg = 1;
+ return lua_tothread(L, 1);
+ }
+ else {
+ *arg = 0;
+ return L;
+ }
+}
+
+
+static void treatstackoption (lua_State *L, lua_State *L1, const char *fname) {
+ if (L == L1) {
+ lua_pushvalue(L, -2);
+ lua_remove(L, -3);
+ }
+ else
+ lua_xmove(L1, L, 1);
+ lua_setfield(L, -2, fname);
+}
+
+
+static int db_getinfo (lua_State *L) {
+ lua_Debug ar;
+ int arg;
+ lua_State *L1 = getthread(L, &arg);
+ const char *options = luaL_optstring(L, arg+2, "flnSu");
+ if (lua_isnumber(L, arg+1)) {
+ if (!lua_getstack(L1, (int)lua_tointeger(L, arg+1), &ar)) {
+ lua_pushnil(L); /* level out of range */
+ return 1;
+ }
+ }
+ else if (lua_isfunction(L, arg+1)) {
+ lua_pushfstring(L, ">%s", options);
+ options = lua_tostring(L, -1);
+ lua_pushvalue(L, arg+1);
+ lua_xmove(L, L1, 1);
+ }
+ else
+ return luaL_argerror(L, arg+1, "function or level expected");
+ if (!lua_getinfo(L1, options, &ar))
+ return luaL_argerror(L, arg+2, "invalid option");
+ lua_createtable(L, 0, 2);
+ if (strchr(options, 'S')) {
+ settabss(L, "source", ar.source);
+ settabss(L, "short_src", ar.short_src);
+ settabsi(L, "linedefined", ar.linedefined);
+ settabsi(L, "lastlinedefined", ar.lastlinedefined);
+ settabss(L, "what", ar.what);
+ }
+ if (strchr(options, 'l'))
+ settabsi(L, "currentline", ar.currentline);
+ if (strchr(options, 'u'))
+ settabsi(L, "nups", ar.nups);
+ if (strchr(options, 'n')) {
+ settabss(L, "name", ar.name);
+ settabss(L, "namewhat", ar.namewhat);
+ }
+ if (strchr(options, 'L'))
+ treatstackoption(L, L1, "activelines");
+ if (strchr(options, 'f'))
+ treatstackoption(L, L1, "func");
+ return 1; /* return table */
+}
+
+
+static int db_getlocal (lua_State *L) {
+ int arg;
+ lua_State *L1 = getthread(L, &arg);
+ lua_Debug ar;
+ const char *name;
+ if (!lua_getstack(L1, luaL_checkint(L, arg+1), &ar)) /* out of range? */
+ return luaL_argerror(L, arg+1, "level out of range");
+ name = lua_getlocal(L1, &ar, luaL_checkint(L, arg+2));
+ if (name) {
+ lua_xmove(L1, L, 1);
+ lua_pushstring(L, name);
+ lua_pushvalue(L, -2);
+ return 2;
+ }
+ else {
+ lua_pushnil(L);
+ return 1;
+ }
+}
+
+
+static int auxupvalue (lua_State *L, int get) {
+ const char *name;
+ int n = luaL_checkint(L, 2);
+ luaL_checktype(L, 1, LUA_TFUNCTION);
+ if (lua_iscfunction(L, 1)) return 0; /* cannot touch C upvalues from Lua */
+ name = get ? lua_getupvalue(L, 1, n) : lua_setupvalue(L, 1, n);
+ if (name == NULL) return 0;
+ lua_pushstring(L, name);
+ lua_insert(L, -(get+1));
+ return get + 1;
+}
+
+
+static int db_getupvalue (lua_State *L) {
+ return auxupvalue(L, 1);
+}
+
+
+
+static char KEY_HOOK = 'h';
+
+
+static void hookf (lua_State *L, lua_Debug *ar) {
+ static const char *const hooknames[] =
+ {"call", "return", "line", "count", "tail return"};
+ lua_pushlightuserdata(L, (void *)&KEY_HOOK);
+ lua_rawget(L, LUA_REGISTRYINDEX);
+ lua_pushlightuserdata(L, L);
+ lua_rawget(L, -2);
+ if (lua_isfunction(L, -1)) {
+ lua_pushstring(L, hooknames[(int)ar->event]);
+ if (ar->currentline >= 0)
+ lua_pushinteger(L, ar->currentline);
+ else lua_pushnil(L);
+ lua_assert(lua_getinfo(L, "lS", ar));
+ lua_call(L, 2, 0);
+ }
+}
+
+
+static int makemask (const char *smask, int count) {
+ int mask = 0;
+ if (strchr(smask, 'c')) mask |= LUA_MASKCALL;
+ if (strchr(smask, 'r')) mask |= LUA_MASKRET;
+ if (strchr(smask, 'l')) mask |= LUA_MASKLINE;
+ if (count > 0) mask |= LUA_MASKCOUNT;
+ return mask;
+}
+
+
+static char *unmakemask (int mask, char *smask) {
+ int i = 0;
+ if (mask & LUA_MASKCALL) smask[i++] = 'c';
+ if (mask & LUA_MASKRET) smask[i++] = 'r';
+ if (mask & LUA_MASKLINE) smask[i++] = 'l';
+ smask[i] = '\0';
+ return smask;
+}
+
+
+static void gethooktable (lua_State *L) {
+ lua_pushlightuserdata(L, (void *)&KEY_HOOK);
+ lua_rawget(L, LUA_REGISTRYINDEX);
+ if (!lua_istable(L, -1)) {
+ lua_pop(L, 1);
+ lua_createtable(L, 0, 1);
+ lua_pushlightuserdata(L, (void *)&KEY_HOOK);
+ lua_pushvalue(L, -2);
+ lua_rawset(L, LUA_REGISTRYINDEX);
+ }
+}
+
+
+static int db_sethook (lua_State *L) {
+ int arg, mask, count;
+ lua_Hook func;
+ lua_State *L1 = getthread(L, &arg);
+ if (lua_isnoneornil(L, arg+1)) {
+ lua_settop(L, arg+1);
+ func = NULL; mask = 0; count = 0; /* turn off hooks */
+ }
+ else {
+ const char *smask = luaL_checkstring(L, arg+2);
+ luaL_checktype(L, arg+1, LUA_TFUNCTION);
+ count = luaL_optint(L, arg+3, 0);
+ func = hookf; mask = makemask(smask, count);
+ }
+ gethooktable(L);
+ lua_pushlightuserdata(L, L1);
+ lua_pushvalue(L, arg+1);
+ lua_rawset(L, -3); /* set new hook */
+ lua_pop(L, 1); /* remove hook table */
+ lua_sethook(L1, func, mask, count); /* set hooks */
+ return 0;
+}
+
+
+static int db_gethook (lua_State *L) {
+ int arg;
+ lua_State *L1 = getthread(L, &arg);
+ char buff[5];
+ int mask = lua_gethookmask(L1);
+ lua_Hook hook = lua_gethook(L1);
+ if (hook != NULL && hook != hookf) /* external hook? */
+ lua_pushliteral(L, "external hook");
+ else {
+ gethooktable(L);
+ lua_pushlightuserdata(L, L1);
+ lua_rawget(L, -2); /* get hook */
+ lua_remove(L, -2); /* remove hook table */
+ }
+ lua_pushstring(L, unmakemask(mask, buff));
+ lua_pushinteger(L, lua_gethookcount(L1));
+ return 3;
+}
+
+
+#define LEVELS1 12 /* size of the first part of the stack */
+#define LEVELS2 10 /* size of the second part of the stack */
+
+static int db_errorfb (lua_State *L) {
+ int level;
+ int firstpart = 1; /* still before eventual `...' */
+ int arg;
+ lua_State *L1 = getthread(L, &arg);
+ lua_Debug ar;
+ if (lua_isnumber(L, arg+2)) {
+ level = (int)lua_tointeger(L, arg+2);
+ lua_pop(L, 1);
+ }
+ else
+ level = (L == L1) ? 1 : 0; /* level 0 may be this own function */
+ if (lua_gettop(L) == arg)
+ lua_pushliteral(L, "");
+ else if (!lua_isstring(L, arg+1)) return 1; /* message is not a string */
+ else lua_pushliteral(L, "\n");
+ lua_pushliteral(L, "stack traceback:");
+ while (lua_getstack(L1, level++, &ar)) {
+ if (level > LEVELS1 && firstpart) {
+ /* no more than `LEVELS2' more levels? */
+ if (!lua_getstack(L1, level+LEVELS2, &ar))
+ level--; /* keep going */
+ else {
+ lua_pushliteral(L, "\n\t..."); /* too many levels */
+ while (lua_getstack(L1, level+LEVELS2, &ar)) /* find last levels */
+ level++;
+ }
+ firstpart = 0;
+ continue;
+ }
+ lua_pushliteral(L, "\n\t");
+ lua_getinfo(L1, "Snl", &ar);
+ lua_pushfstring(L, "%s:", ar.short_src);
+ if (ar.currentline > 0)
+ lua_pushfstring(L, "%d:", ar.currentline);
+ if (*ar.namewhat != '\0') /* is there a name? */
+ lua_pushfstring(L, " in function " LUA_QS, ar.name);
+ else {
+ if (*ar.what == 'm') /* main? */
+ lua_pushfstring(L, " in main chunk");
+ else if (*ar.what == 'C' || *ar.what == 't')
+ lua_pushliteral(L, " ?"); /* C function or tail call */
+ else
+ lua_pushfstring(L, " in function <%s:%d>",
+ ar.short_src, ar.linedefined);
+ }
+ lua_concat(L, lua_gettop(L) - arg);
+ }
+ lua_concat(L, lua_gettop(L) - arg);
+ return 1;
+}
+
+
+static const luaL_Reg dblib[] = {
+ {"gethook", db_gethook},
+ {"getinfo", db_getinfo},
+ {"getlocal", db_getlocal},
+ {"getupvalue", db_getupvalue},
+ {"sethook", db_sethook},
+ {"traceback", db_errorfb},
+ {NULL, NULL}
+};
+
+
+LUALIB_API int luaopen_debug (lua_State *L) {
+ luaL_register(L, LUA_DBLIBNAME, dblib);
+ return 1;
+}
diff --git a/src/blua/linit.c b/src/blua/linit.c
index dcf05d9f2c925e49457514c57f99afe7bf66c1d8..392d45dce47adf40ce753e400dcf1df2e2f46d91 100644
--- a/src/blua/linit.c
+++ b/src/blua/linit.c
@@ -20,6 +20,7 @@ static const luaL_Reg lualibs[] = {
{LUA_IOLIBNAME, luaopen_io},
{LUA_OSLIBNAME, luaopen_os},
{LUA_STRLIBNAME, luaopen_string},
+ {LUA_DBLIBNAME, luaopen_debug},
{NULL, NULL}
};
diff --git a/src/blua/lualib.h b/src/blua/lualib.h
index 7127e4d77e56c1d2aee9c7079b59c5a3adc959a2..70facb70cca96db5924b35ad2f74bc6148509759 100644
--- a/src/blua/lualib.h
+++ b/src/blua/lualib.h
@@ -30,6 +30,9 @@ LUALIB_API int (luaopen_os) (lua_State *L);
#define LUA_STRLIBNAME "string"
LUALIB_API int (luaopen_string) (lua_State *L);
+#define LUA_DBLIBNAME "debug"
+LUALIB_API int (luaopen_debug) (lua_State *L);
+
/* open all previous libraries */
LUALIB_API void (luaL_openlibs) (lua_State *L);
diff --git a/src/byteptr.h b/src/byteptr.h
index 4377fae571a59f67b70a9410a44ea851e534e400..61cefd350b758835a1b5b0c0f2853d04e95c2954 100644
--- a/src/byteptr.h
+++ b/src/byteptr.h
@@ -1,7 +1,7 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
diff --git a/src/command.c b/src/command.c
index e0156274ea12353809653fd64e50a9205ee32d29..ab6cfc08af7c4cde9f756d868b02e42ffd29229d 100644
--- a/src/command.c
+++ b/src/command.c
@@ -1,7 +1,7 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -648,7 +648,7 @@ static void COM_ExecuteString(char *ptext)
{
if ((com_flags & COM_LUA) && !(cmd->flags & COM_LUA))
{
- CONS_Alert(CONS_WARNING, "Command '%s' cannot be run from Lua.\n", cmd->name);
+ CONS_Alert(CONS_WARNING, "Command '%s' cannot be run from a script.\n", cmd->name);
return;
}
@@ -705,7 +705,7 @@ static void add_alias(char *newname, char *newcmd)
{
if (!stricmp(newname, a->name))
{
- Z_Free(a->value); // Free old cmd
+ Z_Free(a->value); // Free old cmd
a->value = newcmd;
return;
}
@@ -809,49 +809,60 @@ static void COM_CEchoDuration_f(void)
/** Executes a script file.
*/
-static void COM_Exec_f(void)
+boolean COM_ExecFile(const char *scriptname, com_flags_t flags, boolean silent)
{
UINT8 *buf = NULL;
char filename[256];
- if (COM_Argc() < 2 || COM_Argc() > 3)
- {
- CONS_Printf(M_GetText("exec <filename>: run a script file\n"));
- return;
- }
-
- if (!D_CheckPathAllowed(COM_Argv(1), "tried to exec"))
- return;
+ if (!D_CheckPathAllowed(scriptname, "tried to exec"))
+ return false;
// load file
// Try with Argv passed verbatim first, for back compat
- FIL_ReadFile(COM_Argv(1), &buf);
+ FIL_ReadFile(scriptname, &buf);
if (!buf)
{
// Now try by searching the file path
// filename is modified with the full found path
- strcpy(filename, COM_Argv(1));
+ strlcpy(filename, scriptname, sizeof(filename));
if (findfile(filename, NULL, true) != FS_NOTFOUND)
FIL_ReadFile(filename, &buf);
if (!buf)
- {
- if (!COM_CheckParm("-noerror"))
- CONS_Printf(M_GetText("couldn't execute file %s\n"), COM_Argv(1));
- return;
- }
+ return false;
}
- if (!COM_CheckParm("-silent"))
- CONS_Printf(M_GetText("executing %s\n"), COM_Argv(1));
+ if (!silent)
+ CONS_Printf(M_GetText("Executing %s\n"), scriptname);
// insert text file into the command buffer
- COM_BufAddTextEx((char *)buf, com_flags);
- COM_BufAddTextEx("\n", com_flags);
+ COM_BufAddTextEx((char *)buf, flags);
+ COM_BufAddTextEx("\n", flags);
// free buffer
Z_Free(buf);
+
+ return true;
+}
+
+static void COM_Exec_f(void)
+{
+ boolean silent;
+
+ if (COM_Argc() < 2 || COM_Argc() > 3)
+ {
+ CONS_Printf(M_GetText("exec <filename>: run a script file\n"));
+ return;
+ }
+
+ silent = COM_CheckParm("-silent");
+
+ if (COM_ExecFile(COM_Argv(1), com_flags, silent))
+ return;
+
+ if (!COM_CheckParm("-noerror"))
+ CONS_Printf(M_GetText("Couldn't execute file %s\n"), COM_Argv(1));
}
/** Delays execution of the rest of the commands until the next frame.
@@ -1722,8 +1733,7 @@ badinput:
static boolean serverloading = false;
-static consvar_t *
-ReadNetVar (UINT8 **p, char **return_value, boolean *return_stealth)
+static consvar_t *ReadNetVar(save_t *p, char **return_value, boolean *return_stealth)
{
UINT16 netid;
char *val;
@@ -1731,10 +1741,10 @@ ReadNetVar (UINT8 **p, char **return_value, boolean *return_stealth)
consvar_t *cvar;
- netid = READUINT16 (*p);
- val = (char *)*p;
- SKIPSTRING (*p);
- stealth = READUINT8 (*p);
+ netid = P_ReadUINT16(p);
+ val = (char *)&p->buf[p->pos];
+ P_SkipString(p);
+ stealth = P_ReadUINT8(p);
cvar = CV_FindNetVar(netid);
@@ -1752,8 +1762,7 @@ ReadNetVar (UINT8 **p, char **return_value, boolean *return_stealth)
}
#ifdef OLD22DEMOCOMPAT
-static consvar_t *
-ReadOldDemoVar (UINT8 **p, char **return_value, boolean *return_stealth)
+static consvar_t *ReadOldDemoVar(save_t *p, char **return_value, boolean *return_stealth)
{
UINT16 id;
char *val;
@@ -1761,10 +1770,10 @@ ReadOldDemoVar (UINT8 **p, char **return_value, boolean *return_stealth)
old_demo_var_t *demovar;
- id = READUINT16 (*p);
- val = (char *)*p;
- SKIPSTRING (*p);
- stealth = READUINT8 (*p);
+ id = P_ReadUINT16(p);
+ val = (char *)&p->buf[p->pos];
+ P_SkipString(p);
+ stealth = P_ReadUINT8(p);
demovar = CV_FindOldDemoVar(id);
@@ -1783,8 +1792,7 @@ ReadOldDemoVar (UINT8 **p, char **return_value, boolean *return_stealth)
}
#endif/*OLD22DEMOCOMPAT*/
-static consvar_t *
-ReadDemoVar (UINT8 **p, char **return_value, boolean *return_stealth)
+static consvar_t *ReadDemoVar(save_t *p, char **return_value, boolean *return_stealth)
{
char *name;
char *val;
@@ -1792,11 +1800,11 @@ ReadDemoVar (UINT8 **p, char **return_value, boolean *return_stealth)
consvar_t *cvar;
- name = (char *)*p;
- SKIPSTRING (*p);
- val = (char *)*p;
- SKIPSTRING (*p);
- stealth = READUINT8 (*p);
+ name = (char *)&p->buf[p->pos];
+ P_SkipString(p);
+ val = (char *)&p->buf[p->pos];
+ P_SkipString(p);
+ stealth = P_ReadUINT8(p);
cvar = CV_FindVar(name);
@@ -1826,41 +1834,46 @@ static void Got_NetVar(UINT8 **p, INT32 playernum)
return;
}
- cvar = ReadNetVar(p, &svalue, &stealth);
+ save_t save_p;
+ save_p.buf = *p;
+ save_p.size = MAXTEXTCMD;
+ save_p.pos = 0;
+ cvar = ReadNetVar(&save_p, &svalue, &stealth);
+ *p = &save_p.buf[save_p.pos];
if (cvar)
Setvalue(cvar, svalue, stealth);
}
-void CV_SaveVars(UINT8 **p, boolean in_demo)
+void CV_SaveVars(save_t *p, boolean in_demo)
{
consvar_t *cvar;
- UINT8 *count_p = *p;
+ UINT8 *count_p = &p->buf[p->pos];
UINT16 count = 0;
// send only changed cvars ...
// the client will reset all netvars to default before loading
- WRITEUINT16(*p, 0x0000);
+ P_WriteUINT16(p, 0x0000);
for (cvar = consvar_vars; cvar; cvar = cvar->next)
if ((cvar->flags & CV_NETVAR) && !CV_IsSetToDefault(cvar))
{
if (in_demo)
{
- WRITESTRING(*p, cvar->name);
+ P_WriteString(p, cvar->name);
}
else
{
- WRITEUINT16(*p, cvar->netid);
+ P_WriteUINT16(p, cvar->netid);
}
- WRITESTRING(*p, cvar->string);
- WRITEUINT8(*p, false);
+ P_WriteString(p, cvar->string);
+ P_WriteUINT8(p, false);
++count;
}
WRITEUINT16(count_p, count);
}
-static void CV_LoadVars(UINT8 **p,
- consvar_t *(*got)(UINT8 **p, char **ret_value, boolean *ret_stealth))
+static void CV_LoadVars(save_t *p,
+ consvar_t *(*got)(save_t *p, char **ret_value, boolean *ret_stealth))
{
const boolean store = (client || demoplayback);
@@ -1888,7 +1901,7 @@ static void CV_LoadVars(UINT8 **p,
}
}
- count = READUINT16(*p);
+ count = P_ReadUINT16(p);
while (count--)
{
cvar = (*got)(p, &val, &stealth);
@@ -1921,19 +1934,19 @@ void CV_RevertNetVars(void)
}
}
-void CV_LoadNetVars(UINT8 **p)
+void CV_LoadNetVars(save_t *p)
{
CV_LoadVars(p, ReadNetVar);
}
#ifdef OLD22DEMOCOMPAT
-void CV_LoadOldDemoVars(UINT8 **p)
+void CV_LoadOldDemoVars(save_t *p)
{
CV_LoadVars(p, ReadOldDemoVar);
}
#endif
-void CV_LoadDemoVars(UINT8 **p)
+void CV_LoadDemoVars(save_t *p)
{
CV_LoadVars(p, ReadDemoVar);
}
@@ -1986,7 +1999,7 @@ static void CV_SetCVar(consvar_t *var, const char *value, boolean stealth)
if (!var->string)
I_Error("CV_Set: %s no string set!\n", var->name);
#endif
- if (!var || !var->string || !value || !stricmp(var->string, value))
+ if (!var || !var->string || !value || (var->can_change == NULL && !stricmp(var->string, value)))
return; // no changes
if (var->flags & CV_NETVAR)
@@ -2491,7 +2504,7 @@ static boolean CV_Command(void)
if (CV_Immutable(v))
{
- CONS_Alert(CONS_WARNING, "Variable '%s' cannot be changed from Lua.\n", v->name);
+ CONS_Alert(CONS_WARNING, "Variable '%s' cannot be changed from a script.\n", v->name);
return true;
}
diff --git a/src/command.h b/src/command.h
index deb30e28bfacae8d554257703b7fe940a13053f6..e0724a9e19edac1f3b236e4251128df929c77feb 100644
--- a/src/command.h
+++ b/src/command.h
@@ -1,7 +1,7 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -15,6 +15,7 @@
#include <stdio.h>
#include "doomdef.h"
+#include "p_saveg.h"
//===================================
// Command buffer & command execution
@@ -65,6 +66,9 @@ void COM_ImmedExecute(const char *ptext);
// Execute commands in buffer, flush them
void COM_BufExecute(void);
+// Executes a script from a file
+boolean COM_ExecFile(const char *scriptname, com_flags_t flags, boolean silent);
+
// As above; and progress the wait timer.
void COM_BufTicker(void);
@@ -219,19 +223,19 @@ void CV_AddValue(consvar_t *var, INT32 increment);
void CV_SaveVariables(FILE *f);
// load/save gamesate (load and save option and for network join in game)
-void CV_SaveVars(UINT8 **p, boolean in_demo);
+void CV_SaveVars(save_t *p, boolean in_demo);
#define CV_SaveNetVars(p) CV_SaveVars(p, false)
-void CV_LoadNetVars(UINT8 **p);
+void CV_LoadNetVars(save_t *p);
// then revert after leaving a netgame
void CV_RevertNetVars(void);
#define CV_SaveDemoVars(p) CV_SaveVars(p, true)
-void CV_LoadDemoVars(UINT8 **p);
+void CV_LoadDemoVars(save_t *p);
#ifdef OLD22DEMOCOMPAT
-void CV_LoadOldDemoVars(UINT8 **p);
+void CV_LoadOldDemoVars(save_t *p);
#endif
// reset cheat netvars after cheats is deactivated
diff --git a/src/config.h.in b/src/config.h.in
index 6d49a698934bf8b498f6bfb402bbaa7f8ff93191..0f24cfc4466e3b8387777ba68a1b83ead3f3dbc3 100644
--- a/src/config.h.in
+++ b/src/config.h.in
@@ -40,12 +40,14 @@
* Last updated 2023 / 05 / 02 - v2.2.11 - patch.pk3 & zones.pk3
* Last updated 2023 / 09 / 06 - v2.2.12 - patch.pk3
* Last updated 2023 / 09 / 09 - v2.2.13 - none
+ * Last updated 2025 / 01 / 16 - v2.2.14 - main assets
+ * Last updated 2025 / 01 / 24 - v2.2.15 - main assets
*/
-#define ASSET_HASH_SRB2_PK3 "ad911f29a28a18968ee5b2d11c2acb39"
-#define ASSET_HASH_ZONES_PK3 "1c8adf8d079ecb87d00081f158acf3c7"
-#define ASSET_HASH_PLAYER_DTA "2e7aaae8a6b1b77d90ffe7606ceadb6c"
+#define ASSET_HASH_SRB2_PK3 "3182ce524acc2072ddaa81acf4b6a9aa"
+#define ASSET_HASH_ZONES_PK3 "88ff4c300851ccdb0406698eadd89907"
+#define ASSET_HASH_CHARACTERS_PK3 "5c5936b8a690e007c0939bd0785a41fb"
#ifdef USE_PATCH_DTA
-#define ASSET_HASH_PATCH_PK3 "3c7b73f34af7e9a7bceb2d5260f76172"
+#define ASSET_HASH_PATCH_PK3 "00000000000000000000000000000000"
#endif
#endif
diff --git a/src/console.c b/src/console.c
index 0c3eac4f793854dad336dc641a73874cea74d510..50ecfec9c28fa11a9395907478dbb93d9d416a24 100644
--- a/src/console.c
+++ b/src/console.c
@@ -1,7 +1,7 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
diff --git a/src/console.h b/src/console.h
index 6ad1dba1e458c19d47bb2599f9d3a87ce0fb17c1..2af01f1a3af8bdd50901eabaa5b301107741e213 100644
--- a/src/console.h
+++ b/src/console.h
@@ -1,7 +1,7 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
diff --git a/src/d_main.c b/src/d_main.c
index bf6c62ef2d8c591742e18d63bacd0f4c6ab16183..d75a4d5013d9a92e7abccad7211721b3fa1f00b5 100644
--- a/src/d_main.c
+++ b/src/d_main.c
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2025 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -1179,8 +1179,8 @@ static void IdentifyVersion(void)
// Add the maps
D_AddFile(&startupwadfiles, va(pandf,srb2waddir, "zones.pk3"));
- // Add the players
- D_AddFile(&startupwadfiles, va(pandf,srb2waddir, "player.dta"));
+ // Add the characters
+ D_AddFile(&startupwadfiles, va(pandf,srb2waddir, "characters.pk3"));
#ifdef USE_PATCH_DTA
// Add our crappy patches to fix our bugs
@@ -1199,7 +1199,7 @@ static void IdentifyVersion(void)
I_Error("File "str" has been modified with non-music/sound lumps"); \
}
- MUSICTEST("music.dta")
+ MUSICTEST("music.pk3")
//MUSICTEST("patch_music.pk3")
}
#endif
@@ -1250,7 +1250,7 @@ void D_SRB2Main(void)
// Print GPL notice for our console users (Linux)
CONS_Printf(
"\n\nSonic Robo Blast 2\n"
- "Copyright (C) 1998-2023 by Sonic Team Junior\n\n"
+ "Copyright (C) 1998-2025 by Sonic Team Junior\n\n"
"This program comes with ABSOLUTELY NO WARRANTY.\n\n"
"This is free software, and you are welcome to redistribute it\n"
"and/or modify it under the terms of the GNU General Public License\n"
@@ -1431,7 +1431,7 @@ void D_SRB2Main(void)
// Make backups of some SOCcable tables.
P_BackupTables();
- mainwads = 3; // doesn't include music.dta
+ mainwads = 3; // doesn't include music.pk3
#ifdef USE_PATCH_DTA
mainwads++;
#endif
@@ -1446,11 +1446,11 @@ void D_SRB2Main(void)
// Check MD5s of autoloaded files
W_VerifyFileMD5(0, ASSET_HASH_SRB2_PK3); // srb2.pk3
W_VerifyFileMD5(1, ASSET_HASH_ZONES_PK3); // zones.pk3
- W_VerifyFileMD5(2, ASSET_HASH_PLAYER_DTA); // player.dta
+ W_VerifyFileMD5(2, ASSET_HASH_CHARACTERS_PK3); // characters.pk3
#ifdef USE_PATCH_DTA
W_VerifyFileMD5(3, ASSET_HASH_PATCH_PK3); // patch.pk3
#endif
- // don't check music.dta because people like to modify it, and it doesn't matter if they do
+ // don't check music.pk3 because people like to modify it, and it doesn't matter if they do
// ...except it does if they slip maps in there, and that's what W_VerifyNMUSlumps is for.
#endif //ifndef DEVELOP
@@ -1600,7 +1600,7 @@ void D_SRB2Main(void)
{
if (!M_IsNextParm())
I_Error("usage: -room <room_id>\nCheck the Master Server's webpage for room ID numbers.\n");
- ms_RoomId = atoi(M_GetNextParm());
+ CV_SetValue(&cv_masterserver_room_id, atoi(M_GetNextParm()));
#ifdef UPDATE_ALERT
GetMODVersion_Console();
diff --git a/src/d_player.h b/src/d_player.h
index 95d2f609dab322189fcb3892d7beace6d0fd45dc..1dc3fb5293d7fd56baae6518f2ea29adea5baecc 100644
--- a/src/d_player.h
+++ b/src/d_player.h
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2025 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -45,14 +45,16 @@ typedef enum
SF_MARIODAMAGE = SF_NOJUMPDAMAGE|SF_STOMPDAMAGE, // The Mario method of being able to damage enemies, etc.
SF_MACHINE = 1<<10, // Beep boop. Are you a robot?
SF_DASHMODE = 1<<11, // Sonic Advance 2 style top speed increase?
- SF_FASTEDGE = 1<<12, // Faster edge teeter?
- SF_MULTIABILITY = 1<<13, // Revenge of Final Demo.
- SF_NONIGHTSROTATION = 1<<14, // Disable sprite rotation for NiGHTS
- SF_NONIGHTSSUPER = 1<<15, // Disable super colors for NiGHTS (if you have SF_SUPER)
- SF_NOSUPERSPRITES = 1<<16, // Don't use super sprites while super
- SF_NOSUPERJUMPBOOST = 1<<17, // Disable the jump boost given while super (i.e. Knuckles)
- SF_CANBUSTWALLS = 1<<18, // Can naturally bust walls on contact? (i.e. Knuckles)
- SF_NOSHIELDABILITY = 1<<19, // Disable shield abilities
+ SF_FASTWAIT = 1<<12, // Faster wait animation?
+ SF_FASTEDGE = 1<<13, // Faster edge teeter?
+ SF_JETFUME = 1<<14, // Follow item uses Metal Sonic's jet fume behavior
+ SF_MULTIABILITY = 1<<15, // Revenge of Final Demo.
+ SF_NONIGHTSROTATION = 1<<16, // Disable sprite rotation for NiGHTS
+ SF_NONIGHTSSUPER = 1<<17, // Disable super sprites and colors for NiGHTS
+ SF_NOSUPERSPRITES = 1<<18, // Don't use super sprites while super
+ SF_NOSUPERJUMPBOOST = 1<<19, // Disable the jump boost given while super (i.e. Knuckles)
+ SF_CANBUSTWALLS = 1<<20, // Can naturally bust walls on contact? (i.e. Knuckles)
+ SF_NOSHIELDABILITY = 1<<21, // Disable shield abilities
// free up to and including 1<<31
} skinflags_t;
@@ -158,10 +160,6 @@ typedef enum
PF_FORCESTRAFE = 1<<28, // Turning inputs are translated into strafing inputs
PF_CANCARRY = 1<<29, // Can carry another player?
PF_FINISHED = 1<<30, // The player finished the level. NOT the same as exiting
-
- // True if shield button down last tic
- // This may be the final flag, but 2.3 could free up the others
- PF_SHIELDDOWN = 1<<31,
// up to 1<<31 is free
} pflags_t;
diff --git a/src/d_think.h b/src/d_think.h
index 58912458783a2f3b2187e50ebaf00a667a0e0a78..76c1bb5b8af11a5557bab32705897445e699ca5b 100644
--- a/src/d_think.h
+++ b/src/d_think.h
@@ -51,6 +51,8 @@ typedef struct thinker_s
// killough 11/98: count of how many other objects reference
// this one using pointers. Used for garbage collection.
INT32 references;
+
+ boolean removing;
boolean cachable;
#ifdef PARANOIA
diff --git a/src/d_ticcmd.h b/src/d_ticcmd.h
index 43eb0f00b8df58da69c2dc7123d274d69070c104..2481ed738b23769a546fef840500d10ba7b024f5 100644
--- a/src/d_ticcmd.h
+++ b/src/d_ticcmd.h
@@ -26,23 +26,20 @@
// Button/action code definitions.
typedef enum
{
- // First 3 bits are weapon change info, DO NOT USE!
- BT_WEAPONMASK = 0x07, //our first three bits.
-
- BT_SHIELD = 1<<3, // shield or super action
+ // First 4 bits are weapon change info, DO NOT USE!
+ BT_WEAPONMASK = 0x0F, //our first four bits.
- BT_WEAPONNEXT = 1<<4, // select next weapon
- BT_WEAPONPREV = 1<<5, // select previous weapon
+ BT_WEAPONNEXT = 1<<4,
+ BT_WEAPONPREV = 1<<5,
+
+ BT_ATTACK = 1<<6, // shoot rings
+ BT_SPIN = 1<<7,
+ BT_CAMLEFT = 1<<8, // turn camera left
+ BT_CAMRIGHT = 1<<9, // turn camera right
+ BT_TOSSFLAG = 1<<10,
+ BT_JUMP = 1<<11,
+ BT_FIRENORMAL = 1<<12, // Fire a normal ring no matter what
- BT_ATTACK = 1<<6, // shoot rings
- BT_SPIN = 1<<7, // spin action
- BT_CAMLEFT = 1<<8, // turn camera left
- BT_CAMRIGHT = 1<<9, // turn camera right
- BT_TOSSFLAG = 1<<10, // toss flag or emeralds
- BT_JUMP = 1<<11, // jump action
- BT_FIRENORMAL = 1<<12, // fire a normal ring no matter what
-
- // custom lua buttons
BT_CUSTOM1 = 1<<13,
BT_CUSTOM2 = 1<<14,
BT_CUSTOM3 = 1<<15,
diff --git a/src/dedicated/i_system.c b/src/dedicated/i_system.c
index 1a1db8fb351e6017a8ee9d7745556550245e47c1..643e24f5afb677f450dab073097388661c35c98a 100644
--- a/src/dedicated/i_system.c
+++ b/src/dedicated/i_system.c
@@ -3,7 +3,7 @@
//
// Copyright (C) 1993-1996 by id Software, Inc.
// Portions Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 2014-2023 by Sonic Team Junior.
+// Copyright (C) 2014-2025 by Sonic Team Junior.
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
@@ -65,10 +65,11 @@ typedef LPVOID (WINAPI *p_MapViewOfFile) (HANDLE, DWORD, DWORD, DWORD, SIZE_T);
#pragma warning(default : 4214 4244)
#endif
-#if defined (__unix__) || defined(__APPLE__) || (defined (UNIXCOMMON) && !defined (__HAIKU__))
-#if defined (__linux__)
-#include <sys/vfs.h>
+#if defined (__unix__) || defined(__APPLE__) || defined (UNIXCOMMON)
+#if defined (__linux__) || defined (__HAIKU__)
+#include <sys/statvfs.h>
#else
+#include <sys/statvfs.h>
#include <sys/param.h>
#include <sys/mount.h>
/*For meminfo*/
@@ -81,7 +82,7 @@ typedef LPVOID (WINAPI *p_MapViewOfFile) (HANDLE, DWORD, DWORD, DWORD, SIZE_T);
#endif
#endif
-#if defined (__linux__) || (defined (UNIXCOMMON) && !defined (__HAIKU__))
+#if defined (__linux__) || defined (UNIXCOMMON)
#ifndef NOTERMIOS
#include <termios.h>
#include <sys/ioctl.h> // ioctl
@@ -96,8 +97,10 @@ typedef LPVOID (WINAPI *p_MapViewOfFile) (HANDLE, DWORD, DWORD, DWORD, SIZE_T);
#if defined (__unix__) || (defined (UNIXCOMMON) && !defined (__APPLE__))
#include <errno.h>
#include <sys/wait.h>
+#ifndef __HAIKU__ // haiku's crash dialog is just objectively better
#define NEWSIGNALHANDLER
#endif
+#endif
#ifndef NOMUMBLE
#ifdef __linux__ // need -lrt
@@ -374,15 +377,24 @@ void I_Sleep(UINT32 ms)
void I_SleepDuration(precise_t duration)
{
-#if defined(__linux__) || defined(__FreeBSD__)
+#if defined(__linux__) || defined(__FreeBSD__) || defined(__HAIKU__)
UINT64 precision = I_GetPrecisePrecision();
- struct timespec ts = {
- .tv_sec = duration / precision,
- .tv_nsec = duration * 1000000000 / precision % 1000000000,
- };
- int status;
- do status = clock_nanosleep(CLOCK_MONOTONIC, 0, &ts, &ts);
- while (status == EINTR);
+ precise_t dest = I_GetPreciseTime() + duration;
+ precise_t slack = (precision / 5000); // 0.2 ms slack
+ if (duration > slack)
+ {
+ duration -= slack;
+ struct timespec ts = {
+ .tv_sec = duration / precision,
+ .tv_nsec = duration * 1000000000 / precision % 1000000000,
+ };
+ int status;
+ do status = clock_nanosleep(CLOCK_MONOTONIC, 0, &ts, &ts);
+ while (status == EINTR);
+ }
+
+ // busy-wait the rest
+ while (((INT64)dest - (INT64)I_GetPreciseTime()) > 0);
#else
UINT64 precision = I_GetPrecisePrecision();
INT32 sleepvalue = cv_sleep.value;
@@ -705,10 +717,9 @@ typedef struct
static feild_t tty_con;
-// when printing general stuff to stdout stderr (Sys_Printf)
-// we need to disable the tty console stuff
-// this increments so we can recursively disable
-static INT32 ttycon_hide = 0;
+// lock to prevent clearing partial lines, since not everything
+// printed ends on a newline.
+static boolean ttycon_ateol = true;
// some key codes that the terminal may be using
// TTimo NOTE: I'm not sure how relevant this is
static INT32 tty_erase;
@@ -736,63 +747,31 @@ static inline void tty_FlushIn(void)
// TTimo NOTE: it seems on some terminals just sending '\b' is not enough
// so for now, in any case we send "\b \b" .. yeah well ..
// (there may be a way to find out if '\b' alone would work though)
+// Hanicef NOTE: using \b this way is unreliable because of terminal state,
+// it's better to use \r to reset the cursor to the beginning of the
+// line and clear from there.
static void tty_Back(void)
{
- char key;
- ssize_t d;
- key = '\b';
- d = write(STDOUT_FILENO, &key, 1);
- key = ' ';
- d = write(STDOUT_FILENO, &key, 1);
- key = '\b';
- d = write(STDOUT_FILENO, &key, 1);
- (void)d;
-}
-
-static void tty_Clear(void)
-{
- size_t i;
+ write(STDOUT_FILENO, "\r", 1);
if (tty_con.cursor>0)
{
- for (i=0; i<tty_con.cursor; i++)
- {
- tty_Back();
- }
+ write(STDOUT_FILENO, tty_con.buffer, tty_con.cursor);
}
-
+ write(STDOUT_FILENO, " \b", 2);
}
-// clear the display of the line currently edited
-// bring cursor back to beginning of line
-static inline void tty_Hide(void)
-{
- //I_Assert(consolevent);
- if (ttycon_hide)
- {
- ttycon_hide++;
- return;
- }
- tty_Clear();
- ttycon_hide++;
-}
-
-// show the current line
-// FIXME TTimo need to position the cursor if needed??
-static inline void tty_Show(void)
+static void tty_Clear(void)
{
size_t i;
- ssize_t d;
- //I_Assert(consolevent);
- I_Assert(ttycon_hide>0);
- ttycon_hide--;
- if (ttycon_hide == 0 && tty_con.cursor)
+ write(STDOUT_FILENO, "\r", 1);
+ if (tty_con.cursor>0)
{
for (i=0; i<tty_con.cursor; i++)
{
- d = write(STDOUT_FILENO, tty_con.buffer+i, 1);
+ write(STDOUT_FILENO, " ", 1);
}
+ write(STDOUT_FILENO, "\r", 1);
}
- (void)d;
}
// never exit without calling this, or your terminal will be left in a pretty bad state
@@ -900,6 +879,11 @@ static void I_GetConsoleEvents(void)
tty_con.cursor = 0;
ev.key = KEY_ENTER;
}
+ else if (key == 0x4) // ^D, aka EOF
+ {
+ // shut down, most unix programs behave this way
+ I_Quit();
+ }
else continue;
}
else if (tty_con.cursor < sizeof(tty_con.buffer))
@@ -999,20 +983,8 @@ static void I_GetConsoleEvents(void)
static void I_StartupConsole(void)
{
HANDLE ci, co;
- const INT32 ded = M_CheckParm("-dedicated");
- BOOL gotConsole = FALSE;
- if (M_CheckParm("-console") || ded)
- gotConsole = AllocConsole();
-#ifdef _DEBUG
- else if (M_CheckParm("-noconsole") && !ded)
-#else
- else if (!M_CheckParm("-console") && !ded)
-#endif
- {
- FreeConsole();
- gotConsole = FALSE;
- }
-
+ BOOL gotConsole = AllocConsole();
+ consolevent = !M_CheckParm("-noconsole");
if (gotConsole)
{
SetConsoleTitleA("SRB2 Console");
@@ -1040,12 +1012,7 @@ static inline void I_ShutdownConsole(void){}
static void I_GetConsoleEvents(void){}
static inline void I_StartupConsole(void)
{
-#ifdef _DEBUG
consolevent = !M_CheckParm("-noconsole");
-#else
- consolevent = M_CheckParm("-console");
-#endif
-
framebuffer = M_CheckParm("-framebuffer");
if (framebuffer)
@@ -1063,6 +1030,9 @@ void I_OutputMsg(const char *fmt, ...)
va_start(argptr,fmt);
len = vsnprintf(NULL, 0, fmt, argptr);
va_end(argptr);
+ if (len == 0)
+ return;
+
txt = malloc(len+1);
va_start(argptr,fmt);
vsprintf(txt, fmt, argptr);
@@ -1152,18 +1122,20 @@ void I_OutputMsg(const char *fmt, ...)
}
#else
#ifdef HAVE_TERMIOS
- if (consolevent)
+ if (consolevent && ttycon_ateol)
{
- tty_Hide();
+ tty_Clear();
+ ttycon_ateol = false;
}
#endif
if (!framebuffer)
fprintf(stderr, "%s", txt);
#ifdef HAVE_TERMIOS
- if (consolevent)
+ if (consolevent && txt[len-1] == '\n')
{
- tty_Show();
+ write(STDOUT_FILENO, tty_con.buffer, tty_con.cursor);
+ ttycon_ateol = true;
}
#endif
@@ -1243,18 +1215,13 @@ void I_ShutdownSystem(void)
void I_GetDiskFreeSpace(INT64* freespace)
{
#if defined (__unix__) || defined(__APPLE__) || defined (UNIXCOMMON)
-#if defined (SOLARIS) || defined (__HAIKU__)
- *freespace = INT32_MAX;
- return;
-#else // Both Linux and BSD have this, apparently.
- struct statfs stfs;
- if (statfs(srb2home, &stfs) == -1)
+ struct statvfs stfs;
+ if (statvfs(srb2home, &stfs) == -1)
{
*freespace = INT32_MAX;
return;
}
*freespace = stfs.f_bavail * stfs.f_bsize;
-#endif
#elif defined (_WIN32)
static p_GetDiskFreeSpaceExA pfnGetDiskFreeSpaceEx = NULL;
static boolean testwin95 = false;
@@ -1470,8 +1437,10 @@ const char *I_LocateWad(void)
{
// change to the directory where we found srb2.pk3
#if defined (_WIN32)
+ waddir = _fullpath(NULL, waddir, MAX_PATH);
SetCurrentDirectoryA(waddir);
#else
+ waddir = realpath(waddir, NULL);
if (chdir(waddir) == -1)
I_OutputMsg("Couldn't change working directory\n");
#endif
@@ -1604,4 +1573,3 @@ boolean I_GetTextInputMode(void)
}
#include "../sdl/dosstr.c"
-
diff --git a/src/dedicated/i_threads.c b/src/dedicated/i_threads.c
index 6902e23a52da14cf1861df5c1f194a4ea617af17..55c0a069e5d3f42e03c8286d4862f87e9c8f4a8e 100644
--- a/src/dedicated/i_threads.c
+++ b/src/dedicated/i_threads.c
@@ -157,7 +157,7 @@ void I_wake_all_cond(I_cond *anchor)
pthread_mutex_lock(&thread_lock);
if (*anchor == NULL)
{
- *anchor = malloc(sizeof(pthread_t));
+ *anchor = malloc(sizeof(pthread_cond_t));
pthread_cond_init(*anchor, NULL);
}
pthread_mutex_unlock(&thread_lock);
diff --git a/src/dedicated/i_video.c b/src/dedicated/i_video.c
index 2c998117accb71be25850438bdac2ee6c4db0509..19f2d0cbd51bba44266ca0b92627b542cb8c948b 100644
--- a/src/dedicated/i_video.c
+++ b/src/dedicated/i_video.c
@@ -1,4 +1,4 @@
-#include "../doomdef.h"
+#include "../doomdef.h"
#include "../command.h"
#include "../i_video.h"
@@ -76,4 +76,3 @@ void I_ReadScreen(UINT8 *scr)
void I_BeginRead(void){}
void I_EndRead(void){}
-
diff --git a/src/deh_lua.c b/src/deh_lua.c
index 64fb52fc7423a7486c9d6736762fedd0fcde64ba..48f737a1ff5c6587414b2efe2edbc566c9c25034 100644
--- a/src/deh_lua.c
+++ b/src/deh_lua.c
@@ -1,7 +1,7 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -11,7 +11,6 @@
/// \brief Lua SOC library
#include "deh_lua.h"
-#include "g_input.h"
// freeslot takes a name (string only!)
// and allocates it to the appropriate free slot.
@@ -28,6 +27,12 @@ static inline int lib_freeslot(lua_State *L)
if (!lua_lumploading)
return luaL_error(L, "This function cannot be called from within a hook or coroutine!");
+ if (!deh_loaded)
+ {
+ initfreeslots();
+ deh_loaded = true;
+ }
+
while (n-- > 0)
{
s = Z_StrDup(luaL_checkstring(L,1));
@@ -594,20 +599,12 @@ static int ScanConstants(lua_State *L, boolean mathlib, const char *word)
return luaL_error(L, "translation '%s' could not be found.\n", word);
}
- // TODO: 2.3: Delete these aliases
- else if (fastcmp(word, "BT_USE"))
+ // TODO: 2.3: Delete this alias
+ if (fastcmp(word, "BT_USE"))
{
CacheAndPushConstant(L, word, (lua_Integer)BT_SPIN);
return 1;
}
- else if (fastcmp(word, "GC_WEPSLOT8") || fastcmp(word, "GC_WEPSLOT9") || fastcmp(word, "GC_WEPSLOT10"))
- {
- // Using GC_WEPSLOT7 isn't accurate, but ensures that "if x >= GC_WEPSLOT1 and x <= GC_WEPSLOT10" keeps the intended effect
- CacheAndPushConstant(L, word, (lua_Integer)GC_WEPSLOT7);
- if (!mathlib)
- LUA_Deprecated(L, "GC_WEPSLOT8\"-\"GC_WEPSLOT10", "GC_WEPSLOT1\"-\"GC_WEPSLOT7");
- return 1;
- }
for (i = 0; INT_CONST[i].n; i++)
if (fastcmp(word,INT_CONST[i].n)) {
diff --git a/src/deh_soc.c b/src/deh_soc.c
index 3759cc9c7552987029edcc8f6c1e76322ef61ed3..343beb3012676b93256af35c0bd57ff6ba7e9076 100644
--- a/src/deh_soc.c
+++ b/src/deh_soc.c
@@ -1,7 +1,7 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2025 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -286,6 +286,7 @@ void readPlayer(MYFILE *f, INT32 num)
}
if (playertext)
{
+ // PLAYERTEXT is really weird, so this doesn't use deh_strlcpy.
strlcpy(description[num].notes, playertext, NOTE_SIZE);
strlcat(description[num].notes,
myhashfgets(playertext, NOTE_SIZE, f), NOTE_SIZE);
@@ -324,7 +325,8 @@ void readPlayer(MYFILE *f, INT32 num)
if (fastcmp(word, "PICNAME"))
{
SLOTFOUND
- strncpy(description[num].picname, word2, sizeof(description[num].picname)-1);
+ deh_strlcpy(description[num].picname, word2, sizeof description[num].picname,
+ va("Character %d: picname", num));
}
else if (fastcmp(word, "DISPLAYNAME"))
{
@@ -345,7 +347,8 @@ void readPlayer(MYFILE *f, INT32 num)
cur = strchr(cur, '#');
}
- strlcpy(description[num].displayname, stringvalue, sizeof description[num].displayname);
+ deh_strlcpy(description[num].displayname, stringvalue, sizeof description[num].displayname,
+ va("Character %d: displayname", num));
}
else if (fastcmp(word, "OPPOSITECOLOR") || fastcmp(word, "OPPOSITECOLOUR"))
{
@@ -355,7 +358,8 @@ void readPlayer(MYFILE *f, INT32 num)
else if (fastcmp(word, "NAMETAG") || fastcmp(word, "TAGNAME"))
{
SLOTFOUND
- strncpy(description[num].nametag, word2, sizeof(description[num].nametag)-1);
+ deh_strlcpy(description[num].nametag, word2, sizeof description[num].nametag,
+ va("Character %d: nametag", num));
}
else if (fastcmp(word, "TAGTEXTCOLOR") || fastcmp(word, "TAGTEXTCOLOUR"))
{
@@ -387,7 +391,8 @@ void readPlayer(MYFILE *f, INT32 num)
{
// Send to free slot.
SLOTFOUND
- strlcpy(description[num].skinname, word2, sizeof description[num].skinname);
+ deh_strlcpy(description[num].skinname, word2, sizeof description[num].skinname,
+ va("Character %d: skinname", num));
strlwr(description[num].skinname);
}
else if (!failure)
@@ -1196,6 +1201,7 @@ void readgametype(MYFILE *f, char *gtname)
}
if (descr)
{
+ // DESCRIPTION is really weird, so this doesn't use deh_strlcpy.
strlcpy(gtdescription, descr, sizeof (gtdescription));
strlcat(gtdescription,
myhashfgets(descr, sizeof (gtdescription), f),
@@ -1402,7 +1408,7 @@ void readlevelheader(MYFILE *f, INT32 num)
{
deh_strlcpy(mapheaderinfo[num-1]->lvlttl, word2,
sizeof(mapheaderinfo[num-1]->lvlttl), va("Level header %d: levelname", num));
- strlcpy(mapheaderinfo[num-1]->selectheading, word2, sizeof(mapheaderinfo[num-1]->selectheading)); // not deh_ so only complains once
+ strlcpy(mapheaderinfo[num-1]->selectheading, word2, sizeof(mapheaderinfo[num-1]->selectheading)); // not deh_strlcpy so only complains once
continue;
}
// CHEAP HACK: move this over here for lowercase subtitles
@@ -1445,10 +1451,10 @@ void readlevelheader(MYFILE *f, INT32 num)
// Newly allocated
modoption = &mapheaderinfo[num-1]->customopts[j];
- strncpy(modoption->option, word, 31);
- modoption->option[31] = '\0';
- strncpy(modoption->value, word2, 255);
- modoption->value[255] = '\0';
+ deh_strlcpy(modoption->option, word, sizeof(modoption->option),
+ va("Level header %d: custom option %d key", num, j));
+ deh_strlcpy(modoption->value, word2, sizeof(modoption->value),
+ va("Level header %d: custom option %d value", num, j));
continue;
}
@@ -1626,7 +1632,7 @@ void readlevelheader(MYFILE *f, INT32 num)
else if (fastcmp(word, "KEYWORDS"))
{
deh_strlcpy(mapheaderinfo[num-1]->keywords, word2,
- sizeof(mapheaderinfo[num-1]->keywords), va("Level header %d: keywords", num));
+ sizeof(mapheaderinfo[num-1]->keywords), va("Level header %d: keywords", num));
}
else if (fastcmp(word, "MUSIC"))
{
@@ -1675,7 +1681,8 @@ void readlevelheader(MYFILE *f, INT32 num)
}
else if (fastcmp(word, "FORCECHARACTER"))
{
- strlcpy(mapheaderinfo[num-1]->forcecharacter, word2, SKINNAMESIZE+1);
+ deh_strlcpy(mapheaderinfo[num-1]->forcecharacter, word2, sizeof mapheaderinfo[num-1]->forcecharacter,
+ va("Level header %d: forcecharacter", num));
strlwr(mapheaderinfo[num-1]->forcecharacter); // skin names are lowercase
}
else if (fastcmp(word, "WEATHER"))
@@ -1683,7 +1690,10 @@ void readlevelheader(MYFILE *f, INT32 num)
else if (fastcmp(word, "SKYNUM"))
mapheaderinfo[num-1]->skynum = (INT16)i;
else if (fastcmp(word, "INTERSCREEN"))
- strncpy(mapheaderinfo[num-1]->interscreen, word2, sizeof(mapheaderinfo[num-1]->interscreen)-1);
+ {
+ deh_strlcpy(mapheaderinfo[num-1]->interscreen, word2, sizeof mapheaderinfo[num-1]->interscreen,
+ va("Level header %d: interscreen", num));
+ }
else if (fastcmp(word, "PRECUTSCENENUM"))
mapheaderinfo[num-1]->precutscenenum = (UINT8)i;
else if (fastcmp(word, "CUTSCENENUM"))
@@ -1985,14 +1995,17 @@ static void readcutscenescene(MYFILE *f, INT32 num, INT32 scenenum)
picid = (UINT8)atoi(word + 3);
if (picid > 8 || picid == 0)
{
- deh_warning("CutSceneScene %d: unknown word '%s'", num, word);
+ deh_warning("Cutscene %d, scene %d: pic number %d out of range (1 - %d)",
+ num + 1, scenenum + 1, picid, 8);
continue;
}
--picid;
if (fastcmp(word+4, "NAME"))
{
- strncpy(cutscenes[num]->scene[scenenum].picname[picid], word2, 8);
+ deh_strlcpy(cutscenes[num]->scene[scenenum].picname[picid], word2,
+ sizeof cutscenes[num]->scene[scenenum].picname[picid],
+ va("Cutscene %d, scene %d, pic %d: name", num + 1, scenenum + 1, picid + 1));
}
else if (fastcmp(word+4, "HIRES"))
{
@@ -2011,12 +2024,13 @@ static void readcutscenescene(MYFILE *f, INT32 num, INT32 scenenum)
cutscenes[num]->scene[scenenum].ycoord[picid] = usi;
}
else
- deh_warning("CutSceneScene %d: unknown word '%s'", num, word);
+ deh_warning("Cutscene %d, scene %d: unknown word '%s'", num + 1, scenenum + 1, word);
}
else if (fastcmp(word, "MUSIC"))
{
- strncpy(cutscenes[num]->scene[scenenum].musswitch, word2, 7);
- cutscenes[num]->scene[scenenum].musswitch[6] = 0;
+ deh_strlcpy(cutscenes[num]->scene[scenenum].musswitch, word2,
+ sizeof cutscenes[num]->scene[scenenum].musswitch,
+ va("Cutscene %d, scene %d: music", num + 1, scenenum + 1));
}
else if (fastcmp(word, "MUSICTRACK"))
{
@@ -2051,7 +2065,7 @@ static void readcutscenescene(MYFILE *f, INT32 num, INT32 scenenum)
cutscenes[num]->scene[scenenum].fadecolor = (UINT8)i;
}
else
- deh_warning("CutSceneScene %d: unknown word '%s'", num, word);
+ deh_warning("Cutscene %d, scene %d: unknown word '%s'", num + 1, scenenum + 1, word);
}
} while (!myfeof(f)); // finish when the line is empty
@@ -2109,11 +2123,10 @@ void readcutscene(MYFILE *f, INT32 num)
readcutscenescene(f, num, value - 1);
}
else
- deh_warning("Scene number %d out of range (1 - 128)", value);
-
+ deh_warning("Cutscene %d: scene number %d out of range (1 - 128)", num + 1, value);
}
else
- deh_warning("Cutscene %d: unknown word '%s', Scene <num> expected.", num, word);
+ deh_warning("Cutscene %d: unknown word '%s', Scene <num> expected.", num + 1, word);
}
} while (!myfeof(f)); // finish when the line is empty
@@ -2234,7 +2247,8 @@ static void readtextpromptpage(MYFILE *f, INT32 num, INT32 pagenum)
for (picid = 0; picid < MAX_PROMPT_PICS; picid++)
{
- strncpy(textprompts[num]->page[pagenum].picname[picid], textprompts[num]->page[metapagenum].picname[picid], 8);
+ // Doesn't use deh_strlcpy because it's not copying input.
+ strlcpy(textprompts[num]->page[pagenum].picname[picid], textprompts[num]->page[metapagenum].picname[picid], sizeof textprompts[num]->page[pagenum].picname[picid]);
textprompts[num]->page[pagenum].pichires[picid] = textprompts[num]->page[metapagenum].pichires[picid];
textprompts[num]->page[pagenum].picduration[picid] = textprompts[num]->page[metapagenum].picduration[picid];
textprompts[num]->page[pagenum].xcoord[picid] = textprompts[num]->page[metapagenum].xcoord[picid];
@@ -2247,14 +2261,17 @@ static void readtextpromptpage(MYFILE *f, INT32 num, INT32 pagenum)
picid = (UINT8)atoi(word + 3);
if (picid > MAX_PROMPT_PICS || picid == 0)
{
- deh_warning("textpromptscene %d: unknown word '%s'", num, word);
+ deh_warning("Text prompt %d, page %d: pic number %d out of range (1 - %d)",
+ num + 1, pagenum + 1, picid, MAX_PROMPT_PICS);
continue;
}
--picid;
if (fastcmp(word+4, "NAME"))
{
- strncpy(textprompts[num]->page[pagenum].picname[picid], word2, 8);
+ deh_strlcpy(textprompts[num]->page[pagenum].picname[picid], word2,
+ sizeof textprompts[num]->page[pagenum].picname[picid],
+ va("Text prompt %d, page %d, pic %d: name", num + 1, pagenum + 1, picid + 1));
}
else if (fastcmp(word+4, "HIRES"))
{
@@ -2273,12 +2290,16 @@ static void readtextpromptpage(MYFILE *f, INT32 num, INT32 pagenum)
textprompts[num]->page[pagenum].ycoord[picid] = usi;
}
else
- deh_warning("textpromptscene %d: unknown word '%s'", num, word);
+ {
+ deh_warning("Text prompt %d, page %d: unknown word '%s'",
+ num + 1, pagenum + 1, word);
+ }
}
else if (fastcmp(word, "MUSIC"))
{
- strncpy(textprompts[num]->page[pagenum].musswitch, word2, 7);
- textprompts[num]->page[pagenum].musswitch[6] = 0;
+ deh_strlcpy(textprompts[num]->page[pagenum].musswitch, word2,
+ sizeof textprompts[num]->page[pagenum].musswitch,
+ va("Text prompt %d, page %d: music", num + 1, pagenum + 1));
}
else if (fastcmp(word, "MUSICTRACK"))
{
@@ -2293,30 +2314,35 @@ static void readtextpromptpage(MYFILE *f, INT32 num, INT32 pagenum)
{
if (*word2 != '\0')
{
- INT32 j;
+ size_t j;
// HACK: Add yellow control char now
// so the drawing function doesn't call it repeatedly
- char name[34];
+ char name[32 + 2];
name[0] = '\x82'; // color yellow
- name[1] = 0;
- strncat(name, word2, 32);
- name[33] = 0;
+
+ // So that we still get a warning.
+ deh_strlcpy(name + 1, word2, (sizeof(name)) - 1,
+ va("Text prompt %d, page %d: name", num + 1, pagenum + 1));
// Replace _ with ' '
- for (j = 0; j < 32 && name[j]; j++)
+ for (j = 1; j < sizeof(name) && name[j]; j++)
{
if (name[j] == '_')
name[j] = ' ';
}
- strncpy(textprompts[num]->page[pagenum].name, name, sizeof(textprompts[num]->page[pagenum].name));
+ strlcpy(textprompts[num]->page[pagenum].name, name, sizeof(textprompts[num]->page[pagenum].name));
}
else
*textprompts[num]->page[pagenum].name = '\0';
}
else if (fastcmp(word, "ICON"))
- strncpy(textprompts[num]->page[pagenum].iconname, word2, 8);
+ {
+ deh_strlcpy(textprompts[num]->page[pagenum].iconname, word2,
+ sizeof textprompts[num]->page[pagenum].iconname,
+ va("Text prompt %d, page %d: icon", num + 1, pagenum + 1));
+ }
else if (fastcmp(word, "ICONALIGN"))
textprompts[num]->page[pagenum].rightside = (i || word2[0] == 'R');
else if (fastcmp(word, "ICONFLIP"))
@@ -2383,8 +2409,9 @@ static void readtextpromptpage(MYFILE *f, INT32 num, INT32 pagenum)
{
UINT8 metapagenum = usi - 1;
- strncpy(textprompts[num]->page[pagenum].name, textprompts[num]->page[metapagenum].name, 32);
- strncpy(textprompts[num]->page[pagenum].iconname, textprompts[num]->page[metapagenum].iconname, 8);
+ // Doesn't use deh_strlcpy because it's not copying input.
+ strlcpy(textprompts[num]->page[pagenum].name, textprompts[num]->page[metapagenum].name, sizeof textprompts[num]->page[pagenum].name);
+ strlcpy(textprompts[num]->page[pagenum].iconname, textprompts[num]->page[metapagenum].iconname, sizeof textprompts[num]->page[pagenum].iconname);
textprompts[num]->page[pagenum].rightside = textprompts[num]->page[metapagenum].rightside;
textprompts[num]->page[pagenum].iconflip = textprompts[num]->page[metapagenum].iconflip;
textprompts[num]->page[pagenum].lines = textprompts[num]->page[metapagenum].lines;
@@ -2399,17 +2426,25 @@ static void readtextpromptpage(MYFILE *f, INT32 num, INT32 pagenum)
}
}
else if (fastcmp(word, "TAG"))
- strncpy(textprompts[num]->page[pagenum].tag, word2, 33);
+ {
+ deh_strlcpy(textprompts[num]->page[pagenum].tag, word2,
+ sizeof textprompts[num]->page[pagenum].tag,
+ va("Text prompt %d, page %d: tag", num + 1, pagenum + 1));
+ }
else if (fastcmp(word, "NEXTPROMPT"))
textprompts[num]->page[pagenum].nextprompt = usi;
else if (fastcmp(word, "NEXTPAGE"))
textprompts[num]->page[pagenum].nextpage = usi;
else if (fastcmp(word, "NEXTTAG"))
- strncpy(textprompts[num]->page[pagenum].nexttag, word2, 33);
+ {
+ deh_strlcpy(textprompts[num]->page[pagenum].nexttag, word2,
+ sizeof textprompts[num]->page[pagenum].nexttag,
+ va("Text prompt %d, page %d: nexttag", num + 1, pagenum + 1));
+ }
else if (fastcmp(word, "TIMETONEXT"))
textprompts[num]->page[pagenum].timetonext = get_number(word2);
else
- deh_warning("PromptPage %d: unknown word '%s'", num, word);
+ deh_warning("Text prompt %d, page %d: unknown word '%s'", num + 1, pagenum + 1, word);
}
} while (!myfeof(f)); // finish when the line is empty
@@ -2469,11 +2504,11 @@ void readtextprompt(MYFILE *f, INT32 num)
readtextpromptpage(f, num, value - 1);
}
else
- deh_warning("Page number %d out of range (1 - %d)", value, MAX_PAGES);
+ deh_warning("Prompt %d: page number %d out of range (1 - %d)", num + 1, value, MAX_PAGES);
}
else
- deh_warning("Prompt %d: unknown word '%s', Page <num> expected.", num, word);
+ deh_warning("Prompt %d: unknown word '%s', Page <num> expected.", num + 1, word);
}
} while (!myfeof(f)); // finish when the line is empty
@@ -2522,7 +2557,8 @@ void readmenu(MYFILE *f, INT32 num)
if (fastcmp(word, "BACKGROUNDNAME"))
{
- strncpy(menupres[num].bgname, word2, 8);
+ deh_strlcpy(menupres[num].bgname, word2,
+ sizeof menupres[num].bgname, va("Menu %d: backgroundname", num));
titlechanged = true;
}
else if (fastcmp(word, "HIDEBACKGROUND"))
@@ -2565,7 +2601,8 @@ void readmenu(MYFILE *f, INT32 num)
}
else if (fastcmp(word, "TITLEPICSNAME"))
{
- strncpy(menupres[num].ttname, word2, 9);
+ deh_strlcpy(menupres[num].ttname, word2,
+ sizeof menupres[num].ttname, va("Menu %d: titlepicsname", num));
titlechanged = true;
}
else if (fastcmp(word, "TITLEPICSX"))
@@ -2601,8 +2638,8 @@ void readmenu(MYFILE *f, INT32 num)
}
else if (fastcmp(word, "MUSIC"))
{
- strncpy(menupres[num].musname, word2, 7);
- menupres[num].musname[6] = 0;
+ deh_strlcpy(menupres[num].musname, word2,
+ sizeof menupres[num].musname, va("Menu %d: music", num));
titlechanged = true;
}
else if (fastcmp(word, "MUSICTRACK"))
@@ -3584,22 +3621,20 @@ void readmaincfg(MYFILE *f)
if (fastcmp(word, "EXECCFG"))
{
if (strchr(word2, '.'))
- COM_BufAddText(va("exec %s\n", word2));
+ COM_ExecFile(word2, COM_LUA, false);
else
{
lumpnum_t lumpnum;
char newname[9];
- strncpy(newname, word2, 8);
-
- newname[8] = '\0';
+ deh_strlcpy(newname, word2, sizeof newname, va("Maincfg: execcfg"));
lumpnum = W_CheckNumForName(newname);
if (lumpnum == LUMPERROR || W_LumpLength(lumpnum) == 0)
CONS_Debug(DBG_SETUP, "SOC Error: script lump %s not found/not valid.\n", newname);
else
- COM_BufInsertText(W_CacheLumpNum(lumpnum, PU_CACHE));
+ COM_BufInsertTextEx(W_CacheLumpNum(lumpnum, PU_CACHE), COM_LUA);
}
}
@@ -3800,7 +3835,7 @@ void readmaincfg(MYFILE *f)
}
else if (fastcmp(word, "TITLEPICSNAME"))
{
- strncpy(ttname, word2, sizeof(ttname)-1);
+ deh_strlcpy(ttname, word2, sizeof ttname, va("Maincfg: titlepicsname"));
titlechanged = true;
}
else if (fastcmp(word, "TITLEPICSX"))
@@ -3910,7 +3945,7 @@ void readmaincfg(MYFILE *f)
}
else if (fastcmp(word, "CUSTOMVERSION"))
{
- strlcpy(customversionstring, word2, sizeof (customversionstring));
+ deh_strlcpy(customversionstring, word2, sizeof customversionstring, va("Maincfg: customversion"));
//titlechanged = true;
}
else if (fastcmp(word, "BOOTMAP"))
@@ -3925,6 +3960,7 @@ void readmaincfg(MYFILE *f)
value = get_number(word2);
bootmap = (INT16)value;
+ bootmapchanged = true;
//titlechanged = true;
}
else if (fastcmp(word, "STARTCHAR"))
diff --git a/src/deh_tables.c b/src/deh_tables.c
index b1ff4b0a385a64d84841ef71073e9e8a892b305a..d983bab54deab2b23f6bc4fb932c6208c81f13bb 100644
--- a/src/deh_tables.c
+++ b/src/deh_tables.c
@@ -1,7 +1,7 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2025 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -1081,11 +1081,11 @@ const char *const STATE_LIST[] = { // array length left dynamic for sanity testi
"S_FANG_FIRE1",
"S_FANG_FIRE2",
"S_FANG_FIRE3",
- "S_FANG_FIRE4",
"S_FANG_FIREREPEAT",
"S_FANG_LOBSHOT0",
"S_FANG_LOBSHOT1",
"S_FANG_LOBSHOT2",
+ "S_FANG_LOBSHOT3",
"S_FANG_WAIT1",
"S_FANG_WAIT2",
"S_FANG_WALLHIT",
@@ -1107,6 +1107,7 @@ const char *const STATE_LIST[] = { // array length left dynamic for sanity testi
"S_FANG_PINCHLOBSHOT2",
"S_FANG_PINCHLOBSHOT3",
"S_FANG_PINCHLOBSHOT4",
+ "S_FANG_PINCHLOBSHOT5",
"S_FANG_DIE1",
"S_FANG_DIE2",
"S_FANG_DIE3",
@@ -2245,6 +2246,10 @@ const char *const STATE_LIST[] = { // array length left dynamic for sanity testi
"S_LAMPPOST2", // with snow
"S_HANGSTAR",
"S_MISTLETOE",
+ "S_SSZTREE",
+ "S_SSZTREE_BRANCH",
+ "S_SSZTREE2",
+ "S_SSZTREE2_BRANCH",
// Xmas GFZ bushes
"S_XMASBLUEBERRYBUSH",
"S_XMASBERRYBUSH",
@@ -2252,11 +2257,9 @@ const char *const STATE_LIST[] = { // array length left dynamic for sanity testi
// FHZ
"S_FHZICE1",
"S_FHZICE2",
- "S_ROSY_IDLE1",
- "S_ROSY_IDLE2",
- "S_ROSY_IDLE3",
- "S_ROSY_IDLE4",
+ "S_ROSY_IDLE",
"S_ROSY_JUMP",
+ "S_ROSY_FALL",
"S_ROSY_WALK",
"S_ROSY_HUG",
"S_ROSY_PAIN",
@@ -2365,6 +2368,9 @@ const char *const STATE_LIST[] = { // array length left dynamic for sanity testi
"S_DBALL5",
"S_DBALL6",
"S_EGGSTATUE2",
+ "S_GINE",
+ "S_PPAL",
+ "S_PPEL",
// Shield Orb
"S_ARMA1",
@@ -3249,6 +3255,7 @@ const char *const STATE_LIST[] = { // array length left dynamic for sanity testi
"S_MARIOBUSH2",
"S_TOAD",
+
// Nights-specific stuff
"S_NIGHTSDRONE_MAN1",
"S_NIGHTSDRONE_MAN2",
@@ -3552,6 +3559,12 @@ const char *const STATE_LIST[] = { // array length left dynamic for sanity testi
"S_YELLOWBRICKDEBRIS",
"S_NAMECHECK",
+
+ // LJ Knuckles
+ "S_OLDK_STND",
+ "S_OLDK_DIE0",
+ "S_OLDK_DIE1",
+ "S_OLDK_DIE2",
};
// RegEx to generate this from info.h: ^\tMT_([^,]+), --> \t"MT_\1",
@@ -4023,6 +4036,10 @@ const char *const MOBJTYPE_LIST[] = { // array length left dynamic for sanity t
"MT_LAMPPOST2", // with snow
"MT_HANGSTAR",
"MT_MISTLETOE",
+ "MT_SSZTREE",
+ "MT_SSZTREE_BRANCH",
+ "MT_SSZTREE2",
+ "MT_SSZTREE2_BRANCH",
// Xmas GFZ bushes
"MT_XMASBLUEBERRYBUSH",
"MT_XMASBERRYBUSH",
@@ -4102,6 +4119,9 @@ const char *const MOBJTYPE_LIST[] = { // array length left dynamic for sanity t
// Misc scenery
"MT_DBALL",
"MT_EGGSTATUE2",
+ "MT_GINE",
+ "MT_PPAL",
+ "MT_PPEL",
// Powerup Indicators
"MT_ELEMENTAL_ORB", // Elemental shield mobj
@@ -4329,6 +4349,8 @@ const char *const MOBJTYPE_LIST[] = { // array length left dynamic for sanity t
"MT_NAMECHECK",
"MT_RAY",
+
+ "MT_OLDK",
};
const char *const MOBJFLAG_LIST[] = {
@@ -5236,7 +5258,9 @@ struct int_const_s const INT_CONST[] = {
{"SF_MARIODAMAGE",SF_MARIODAMAGE},
{"SF_MACHINE",SF_MACHINE},
{"SF_DASHMODE",SF_DASHMODE},
+ {"SF_FASTWAIT",SF_FASTWAIT},
{"SF_FASTEDGE",SF_FASTEDGE},
+ {"SF_JETFUME",SF_JETFUME},
{"SF_MULTIABILITY",SF_MULTIABILITY},
{"SF_NONIGHTSROTATION",SF_NONIGHTSROTATION},
{"SF_NONIGHTSSUPER",SF_NONIGHTSSUPER},
@@ -5584,8 +5608,7 @@ struct int_const_s const INT_CONST[] = {
{"ROTAXIS_Z",ROTAXIS_Z},
// Buttons (ticcmd_t)
- {"BT_WEAPONMASK",BT_WEAPONMASK}, //our first three bits.
- {"BT_SHIELD",BT_SHIELD},
+ {"BT_WEAPONMASK",BT_WEAPONMASK}, //our first four bits.
{"BT_WEAPONNEXT",BT_WEAPONNEXT},
{"BT_WEAPONPREV",BT_WEAPONPREV},
{"BT_ATTACK",BT_ATTACK}, // shoot rings
@@ -5745,7 +5768,6 @@ struct int_const_s const INT_CONST[] = {
{"JA_DIGITAL",JA_DIGITAL},
{"JA_JUMP",JA_JUMP},
{"JA_SPIN",JA_SPIN},
- {"JA_SHIELD",JA_SHIELD},
{"JA_FIRE",JA_FIRE},
{"JA_FIRENORMAL",JA_FIRENORMAL},
{"JOYAXISRANGE",JOYAXISRANGE},
@@ -5767,7 +5789,9 @@ struct int_const_s const INT_CONST[] = {
{"GC_WEPSLOT5",GC_WEPSLOT5},
{"GC_WEPSLOT6",GC_WEPSLOT6},
{"GC_WEPSLOT7",GC_WEPSLOT7},
- {"GC_SHIELD",GC_SHIELD},
+ {"GC_WEPSLOT8",GC_WEPSLOT8},
+ {"GC_WEPSLOT9",GC_WEPSLOT9},
+ {"GC_WEPSLOT10",GC_WEPSLOT10},
{"GC_FIRE",GC_FIRE},
{"GC_FIRENORMAL",GC_FIRENORMAL},
{"GC_TOSSFLAG",GC_TOSSFLAG},
diff --git a/src/deh_tables.h b/src/deh_tables.h
index b6986adff0166c3132be5f70ca78c7835030998f..94af2fa52ed89180d61a3c6eed0468229a727f34 100644
--- a/src/deh_tables.h
+++ b/src/deh_tables.h
@@ -1,7 +1,7 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
diff --git a/src/dehacked.c b/src/dehacked.c
index 2050a117f67128dae4e40b992e5a49f1538457d7..470e468a0ba01c2d6bdda441dad3b195111cab2c 100644
--- a/src/dehacked.c
+++ b/src/dehacked.c
@@ -20,6 +20,7 @@ boolean deh_loaded = false;
boolean gamedataadded = false;
boolean titlechanged = false;
boolean introchanged = false;
+boolean bootmapchanged = false;
static int dbg_line;
static INT32 deh_num_warning = 0;
@@ -192,11 +193,14 @@ static void DEH_LoadDehackedFile(MYFILE *f, boolean mainfile)
INT32 i;
if (!deh_loaded)
+ {
initfreeslots();
+ deh_loaded = true;
+ }
deh_num_warning = 0;
- gamedataadded = titlechanged = introchanged = false;
+ gamedataadded = titlechanged = introchanged = bootmapchanged = false;
// it doesn't test the version of SRB2 and version of dehacked file
dbg_line = -1; // start at -1 so the first line is 0.
@@ -587,7 +591,12 @@ static void DEH_LoadDehackedFile(MYFILE *f, boolean mainfile)
if (gamestate == GS_TITLESCREEN)
{
- if (introchanged)
+ if (bootmapchanged && bootmap)
+ {
+ menuactive = false;
+ D_MapChange(bootmap, gametype, ultimatemode, true, 0, false, false);
+ }
+ else if (introchanged)
{
menuactive = false;
I_UpdateMouseGrab();
@@ -605,14 +614,10 @@ static void DEH_LoadDehackedFile(MYFILE *f, boolean mainfile)
if (deh_num_warning)
{
CONS_Printf(M_GetText("%d warning%s in the SOC lump\n"), deh_num_warning, deh_num_warning == 1 ? "" : "s");
- if (devparm) {
+ if (devparm)
I_Error("%s%s",va(M_GetText("%d warning%s in the SOC lump\n"), deh_num_warning, deh_num_warning == 1 ? "" : "s"), M_GetText("See log.txt for details.\n"));
- //while (!I_GetKey())
- //I_OsPolling();
- }
}
- deh_loaded = true;
Z_Free(s);
}
diff --git a/src/dehacked.h b/src/dehacked.h
index d985b14b031d648b35f991d03e6797ab72f52137..e7b9b46566411f51654f2b60270ff745b28b18c2 100644
--- a/src/dehacked.h
+++ b/src/dehacked.h
@@ -39,6 +39,7 @@ extern boolean deh_loaded;
extern boolean gamedataadded;
extern boolean titlechanged;
extern boolean introchanged;
+extern boolean bootmapchanged;
#define MAX_ACTION_RECURSION 30
extern const char *luaactions[MAX_ACTION_RECURSION];
diff --git a/src/doomdef.h b/src/doomdef.h
index 1b0e76314b13d080fc18c8f3463c066616c4b8c8..81ab7bbfb5505507f3df07b6b5709b6d4f995e81 100644
--- a/src/doomdef.h
+++ b/src/doomdef.h
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -168,7 +168,7 @@ extern char logfilename[1024];
// Does this version require an added patch file?
// Comment or uncomment this as necessary.
-#define USE_PATCH_DTA
+//#define USE_PATCH_DTA
// Enforce a limit of loaded WAD files.
//#define ENFORCE_WAD_LIMIT
diff --git a/src/doomstat.h b/src/doomstat.h
index bde2bacc72890d47b61a6085a26c5cda33dcfad0..b5b2984407cc7cf03d213de8cb70f3bab720fc88 100644
--- a/src/doomstat.h
+++ b/src/doomstat.h
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2025 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -209,19 +209,19 @@ typedef struct
UINT8 picmode; // sequence mode after displaying last pic, 0 = persist, 1 = loop, 2 = destroy
UINT8 pictoloop; // if picmode == loop, which pic to loop to?
UINT8 pictostart; // initial pic number to show
- char picname[MAX_PROMPT_PICS][8];
+ char picname[MAX_PROMPT_PICS][8+1];
UINT8 pichires[MAX_PROMPT_PICS];
UINT16 xcoord[MAX_PROMPT_PICS]; // gfx
UINT16 ycoord[MAX_PROMPT_PICS]; // gfx
UINT16 picduration[MAX_PROMPT_PICS];
- char musswitch[7];
+ char musswitch[6+1];
UINT16 musswitchflags;
UINT8 musicloop;
- char tag[33]; // page tag
- char name[34]; // narrator name, extra char for color
- char iconname[8]; // narrator icon lump
+ char tag[32+1]; // page tag
+ char name[32+2]; // narrator name, extra char for color
+ char iconname[8+1]; // narrator icon lump
boolean rightside; // narrator side, false = left, true = right
boolean iconflip; // narrator flip icon horizontally
UINT8 hidehud; // hide hud, 0 = show all, 1 = hide depending on prompt position (top/bottom), 2 = hide all
@@ -233,7 +233,7 @@ typedef struct
sfxenum_t textsfx; // sfx_ id for printing text
UINT8 nextprompt; // next prompt to jump to, one-based. 0 = current prompt
UINT8 nextpage; // next page to jump to, one-based. 0 = next page within prompt->numpages
- char nexttag[33]; // next tag to jump to. If set, this overrides nextprompt and nextpage.
+ char nexttag[32+1]; // next tag to jump to. If set, this overrides nextprompt and nextpage.
INT32 timetonext; // time in tics to jump to next page automatically. 0 = don't jump automatically
char *text;
} textpage_t;
@@ -287,8 +287,8 @@ typedef struct
// (This is not ifdeffed so the map header structure can stay identical, just in case.)
typedef struct
{
- char option[32]; // 31 usable characters
- char value[256]; // 255 usable characters. If this seriously isn't enough then wtf.
+ char option[31+1]; // 31 usable characters
+ char value[255+1]; // 255 usable characters. If this seriously isn't enough then wtf.
} customoption_t;
/** Map header information.
@@ -303,7 +303,7 @@ typedef struct
INT16 nextlevel; ///< Map number of next level, or 1100-1102 to end.
INT16 marathonnext; ///< See nextlevel, but for Marathon mode. Necessary to support hub worlds ala SUGOI.
char keywords[32+1]; ///< Keywords separated by space to search for. 32 characters.
- char musname[7]; ///< Music track to play. "" for no music.
+ char musname[6+1]; ///< 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.
UINT32 muspos; ///< Music position to jump to.
char forcecharacter[16+1]; ///< (SKINNAMESIZE+1) Skin to switch to or "" to disable.
@@ -330,7 +330,7 @@ typedef struct
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.
+ char selectheading[21+1]; ///< Level select heading. Allows for controllable grouping.
UINT16 startrings; ///< Number of rings players start with.
INT32 sstimer; ///< Timer for special stages.
UINT32 ssspheres; ///< Sphere requirement in special stages.
@@ -352,9 +352,9 @@ typedef struct
// Music stuff.
UINT32 musinterfadeout; ///< Fade out level music on intermission screen in milliseconds
- char musintername[7]; ///< Intermission screen music.
+ char musintername[6+1]; ///< Intermission screen music.
- char muspostbossname[7]; ///< Post-bossdeath music.
+ char muspostbossname[6+1]; ///< Post-bossdeath music.
UINT16 muspostbosstrack; ///< Post-bossdeath track.
UINT32 muspostbosspos; ///< Post-bossdeath position
UINT32 muspostbossfadein; ///< Post-bossdeath fade-in milliseconds.
diff --git a/src/doomtype.h b/src/doomtype.h
index fa8616793e0aeab7bea18c77ef78a4520770b802..415669ac479e928250d429bad545d34eff2770d5 100644
--- a/src/doomtype.h
+++ b/src/doomtype.h
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
diff --git a/src/f_finale.c b/src/f_finale.c
index 810af4e82f3ea4f08d035b626a6afffef52a0467..c6d957292138915a6def4b975648e81e708cfd5a 100644
--- a/src/f_finale.c
+++ b/src/f_finale.c
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -1065,12 +1065,12 @@ static const char *credits[] = {
"Julio \"Chaos Zero 64\" Guir",
"\"Hanicef\"",
"\"Hannu_Hanhi\"", // For many OpenGL performance improvements!
+ "\"hazepastel\"",
"Kepa \"Nev3r\" Iceta",
"Thomas \"Shadow Hog\" Igoe",
"Iestyn \"Monster Iestyn\" Jealous",
"\"Kaito Sinclaire\"",
"\"Kalaron\"", // Coded some of Sryder13's collection of OpenGL fixes, especially fog
- "\"katsy\"",
"Ronald \"Furyhunter\" Kinard", // The SDL2 port
"\"Lat'\"", // SRB2-CHAT, the chat window from Kart
"\"LZA\"",
@@ -1080,6 +1080,7 @@ static const char *credits[] = {
"Louis-Antoine \"LJ Sonic\" de Moulins", // de Rochefort doesn't quite fit on the screen sorry lol
"John \"JTE\" Muniz",
"Colin \"Sonict\" Pfaff",
+ "\"Radicalicious\"",
"James \"james\" Robert Roman",
"Sean \"Sryder13\" Ryder",
"Ehab \"Wolfy\" Saeed",
@@ -1103,7 +1104,8 @@ static const char *credits[] = {
"\"ChrispyPixels\"",
"Paul \"Boinciel\" Clempson",
"Sally \"TehRealSalt\" Cochenour",
- "\"Dave Lite\"",
+ "\"DaJumpJump\"", // New Ringslinger graphics (2.2.14)
+ "\"DeltaSanic\"",
"Desmond \"Blade\" DesJardins",
"Sherman \"CoatRack\" DesJardins",
"\"DirkTheHusky\"",
@@ -1119,6 +1121,7 @@ static const char *credits[] = {
"Alice \"Alacroix\" de Lemos",
"Logan \"Hyperchaotix\" McCloud",
"Alexander \"DrTapeworm\" Moench-Ford",
+ "\"orbitalviolet\"", // summit showdown hehehehe (aka Evertone)
"Andrew \"Senku Niola\" Moran",
"\"MotorRoach\"",
"Phillip \"TelosTurntable\" Robinson",
@@ -1127,6 +1130,7 @@ static const char *credits[] = {
"David \"Instant Sonic\" Spencer Jr.",
"\"SSNTails\"",
"Daniel \"Inazuma\" Trinh",
+ "Samuel \"Spectorious\" Tuttle",
"\"VelocitOni\"",
"Jarrett \"JEV3\" Voight",
"",
@@ -1135,6 +1139,7 @@ static const char *credits[] = {
"Victor \"VAdaPEGA\" Ara\x1Fjo", // Araújo
"Malcolm \"RedXVI\" Brown",
"Dave \"DemonTomatoDave\" Bulmer",
+ "Dan Cidoni", // aka Krabs
"Paul \"Boinciel\" Clempson",
"\"Cyan Helkaraxe\"",
"Claire \"clairebun\" Ellis",
@@ -1153,24 +1158,30 @@ static const char *credits[] = {
"Colette \"fickleheart\" Bordelon",
"Hank \"FuriousFox\" Brannock",
"Matthew \"Fawfulfan\" Chapman",
+ "Dan Cidoni", // aka Krabs
"Paul \"Boinciel\" Clempson",
"Sally \"TehRealSalt\" Cochenour",
"Desmond \"Blade\" DesJardins",
"Sherman \"CoatRack\" DesJardins",
"Ben \"Mystic\" Geyer",
"Nathan \"Jazz\" Giroux",
+ "\"GomaTheMascar\"",
"Vivian \"toaster\" Grannell",
"James \"SeventhSentinel\" Hall",
"Kepa \"Nev3r\" Iceta",
"Thomas \"Shadow Hog\" Igoe",
+ "Mujamel \"MK\" Khan",
"\"Kaito Sinclaire\"",
"Alexander \"DrTapeworm\" Moench-Ford",
+ "\"Radicalicious\"",
"\"Revan\"",
"Anna \"QueenDelta\" Sandlin",
"Wessel \"sphere\" Smit",
"\"SSNTails\"",
+ "Aaron \"Othius\" Stojkov",
"Rob Tisdell",
"\"Torgo\"",
+ "Samuel \"Spectorious\" Tuttle",
"Jarrett \"JEV3\" Voight",
"Johnny \"Sonikku\" Wallbank",
"Marco \"mazmazz\" Zafra",
@@ -3435,7 +3446,7 @@ void F_TitleScreenTicker(boolean run)
{
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
{
- if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (th->removing)
continue;
mo2 = (mobj_t *)th;
@@ -3645,7 +3656,7 @@ static void F_DrawContinueCharacter(INT32 dx, INT32 dy, UINT8 n)
(
HUD_HOOK(continue), luahuddrawlist_continue[n], contPlayers[n],
dx, dy, contskins[n]->highresscale,
- (INT32)(&contskins[n] - skins), cont_spr2[n][0], cont_spr2[n][1], cont_spr2[n][2] + 1, contColors[n], // add 1 to rotation to convert internal angle numbers (0-7) to WAD editor angle numbers (1-8)
+ (INT32)(contskins[n]->skinnum), cont_spr2[n][0], cont_spr2[n][1], cont_spr2[n][2] + 1, contColors[n], // add 1 to rotation to convert internal angle numbers (0-7) to WAD editor angle numbers (1-8)
imcontinuing ? continuetime : timetonext, imcontinuing
);
}
@@ -3711,7 +3722,7 @@ void F_ContinueDrawer(void)
else if (ncontinues > 10)
{
if (!(continuetime & 1) || continuetime > 17)
- V_DrawContinueIcon(x, 68, 0, (INT32)(&contskins[0] - skins), contColors[0]);
+ V_DrawContinueIcon(x, 68, 0, contskins[0]->skinnum, contColors[0]);
V_DrawScaledPatch(x+12, 66, 0, stlivex);
V_DrawRightAlignedString(x+38, 64, 0,
va("%d",(imcontinuing ? ncontinues-1 : ncontinues)));
@@ -3725,7 +3736,7 @@ void F_ContinueDrawer(void)
{
if (i == (ncontinues/2) && ((continuetime & 1) || continuetime > 17))
continue;
- V_DrawContinueIcon(x - (i*30), 68, 0, (INT32)(&contskins[0] - skins), contColors[0]);
+ V_DrawContinueIcon(x - (i*30), 68, 0, contskins[0]->skinnum, contColors[0]);
}
x = BASEVIDWIDTH>>1;
}
diff --git a/src/f_finale.h b/src/f_finale.h
index 4b777eb11fe45e65b6df4a81a24d47955763551b..e12a81cc62509543b26a443a4f3e954d64a8d851 100644
--- a/src/f_finale.h
+++ b/src/f_finale.h
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
diff --git a/src/filesrch.c b/src/filesrch.c
index 67a2e8976f88548c0f6f77b2143fbef6888d820f..7f104f8cac58ba1e109605b5b0598f14b3a86ce6 100644
--- a/src/filesrch.c
+++ b/src/filesrch.c
@@ -698,7 +698,7 @@ static void initdirpath(char *dirpath, size_t *dirpathindex, int depthleft)
dirpathindex[depthleft]--;
}
-//sortdir by name?
+//sortdir by name?
static int lumpnamecompare(const void *A, const void *B)
{
const lumpinfo_t *pA = A;
diff --git a/src/g_demo.c b/src/g_demo.c
index cfa34fc7e76c7978a52603fdd05f3e55d19f3e17..479020905ee9bb12f78fda614b4da70d13c75bbc 100644
--- a/src/g_demo.c
+++ b/src/g_demo.c
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -100,7 +100,7 @@ demoghost *ghosts = NULL;
// DEMO RECORDING
//
-#define DEMOVERSION 0x0012
+#define DEMOVERSION 0x0011
#define DEMOHEADER "\xF0" "SRB2Replay" "\x0F"
#define DF_GHOST 0x01 // This demo contains ghost data too!
@@ -185,11 +185,7 @@ void G_ReadDemoTiccmd(ticcmd_t *cmd, INT32 playernum)
if (ziptic & ZT_ANGLE)
oldcmd.angleturn = READINT16(demo_p);
if (ziptic & ZT_BUTTONS)
- {
oldcmd.buttons = (oldcmd.buttons & (BT_CAMLEFT|BT_CAMRIGHT)) | (READUINT16(demo_p) & ~(BT_CAMLEFT|BT_CAMRIGHT));
- if (demoversion < 0x0012 && oldcmd.buttons & BT_SPIN)
- oldcmd.buttons |= BT_SHIELD; // Copy BT_SPIN to BT_SHIELD for pre-Shield-button demos
- }
if (ziptic & ZT_AIMING)
oldcmd.aiming = READINT16(demo_p);
if (ziptic & ZT_LATENCY)
@@ -614,7 +610,7 @@ void G_ConsGhostTic(void)
mobj = NULL;
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
{
- if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (th->removing)
continue;
mobj = (mobj_t *)th;
if (mobj->type == (mobjtype_t)type && mobj->x == x && mobj->y == y && mobj->z == z)
@@ -1454,6 +1450,7 @@ void G_BeginRecording(void)
char *filename;
UINT16 totalfiles;
UINT8 *m;
+ save_t savebuffer;
if (demo_p)
return;
@@ -1603,7 +1600,11 @@ void G_BeginRecording(void)
}
// Save netvar data
- CV_SaveDemoVars(&demo_p);
+ savebuffer.buf = demo_p;
+ savebuffer.size = demoend - demo_p;
+ savebuffer.pos = 0;
+ CV_SaveDemoVars(&savebuffer);
+ demo_p = &savebuffer.buf[savebuffer.pos];
memset(&oldcmd,0,sizeof(oldcmd));
memset(&oldghost,0,sizeof(oldghost));
@@ -2236,10 +2237,24 @@ void G_DoPlayDemo(char *defdemoname)
// net var data
#ifdef OLD22DEMOCOMPAT
if (demoversion < 0x000d)
- CV_LoadOldDemoVars(&demo_p);
+ {
+ save_t savebuffer;
+ savebuffer.buf = demo_p;
+ savebuffer.size = demoend - demo_p;
+ savebuffer.pos = 0;
+ CV_LoadOldDemoVars(&savebuffer);
+ demo_p = &savebuffer.buf[savebuffer.pos];
+ }
else
#endif
- CV_LoadDemoVars(&demo_p);
+ {
+ save_t savebuffer;
+ savebuffer.buf = demo_p;
+ savebuffer.size = demoend - demo_p;
+ savebuffer.pos = 0;
+ CV_LoadDemoVars(&savebuffer);
+ demo_p = &savebuffer.buf[savebuffer.pos];
+ }
// Sigh ... it's an empty demo.
if (*demo_p == DEMOMARKER)
@@ -2677,7 +2692,7 @@ void G_DoPlayMetal(void)
// find metal sonic
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
{
- if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (th->removing)
continue;
mo = (mobj_t *)th;
diff --git a/src/g_demo.h b/src/g_demo.h
index 67f61f54de1166034d4376faa6ca340b39779e9d..d7c68287170f6f76a66f14b8980150167872cea0 100644
--- a/src/g_demo.h
+++ b/src/g_demo.h
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
diff --git a/src/g_game.c b/src/g_game.c
index 5d6954b9b7cef3c6e5b34a1c2a5115fde61fdfb8..1c186ae03149780b254c72f5243ed3d551350e52 100644
--- a/src/g_game.c
+++ b/src/g_game.c
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -256,8 +256,6 @@ boolean precache = true; // if true, load all graphics at start
INT16 prevmap, nextmap;
-static UINT8 *savebuffer;
-
// Analog Control
static void UserAnalog_OnChange(void);
static void UserAnalog2_OnChange(void);
@@ -403,29 +401,27 @@ consvar_t cv_cam_lockonboss[2] = {
CVAR_INIT ("cam2_lockaimassist", "Full", CV_SAVE|CV_ALLOWLUA, lockedassist_cons_t, NULL),
};
-consvar_t cv_moveaxis = CVAR_INIT ("joyaxis_move", "Y-Axis", CV_SAVE, joyaxis_cons_t, NULL);
-consvar_t cv_sideaxis = CVAR_INIT ("joyaxis_side", "X-Axis", CV_SAVE, joyaxis_cons_t, NULL);
-consvar_t cv_lookaxis = CVAR_INIT ("joyaxis_look", "X-Rudder-", CV_SAVE, joyaxis_cons_t, NULL);
-consvar_t cv_turnaxis = CVAR_INIT ("joyaxis_turn", "Z-Axis", CV_SAVE, joyaxis_cons_t, NULL);
-consvar_t cv_jumpaxis = CVAR_INIT ("joyaxis_jump", "None", CV_SAVE, joyaxis_cons_t, NULL);
-consvar_t cv_spinaxis = CVAR_INIT ("joyaxis_spin", "None", CV_SAVE, joyaxis_cons_t, NULL);
-consvar_t cv_shieldaxis = CVAR_INIT ("joyaxis_shield", "None", CV_SAVE, joyaxis_cons_t, NULL);
-consvar_t cv_fireaxis = CVAR_INIT ("joyaxis_fire", "Z-Rudder", CV_SAVE, joyaxis_cons_t, NULL);
-consvar_t cv_firenaxis = CVAR_INIT ("joyaxis_firenormal", "Z-Axis", CV_SAVE, joyaxis_cons_t, NULL);
-consvar_t cv_deadzone = CVAR_INIT ("joy_deadzone", "0.125", CV_FLOAT|CV_SAVE, zerotoone_cons_t, NULL);
-consvar_t cv_digitaldeadzone = CVAR_INIT ("joy_digdeadzone", "0.25", CV_FLOAT|CV_SAVE, zerotoone_cons_t, NULL);
-
-consvar_t cv_moveaxis2 = CVAR_INIT ("joyaxis2_move", "Y-Axis", CV_SAVE, joyaxis_cons_t, NULL);
-consvar_t cv_sideaxis2 = CVAR_INIT ("joyaxis2_side", "X-Axis", CV_SAVE, joyaxis_cons_t, NULL);
-consvar_t cv_lookaxis2 = CVAR_INIT ("joyaxis2_look", "X-Rudder-", CV_SAVE, joyaxis_cons_t, NULL);
-consvar_t cv_turnaxis2 = CVAR_INIT ("joyaxis2_turn", "Z-Axis", CV_SAVE, joyaxis_cons_t, NULL);
-consvar_t cv_jumpaxis2 = CVAR_INIT ("joyaxis2_jump", "None", CV_SAVE, joyaxis_cons_t, NULL);
-consvar_t cv_spinaxis2 = CVAR_INIT ("joyaxis2_spin", "None", CV_SAVE, joyaxis_cons_t, NULL);
-consvar_t cv_shieldaxis2 = CVAR_INIT ("joyaxis2_shield", "None", CV_SAVE, joyaxis_cons_t, NULL);
-consvar_t cv_fireaxis2 = CVAR_INIT ("joyaxis2_fire", "Z-Rudder", CV_SAVE, joyaxis_cons_t, NULL);
-consvar_t cv_firenaxis2 = CVAR_INIT ("joyaxis2_firenormal", "Z-Axis", CV_SAVE, joyaxis_cons_t, NULL);
-consvar_t cv_deadzone2 = CVAR_INIT ("joy_deadzone2", "0.125", CV_FLOAT|CV_SAVE, zerotoone_cons_t, NULL);
-consvar_t cv_digitaldeadzone2 = CVAR_INIT ("joy_digdeadzone2", "0.25", CV_FLOAT|CV_SAVE, zerotoone_cons_t, NULL);
+consvar_t cv_moveaxis = CVAR_INIT ("joyaxis_move", "Y-Axis", CV_SAVE, joyaxis_cons_t, NULL);
+consvar_t cv_sideaxis = CVAR_INIT ("joyaxis_side", "X-Axis", CV_SAVE, joyaxis_cons_t, NULL);
+consvar_t cv_lookaxis = CVAR_INIT ("joyaxis_look", "X-Rudder-", CV_SAVE, joyaxis_cons_t, NULL);
+consvar_t cv_turnaxis = CVAR_INIT ("joyaxis_turn", "Z-Axis", CV_SAVE, joyaxis_cons_t, NULL);
+consvar_t cv_jumpaxis = CVAR_INIT ("joyaxis_jump", "None", CV_SAVE, joyaxis_cons_t, NULL);
+consvar_t cv_spinaxis = CVAR_INIT ("joyaxis_spin", "None", CV_SAVE, joyaxis_cons_t, NULL);
+consvar_t cv_fireaxis = CVAR_INIT ("joyaxis_fire", "Z-Rudder", CV_SAVE, joyaxis_cons_t, NULL);
+consvar_t cv_firenaxis = CVAR_INIT ("joyaxis_firenormal", "Z-Axis", CV_SAVE, joyaxis_cons_t, NULL);
+consvar_t cv_deadzone = CVAR_INIT ("joy_deadzone", "0.125", CV_FLOAT|CV_SAVE, zerotoone_cons_t, NULL);
+consvar_t cv_digitaldeadzone = CVAR_INIT ("joy_digdeadzone", "0.25", CV_FLOAT|CV_SAVE, zerotoone_cons_t, NULL);
+
+consvar_t cv_moveaxis2 = CVAR_INIT ("joyaxis2_move", "Y-Axis", CV_SAVE, joyaxis_cons_t, NULL);
+consvar_t cv_sideaxis2 = CVAR_INIT ("joyaxis2_side", "X-Axis", CV_SAVE, joyaxis_cons_t, NULL);
+consvar_t cv_lookaxis2 = CVAR_INIT ("joyaxis2_look", "X-Rudder-", CV_SAVE, joyaxis_cons_t, NULL);
+consvar_t cv_turnaxis2 = CVAR_INIT ("joyaxis2_turn", "Z-Axis", CV_SAVE, joyaxis_cons_t, NULL);
+consvar_t cv_jumpaxis2 = CVAR_INIT ("joyaxis2_jump", "None", CV_SAVE, joyaxis_cons_t, NULL);
+consvar_t cv_spinaxis2 = CVAR_INIT ("joyaxis2_spin", "None", CV_SAVE, joyaxis_cons_t, NULL);
+consvar_t cv_fireaxis2 = CVAR_INIT ("joyaxis2_fire", "Z-Rudder", CV_SAVE, joyaxis_cons_t, NULL);
+consvar_t cv_firenaxis2 = CVAR_INIT ("joyaxis2_firenormal", "Z-Axis", CV_SAVE, joyaxis_cons_t, NULL);
+consvar_t cv_deadzone2 = CVAR_INIT ("joy_deadzone2", "0.125", CV_FLOAT|CV_SAVE, zerotoone_cons_t, NULL);
+consvar_t cv_digitaldeadzone2 = CVAR_INIT ("joy_digdeadzone2", "0.25", CV_FLOAT|CV_SAVE, zerotoone_cons_t, NULL);
player_t *seenplayer; // player we're aiming at right now
@@ -896,9 +892,6 @@ INT32 JoyAxis(joyaxis_e axissel)
case JA_SPIN:
axisval = cv_spinaxis.value;
break;
- case JA_SHIELD:
- axisval = cv_shieldaxis.value;
- break;
case JA_FIRE:
axisval = cv_fireaxis.value;
break;
@@ -972,9 +965,6 @@ INT32 Joy2Axis(joyaxis_e axissel)
case JA_SPIN:
axisval = cv_spinaxis2.value;
break;
- case JA_SHIELD:
- axisval = cv_shieldaxis2.value;
- break;
case JA_FIRE:
axisval = cv_fireaxis2.value;
break;
@@ -1342,10 +1332,10 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
if (PLAYERINPUTDOWN(ssplayer, GC_WEAPONPREV))
cmd->buttons |= BT_WEAPONPREV; // Previous Weapon
-#if NUM_WEAPONS > 7
-"Add extra inputs to g_input.h/gamecontrols_e, and fix conflicts in d_ticcmd.h/ticcmd_t/buttons"
+#if NUM_WEAPONS > 10
+"Add extra inputs to g_input.h/gamecontrols_e"
#endif
- //use the three avaliable bits to determine the weapon.
+ //use the four avaliable bits to determine the weapon.
cmd->buttons &= ~BT_WEAPONMASK;
for (i = 0; i < NUM_WEAPONS; ++i)
if (PLAYERINPUTDOWN(ssplayer, GC_WEPSLOT1 + i))
@@ -1364,15 +1354,9 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
if (PLAYERINPUTDOWN(ssplayer, GC_FIRENORMAL) || (usejoystick && axis > 0))
cmd->buttons |= BT_FIRENORMAL;
- // Toss flag button
if (PLAYERINPUTDOWN(ssplayer, GC_TOSSFLAG))
cmd->buttons |= BT_TOSSFLAG;
- // Shield button
- axis = PlayerJoyAxis(ssplayer, JA_SHIELD);
- if (PLAYERINPUTDOWN(ssplayer, GC_SHIELD) || (usejoystick && axis > 0))
- cmd->buttons |= BT_SHIELD;
-
// Lua scriptable buttons
if (PLAYERINPUTDOWN(ssplayer, GC_CUSTOM1))
cmd->buttons |= BT_CUSTOM1;
@@ -1386,7 +1370,7 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
if (PLAYERINPUTDOWN(ssplayer, GC_SPIN) || (usejoystick && axis > 0))
cmd->buttons |= BT_SPIN;
- if (gamestate != GS_LEVEL) // not in a level, don't build anything else
+ if (gamestate == GS_INTRO) // prevent crash in intro
{
cmd->angleturn = ticcmd_oldangleturn[forplayer];
cmd->aiming = G_ClipAimingPitch(myaiming);
@@ -1724,7 +1708,7 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
// At this point, cmd doesn't contain the final angle yet,
// So we need to temporarily transform it so Lua scripters
// don't need to handle it differently than in other hooks.
- if (addedtogame)
+ if (addedtogame && gamestate == GS_LEVEL)
{
INT16 extra = ticcmd_oldangleturn[forplayer] - player->oldrelangleturn;
INT16 origangle = cmd->angleturn;
@@ -1936,6 +1920,8 @@ void G_DoLoadLevel(boolean resetplayer)
//
void G_StartTitleCard(void)
{
+ ST_stopTitleCard();
+
// The title card has been disabled for this map.
// Oh well.
if (!G_IsTitleCardAvailable())
@@ -2624,6 +2610,7 @@ void G_PlayerReborn(INT32 player, boolean betweenmaps)
boolean spectator;
boolean outofcoop;
boolean removing;
+ boolean muted;
INT16 bot;
SINT8 pity;
INT16 rings;
@@ -2641,6 +2628,7 @@ void G_PlayerReborn(INT32 player, boolean betweenmaps)
spectator = players[player].spectator;
outofcoop = players[player].outofcoop;
removing = players[player].removing;
+ muted = players[player].muted;
pflags = (players[player].pflags & (PF_FLIPCAM|PF_ANALOGMODE|PF_DIRECTIONCHAR|PF_AUTOBRAKE|PF_TAGIT|PF_GAMETYPEOVER));
playerangleturn = players[player].angleturn;
oldrelangleturn = players[player].oldrelangleturn;
@@ -2718,6 +2706,7 @@ void G_PlayerReborn(INT32 player, boolean betweenmaps)
p->spectator = spectator;
p->outofcoop = outofcoop;
p->removing = removing;
+ p->muted = muted;
p->angleturn = playerangleturn;
p->oldrelangleturn = oldrelangleturn;
@@ -2774,7 +2763,6 @@ void G_PlayerReborn(INT32 player, boolean betweenmaps)
p->pflags |= PF_SPINDOWN;
p->pflags |= PF_ATTACKDOWN;
p->pflags |= PF_JUMPDOWN;
- p->pflags |= PF_SHIELDDOWN;
p->playerstate = PST_LIVE;
p->panim = PA_IDLE; // standing animation
@@ -3069,7 +3057,7 @@ void G_ChangePlayerReferences(mobj_t *oldmo, mobj_t *newmo)
// scan all thinkers
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
{
- if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (th->removing)
continue;
mo2 = (mobj_t *)th;
@@ -4396,7 +4384,7 @@ void G_LoadGameSettings(void)
// Loads the main data file, which stores information such as emblems found, etc.
void G_LoadGameData(gamedata_t *data)
{
- size_t length;
+ save_t savebuffer;
INT32 i, j;
UINT32 versionID;
@@ -4438,18 +4426,18 @@ void G_LoadGameData(gamedata_t *data)
return;
}
- length = FIL_ReadFile(va(pandf, srb2home, gamedatafilename), &savebuffer);
- if (!length)
+ savebuffer.size = FIL_ReadFile(va(pandf, srb2home, gamedatafilename), &savebuffer.buf);
+ if (!savebuffer.size)
{
// No gamedata. We can save a new one.
data->loaded = true;
return;
}
- save_p = savebuffer;
+ savebuffer.pos = 0;
// Version check
- versionID = READUINT32(save_p);
+ versionID = P_ReadUINT32(&savebuffer);
if (versionID != GAMEDATA_ID
#ifdef COMPAT_GAMEDATA_ID // backwards compat behavior
&& versionID != COMPAT_GAMEDATA_ID
@@ -4460,8 +4448,7 @@ void G_LoadGameData(gamedata_t *data)
if (strcmp(srb2home,"."))
gdfolder = srb2home;
- Z_Free(savebuffer);
- save_p = NULL;
+ Z_Free(savebuffer.buf);
I_Error("Game data is from another version of SRB2.\nDelete %s(maybe in %s) and try again.", gamedatafilename, gdfolder);
}
@@ -4473,14 +4460,14 @@ void G_LoadGameData(gamedata_t *data)
}
#endif
- data->totalplaytime = READUINT32(save_p);
+ data->totalplaytime = P_ReadUINT32(&savebuffer);
#ifdef COMPAT_GAMEDATA_ID
if (versionID == COMPAT_GAMEDATA_ID)
{
// We'll temporarily use the old condition when loading an older file.
// The proper mod-specific hash will get saved in afterwards.
- boolean modded = READUINT8(save_p);
+ boolean modded = P_ReadUINT8(&savebuffer);
if (modded && !savemoddata)
{
@@ -4500,13 +4487,13 @@ void G_LoadGameData(gamedata_t *data)
strcpy(currentfilename, gamedatafilename);
STRBUFCPY(backupfilename, strcat(currentfilename, bak));
- FIL_WriteFile(va(pandf, srb2home, backupfilename), savebuffer, length);
+ FIL_WriteFile(va(pandf, srb2home, backupfilename), &savebuffer.buf, savebuffer.size);
}
else
#endif
{
// Quick & dirty hash for what mod this save file is for.
- UINT32 modID = READUINT32(save_p);
+ UINT32 modID = P_ReadUINT32(&savebuffer);
UINT32 expectedID = quickncasehash(timeattackfolder, sizeof timeattackfolder);
if (modID != expectedID)
@@ -4518,50 +4505,50 @@ void G_LoadGameData(gamedata_t *data)
// TODO put another cipher on these things? meh, I don't care...
for (i = 0; i < NUMMAPS; i++)
- if ((data->mapvisited[i] = READUINT8(save_p)) > MV_MAX)
+ if ((data->mapvisited[i] = P_ReadUINT8(&savebuffer)) > MV_MAX)
goto datacorrupt;
// To save space, use one bit per collected/achieved/unlocked flag
for (i = 0; i < max_emblems;)
{
- rtemp = READUINT8(save_p);
+ rtemp = P_ReadUINT8(&savebuffer);
for (j = 0; j < 8 && j+i < max_emblems; ++j)
data->collected[j+i] = ((rtemp >> j) & 1);
i += j;
}
for (i = 0; i < max_extraemblems;)
{
- rtemp = READUINT8(save_p);
+ rtemp = P_ReadUINT8(&savebuffer);
for (j = 0; j < 8 && j+i < max_extraemblems; ++j)
data->extraCollected[j+i] = ((rtemp >> j) & 1);
i += j;
}
for (i = 0; i < max_unlockables;)
{
- rtemp = READUINT8(save_p);
+ rtemp = P_ReadUINT8(&savebuffer);
for (j = 0; j < 8 && j+i < max_unlockables; ++j)
data->unlocked[j+i] = ((rtemp >> j) & 1);
i += j;
}
for (i = 0; i < max_conditionsets;)
{
- rtemp = READUINT8(save_p);
+ rtemp = P_ReadUINT8(&savebuffer);
for (j = 0; j < 8 && j+i < max_conditionsets; ++j)
data->achieved[j+i] = ((rtemp >> j) & 1);
i += j;
}
- data->timesBeaten = READUINT32(save_p);
- data->timesBeatenWithEmeralds = READUINT32(save_p);
- data->timesBeatenUltimate = READUINT32(save_p);
+ data->timesBeaten = P_ReadUINT32(&savebuffer);
+ data->timesBeatenWithEmeralds = P_ReadUINT32(&savebuffer);
+ data->timesBeatenUltimate = P_ReadUINT32(&savebuffer);
// Main records
for (i = 0; i < NUMMAPS; ++i)
{
- recscore = READUINT32(save_p);
- rectime = (tic_t)READUINT32(save_p);
- recrings = READUINT16(save_p);
- save_p++; // compat
+ recscore = P_ReadUINT32(&savebuffer);
+ rectime = (tic_t)P_ReadUINT32(&savebuffer);
+ recrings = P_ReadUINT16(&savebuffer);
+ P_ReadUINT8(&savebuffer); // compat
if (recrings > 10000 || recscore > MAXSCORE)
goto datacorrupt;
@@ -4578,16 +4565,16 @@ void G_LoadGameData(gamedata_t *data)
// Nights records
for (i = 0; i < NUMMAPS; ++i)
{
- if ((recmares = READUINT8(save_p)) == 0)
+ if ((recmares = P_ReadUINT8(&savebuffer)) == 0)
continue;
G_AllocNightsRecordData((INT16)i, data);
for (curmare = 0; curmare < (recmares+1); ++curmare)
{
- data->nightsrecords[i]->score[curmare] = READUINT32(save_p);
- data->nightsrecords[i]->grade[curmare] = READUINT8(save_p);
- data->nightsrecords[i]->time[curmare] = (tic_t)READUINT32(save_p);
+ data->nightsrecords[i]->score[curmare] = P_ReadUINT32(&savebuffer);
+ data->nightsrecords[i]->grade[curmare] = P_ReadUINT8(&savebuffer);
+ data->nightsrecords[i]->time[curmare] = (tic_t)P_ReadUINT32(&savebuffer);
if (data->nightsrecords[i]->grade[curmare] > GRADE_S)
{
@@ -4599,8 +4586,7 @@ void G_LoadGameData(gamedata_t *data)
}
// done
- Z_Free(savebuffer);
- save_p = NULL;
+ Z_Free(savebuffer.buf);
// Don't consider loaded until it's a success!
// It used to do this much earlier, but this would cause the gamedata to
@@ -4621,8 +4607,7 @@ void G_LoadGameData(gamedata_t *data)
if (strcmp(srb2home,"."))
gdfolder = srb2home;
- Z_Free(savebuffer);
- save_p = NULL;
+ Z_Free(savebuffer.buf);
I_Error("Corrupt game data file.\nDelete %s(maybe in %s) and try again.", gamedatafilename, gdfolder);
}
@@ -4632,9 +4617,8 @@ void G_LoadGameData(gamedata_t *data)
// Saves the main data file, which stores information such as emblems found, etc.
void G_SaveGameData(gamedata_t *data)
{
- UINT8 *data_p;
+ save_t savebuffer;
- size_t length;
INT32 i, j;
UINT8 btemp;
@@ -4646,30 +4630,31 @@ void G_SaveGameData(gamedata_t *data)
if (!data->loaded)
return; // If never loaded (-nodata), don't save
- data_p = savebuffer = (UINT8 *)malloc(GAMEDATASIZE);
- if (!data_p)
+ savebuffer.size = GAMEDATASIZE;
+ savebuffer.buf = (UINT8 *)malloc(savebuffer.size);
+ if (!savebuffer.buf)
{
CONS_Alert(CONS_ERROR, M_GetText("No more free memory for saving game data\n"));
return;
}
+ savebuffer.pos = 0;
if (usedCheats)
{
- free(savebuffer);
- savebuffer = NULL;
+ free(savebuffer.buf);
return;
}
// Version test
- WRITEUINT32(data_p, GAMEDATA_ID);
+ P_WriteUINT32(&savebuffer, GAMEDATA_ID);
- WRITEUINT32(data_p, data->totalplaytime);
+ P_WriteUINT32(&savebuffer, data->totalplaytime);
- WRITEUINT32(data_p, quickncasehash(timeattackfolder, sizeof timeattackfolder));
+ P_WriteUINT32(&savebuffer, quickncasehash(timeattackfolder, sizeof timeattackfolder));
// TODO put another cipher on these things? meh, I don't care...
for (i = 0; i < NUMMAPS; i++)
- WRITEUINT8(data_p, (data->mapvisited[i] & MV_MAX));
+ P_WriteUINT8(&savebuffer, (data->mapvisited[i] & MV_MAX));
// To save space, use one bit per collected/achieved/unlocked flag
for (i = 0; i < MAXEMBLEMS;)
@@ -4677,7 +4662,7 @@ void G_SaveGameData(gamedata_t *data)
btemp = 0;
for (j = 0; j < 8 && j+i < MAXEMBLEMS; ++j)
btemp |= (data->collected[j+i] << j);
- WRITEUINT8(data_p, btemp);
+ P_WriteUINT8(&savebuffer, btemp);
i += j;
}
for (i = 0; i < MAXEXTRAEMBLEMS;)
@@ -4685,7 +4670,7 @@ void G_SaveGameData(gamedata_t *data)
btemp = 0;
for (j = 0; j < 8 && j+i < MAXEXTRAEMBLEMS; ++j)
btemp |= (data->extraCollected[j+i] << j);
- WRITEUINT8(data_p, btemp);
+ P_WriteUINT8(&savebuffer, btemp);
i += j;
}
for (i = 0; i < MAXUNLOCKABLES;)
@@ -4693,7 +4678,7 @@ void G_SaveGameData(gamedata_t *data)
btemp = 0;
for (j = 0; j < 8 && j+i < MAXUNLOCKABLES; ++j)
btemp |= (data->unlocked[j+i] << j);
- WRITEUINT8(data_p, btemp);
+ P_WriteUINT8(&savebuffer, btemp);
i += j;
}
for (i = 0; i < MAXCONDITIONSETS;)
@@ -4701,30 +4686,30 @@ void G_SaveGameData(gamedata_t *data)
btemp = 0;
for (j = 0; j < 8 && j+i < MAXCONDITIONSETS; ++j)
btemp |= (data->achieved[j+i] << j);
- WRITEUINT8(data_p, btemp);
+ P_WriteUINT8(&savebuffer, btemp);
i += j;
}
- WRITEUINT32(data_p, data->timesBeaten);
- WRITEUINT32(data_p, data->timesBeatenWithEmeralds);
- WRITEUINT32(data_p, data->timesBeatenUltimate);
+ P_WriteUINT32(&savebuffer, data->timesBeaten);
+ P_WriteUINT32(&savebuffer, data->timesBeatenWithEmeralds);
+ P_WriteUINT32(&savebuffer, data->timesBeatenUltimate);
// Main records
for (i = 0; i < NUMMAPS; i++)
{
if (data->mainrecords[i])
{
- WRITEUINT32(data_p, data->mainrecords[i]->score);
- WRITEUINT32(data_p, data->mainrecords[i]->time);
- WRITEUINT16(data_p, data->mainrecords[i]->rings);
+ P_WriteUINT32(&savebuffer, data->mainrecords[i]->score);
+ P_WriteUINT32(&savebuffer, data->mainrecords[i]->time);
+ P_WriteUINT16(&savebuffer, data->mainrecords[i]->rings);
}
else
{
- WRITEUINT32(data_p, 0);
- WRITEUINT32(data_p, 0);
- WRITEUINT16(data_p, 0);
+ P_WriteUINT32(&savebuffer, 0);
+ P_WriteUINT32(&savebuffer, 0);
+ P_WriteUINT16(&savebuffer, 0);
}
- WRITEUINT8(data_p, 0); // compat
+ P_WriteUINT8(&savebuffer, 0); // compat
}
// NiGHTS records
@@ -4732,25 +4717,22 @@ void G_SaveGameData(gamedata_t *data)
{
if (!data->nightsrecords[i] || !data->nightsrecords[i]->nummares)
{
- WRITEUINT8(data_p, 0);
+ P_WriteUINT8(&savebuffer, 0);
continue;
}
- WRITEUINT8(data_p, data->nightsrecords[i]->nummares);
+ P_WriteUINT8(&savebuffer, data->nightsrecords[i]->nummares);
for (curmare = 0; curmare < (data->nightsrecords[i]->nummares + 1); ++curmare)
{
- WRITEUINT32(data_p, data->nightsrecords[i]->score[curmare]);
- WRITEUINT8(data_p, data->nightsrecords[i]->grade[curmare]);
- WRITEUINT32(data_p, data->nightsrecords[i]->time[curmare]);
+ P_WriteUINT32(&savebuffer, data->nightsrecords[i]->score[curmare]);
+ P_WriteUINT8(&savebuffer, data->nightsrecords[i]->grade[curmare]);
+ P_WriteUINT32(&savebuffer, data->nightsrecords[i]->time[curmare]);
}
}
- length = data_p - savebuffer;
-
- FIL_WriteFile(va(pandf, srb2home, gamedatafilename), savebuffer, length);
- free(savebuffer);
- savebuffer = NULL;
+ FIL_WriteFile(va(pandf, srb2home, gamedatafilename), savebuffer.buf, savebuffer.pos);
+ free(savebuffer.buf);
}
#define VERSIONSIZE 16
@@ -4761,7 +4743,7 @@ void G_SaveGameData(gamedata_t *data)
//
void G_LoadGame(UINT32 slot, INT16 mapoverride)
{
- size_t length;
+ save_t savebuffer;
char vcheck[VERSIONSIZE];
char savename[255];
@@ -4778,18 +4760,18 @@ void G_LoadGame(UINT32 slot, INT16 mapoverride)
else
sprintf(savename, savegamename, slot);
- length = FIL_ReadFile(savename, &savebuffer);
- if (!length)
+ savebuffer.size = FIL_ReadFile(savename, &savebuffer.buf);
+ if (!savebuffer.size)
{
CONS_Printf(M_GetText("Couldn't read file %s\n"), savename);
return;
}
- save_p = savebuffer;
+ savebuffer.pos = 0;
memset(vcheck, 0, sizeof (vcheck));
sprintf(vcheck, (marathonmode ? "back-up %d" : "version %d"), VERSION);
- if (strcmp((const char *)save_p, (const char *)vcheck))
+ if (strcmp((const char *)&savebuffer.buf[savebuffer.pos], (const char *)vcheck))
{
#ifdef SAVEGAME_OTHERVERSIONS
M_StartMessage(M_GetText("Save game from different version.\nYou can load this savegame, but\nsaving afterwards will be disabled.\n\nDo you want to continue anyway?\n\n(Press 'Y' to confirm)\n"),
@@ -4799,15 +4781,14 @@ void G_LoadGame(UINT32 slot, INT16 mapoverride)
M_ClearMenus(true); // so ESC backs out to title
M_StartMessage(M_GetText("Save game from different version\n\nPress ESC\n"), NULL, MM_NOTHING);
Command_ExitGame_f();
- Z_Free(savebuffer);
- save_p = savebuffer = NULL;
+ Z_Free(savebuffer.buf);
// no cheating!
memset(&savedata, 0, sizeof(savedata));
#endif
return; // bad version
}
- save_p += VERSIONSIZE;
+ savebuffer.pos += VERSIONSIZE;
// if (demoplayback) // reset game engine
// G_StopDemo();
@@ -4816,13 +4797,12 @@ void G_LoadGame(UINT32 slot, INT16 mapoverride)
// automapactive = false;
// dearchive all the modifications
- if (!P_LoadGame(mapoverride))
+ if (!P_LoadGame(&savebuffer, mapoverride))
{
M_ClearMenus(true); // so ESC backs out to title
M_StartMessage(M_GetText("Savegame file corrupted\n\nPress ESC\n"), NULL, MM_NOTHING);
Command_ExitGame_f();
- Z_Free(savebuffer);
- save_p = savebuffer = NULL;
+ Z_Free(savebuffer.buf);
// no cheating!
memset(&savedata, 0, sizeof(savedata));
@@ -4830,13 +4810,12 @@ void G_LoadGame(UINT32 slot, INT16 mapoverride)
}
if (marathonmode)
{
- marathontime = READUINT32(save_p);
- marathonmode |= READUINT8(save_p);
+ marathontime = P_ReadUINT32(&savebuffer);
+ marathonmode |= P_ReadUINT8(&savebuffer);
}
// done
- Z_Free(savebuffer);
- save_p = savebuffer = NULL;
+ Z_Free(savebuffer.buf);
displayplayer = consoleplayer;
multiplayer = splitscreen = false;
@@ -4854,6 +4833,7 @@ void G_LoadGame(UINT32 slot, INT16 mapoverride)
//
void G_SaveGame(UINT32 slot, INT16 mapnum)
{
+ save_t savebuffer;
boolean saved;
char savename[256] = "";
const char *backup;
@@ -4867,33 +4847,32 @@ void G_SaveGame(UINT32 slot, INT16 mapnum)
gameaction = ga_nothing;
{
char name[VERSIONSIZE];
- size_t length;
- save_p = savebuffer = (UINT8 *)malloc(SAVEGAMESIZE);
- if (!save_p)
+ savebuffer.size = SAVEGAMESIZE;
+ savebuffer.buf = (UINT8 *)malloc(savebuffer.size);
+ if (!savebuffer.buf)
{
CONS_Alert(CONS_ERROR, M_GetText("No more free memory for saving game data\n"));
return;
}
+ savebuffer.pos = 0;
memset(name, 0, sizeof (name));
sprintf(name, (marathonmode ? "back-up %d" : "version %d"), VERSION);
- WRITEMEM(save_p, name, VERSIONSIZE);
+ P_WriteMem(&savebuffer, name, VERSIONSIZE);
- P_SaveGame(mapnum);
+ P_SaveGame(&savebuffer, mapnum);
if (marathonmode)
{
UINT32 writetime = marathontime;
if (!(marathonmode & MA_INGAME))
writetime += TICRATE*5; // live event backup penalty because we don't know how long it takes to get to the next map
- WRITEUINT32(save_p, writetime);
- WRITEUINT8(save_p, (marathonmode & ~MA_INIT));
+ P_WriteUINT32(&savebuffer, writetime);
+ P_WriteUINT8(&savebuffer, (marathonmode & ~MA_INIT));
}
- length = save_p - savebuffer;
- saved = FIL_WriteFile(backup, savebuffer, length);
- free(savebuffer);
- save_p = savebuffer = NULL;
+ saved = FIL_WriteFile(backup, savebuffer.buf, savebuffer.pos);
+ free(savebuffer.buf);
}
gameaction = ga_nothing;
@@ -4905,11 +4884,10 @@ void G_SaveGame(UINT32 slot, INT16 mapnum)
}
#define BADSAVE goto cleanup;
-#define CHECKPOS if (save_p >= end_p) BADSAVE
void G_SaveGameOver(UINT32 slot, boolean modifylives)
{
+ save_t savebuffer;
boolean saved = false;
- size_t length;
char vcheck[VERSIONSIZE];
char savename[255];
const char *backup;
@@ -4920,42 +4898,38 @@ void G_SaveGameOver(UINT32 slot, boolean modifylives)
sprintf(savename, savegamename, slot);
backup = va("%s",savename);
- length = FIL_ReadFile(savename, &savebuffer);
- if (!length)
+ savebuffer.size = FIL_ReadFile(savename, &savebuffer.buf);
+ if (!savebuffer.size)
{
CONS_Printf(M_GetText("Couldn't read file %s\n"), savename);
return;
}
+ savebuffer.pos = 0;
+
{
char temp[sizeof(timeattackfolder)];
- UINT8 *end_p = savebuffer + length;
UINT8 *lives_p;
SINT8 pllives;
#ifdef NEWSKINSAVES
INT16 backwardsCompat = 0;
#endif
- save_p = savebuffer;
// Version check
memset(vcheck, 0, sizeof (vcheck));
sprintf(vcheck, (marathonmode ? "back-up %d" : "version %d"), VERSION);
- if (strcmp((const char *)save_p, (const char *)vcheck)) BADSAVE
- save_p += VERSIONSIZE;
+ if (strcmp((const char *)&savebuffer.buf[savebuffer.pos], (const char *)vcheck)) BADSAVE
+ savebuffer.pos += VERSIONSIZE;
// P_UnArchiveMisc()
- (void)READINT16(save_p);
- CHECKPOS
- (void)READUINT16(save_p); // emeralds
- CHECKPOS
- READSTRINGN(save_p, temp, sizeof(temp)); // mod it belongs to
+ (void)P_ReadINT16(&savebuffer);
+ (void)P_ReadUINT16(&savebuffer); // emeralds
+ P_ReadStringN(&savebuffer, temp, sizeof(temp)); // mod it belongs to
if (strcmp(temp, timeattackfolder)) BADSAVE
// P_UnArchivePlayer()
- CHECKPOS
#ifdef NEWSKINSAVES
- backwardsCompat = READUINT16(save_p);
- CHECKPOS
+ backwardsCompat = P_ReadUINT16(&savebuffer);
if (backwardsCompat == NEWSKINSAVES) // New save, read skin names
#endif
@@ -4963,47 +4937,37 @@ void G_SaveGameOver(UINT32 slot, boolean modifylives)
char ourSkinName[SKINNAMESIZE+1];
char botSkinName[SKINNAMESIZE+1];
- READSTRINGN(save_p, ourSkinName, SKINNAMESIZE);
- CHECKPOS
+ P_ReadStringN(&savebuffer, ourSkinName, SKINNAMESIZE);
- READSTRINGN(save_p, botSkinName, SKINNAMESIZE);
- CHECKPOS
+ P_ReadStringN(&savebuffer, botSkinName, SKINNAMESIZE);
}
- WRITEUINT8(save_p, numgameovers);
- CHECKPOS
+ P_WriteUINT8(&savebuffer, numgameovers);
- lives_p = save_p;
- pllives = READSINT8(save_p); // lives
- CHECKPOS
+ lives_p = &savebuffer.buf[savebuffer.pos];
+ pllives = P_ReadSINT8(&savebuffer); // lives
if (modifylives && pllives < startinglivesbalance[numgameovers])
{
- pllives = startinglivesbalance[numgameovers];
- WRITESINT8(lives_p, pllives);
+ *lives_p = startinglivesbalance[numgameovers];
}
- (void)READINT32(save_p); // Score
- CHECKPOS
- (void)READINT32(save_p); // continues
+ (void)P_ReadINT32(&savebuffer); // Score
+ (void)P_ReadINT32(&savebuffer); // continues
// File end marker check
- CHECKPOS
- switch (READUINT8(save_p))
+ switch (P_ReadUINT8(&savebuffer))
{
case 0xb7:
{
UINT8 i, banksinuse;
- CHECKPOS
- banksinuse = READUINT8(save_p);
- CHECKPOS
+ banksinuse = P_ReadUINT8(&savebuffer);
if (banksinuse > NUM_LUABANKS)
BADSAVE
for (i = 0; i < banksinuse; i++)
{
- (void)READINT32(save_p);
- CHECKPOS
+ (void)P_ReadINT32(&savebuffer);
}
- if (READUINT8(save_p) != 0x1d)
+ if (P_ReadUINT8(&savebuffer) != 0x1d)
BADSAVE
}
case 0x1d:
@@ -5013,7 +4977,7 @@ void G_SaveGameOver(UINT32 slot, boolean modifylives)
}
// done
- saved = FIL_WriteFile(backup, savebuffer, length);
+ saved = FIL_WriteFile(backup, savebuffer.buf, savebuffer.size);
}
cleanup:
@@ -5021,11 +4985,9 @@ cleanup:
CONS_Printf(M_GetText("Game saved.\n"));
else if (!saved)
CONS_Alert(CONS_ERROR, M_GetText("Error while writing to %s for save slot %u, base: %s\n"), backup, slot, (marathonmode ? liveeventbackup : savegamename));
- Z_Free(savebuffer);
- save_p = savebuffer = NULL;
+ Z_Free(savebuffer.buf);
}
-#undef CHECKPOS
#undef BADSAVE
//
diff --git a/src/g_game.h b/src/g_game.h
index 0d5fc7e373179f9b9905ab9361bb2dafb146afb7..f72ea6b41b1b29b4b263b9039c0ad588bc78de17 100644
--- a/src/g_game.h
+++ b/src/g_game.h
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -71,8 +71,8 @@ typedef enum {
#define P_ControlStyle(player) ((((player)->pflags & PF_ANALOGMODE) ? CS_LMAOGALOG : 0) | (((player)->pflags & PF_DIRECTIONCHAR) ? CS_STANDARD : 0))
extern consvar_t cv_autobrake, cv_autobrake2;
-extern consvar_t cv_sideaxis, cv_turnaxis, cv_moveaxis, cv_lookaxis, cv_jumpaxis, cv_spinaxis, cv_shieldaxis, cv_fireaxis, cv_firenaxis, cv_deadzone, cv_digitaldeadzone;
-extern consvar_t cv_sideaxis2,cv_turnaxis2,cv_moveaxis2,cv_lookaxis2,cv_jumpaxis2,cv_spinaxis2,cv_shieldaxis2,cv_fireaxis2,cv_firenaxis2,cv_deadzone2,cv_digitaldeadzone2;
+extern consvar_t cv_sideaxis,cv_turnaxis,cv_moveaxis,cv_lookaxis,cv_jumpaxis,cv_spinaxis,cv_fireaxis,cv_firenaxis,cv_deadzone,cv_digitaldeadzone;
+extern consvar_t cv_sideaxis2,cv_turnaxis2,cv_moveaxis2,cv_lookaxis2,cv_jumpaxis2,cv_spinaxis2,cv_fireaxis2,cv_firenaxis2,cv_deadzone2,cv_digitaldeadzone2;
extern consvar_t cv_ghost_bestscore, cv_ghost_besttime, cv_ghost_bestrings, cv_ghost_last, cv_ghost_guest;
// hi here's some new controls
@@ -100,7 +100,6 @@ typedef enum
JA_JUMP = JA_DIGITAL,
JA_SPIN,
- JA_SHIELD,
JA_FIRE,
JA_FIRENORMAL,
} joyaxis_e;
diff --git a/src/g_input.c b/src/g_input.c
index 4a9692e8812ad89b20a85fb5f727acf9f8e52e86..4fbdf5e7586d41c4dd09f0a5e5c3e2aafa67c99d 100644
--- a/src/g_input.c
+++ b/src/g_input.c
@@ -1,7 +1,7 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -576,7 +576,9 @@ static const char *gamecontrolname[NUM_GAMECONTROLS] =
"weapon5",
"weapon6",
"weapon7",
- "shield",
+ "weapon8",
+ "weapon9",
+ "weapon10",
"fire",
"firenormal",
"tossflag",
@@ -691,7 +693,6 @@ void G_DefineDefaultControls(void)
gamecontroldefault[gcs_fps][GC_CENTERVIEW ][0] = KEY_LCTRL;
gamecontroldefault[gcs_fps][GC_JUMP ][0] = KEY_SPACE;
gamecontroldefault[gcs_fps][GC_SPIN ][0] = KEY_LSHIFT;
- gamecontroldefault[gcs_fps][GC_SHIELD ][0] = KEY_LALT;
gamecontroldefault[gcs_fps][GC_FIRE ][0] = KEY_RCTRL;
gamecontroldefault[gcs_fps][GC_FIRE ][1] = KEY_MOUSE1+0;
gamecontroldefault[gcs_fps][GC_FIRENORMAL ][0] = KEY_RALT;
@@ -712,7 +713,6 @@ void G_DefineDefaultControls(void)
gamecontroldefault[gcs_platform][GC_CENTERVIEW ][0] = KEY_END;
gamecontroldefault[gcs_platform][GC_JUMP ][0] = KEY_SPACE;
gamecontroldefault[gcs_platform][GC_SPIN ][0] = KEY_LSHIFT;
- gamecontroldefault[gcs_platform][GC_SHIELD ][0] = KEY_LALT;
gamecontroldefault[gcs_platform][GC_FIRE ][0] = 's';
gamecontroldefault[gcs_platform][GC_FIRE ][1] = KEY_MOUSE1+0;
gamecontroldefault[gcs_platform][GC_FIRENORMAL ][0] = 'w';
@@ -728,6 +728,9 @@ void G_DefineDefaultControls(void)
gamecontroldefault[i][GC_WEPSLOT5 ][0] = '5';
gamecontroldefault[i][GC_WEPSLOT6 ][0] = '6';
gamecontroldefault[i][GC_WEPSLOT7 ][0] = '7';
+ gamecontroldefault[i][GC_WEPSLOT8 ][0] = '8';
+ gamecontroldefault[i][GC_WEPSLOT9 ][0] = '9';
+ gamecontroldefault[i][GC_WEPSLOT10 ][0] = '0';
gamecontroldefault[i][GC_TOSSFLAG ][0] = '\'';
gamecontroldefault[i][GC_CAMTOGGLE ][0] = 'v';
gamecontroldefault[i][GC_CAMRESET ][0] = 'r';
@@ -743,34 +746,34 @@ void G_DefineDefaultControls(void)
// Gamepad controls -- same for both schemes
gamecontroldefault[i][GC_JUMP ][1] = KEY_JOY1+0; // A
gamecontroldefault[i][GC_SPIN ][1] = KEY_JOY1+2; // X
- gamecontroldefault[i][GC_SHIELD ][1] = KEY_JOY1+1; // B
- gamecontroldefault[i][GC_CUSTOM1 ][1] = KEY_JOY1+3; // Y
- gamecontroldefault[i][GC_CUSTOM2 ][1] = KEY_JOY1+4; // LB
- gamecontroldefault[i][GC_CENTERVIEW ][1] = KEY_JOY1+5; // RB
+ gamecontroldefault[i][GC_CUSTOM1 ][1] = KEY_JOY1+1; // B
+ gamecontroldefault[i][GC_CUSTOM2 ][1] = KEY_JOY1+3; // Y
gamecontroldefault[i][GC_CUSTOM3 ][1] = KEY_JOY1+8; // Left Stick
- gamecontroldefault[i][GC_CAMTOGGLE ][1] = KEY_JOY1+9; // Right Stick
- gamecontroldefault[i][GC_SCORES ][1] = KEY_JOY1+6; // Back
+ gamecontroldefault[i][GC_CAMTOGGLE ][1] = KEY_JOY1+4; // LB
+ gamecontroldefault[i][GC_CENTERVIEW ][1] = KEY_JOY1+5; // RB
+ gamecontroldefault[i][GC_SCREENSHOT ][1] = KEY_JOY1+6; // Back
gamecontroldefault[i][GC_SYSTEMMENU ][0] = KEY_JOY1+7; // Start
- gamecontroldefault[i][GC_VIEWPOINTNEXT][1] = KEY_HAT1+0; // D-Pad Up
- gamecontroldefault[i][GC_TOSSFLAG ][1] = KEY_HAT1+1; // D-Pad Down
gamecontroldefault[i][GC_WEAPONPREV ][1] = KEY_HAT1+2; // D-Pad Left
gamecontroldefault[i][GC_WEAPONNEXT ][1] = KEY_HAT1+3; // D-Pad Right
+ gamecontroldefault[i][GC_VIEWPOINTNEXT][1] = KEY_JOY1+9; // Right Stick
+ gamecontroldefault[i][GC_TOSSFLAG ][1] = KEY_HAT1+0; // D-Pad Up
+ gamecontroldefault[i][GC_SCORES ][1] = KEY_HAT1+1; // D-Pad Down
// Second player controls only have joypad defaults
gamecontrolbisdefault[i][GC_JUMP ][1] = KEY_2JOY1+0; // A
gamecontrolbisdefault[i][GC_SPIN ][1] = KEY_2JOY1+2; // X
- gamecontrolbisdefault[i][GC_SHIELD ][1] = KEY_2JOY1+1; // B
- gamecontrolbisdefault[i][GC_CUSTOM1 ][1] = KEY_2JOY1+3; // Y
- gamecontrolbisdefault[i][GC_CUSTOM2 ][1] = KEY_2JOY1+4; // LB
- gamecontrolbisdefault[i][GC_CENTERVIEW ][1] = KEY_2JOY1+5; // RB
+ gamecontrolbisdefault[i][GC_CUSTOM1 ][1] = KEY_2JOY1+1; // B
+ gamecontrolbisdefault[i][GC_CUSTOM2 ][1] = KEY_2JOY1+3; // Y
gamecontrolbisdefault[i][GC_CUSTOM3 ][1] = KEY_2JOY1+8; // Left Stick
- gamecontrolbisdefault[i][GC_CAMTOGGLE ][1] = KEY_2JOY1+9; // Right Stick
- //gamecontrolbisdefault[i][GC_SCORES ][1] = KEY_2JOY1+6; // Back
+ gamecontrolbisdefault[i][GC_CAMTOGGLE ][1] = KEY_2JOY1+4; // LB
+ gamecontrolbisdefault[i][GC_CENTERVIEW ][1] = KEY_2JOY1+5; // RB
+ gamecontrolbisdefault[i][GC_SCREENSHOT ][1] = KEY_2JOY1+6; // Back
//gamecontrolbisdefault[i][GC_SYSTEMMENU ][0] = KEY_2JOY1+7; // Start
- gamecontrolbisdefault[i][GC_VIEWPOINTNEXT][1] = KEY_2HAT1+0; // D-Pad Up
- gamecontrolbisdefault[i][GC_TOSSFLAG ][1] = KEY_2HAT1+1; // D-Pad Down
gamecontrolbisdefault[i][GC_WEAPONPREV ][1] = KEY_2HAT1+2; // D-Pad Left
gamecontrolbisdefault[i][GC_WEAPONNEXT ][1] = KEY_2HAT1+3; // D-Pad Right
+ gamecontrolbisdefault[i][GC_VIEWPOINTNEXT][1] = KEY_2JOY1+9; // Right Stick
+ gamecontrolbisdefault[i][GC_TOSSFLAG ][1] = KEY_2HAT1+0; // D-Pad Up
+ //gamecontrolbisdefault[i][GC_SCORES ][1] = KEY_2HAT1+1; // D-Pad Down
}
}
diff --git a/src/g_input.h b/src/g_input.h
index 48c103076667df50884767685386b98bd4865a02..e9c909e6e2c222360086874ddb27e2495b4e0381 100644
--- a/src/g_input.h
+++ b/src/g_input.h
@@ -74,7 +74,9 @@ typedef enum
GC_WEPSLOT5,
GC_WEPSLOT6,
GC_WEPSLOT7,
- GC_SHIELD,
+ GC_WEPSLOT8,
+ GC_WEPSLOT9,
+ GC_WEPSLOT10,
GC_FIRE,
GC_FIRENORMAL,
GC_TOSSFLAG,
diff --git a/src/hardware/hw_batching.c b/src/hardware/hw_batching.c
index b9ab2592d3f00a4fcdb4c1af31e2eaae484cd584..5d1af10e2a35e073472e9e4d6cbd90e31bdaec40 100644
--- a/src/hardware/hw_batching.c
+++ b/src/hardware/hw_batching.c
@@ -1,6 +1,6 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
-// Copyright (C) 2020-2023 by Sonic Team Junior.
+// Copyright (C) 2020-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -114,7 +114,7 @@ void HWR_ProcessPolygon(FSurfaceInfo *pSurf, FOutVector *pOutVerts, FUINT iNumPt
polygonArray[polygonArraySize].numVerts = iNumPts;
polygonArray[polygonArraySize].polyFlags = PolyFlags;
polygonArray[polygonArraySize].texture = current_texture;
- polygonArray[polygonArraySize].shader = (shader_target != -1) ? HWR_GetShaderFromTarget(shader_target) : shader_target;
+ polygonArray[polygonArraySize].shader = (shader_target != SHADER_NONE) ? HWR_GetShaderFromTarget(shader_target) : shader_target;
polygonArray[polygonArraySize].horizonSpecial = horizonSpecial;
// default to polygonArraySize so we don't lose order on horizon lines
// (yes, it's supposed to be negative, since we're sorting in that direction)
@@ -311,7 +311,6 @@ void HWR_RenderBatches(void)
int nextIndex = polygonIndexArray[polygonReadPos];
if (polygonArray[index].hash != polygonArray[nextIndex].hash)
{
- changeState = true;
nextShader = polygonArray[nextIndex].shader;
nextTexture = polygonArray[nextIndex].texture;
nextPolyFlags = polygonArray[nextIndex].polyFlags;
@@ -320,14 +319,17 @@ void HWR_RenderBatches(void)
nextTexture = 0;
if (currentShader != nextShader && cv_glshaders.value && gl_shadersavailable)
{
+ changeState = true;
changeShader = true;
}
if (currentTexture != nextTexture)
{
+ changeState = true;
changeTexture = true;
}
if (currentPolyFlags != nextPolyFlags)
{
+ changeState = true;
changePolyFlags = true;
}
if (cv_glshaders.value && gl_shadersavailable)
@@ -339,6 +341,7 @@ void HWR_RenderBatches(void)
currentSurfaceInfo.LightInfo.fade_start != nextSurfaceInfo.LightInfo.fade_start ||
currentSurfaceInfo.LightInfo.fade_end != nextSurfaceInfo.LightInfo.fade_end)
{
+ changeState = true;
changeSurfaceInfo = true;
}
}
@@ -346,6 +349,7 @@ void HWR_RenderBatches(void)
{
if (currentSurfaceInfo.PolyColor.rgba != nextSurfaceInfo.PolyColor.rgba)
{
+ changeState = true;
changeSurfaceInfo = true;
}
}
diff --git a/src/hardware/hw_batching.h b/src/hardware/hw_batching.h
index df1a4c38be5ceeea84fb61fa22ad31b8a8063dea..4214ca410c071994bb1e16576e5f4d6c4ebfb311 100644
--- a/src/hardware/hw_batching.h
+++ b/src/hardware/hw_batching.h
@@ -1,6 +1,6 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
-// Copyright (C) 2020-2023 by Sonic Team Junior.
+// Copyright (C) 2020-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
diff --git a/src/hardware/hw_cache.c b/src/hardware/hw_cache.c
index f282ca89184b9d47fe000f47e126880c0467b602..b71bf7007e03ab2cdb7d229d84aa5a57deb8cc8c 100644
--- a/src/hardware/hw_cache.c
+++ b/src/hardware/hw_cache.c
@@ -1258,20 +1258,29 @@ void HWR_SetMapPalette(void)
// Creates a hardware lighttable from the supplied lighttable.
// Returns the id of the hw lighttable, usable in FSurfaceInfo.
-UINT32 HWR_CreateLightTable(UINT8 *lighttable)
+UINT32 HWR_CreateLightTable(UINT8 *lighttable, RGBA_t *hw_lighttable)
{
- UINT32 i, id;
+ UINT32 i;
RGBA_t *palette = HWR_GetTexturePalette();
- RGBA_t *hw_lighttable = Z_Malloc(256 * 32 * sizeof(RGBA_t), PU_STATIC, NULL);
// To make the palette index -> RGBA mapping easier for the shader,
// the hardware lighttable is composed of RGBA colors instead of palette indices.
for (i = 0; i < 256 * 32; i++)
hw_lighttable[i] = palette[lighttable[i]];
- id = HWD.pfnCreateLightTable(hw_lighttable);
- Z_Free(hw_lighttable);
- return id;
+ return HWD.pfnCreateLightTable(hw_lighttable);
+}
+
+// Updates a hardware lighttable of a given id from the supplied lighttable.
+void HWR_UpdateLightTable(UINT32 id, UINT8 *lighttable, RGBA_t *hw_lighttable)
+{
+ UINT32 i;
+ RGBA_t *palette = HWR_GetTexturePalette();
+
+ for (i = 0; i < 256 * 32; i++)
+ hw_lighttable[i] = palette[lighttable[i]];
+
+ HWD.pfnUpdateLightTable(id, hw_lighttable);
}
// get hwr lighttable id for colormap, create it if it doesn't already exist
@@ -1285,25 +1294,41 @@ UINT32 HWR_GetLightTableID(extracolormap_t *colormap)
default_colormap = true;
}
+ UINT8 *colormap_pointer;
+
+ if (default_colormap)
+ colormap_pointer = colormaps; // don't actually use the data from the "default colormap"
+ else
+ colormap_pointer = colormap->colormap;
+
// create hw lighttable if there isn't one
- if (!colormap->gl_lighttable_id)
+ if (colormap->gl_lighttable.data == NULL)
{
- UINT8 *colormap_pointer;
+ Z_Malloc(256 * 32 * sizeof(RGBA_t), PU_HWRLIGHTTABLEDATA, &colormap->gl_lighttable.data);
+ }
- if (default_colormap)
- colormap_pointer = colormaps; // don't actually use the data from the "default colormap"
- else
- colormap_pointer = colormap->colormap;
- colormap->gl_lighttable_id = HWR_CreateLightTable(colormap_pointer);
+ // Generate the texture for this light table
+ if (!colormap->gl_lighttable.id)
+ {
+ colormap->gl_lighttable.id = HWR_CreateLightTable(colormap_pointer, colormap->gl_lighttable.data);
+ }
+ // Update the texture if it was directly changed by a script
+ else if (colormap->gl_lighttable.needs_update)
+ {
+ HWR_UpdateLightTable(colormap->gl_lighttable.id, colormap_pointer, colormap->gl_lighttable.data);
}
- return colormap->gl_lighttable_id;
+ colormap->gl_lighttable.needs_update = false;
+
+ return colormap->gl_lighttable.id;
}
// Note: all hardware lighttable ids assigned before this
// call become invalid and must not be used.
void HWR_ClearLightTables(void)
{
+ Z_FreeTag(PU_HWRLIGHTTABLEDATA);
+
if (vid.glstate == VID_GL_LIBRARY_LOADED)
HWD.pfnClearLightTables();
}
diff --git a/src/hardware/hw_defs.h b/src/hardware/hw_defs.h
index 7d06ceb60b86d8ef3fff3d30a21ce29213d6c600..77d7133b67112ec6498ebcf79d3c6432952d38c3 100644
--- a/src/hardware/hw_defs.h
+++ b/src/hardware/hw_defs.h
@@ -1,7 +1,7 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
diff --git a/src/hardware/hw_draw.c b/src/hardware/hw_draw.c
index ddce7d9885d7607e1cabf9bfc5c74ecf6258612b..ab253d5c80f8dc1b1a958fabbf607c224746c4a0 100644
--- a/src/hardware/hw_draw.c
+++ b/src/hardware/hw_draw.c
@@ -1,7 +1,7 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -256,8 +256,8 @@ void HWR_DrawStretchyFixedPatch(patch_t *gpatch, fixed_t x, fixed_t y, fixed_t p
}
// positions of the cx, cy, are between 0 and vid.width/vid.height now, we need them to be between -1 and 1
- cx = -1 + (cx / (vid.width/2));
- cy = 1 - (cy / (vid.height/2));
+ cx = -1.0f + (cx / (vid.width / 2.0f));
+ cy = 1.0f - (cy / (vid.height / 2.0f));
// fwidth and fheight are similar
fwidth /= vid.width / 2;
diff --git a/src/hardware/hw_drv.h b/src/hardware/hw_drv.h
index 45ee2933a69bca328be875ec2e449ca7f74cab39..a5fdc00a47c17e6b5cbeba5d074554a66672cde7 100644
--- a/src/hardware/hw_drv.h
+++ b/src/hardware/hw_drv.h
@@ -1,7 +1,7 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -71,6 +71,7 @@ EXPORT void HWRAPI(SetShaderInfo) (hwdshaderinfo_t info, INT32 value);
EXPORT void HWRAPI(SetPaletteLookup)(UINT8 *lut);
EXPORT UINT32 HWRAPI(CreateLightTable)(RGBA_t *hw_lighttable);
+EXPORT void HWRAPI(UpdateLightTable)(UINT32 id, RGBA_t *hw_lighttable);
EXPORT void HWRAPI(ClearLightTables)(void);
EXPORT void HWRAPI(SetScreenPalette)(RGBA_t *palette);
@@ -125,6 +126,7 @@ struct hwdriver_s
SetPaletteLookup pfnSetPaletteLookup;
CreateLightTable pfnCreateLightTable;
+ UpdateLightTable pfnUpdateLightTable;
ClearLightTables pfnClearLightTables;
SetScreenPalette pfnSetScreenPalette;
};
diff --git a/src/hardware/hw_glob.h b/src/hardware/hw_glob.h
index 5678cd593dfc017d2a1d067d76a8bc71954abb4f..bf9f7da3b4c126154fed2faf81761f348fbeed63 100644
--- a/src/hardware/hw_glob.h
+++ b/src/hardware/hw_glob.h
@@ -1,7 +1,7 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -133,7 +133,8 @@ void HWR_UnlockCachedPatch(GLPatch_t *gpatch);
void HWR_SetPalette(RGBA_t *palette);
void HWR_SetMapPalette(void);
-UINT32 HWR_CreateLightTable(UINT8 *lighttable);
+UINT32 HWR_CreateLightTable(UINT8 *lighttable, RGBA_t *hw_lighttable);
+void HWR_UpdateLightTable(UINT32 id, UINT8 *lighttable, RGBA_t *hw_lighttable);
UINT32 HWR_GetLightTableID(extracolormap_t *colormap);
void HWR_ClearLightTables(void);
diff --git a/src/hardware/hw_light.c b/src/hardware/hw_light.c
index e7769edbd8da2dbaa38debfabae9a34f25d121ee..9011ff05ec855c45291c95946adf110365c2839b 100644
--- a/src/hardware/hw_light.c
+++ b/src/hardware/hw_light.c
@@ -1,7 +1,7 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -395,6 +395,8 @@ light_t *t_lspr[NUMSPRITES] =
&lspr[NOLIGHT], // SPR_XMS4
&lspr[NOLIGHT], // SPR_XMS5
&lspr[NOLIGHT], // SPR_XMS6
+ &lspr[NOLIGHT], // SPR_SNTT
+ &lspr[NOLIGHT], // SPR_SSTT
&lspr[NOLIGHT], // SPR_FHZI
&lspr[NOLIGHT], // SPR_ROSY
@@ -428,6 +430,8 @@ light_t *t_lspr[NUMSPRITES] =
// Misc Scenery
&lspr[NOLIGHT], // SPR_STLG
&lspr[NOLIGHT], // SPR_DBAL
+ &lspr[NOLIGHT], // SPR_GINE
+ &lspr[NOLIGHT], // SPR_PPAL
// Powerup Indicators
&lspr[NOLIGHT], // SPR_ARMA
@@ -614,6 +618,9 @@ light_t *t_lspr[NUMSPRITES] =
&lspr[NOLIGHT], // SPR_GWLG
&lspr[NOLIGHT], // SPR_GWLR
+ // LJ Knuckles
+ &lspr[NOLIGHT], // SPR_OLDK,
+
// Free slots
&lspr[NOLIGHT],
&lspr[NOLIGHT],
diff --git a/src/hardware/hw_main.c b/src/hardware/hw_main.c
index f395a83905de4ecd65bef7017c41cfb8cef8f2f0..a5befe112c60bc704e58b3c3467944b2dd1ed971 100644
--- a/src/hardware/hw_main.c
+++ b/src/hardware/hw_main.c
@@ -1,7 +1,7 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -954,6 +954,7 @@ static boolean HWR_BlendMidtextureSurface(FSurfaceInfo *pSurf)
static void HWR_RenderMidtexture(INT32 gl_midtexture, float cliplow, float cliphigh, fixed_t worldtop, fixed_t worldbottom, fixed_t worldhigh, fixed_t worldlow, fixed_t worldtopslope, fixed_t worldbottomslope, fixed_t worldhighslope, fixed_t worldlowslope, UINT32 lightnum, FOutVector *inWallVerts)
{
+ sector_t *front, *back;
FOutVector wallVerts[4];
FSurfaceInfo Surf;
@@ -963,6 +964,16 @@ static void HWR_RenderMidtexture(INT32 gl_midtexture, float cliplow, float cliph
if (!HWR_BlendMidtextureSurface(&Surf))
return;
+ if (gl_linedef->frontsector->heightsec != -1)
+ front = §ors[gl_linedef->frontsector->heightsec];
+ else
+ front = gl_linedef->frontsector;
+
+ if (gl_linedef->backsector->heightsec != -1)
+ back = §ors[gl_linedef->backsector->heightsec];
+ else
+ back = gl_linedef->backsector;
+
fixed_t texheight = FixedDiv(textureheight[gl_midtexture], abs(gl_sidedef->scaley_mid));
INT32 repeats;
@@ -972,15 +983,15 @@ static void HWR_RenderMidtexture(INT32 gl_midtexture, float cliplow, float cliph
{
fixed_t high, low;
- if (gl_frontsector->ceilingheight > gl_backsector->ceilingheight)
- high = gl_backsector->ceilingheight;
+ if (front->ceilingheight > back->ceilingheight)
+ high = back->ceilingheight;
else
- high = gl_frontsector->ceilingheight;
+ high = front->ceilingheight;
- if (gl_frontsector->floorheight > gl_backsector->floorheight)
- low = gl_frontsector->floorheight;
+ if (front->floorheight > back->floorheight)
+ low = front->floorheight;
else
- low = gl_backsector->floorheight;
+ low = back->floorheight;
repeats = (high - low) / texheight;
if ((high - low) % texheight)
@@ -1007,8 +1018,8 @@ static void HWR_RenderMidtexture(INT32 gl_midtexture, float cliplow, float cliph
if (gl_curline->polyseg)
{
// Change this when polyobjects support slopes
- popentop = popentopslope = gl_curline->backsector->ceilingheight;
- popenbottom = popenbottomslope = gl_curline->backsector->floorheight;
+ popentop = popentopslope = back->ceilingheight;
+ popenbottom = popenbottomslope = back->floorheight;
}
else
{
@@ -1681,7 +1692,7 @@ static void HWR_ProcessSeg(void)
{
blendmode = PF_Masked;
- if ((rover->fofflags & FOF_TRANSLUCENT && !(rover->fofflags & FOF_SPLAT)) || rover->blend)
+ if ((rover->fofflags & FOF_TRANSLUCENT && !((rover->fofflags & FOF_SPLAT) && rover->alpha >= 255)) || rover->blend)
{
blendmode = rover->blend ? HWR_GetBlendModeFlag(rover->blend) : PF_Translucent;
Surf.PolyColor.s.alpha = max(0, min(rover->alpha, 255));
@@ -1838,7 +1849,7 @@ static void HWR_ProcessSeg(void)
{
blendmode = PF_Masked;
- if ((rover->fofflags & FOF_TRANSLUCENT && !(rover->fofflags & FOF_SPLAT)) || rover->blend)
+ if ((rover->fofflags & FOF_TRANSLUCENT && !((rover->fofflags & FOF_SPLAT) && rover->alpha >= 255)) || rover->blend)
{
blendmode = rover->blend ? HWR_GetBlendModeFlag(rover->blend) : PF_Translucent;
Surf.PolyColor.s.alpha = max(0, min(rover->alpha, 255));
@@ -2480,19 +2491,19 @@ static void HWR_Subsector(size_t num)
rover; rover = rover->next)
{
fixed_t bottomCullHeight, topCullHeight, centerHeight;
-
+
if (!(rover->fofflags & FOF_EXISTS) || !(rover->fofflags & FOF_RENDERPLANES))
continue;
if (sub->validcount == validcount)
continue;
-
+
// rendering heights for bottom and top planes
bottomCullHeight = P_GetFFloorBottomZAt(rover, viewx, viewy);
topCullHeight = P_GetFFloorTopZAt(rover, viewx, viewy);
-
+
if (gl_frontsector->cullheight)
{
- if (HWR_DoCulling(gl_frontsector->cullheight, viewsector->cullheight, gl_viewz, FIXED_TO_FLOAT(bottomCullHeight), FIXED_TO_FLOAT(topCullHeight)))
+ if (HWR_DoCulling(gl_frontsector->cullheight, viewsector->cullheight, gl_viewz, FIXED_TO_FLOAT(*rover->bottomheight), FIXED_TO_FLOAT(*rover->topheight)))
continue;
}
@@ -2519,7 +2530,7 @@ static void HWR_Subsector(size_t num)
alpha, rover->master->frontsector, PF_Fog|PF_NoTexture,
true, false, rover->master->frontsector->extra_colormap);
}
- else if ((rover->fofflags & FOF_TRANSLUCENT && !(rover->fofflags & FOF_SPLAT)) || rover->blend) // SoM: Flags are more efficient
+ else if ((rover->fofflags & FOF_TRANSLUCENT && !((rover->fofflags & FOF_SPLAT) && rover->alpha >= 255)) || rover->blend) // SoM: Flags are more efficient
{
light = R_GetPlaneLight(gl_frontsector, centerHeight, viewz < bottomCullHeight ? true : false);
@@ -2565,7 +2576,7 @@ static void HWR_Subsector(size_t num)
alpha, rover->master->frontsector, PF_Fog|PF_NoTexture,
true, false, rover->master->frontsector->extra_colormap);
}
- else if ((rover->fofflags & FOF_TRANSLUCENT && !(rover->fofflags & FOF_SPLAT)) || rover->blend)
+ else if ((rover->fofflags & FOF_TRANSLUCENT && !((rover->fofflags & FOF_SPLAT) && rover->alpha >= 255)) || rover->blend)
{
light = R_GetPlaneLight(gl_frontsector, centerHeight, viewz < topCullHeight ? true : false);
@@ -3094,7 +3105,7 @@ static void HWR_SplitSprite(gl_vissprite_t *spr)
// baseWallVerts is used to know the final shape to easily get the vertex
// co-ordinates
memcpy(wallVerts, baseWallVerts, sizeof(baseWallVerts));
-
+
fixed_t newalpha = spr->mobj->alpha;
// if sprite has linkdraw, then dont write to z-buffer (by not using PF_Occlude)
@@ -3139,7 +3150,7 @@ static void HWR_SplitSprite(gl_vissprite_t *spr)
blend = HWR_GetBlendModeFlag(blendmode)|occlusion;
if (!occlusion) use_linkdraw_hack = true;
}
-
+
Surf.PolyColor.s.alpha = FixedMul(newalpha, Surf.PolyColor.s.alpha);
if (HWR_UseShader())
@@ -3338,7 +3349,7 @@ static void HWR_DrawBoundingBox(gl_vissprite_t *vis)
v[15].y = v[16].y = v[17].y = v[21].y = v[22].y = v[23].y = vis->gzt; // top
Surf.PolyColor = V_GetColor(R_GetBoundingBoxColor(vis->mobj));
-
+
HWR_ProcessPolygon(&Surf, v, 24, (cv_renderhitboxgldepth.value ? 0 : PF_NoDepthTest)|PF_Modulated|PF_NoTexture|PF_WireFrame, SHADER_NONE, false);
}
@@ -3634,7 +3645,7 @@ static void HWR_DrawSprite(gl_vissprite_t *spr)
blend = HWR_GetBlendModeFlag(blendmode)|occlusion;
if (!occlusion) use_linkdraw_hack = true;
}
-
+
Surf.PolyColor.s.alpha = FixedMul(newalpha, Surf.PolyColor.s.alpha);
if (spr->renderflags & RF_SHADOWEFFECTS)
@@ -5594,7 +5605,7 @@ void HWR_RenderPlayerView(INT32 viewnumber, player_t *player)
// Can't have palette rendering if shaders are disabled.
boolean HWR_ShouldUsePaletteRendering(void)
{
- return (cv_glpaletterendering.value && HWR_UseShader());
+ return (pMasterPalette != NULL && cv_glpaletterendering.value && HWR_UseShader());
}
// enable or disable palette rendering state depending on settings and availability
@@ -5711,7 +5722,7 @@ consvar_t cv_glbatching = CVAR_INIT ("gr_batching", "On", 0, CV_OnOff, NULL);
static CV_PossibleValue_t glpalettedepth_cons_t[] = {{16, "16 bits"}, {24, "24 bits"}, {0, NULL}};
-consvar_t cv_glpaletterendering = CVAR_INIT ("gr_paletterendering", "Off", CV_SAVE|CV_CALL, CV_OnOff, CV_glpaletterendering_OnChange);
+consvar_t cv_glpaletterendering = CVAR_INIT ("gr_paletterendering", "On", CV_SAVE|CV_CALL, CV_OnOff, CV_glpaletterendering_OnChange);
consvar_t cv_glpalettedepth = CVAR_INIT ("gr_palettedepth", "16 bits", CV_SAVE|CV_CALL, glpalettedepth_cons_t, CV_glpalettedepth_OnChange);
#define ONLY_IF_GL_LOADED if (vid.glstate != VID_GL_LIBRARY_LOADED) return;
@@ -5783,6 +5794,7 @@ void HWR_AddCommands(void)
CV_RegisterVar(&cv_glskydome);
CV_RegisterVar(&cv_glspritebillboarding);
CV_RegisterVar(&cv_glfakecontrast);
+ CV_RegisterVar(&cv_glslopecontrast);
CV_RegisterVar(&cv_glshearing);
CV_RegisterVar(&cv_glshaders);
diff --git a/src/hardware/hw_main.h b/src/hardware/hw_main.h
index ea610a48b477824fd1d59e45ce70802bce5e460a..2277c32f3c07b6162148b5b3e56b8ac81dac351b 100644
--- a/src/hardware/hw_main.h
+++ b/src/hardware/hw_main.h
@@ -1,7 +1,7 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
diff --git a/src/hardware/hw_md2.c b/src/hardware/hw_md2.c
index 2616d4085c4c9e8fa81e6ce82bfa2f30f072f68f..931867142200338b7635d7b04307df587eafa129 100644
--- a/src/hardware/hw_md2.c
+++ b/src/hardware/hw_md2.c
@@ -1,7 +1,7 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -1193,6 +1193,90 @@ static void adjustTextureCoords(model_t *model, patch_t *patch)
model->max_t = gpatch->max_t;
}
+static INT32 GetAnimDuration(mobj_t *mobj) //part of p_mobj's setplayermobjstate logic, used to make sure that anim durations are actually correct when the speed gets adjusted on players
+{
+ player_t *player = mobj->player;
+ INT32 tics = mobj->state->tics;
+
+ if (!(mobj->frame & FF_ANIMATE) && mobj->anim_duration) //set manually by something through lua
+ return mobj->anim_duration;
+
+ if (!player && mobj->type == MT_TAILSOVERLAY && mobj->tracer) //so tails overlays interpolate properly
+ player = mobj->tracer->player;
+ if (player)
+ {
+ if (player->panim == PA_EDGE && (player->charflags & SF_FASTEDGE))
+ tics = 2;
+ else if (player->powers[pw_tailsfly] && (!(player->mo->eflags & MFE_UNDERWATER) || (mobj->type == MT_PLAYER))) //tailsoverlay does not get adjusted from these rules when underwater
+ {
+ if (player->fly1 > 0)
+ tics = 1;
+ else if (!(player->mo->eflags & MFE_UNDERWATER))
+ tics = 2;
+ else
+ tics = 4;
+ }
+ else if (!(disableSpeedAdjust || player->charflags & SF_NOSPEEDADJUST))
+ {
+ fixed_t speed;// = FixedDiv(player->speed, FixedMul(mobj->scale, player->mo->movefactor));
+ if (player->panim == PA_FALL)
+ {
+ speed = FixedDiv(abs(mobj->momz), mobj->scale);
+ if (speed < 10<<FRACBITS)
+ tics = 4;
+ else if (speed < 20<<FRACBITS)
+ tics = 3;
+ else if (speed < 30<<FRACBITS)
+ tics = 2;
+ else
+ tics = 1;
+ }
+ else if (player->panim == PA_ABILITY2 && player->charability2 == CA2_SPINDASH)
+ {
+ fixed_t step = (player->maxdash - player->mindash)/4;
+ speed = (player->dashspeed - player->mindash);
+ if (speed > 3*step)
+ tics = 1;
+ else if (speed > step)
+ tics = 2;
+ else
+ tics = 3;
+ }
+ else
+ {
+ speed = FixedDiv(player->speed, FixedMul(mobj->scale, player->mo->movefactor));
+ if (player->panim == PA_ROLL || player->panim == PA_JUMP)
+ {
+ if (speed > 16<<FRACBITS)
+ tics = 1;
+ else
+ tics = 2;
+ }
+ else if (P_IsObjectOnGround(mobj) || ((player->charability == CA_FLOAT || player->charability == CA_SLOWFALL) && player->secondjump == 1) || player->powers[pw_super]) // Only if on the ground or superflying.
+ {
+ if (player->panim == PA_WALK)
+ {
+ if (speed > 12<<FRACBITS)
+ tics = 2;
+ else if (speed > 6<<FRACBITS)
+ tics = 3;
+ else
+ tics = 4;
+ }
+ else if ((player->panim == PA_RUN) || (player->panim == PA_DASH))
+ {
+ if (speed > 52<<FRACBITS)
+ tics = 1;
+ else
+ tics = 2;
+ }
+ }
+ }
+ }
+ }
+ return tics;
+}
+
//
// HWR_DrawModel
//
@@ -1266,7 +1350,7 @@ boolean HWR_DrawModel(gl_vissprite_t *spr)
{
patch_t *gpatch, *blendgpatch;
GLPatch_t *hwrPatch = NULL, *hwrBlendPatch = NULL;
- float durs = (float)spr->mobj->state->tics;
+ float durs = GetAnimDuration(spr->mobj);
float tics = (float)spr->mobj->tics;
const boolean papersprite = (R_ThingIsPaperSprite(spr->mobj) && !R_ThingIsFloorSprite(spr->mobj));
const UINT8 flip = (UINT8)(!(spr->mobj->eflags & MFE_VERTICALFLIP) != !R_ThingVerticallyFlipped(spr->mobj));
@@ -1287,9 +1371,9 @@ boolean HWR_DrawModel(gl_vissprite_t *spr)
}
// Apparently people don't like jump frames like that, so back it goes
- //if (tics > durs)
- //durs = tics;
-
+ if (tics > durs)
+ durs = tics;
+
// Make linkdraw objects use their tracer's alpha value
fixed_t newalpha = spr->mobj->alpha;
if ((spr->mobj->flags2 & MF2_LINKDRAW) && spr->mobj->tracer)
@@ -1308,7 +1392,7 @@ boolean HWR_DrawModel(gl_vissprite_t *spr)
Surf.PolyColor.s.alpha = (spr->mobj->flags2 & MF2_SHADOW) ? 0x40 : 0xff;
Surf.PolyFlags = HWR_GetBlendModeFlag(blendmode);
}
-
+
Surf.PolyColor.s.alpha = FixedMul(newalpha, Surf.PolyColor.s.alpha);
// don't forget to enable the depth test because we can't do this
@@ -1607,7 +1691,6 @@ boolean HWR_DrawModel(gl_vissprite_t *spr)
HWD.pfnDrawModel(md2->model, frame, durs, tics, nextFrame, &p, md2->scale * xs, md2->scale * ys, flip, hflip, &Surf);
}
}
-
return true;
}
diff --git a/src/hardware/hw_shaders.c b/src/hardware/hw_shaders.c
index ee1e2acdf58cd73d810c1884cfc5ffe3e4797389..fde67375f016e8132004ee14231cc31e575f5a30 100644
--- a/src/hardware/hw_shaders.c
+++ b/src/hardware/hw_shaders.c
@@ -1,6 +1,6 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
-// Copyright (C) 2021 by Sonic Team Junior.
+// Copyright (C) 2021-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
diff --git a/src/hardware/hw_shaders.h b/src/hardware/hw_shaders.h
index bb0e6a232edc45c2a39ac21a9f56beca4c973ebb..38a2d991191dc7531fb2e72e70b3b5946e98b245 100644
--- a/src/hardware/hw_shaders.h
+++ b/src/hardware/hw_shaders.h
@@ -1,6 +1,6 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
-// Copyright (C) 2021 by Sonic Team Junior.
+// Copyright (C) 2021-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
diff --git a/src/hardware/r_opengl/ogl_win.c b/src/hardware/r_opengl/ogl_win.c
index c9bf601442a5531b35d0ac629730aa83978d17a6..ec8fc9bdb8b77f99f03b97af7df9cbdedea864f4 100644
--- a/src/hardware/r_opengl/ogl_win.c
+++ b/src/hardware/r_opengl/ogl_win.c
@@ -117,7 +117,7 @@ BOOL WINAPI DllMain(HINSTANCE hinstDLL, // handle to DLL module
#define pwglDeleteContext wglDeleteContext;
#define pwglMakeCurrent wglMakeCurrent;
#else
-static HMODULE OGL32, GLU32;
+static HMODULE OGL32;
typedef void *(WINAPI *PFNwglGetProcAddress) (const char *);
static PFNwglGetProcAddress pwglGetProcAddress;
typedef HGLRC (WINAPI *PFNwglCreateContext) (HDC hdc);
@@ -132,13 +132,6 @@ static PFNwglMakeCurrent pwglMakeCurrent;
void *GetGLFunc(const char *proc)
{
void *func = NULL;
- if (strncmp(proc, "glu", 3) == 0)
- {
- if (GLU32)
- func = GetProcAddress(GLU32, proc);
- else
- return NULL;
- }
if (pwglGetProcAddress)
func = pwglGetProcAddress(proc);
if (!func)
@@ -155,8 +148,6 @@ boolean LoadGL(void)
if (!OGL32)
return 0;
- GLU32 = LoadLibrary("GLU32.DLL");
-
pwglGetProcAddress = GetGLFunc("wglGetProcAddress");
pwglCreateContext = GetGLFunc("wglCreateContext");
pwglDeleteContext = GetGLFunc("wglDeleteContext");
@@ -528,7 +519,6 @@ EXPORT void HWRAPI(Shutdown) (void)
ReleaseDC(hWnd, hDC);
hDC = NULL;
}
- FreeLibrary(GLU32);
FreeLibrary(OGL32);
GL_DBG_Printf ("HWRAPI Shutdown(DONE)\n");
}
diff --git a/src/hardware/r_opengl/r_opengl.c b/src/hardware/r_opengl/r_opengl.c
index 75a92c2fb33ad542b0931786a9b4688a9f9dccbc..02a32957a2b940ac15490c0e83fb57658da24c5e 100644
--- a/src/hardware/r_opengl/r_opengl.c
+++ b/src/hardware/r_opengl/r_opengl.c
@@ -96,6 +96,7 @@ static GLint min_filter = GL_LINEAR;
static GLint mag_filter = GL_LINEAR;
static GLint anisotropic_filter = 0;
static boolean model_lighting = false;
+boolean supportMipMap = false;
const GLubyte *gl_version = NULL;
const GLubyte *gl_renderer = NULL;
@@ -417,9 +418,6 @@ static PFNglCopyTexImage2D pglCopyTexImage2D;
typedef void (APIENTRY * PFNglCopyTexSubImage2D) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
static PFNglCopyTexSubImage2D pglCopyTexSubImage2D;
#endif
-/* GLU functions */
-typedef GLint (APIENTRY * PFNgluBuild2DMipmaps) (GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *data);
-static PFNgluBuild2DMipmaps pgluBuild2DMipmaps;
/* 1.2 functions for 3D textures */
typedef void (APIENTRY * PFNglTexImage3D) (GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
@@ -708,9 +706,6 @@ void SetupGLFunc4(void)
pglUniform3fv = GetGLFunc("glUniform3fv");
pglGetUniformLocation = GetGLFunc("glGetUniformLocation");
#endif
-
- // GLU
- pgluBuild2DMipmaps = GetGLFunc("gluBuild2DMipmaps");
}
EXPORT boolean HWRAPI(InitShaders) (void)
@@ -718,7 +713,7 @@ EXPORT boolean HWRAPI(InitShaders) (void)
#ifdef GL_SHADERS
if (!pglUseProgram)
return false;
-
+
gl_fallback_shader.vertex_shader = Z_StrDup(GLSL_FALLBACK_VERTEX_SHADER);
gl_fallback_shader.fragment_shader = Z_StrDup(GLSL_FALLBACK_FRAGMENT_SHADER);
@@ -1617,7 +1612,8 @@ EXPORT void HWRAPI(UpdateTexture) (GLMipmap_t *pTexInfo)
//pglTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, ptex);
if (MipMap)
{
- pgluBuild2DMipmaps(GL_TEXTURE_2D, GL_LUMINANCE_ALPHA, w, h, GL_RGBA, GL_UNSIGNED_BYTE, ptex);
+ pglTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE);
+ pglTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE_ALPHA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, ptex);
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_LOD, 0);
if (pTexInfo->flags & TF_TRANSPARENT)
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LOD, 0); // No mippmaps on transparent stuff
@@ -1638,7 +1634,8 @@ EXPORT void HWRAPI(UpdateTexture) (GLMipmap_t *pTexInfo)
//pglTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, ptex);
if (MipMap)
{
- pgluBuild2DMipmaps(GL_TEXTURE_2D, GL_ALPHA, w, h, GL_RGBA, GL_UNSIGNED_BYTE, ptex);
+ pglTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE);
+ pglTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, ptex);
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_LOD, 0);
if (pTexInfo->flags & TF_TRANSPARENT)
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LOD, 0); // No mippmaps on transparent stuff
@@ -1658,7 +1655,8 @@ EXPORT void HWRAPI(UpdateTexture) (GLMipmap_t *pTexInfo)
{
if (MipMap)
{
- pgluBuild2DMipmaps(GL_TEXTURE_2D, textureformatGL, w, h, GL_RGBA, GL_UNSIGNED_BYTE, ptex);
+ pglTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE);
+ pglTexImage2D(GL_TEXTURE_2D, 0, textureformatGL, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, ptex);
// Control the mipmap level of detail
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_LOD, 0); // the lower the number, the higer the detail
if (pTexInfo->flags & TF_TRANSPARENT)
@@ -2241,7 +2239,7 @@ EXPORT void HWRAPI(SetSpecialState) (hwdspecialstate_t IdState, INT32 Value)
mag_filter = GL_LINEAR;
min_filter = GL_NEAREST;
}
- if (!pgluBuild2DMipmaps)
+ if (!supportMipMap)
{
MipMap = GL_FALSE;
min_filter = GL_LINEAR;
@@ -3257,6 +3255,24 @@ EXPORT UINT32 HWRAPI(CreateLightTable)(RGBA_t *hw_lighttable)
return item->id;
}
+EXPORT void HWRAPI(UpdateLightTable)(UINT32 id, RGBA_t *hw_lighttable)
+{
+ LTListItem *item = LightTablesHead;
+ while (item && item->id != id)
+ item = item->next;
+
+ if (item)
+ {
+ pglBindTexture(GL_TEXTURE_2D, item->id);
+
+ // Just update it
+ pglTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 256, 32, GL_RGBA, GL_UNSIGNED_BYTE, hw_lighttable);
+
+ // restore previously bound texture
+ pglBindTexture(GL_TEXTURE_2D, tex_downloaded);
+ }
+}
+
// Delete light table textures, ids given before become invalid and must not be used.
EXPORT void HWRAPI(ClearLightTables)(void)
{
diff --git a/src/hardware/r_opengl/r_opengl.h b/src/hardware/r_opengl/r_opengl.h
index f7e33c46aa36b9c416a80dc9158c5c7321fb78d0..197f75ea8931735b3e10b80e68a6ae47a5a736f5 100644
--- a/src/hardware/r_opengl/r_opengl.h
+++ b/src/hardware/r_opengl/r_opengl.h
@@ -35,7 +35,6 @@
#else
#include <GL/gl.h>
-#include <GL/glu.h>
#ifdef STATIC_OPENGL // Because of the 1.3 functions, you'll need GLext to compile it if static
#define GL_GLEXT_PROTOTYPES
@@ -127,6 +126,7 @@ extern GLint screen_width;
extern GLint screen_height;
extern GLbyte screen_depth;
extern GLint maximumAnisotropy;
+extern boolean supportMipMap;
/** \brief OpenGL flags for video driver
*/
diff --git a/src/hu_stuff.c b/src/hu_stuff.c
index caf13a445716167adaa20424af74f268565787ea..7f2560bcc4adc2f398d87aa8066119ee9ec3b455 100644
--- a/src/hu_stuff.c
+++ b/src/hu_stuff.c
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -587,8 +587,47 @@ static void Command_CSay_f(void)
DoSayCommand(0, 1, HU_CSAY);
}
-static tic_t spam_tokens[MAXPLAYERS] = { 1 }; // fill the buffer with 1 so the motd can be sent.
-static tic_t spam_tics[MAXPLAYERS];
+UINT8 spam_tokens[MAXPLAYERS] = { 1 }; // fill the buffer with 1 so the motd can be sent.
+tic_t spam_tics[MAXPLAYERS];
+
+static const char *GetChatColorFromSkinColor(INT32 skincolor)
+{
+ const char *textcolor = NULL;
+ UINT16 chatcolor = skincolors[skincolor].chatcolor;
+ if (!chatcolor || chatcolor%0x1000 || chatcolor>V_INVERTMAP)
+ textcolor = "\x80";
+ else if (chatcolor == V_MAGENTAMAP)
+ textcolor = "\x81";
+ else if (chatcolor == V_YELLOWMAP)
+ textcolor = "\x82";
+ else if (chatcolor == V_GREENMAP)
+ textcolor = "\x83";
+ else if (chatcolor == V_BLUEMAP)
+ textcolor = "\x84";
+ else if (chatcolor == V_REDMAP)
+ textcolor = "\x85";
+ else if (chatcolor == V_GRAYMAP)
+ textcolor = "\x86";
+ else if (chatcolor == V_ORANGEMAP)
+ textcolor = "\x87";
+ else if (chatcolor == V_SKYMAP)
+ textcolor = "\x88";
+ else if (chatcolor == V_PURPLEMAP)
+ textcolor = "\x89";
+ else if (chatcolor == V_AQUAMAP)
+ textcolor = "\x8a";
+ else if (chatcolor == V_PERIDOTMAP)
+ textcolor = "\x8b";
+ else if (chatcolor == V_AZUREMAP)
+ textcolor = "\x8c";
+ else if (chatcolor == V_BROWNMAP)
+ textcolor = "\x8d";
+ else if (chatcolor == V_ROSYMAP)
+ textcolor = "\x8e";
+ else if (chatcolor == V_INVERTMAP)
+ textcolor = "\x8f";
+ return textcolor;
+}
/** Receives a message, processing an ::XD_SAY command.
* \sa DoSayCommand
@@ -599,6 +638,7 @@ static void Got_Saycmd(UINT8 **p, INT32 playernum)
SINT8 target;
UINT8 flags;
const char *dispname;
+ char buf[HU_MAXMSGLEN + 1];
char *msg;
boolean action = false;
char *ptr;
@@ -608,8 +648,8 @@ static void Got_Saycmd(UINT8 **p, INT32 playernum)
target = READSINT8(*p);
flags = READUINT8(*p);
- msg = (char *)*p;
- SKIPSTRINGL(*p, HU_MAXMSGLEN + 1);
+ msg = buf;
+ READSTRINGL(*p, msg, HU_MAXMSGLEN + 1);
if ((cv_mute.value || players[playernum].muted || flags & (HU_CSAY|HU_SERVER_SAY)) && playernum != serverplayer && !(IsPlayerAdmin(playernum)))
{
@@ -649,14 +689,12 @@ static void Got_Saycmd(UINT8 **p, INT32 playernum)
else
spam_tokens[playernum] -= 1;
- // run the lua hook even if we were supposed to eat the msg, netgame consistency goes first.
+ if (spam_eatmsg)
+ return; // don't proceed if we were supposed to eat the message.
if (LUA_HookPlayerMsg(playernum, target, flags, msg))
return;
- if (spam_eatmsg)
- return; // don't proceed if we were supposed to eat the message.
-
// If it's a CSAY, just CECHO and be done with it.
if (flags & HU_CSAY)
{
@@ -711,51 +749,27 @@ static void Got_Saycmd(UINT8 **p, INT32 playernum)
{
if (players[playernum].ctfteam == 1) // red
{
- cstart = "\x85";
- textcolor = "\x85";
+ cstart = textcolor = GetChatColorFromSkinColor(skincolor_redteam);
}
else // blue
{
- cstart = "\x84";
- textcolor = "\x84";
+ cstart = textcolor = GetChatColorFromSkinColor(skincolor_blueteam);
}
}
else
{
- UINT16 chatcolor = skincolors[players[playernum].skincolor].chatcolor;
-
- if (!chatcolor || chatcolor%0x1000 || chatcolor>V_INVERTMAP)
- cstart = "\x80";
- else if (chatcolor == V_MAGENTAMAP)
- cstart = "\x81";
- else if (chatcolor == V_YELLOWMAP)
- cstart = "\x82";
- else if (chatcolor == V_GREENMAP)
- cstart = "\x83";
- else if (chatcolor == V_BLUEMAP)
- cstart = "\x84";
- else if (chatcolor == V_REDMAP)
- cstart = "\x85";
- else if (chatcolor == V_GRAYMAP)
- cstart = "\x86";
- else if (chatcolor == V_ORANGEMAP)
- cstart = "\x87";
- else if (chatcolor == V_SKYMAP)
- cstart = "\x88";
- else if (chatcolor == V_PURPLEMAP)
- cstart = "\x89";
- else if (chatcolor == V_AQUAMAP)
- cstart = "\x8a";
- else if (chatcolor == V_PERIDOTMAP)
- cstart = "\x8b";
- else if (chatcolor == V_AZUREMAP)
- cstart = "\x8c";
- else if (chatcolor == V_BROWNMAP)
- cstart = "\x8d";
- else if (chatcolor == V_ROSYMAP)
- cstart = "\x8e";
- else if (chatcolor == V_INVERTMAP)
- cstart = "\x8f";
+ cstart = GetChatColorFromSkinColor(players[playernum].skincolor);
+ if (G_GametypeHasTeams())
+ {
+ if (players[playernum].ctfteam == 1) // red
+ {
+ cstart = GetChatColorFromSkinColor(skincolor_redteam);
+ }
+ else // blue
+ {
+ cstart = GetChatColorFromSkinColor(skincolor_blueteam);
+ }
+ }
}
prefix = cstart;
@@ -1290,7 +1304,7 @@ static void HU_drawMiniChat(void)
V_DrawChatCharacter(x + dx + 2, y+dy, msg[j] |V_SNAPTOBOTTOM|V_SNAPTOLEFT|V_MONOSPACE|transflag, true, colormap);
dx += charwidth;
-
+
if (dx >= boxw-charwidth-2)
{
dx = 0;
@@ -1541,9 +1555,9 @@ static void HU_DrawChat(void)
else if ((n == 1) && !(w_chat[3] == '0') && (!((i == 1) || ((i >= 10) && (i <= 19)))))
continue;
else if ((n == 2) && !(w_chat[3] == '0') && (!((i == 2) || ((i >= 20) && (i <= 29)))))
- continue;
+ continue;
else if ((n == 3) && !(w_chat[3] == '0') && (!((i == 3) || ((i >= 30) && (i <= 31)))))
- continue;
+ continue;
else // general case.
if (i != n) continue;
}
diff --git a/src/hu_stuff.h b/src/hu_stuff.h
index ca77ed93002750d6cefa28584d8e4de7be3bfc65..2618d873b1392b7d9ac30d0d5ea2e3e2e4cd81da 100644
--- a/src/hu_stuff.h
+++ b/src/hu_stuff.h
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -79,6 +79,9 @@ void HU_AddChatText(const char *text, boolean playsound);
// set true when entering a chat message
extern boolean chat_on;
+extern UINT8 spam_tokens[MAXPLAYERS];
+extern tic_t spam_tics[MAXPLAYERS];
+
extern patch_t *emeraldpics[3][8];
extern patch_t *rflagico;
extern patch_t *bflagico;
diff --git a/src/i_system.h b/src/i_system.h
index f4d169113c50b0ae5e2c1aca53b4d04f128658f4..5348caf4d39e72575c17ecdf4d2c7825bf5fb3c4 100644
--- a/src/i_system.h
+++ b/src/i_system.h
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
diff --git a/src/i_video.h b/src/i_video.h
index 4b459e25b67bd207bfae911365e1a15eec101db0..f3bbc90b92a61215f1421a5ca4c074cd85ae0875 100644
--- a/src/i_video.h
+++ b/src/i_video.h
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
diff --git a/src/info.c b/src/info.c
index d66c24af81aaafb851e6a83e699d2027add29cb5..3998eb88d2b976fc4d718506a4e6ea687c04e49e 100644
--- a/src/info.c
+++ b/src/info.c
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2025 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -306,6 +306,8 @@ char sprnames[NUMSPRITES + 1][MAXSPRITENAME + 1] =
"XMS4", // Lamppost
"XMS5", // Hanging Star
"XMS6", // Mistletoe
+ "SNTT", // Silver Shiver tree
+ "SSTT", // Silver Shiver tree with snow
"FHZI", // FHZ ice
"ROSY",
@@ -339,6 +341,8 @@ char sprnames[NUMSPRITES + 1][MAXSPRITENAME + 1] =
// Misc Scenery
"STLG", // Stalagmites
"DBAL", // Disco
+ "GINE", // Crystalline Heights tree
+ "PPAL", // Pristine Shores palm trees
// Powerup Indicators
"ARMA", // Armageddon Shield Orb
@@ -524,6 +528,9 @@ char sprnames[NUMSPRITES + 1][MAXSPRITENAME + 1] =
// Gravity Well Objects
"GWLG",
"GWLR",
+
+ // LJ Knuckles
+ "OLDK",
};
char spr2names[NUMPLAYERSPRITES][MAXSPRITENAME + 1] =
@@ -593,6 +600,17 @@ char spr2names[NUMPLAYERSPRITES][MAXSPRITENAME + 1] =
"TALB",
"TALC",
+ "MSC0",
+ "MSC1",
+ "MSC2",
+ "MSC3",
+ "MSC4",
+ "MSC5",
+ "MSC6",
+ "MSC7",
+ "MSC8",
+ "MSC9",
+
"CNT1",
"CNT2",
"CNT3",
@@ -671,6 +689,17 @@ playersprite_t spr2defaults[NUMPLAYERSPRITES] = {
SPR2_TAL0, // SPR2_TALB,
SPR2_TAL6, // SPR2_TALC,
+ 0, // SPR2_MSC0,
+ 0, // SPR2_MSC1,
+ 0, // SPR2_MSC2,
+ 0, // SPR2_MSC3,
+ 0, // SPR2_MSC4,
+ 0, // SPR2_MSC5,
+ 0, // SPR2_MSC6,
+ 0, // SPR2_MSC7,
+ 0, // SPR2_MSC8,
+ 0, // SPR2_MSC9,
+
SPR2_WAIT, // SPR2_CNT1,
SPR2_FALL, // SPR2_CNT2,
SPR2_SPNG, // SPR2_CNT3,
@@ -709,7 +738,7 @@ state_t states[NUMSTATES] =
// Player
{SPR_PLAY, SPR2_STND|FF_ANIMATE, 105, {NULL}, 0, 7, S_PLAY_WAIT, 0}, // S_PLAY_STND
- {SPR_PLAY, SPR2_WAIT|FF_ANIMATE, -1, {NULL}, 0, 16, S_NULL, 0}, // S_PLAY_WAIT
+ {SPR_PLAY, SPR2_WAIT, 16, {NULL}, 0, 0, S_PLAY_WAIT, 0}, // S_PLAY_WAIT
{SPR_PLAY, SPR2_WALK, 4, {NULL}, 0, 0, S_PLAY_WALK, 0}, // S_PLAY_WALK
{SPR_PLAY, SPR2_SKID, 1, {NULL}, 0, 0, S_PLAY_WALK, 0}, // S_PLAY_SKID
{SPR_PLAY, SPR2_RUN , 2, {NULL}, 0, 0, S_PLAY_RUN, 0}, // S_PLAY_RUN
@@ -1368,116 +1397,117 @@ state_t states[NUMSTATES] =
// Boss 5
{SPR_NULL, 0, 2, {A_CheckFlags2}, MF2_AMBUSH, S_FANG_IDLE0, S_FANG_INTRO0, 0}, // S_FANG_SETUP
- {SPR_NULL, 0, 2, {NULL}, 0, 0, S_FANG_INTRO1, 0}, // S_FANG_INTRO0
- {SPR_NULL, 0, 2, {A_Boss5MakeJunk}, -S_FANG_CLONE1, 0, S_FANG_INTRO2, 0}, // S_FANG_INTRO1
- {SPR_NULL, 0, 0, {A_Repeat}, 25, S_FANG_INTRO1, S_FANG_INTRO3, 0}, // S_FANG_INTRO2
- {SPR_NULL, 0, 0, {A_Boss5MakeJunk}, 0, 1, S_FANG_INTRO4, 0}, // S_FANG_INTRO3
- {SPR_FANG, 30, 1, {A_ZThrust}, 9, (1<<16)|1, S_FANG_INTRO5, 0}, // S_FANG_INTRO4
- {SPR_FANG, 27, 1, {A_Boss5CheckOnGround}, S_FANG_INTRO9, 0, S_FANG_INTRO6, 0}, // S_FANG_INTRO5
- {SPR_FANG, 28, 1, {A_Boss5CheckOnGround}, S_FANG_INTRO9, 0, S_FANG_INTRO7, 0}, // S_FANG_INTRO6
- {SPR_FANG, 29, 1, {A_Boss5CheckOnGround}, S_FANG_INTRO9, 0, S_FANG_INTRO8, 0}, // S_FANG_INTRO7
- {SPR_FANG, 30, 1, {A_Boss5CheckOnGround}, S_FANG_INTRO9, 0, S_FANG_INTRO5, 0}, // S_FANG_INTRO8
- {SPR_FANG, 23|FF_ANIMATE, 50, {NULL}, 1, 4, S_FANG_INTRO10, 0}, // S_FANG_INTRO9
- {SPR_FANG, 25, 5, {NULL}, 0, 0, S_FANG_INTRO11, 0}, // S_FANG_INTRO10
- {SPR_FANG, 26, 2, {A_Boss5MakeJunk}, S_BROKENROBOTD, 2, S_FANG_INTRO12, 0}, // S_FANG_INTRO11
- {SPR_FANG, 31|FF_ANIMATE, 50, {NULL}, 3, 4, S_FANG_IDLE1, 0}, // S_FANG_INTRO12
-
- {SPR_FANG, 11, 2, {A_Boss5MakeJunk}, 0, -1, S_FANG_CLONE2, 0}, // S_FANG_CLONE1
- {SPR_FANG, 11, 0, {A_Repeat}, 49, S_FANG_CLONE1, S_FANG_CLONE3, 0}, // S_FANG_INTRO2
- {SPR_FANG, 12, 0, {A_SetObjectFlags}, MF_NOGRAVITY, 1, S_FANG_CLONE4, 0}, // S_FANG_CLONE3
- {SPR_FANG, 12, 1, {A_Boss5CheckOnGround}, S_FANG_IDLE0, 0, S_FANG_CLONE4, 0}, // S_FANG_CLONE4
-
- {SPR_FANG, 0, 0, {A_SetObjectFlags}, MF_NOCLIPTHING, 1, S_FANG_IDLE1, 0}, // S_FANG_IDLE0
- {SPR_FANG, 2, 16, {A_Look}, 1, 0, S_FANG_IDLE2, 0}, // S_FANG_IDLE1
- {SPR_FANG, 3, 16, {A_Look}, 1, 0, S_FANG_IDLE3, 0}, // S_FANG_IDLE2
- {SPR_FANG, 3, 16, {A_Look}, 1, 0, S_FANG_IDLE4, 0}, // S_FANG_IDLE3
- {SPR_FANG, 3, 16, {A_Look}, 1, 0, S_FANG_IDLE5, 0}, // S_FANG_IDLE4
- {SPR_FANG, 2, 16, {A_Look}, 1, 0, S_FANG_IDLE6, 0}, // S_FANG_IDLE5
- {SPR_FANG, 1, 16, {A_Look}, 1, 0, S_FANG_IDLE7, 0}, // S_FANG_IDLE6
- {SPR_FANG, 1, 16, {A_Look}, 1, 0, S_FANG_IDLE8, 0}, // S_FANG_IDLE7
- {SPR_FANG, 1, 16, {A_Look}, 1, 0, S_FANG_IDLE1, 0}, // S_FANG_IDLE8
-
- {SPR_FANG, 14, 0, {A_DoNPCPain}, FRACUNIT, 0, S_FANG_PAIN2, 0}, // S_FANG_PAIN1
- {SPR_FANG, 14, 1, {A_Boss5CheckOnGround}, S_FANG_PATHINGSTART1, S_FANG_PINCHPATHINGSTART1, S_FANG_PAIN2, 0}, // S_FANG_PAIN2
-
- {SPR_FANG, 8, 0, {A_Boss5ExtraRepeat}, 5, 4, S_FANG_PATHINGSTART2, 0}, // S_FANG_PATHINGSTART1
- {SPR_FANG, 8, 0, {A_PlayActiveSound}, 0, 0, S_FANG_PATHING, 0}, // S_FANG_PATHINGSTART2
- {SPR_FANG, 8, 0, {A_Boss5FindWaypoint}, 0, 0, S_FANG_BOUNCE1, 0}, // S_FANG_PATHING
-
- {SPR_FANG, 8, 2, {A_Thrust}, 0, 1, S_FANG_BOUNCE2, 0}, // S_FANG_BOUNCE1
- {SPR_FANG, 9, 2, {NULL}, 0, 0, S_FANG_BOUNCE3, 0}, // S_FANG_BOUNCE2
- {SPR_FANG, 10, 1, {A_Boss5Jump}, 0, 0, S_FANG_BOUNCE4, 0}, // S_FANG_BOUNCE3
- {SPR_FANG, 10, 1, {A_Boss5CheckFalling}, S_FANG_CHECKPATH1, S_FANG_FALL1, S_FANG_BOUNCE4, 0}, // S_FANG_BOUNCE4
-
- {SPR_FANG, 12, 1, {A_Boss5CheckOnGround}, S_FANG_CHECKPATH1, 0, S_FANG_FALL2, 0}, // S_FANG_FALL1
- {SPR_FANG, 13, 1, {A_Boss5CheckOnGround}, S_FANG_CHECKPATH1, 0, S_FANG_FALL1, 0}, // S_FANG_FALL2
-
- {SPR_FANG, 8, 0, {A_Boss5Calm}, 0, 0, S_FANG_CHECKPATH2, 0}, // S_FANG_CHECKPATH1
- {SPR_FANG, 8, 0, {A_Repeat}, 0, S_FANG_PATHINGCONT1, S_FANG_SKID1, 0}, // S_FANG_CHECKPATH2
-
- {SPR_FANG, 9, 0, {A_Boss5PinchShot}, MT_FBOMB, -16, S_FANG_PATHINGCONT2, 0}, // S_FANG_PATHINGCONT1
- {SPR_FANG, 9, 0, {A_PlayActiveSound}, 0, 0, S_FANG_PATHINGCONT3, 0}, // S_FANG_PATHINGCONT2
- {SPR_FANG, 9, 2, {A_Thrust}, 0, 1, S_FANG_PATHING, 0}, // S_FANG_PATHINGCONT3
-
- {SPR_FANG, 4, 0, {A_PlayAttackSound}, 0, 0, S_FANG_SKID2, 0}, // S_FANG_SKID1
- {SPR_FANG, 4, 1, {A_DoNPCSkid}, S_FANG_SKID3, 0, S_FANG_SKID2, 0}, // S_FANG_SKID2
- {SPR_FANG, 4, 10, {NULL}, 0, 0, S_FANG_CHOOSEATTACK, 0}, // S_FANG_SKID3
-
- {SPR_FANG, 0, 0, {A_RandomState}, S_FANG_LOBSHOT0, S_FANG_FIRESTART1, S_NULL, 0}, // S_FANG_CHOOSEATTACK
-
- {SPR_FANG, 5, 0, {A_PrepareRepeat}, 3, 0, S_FANG_FIRESTART2, 0}, // S_FANG_FIRESTART1 // Reset loop
- {SPR_FANG, 5, 18, {A_LookForBetter}, 1, 0, S_FANG_FIRE1, 0}, // S_FANG_FIRESTART2
- {SPR_FANG, 5, 5, {A_FireShot}, MT_CORK, -16, S_FANG_FIRE2, 0}, // S_FANG_FIRE1 // Start of loop
- {SPR_FANG, 6, 5, {NULL}, 0, 0, S_FANG_FIRE3, 0}, // S_FANG_FIRE2
- {SPR_FANG, 7, 5, {NULL}, 0, 0, S_FANG_FIRE4, 0}, // S_FANG_FIRE3
- {SPR_FANG, 5, 5, {NULL}, 2, 0, S_FANG_FIREREPEAT, 0}, // S_FANG_FIRE4
- {SPR_FANG, 5, 0, {A_Repeat}, 3, S_FANG_FIRE1, S_FANG_WAIT1, 0}, // S_FANG_FIREREPEAT // End of loop
-
- {SPR_FANG, 18, 16, {A_LookForBetter}, 1, 0, S_FANG_LOBSHOT1, 0}, // S_FANG_LOBSHOT0
- {SPR_FANG, 19, 2, {A_LookForBetter}, 1, 0, S_FANG_LOBSHOT2, 0}, // S_FANG_LOBSHOT1
- {SPR_FANG, 20, 18, {A_BrakLobShot}, MT_FBOMB, 32+(1<<16), S_FANG_WAIT1, 0}, // S_FANG_LOBSHOT2
-
- {SPR_FANG, FF_ANIMATE|15, 70, {NULL}, 1, 5, S_FANG_WAIT2, 0}, // S_FANG_WAIT1
- {SPR_FANG, 0, 35, {A_Look}, 1, 0, S_FANG_IDLE1, 0}, // S_FANG_WAIT2
-
- {SPR_FANG, 12, 1, {A_Boss5CheckOnGround}, S_FANG_PATHINGSTART2, S_FANG_PINCHPATHINGSTART1, S_FANG_WALLHIT, 0}, // S_FANG_WALLHIT
-
- {SPR_FANG, 8, 0, {A_PrepareRepeat}, 1, 0, S_FANG_PINCHPATHINGSTART2, 0}, // S_FANG_PINCHPATHINGSTART1
- {SPR_FANG, 8, 0, {A_PlayActiveSound}, 0, 0, S_FANG_PINCHPATHING, 0}, // S_FANG_PINCHPATHINGSTART2
- {SPR_FANG, 8, 0, {A_Boss5FindWaypoint}, 1, 0, S_FANG_PINCHBOUNCE0, 0}, // S_FANG_PINCHPATHING
- {SPR_FANG, 8, 0, {A_SetObjectFlags}, MF_NOCLIP|MF_NOCLIPHEIGHT, 2, S_FANG_PINCHBOUNCE1, 0}, // S_FANG_PINCHBOUNCE0
- {SPR_FANG, 8, 2, {A_Thrust}, 0, 1, S_FANG_PINCHBOUNCE2, 0}, // S_FANG_PINCHBOUNCE1
- {SPR_FANG, 9, 2, {NULL}, 0, 0, S_FANG_PINCHBOUNCE3, 0}, // S_FANG_PINCHBOUNCE2
- {SPR_FANG, 10, 2, {A_Boss5Jump}, 0, 0, S_FANG_PINCHBOUNCE4, 0}, // S_FANG_PINCHBOUNCE3
- {SPR_FANG, 10, 1, {A_Boss5CheckFalling}, S_FANG_PINCHSKID1, S_FANG_PINCHFALL0, S_FANG_PINCHBOUNCE4, 0}, // S_FANG_PINCHBOUNCE4
- {SPR_FANG, 12, 0, {A_SetObjectFlags}, MF_NOCLIP|MF_NOCLIPHEIGHT, 1, S_FANG_PINCHFALL1, 0}, // S_FANG_PINCHFALL0
- {SPR_FANG, 12, 1, {A_Boss5CheckOnGround}, S_FANG_PINCHSKID1, 0, S_FANG_PINCHFALL2, 0}, // S_FANG_PINCHFALL1
- {SPR_FANG, 13, 1, {A_Boss5CheckOnGround}, S_FANG_PINCHSKID1, 0, S_FANG_PINCHFALL1, 0}, // S_FANG_PINCHFALL2
- {SPR_FANG, 4, 0, {A_PlayAttackSound}, 0, 0, S_FANG_PINCHSKID2, 0}, // S_FANG_PINCHSKID1
- {SPR_FANG, 4, 1, {A_DoNPCSkid}, S_FANG_PINCHLOBSHOT0, 0, S_FANG_PINCHSKID2, 0}, // S_FANG_PINCHSKID2
- {SPR_FANG, 18, 16, {A_FaceTarget}, 3, 0, S_FANG_PINCHLOBSHOT1, 0}, // S_FANG_PINCHLOBSHOT0
- {SPR_FANG, 19, 2, {A_FaceTarget}, 3, 0, S_FANG_PINCHLOBSHOT2, 0}, // S_FANG_PINCHLOBSHOT1
- {SPR_FANG, 20, 30, {A_Boss5MakeItRain}, MT_FBOMB, -16, S_FANG_PINCHLOBSHOT3, 0}, // S_FANG_PINCHLOBSHOT2
- {SPR_FANG, 20, 18, {A_LinedefExecuteFromArg}, 4, 0, S_FANG_PINCHLOBSHOT4, 0}, // S_FANG_PINCHLOBSHOT3
- {SPR_FANG, 0, 0, {A_Boss5Calm}, 0, 0, S_FANG_PATHINGSTART1, 0}, // S_FANG_PINCHLOBSHOT4
-
- {SPR_FANG, 21, 0, {A_DoNPCPain}, 0, 0, S_FANG_DIE2, 0}, // S_FANG_DIE1
- {SPR_FANG, 21, 1, {A_Boss5CheckOnGround}, S_FANG_DIE3, 0, S_FANG_DIE2, 0}, // S_FANG_DIE2
-
- {SPR_FANG, 22, 0, {A_Scream}, 0, 0, S_FANG_DIE4, 0}, // S_FANG_DIE3
- {SPR_FANG, 22, -1, {A_SetFuse}, 70, 0, S_FANG_DIE5, 0}, // S_FANG_DIE4
-
- {SPR_FANG, 11, 0, {A_PlaySound}, sfx_jump, 0, S_FANG_DIE6, 0}, // S_FANG_DIE5
- {SPR_FANG, 11, 1, {A_ZThrust}, 6, (1<<16)|1, S_FANG_DIE7, 0}, // S_FANG_DIE6
- {SPR_FANG, 11, 1, {A_Boss5CheckFalling}, S_FANG_FLEEPATHING1, S_FANG_DIE8, S_FANG_DIE7, 0}, // S_FANG_DIE7
- {SPR_FANG, 12, 1, {A_Boss5CheckOnGround}, S_FANG_FLEEPATHING1, 0, S_FANG_DIE8, 0}, // S_FANG_DIE8
-
- {SPR_FANG, 9, 0, {A_PlayActiveSound}, 0, 0, S_FANG_FLEEPATHING2, 0}, // S_FANG_FLEEPATHING1
- {SPR_FANG, 8, 2, {A_Boss5FindWaypoint}, 2, 0, S_FANG_FLEEBOUNCE1, 0}, // S_FANG_FLEEPATHING2
- {SPR_FANG, 9, 2, {NULL}, 0, 0, S_FANG_FLEEBOUNCE2, 0}, // S_FANG_FLEEBOUNCE1
- {SPR_FANG, 10, -1, {A_BossDeath}, 0, 0, S_NULL, 0}, // S_FANG_FLEEBOUNCE2
-
- {SPR_FANG, 17, 7*TICRATE, {NULL}, 0, 0, S_NULL, 0}, // S_FANG_KO
+ {SPR_NULL, 0, 2, {NULL}, 0, 0, S_FANG_INTRO1, 0}, // S_FANG_INTRO0
+ {SPR_NULL, 0, 2, {A_Boss5MakeJunk}, -S_FANG_CLONE1, 0, S_FANG_INTRO2, 0}, // S_FANG_INTRO1
+ {SPR_NULL, 0, 0, {A_Repeat}, 25, S_FANG_INTRO1, S_FANG_INTRO3, 0}, // S_FANG_INTRO2
+ {SPR_NULL, 0, 0, {A_Boss5MakeJunk}, 0, 1, S_FANG_INTRO4, 0}, // S_FANG_INTRO3
+ {SPR_PLAY, SPR2_ROLL, 1, {A_ZThrust}, 9, (1<<16)|1, S_FANG_INTRO5, 0}, // S_FANG_INTRO4
+ {SPR_PLAY, SPR2_ROLL, 1, {A_Boss5CheckOnGround}, S_FANG_INTRO9, 0, S_FANG_INTRO6, 0}, // S_FANG_INTRO5
+ {SPR_PLAY, SPR2_ROLL, 1, {A_Boss5CheckOnGround}, S_FANG_INTRO9, 0, S_FANG_INTRO7, 0}, // S_FANG_INTRO6
+ {SPR_PLAY, SPR2_ROLL, 1, {A_Boss5CheckOnGround}, S_FANG_INTRO9, 0, S_FANG_INTRO8, 0}, // S_FANG_INTRO7
+ {SPR_PLAY, SPR2_ROLL, 1, {A_Boss5CheckOnGround}, S_FANG_INTRO9, 0, S_FANG_INTRO5, 0}, // S_FANG_INTRO8
+ {SPR_PLAY, SPR2_MSC0|FF_ANIMATE, 50, {NULL}, 0, 4, S_FANG_INTRO10, 0}, // S_FANG_INTRO9
+ {SPR_PLAY, SPR2_MSC1, 5, {NULL}, 0, 0, S_FANG_INTRO11, 0}, // S_FANG_INTRO10
+ {SPR_PLAY, SPR2_MSC2, 2, {A_Boss5MakeJunk}, S_BROKENROBOTD, 2, S_FANG_INTRO12, 0}, // S_FANG_INTRO11
+ {SPR_PLAY, SPR2_CNT1|FF_ANIMATE, 50, {NULL}, 0, 4, S_FANG_IDLE1, 0}, // S_FANG_INTRO12
+
+ {SPR_PLAY, SPR2_SPNG, 2, {A_Boss5MakeJunk}, 0, -1, S_FANG_CLONE2, 0}, // S_FANG_CLONE1
+ {SPR_PLAY, SPR2_SPNG, 0, {A_Repeat}, 49, S_FANG_CLONE1, S_FANG_CLONE3, 0}, // S_FANG_CLONE2
+ {SPR_PLAY, SPR2_FALL, 0, {A_SetObjectFlags}, MF_NOGRAVITY, 1, S_FANG_CLONE4, 0}, // S_FANG_CLONE3
+ {SPR_PLAY, SPR2_FALL, 1, {A_Boss5CheckOnGround}, S_FANG_IDLE0, 0, S_FANG_CLONE4, 0}, // S_FANG_CLONE4
+
+ {SPR_PLAY, 0, 0, {A_SetObjectFlags}, MF_NOCLIPTHING, 1, S_FANG_IDLE1, 0}, // S_FANG_IDLE0
+ {SPR_PLAY, SPR2_WAIT, 16, {A_Look}, 1, 0, S_FANG_IDLE2, 0}, // S_FANG_IDLE1
+ {SPR_PLAY, SPR2_WAIT, 16, {A_Look}, 1, 0, S_FANG_IDLE3, 0}, // S_FANG_IDLE2
+ {SPR_PLAY, SPR2_WAIT, 16, {A_Look}, 1, 0, S_FANG_IDLE4, 0}, // S_FANG_IDLE3
+ {SPR_PLAY, SPR2_WAIT, 16, {A_Look}, 1, 0, S_FANG_IDLE5, 0}, // S_FANG_IDLE4
+ {SPR_PLAY, SPR2_WAIT, 16, {A_Look}, 1, 0, S_FANG_IDLE6, 0}, // S_FANG_IDLE5
+ {SPR_PLAY, SPR2_WAIT, 16, {A_Look}, 1, 0, S_FANG_IDLE7, 0}, // S_FANG_IDLE6
+ {SPR_PLAY, SPR2_WAIT, 16, {A_Look}, 1, 0, S_FANG_IDLE8, 0}, // S_FANG_IDLE7
+ {SPR_PLAY, SPR2_WAIT, 16, {A_Look}, 1, 0, S_FANG_IDLE1, 0}, // S_FANG_IDLE8
+
+ {SPR_PLAY, 0, 0, {A_DoNPCPain}, FRACUNIT, 0, S_FANG_PAIN2, 0}, // S_FANG_PAIN1
+ {SPR_PLAY, SPR2_PAIN, 1, {A_Boss5CheckOnGround}, S_FANG_PATHINGSTART1, S_FANG_PINCHPATHINGSTART1, S_FANG_PAIN2, 0}, // S_FANG_PAIN2
+
+ {SPR_PLAY, 0, 0, {A_Boss5ExtraRepeat}, 5, 4, S_FANG_PATHINGSTART2, 0}, // S_FANG_PATHINGSTART1
+ {SPR_PLAY, 0, 0, {A_PlayActiveSound}, 0, 0, S_FANG_PATHING, 0}, // S_FANG_PATHINGSTART2
+ {SPR_PLAY, 0, 0, {A_Boss5FindWaypoint}, 0, 0, S_FANG_BOUNCE1, 0}, // S_FANG_PATHING
+
+ {SPR_PLAY, SPR2_LAND, 2, {A_Thrust}, 0, 1, S_FANG_BOUNCE2, 0}, // S_FANG_BOUNCE1
+ {SPR_PLAY, SPR2_LAND, 2, {NULL}, 0, 0, S_FANG_BOUNCE3, 0}, // S_FANG_BOUNCE2
+ {SPR_PLAY, SPR2_LAND, 1, {A_Boss5Jump}, 0, 0, S_FANG_BOUNCE4, 0}, // S_FANG_BOUNCE3
+ {SPR_PLAY, SPR2_BNCE, 1, {A_Boss5CheckFalling}, S_FANG_CHECKPATH1, S_FANG_FALL1, S_FANG_BOUNCE4, 0}, // S_FANG_BOUNCE4
+
+ {SPR_PLAY, SPR2_FALL, 1, {A_Boss5CheckOnGround}, S_FANG_CHECKPATH1, 0, S_FANG_FALL2, 0}, // S_FANG_FALL1
+ {SPR_PLAY, SPR2_FALL, 1, {A_Boss5CheckOnGround}, S_FANG_CHECKPATH1, 0, S_FANG_FALL1, 0}, // S_FANG_FALL2
+
+ {SPR_PLAY, 0, 0, {A_Boss5Calm}, 0, 0, S_FANG_CHECKPATH2, 0}, // S_FANG_CHECKPATH1
+ {SPR_PLAY, 0, 0, {A_Repeat}, 0, S_FANG_PATHINGCONT1, S_FANG_SKID1, 0}, // S_FANG_CHECKPATH2
+
+ {SPR_PLAY, 0, 0, {A_Boss5PinchShot}, MT_FBOMB, -16, S_FANG_PATHINGCONT2, 0}, // S_FANG_PATHINGCONT1
+ {SPR_PLAY, 0, 0, {A_PlayActiveSound}, 0, 0, S_FANG_PATHINGCONT3, 0}, // S_FANG_PATHINGCONT2
+ {SPR_PLAY, SPR2_LAND, 2, {A_Thrust}, 0, 1, S_FANG_PATHING, 0}, // S_FANG_PATHINGCONT3
+
+ {SPR_PLAY, 0, 0, {A_PlayAttackSound}, 0, 0, S_FANG_SKID2, 0}, // S_FANG_SKID1
+ {SPR_PLAY, SPR2_SKID, 1, {A_DoNPCSkid}, S_FANG_SKID3, 0, S_FANG_SKID2, 0}, // S_FANG_SKID2
+ {SPR_PLAY, SPR2_SKID, 10, {NULL}, 0, 0, S_FANG_CHOOSEATTACK, 0}, // S_FANG_SKID3
+
+ {SPR_PLAY, 0, 0, {A_RandomState}, S_FANG_LOBSHOT0, S_FANG_FIRESTART1, S_NULL, 0}, // S_FANG_CHOOSEATTACK
+
+ {SPR_PLAY, 0, 0, {A_PrepareRepeat}, 3, 0, S_FANG_FIRESTART2, 0}, // S_FANG_FIRESTART1 // Reset loop
+ {SPR_PLAY, SPR2_FIRE, 18, {A_LookForBetter}, 1, 0, S_FANG_FIRE1, 0}, // S_FANG_FIRESTART2
+ {SPR_PLAY, SPR2_FIRE, 2, {A_FireShot}, MT_CORK, -16, S_FANG_FIRE2, 0}, // S_FANG_FIRE1 // Start of loop
+ {SPR_PLAY, SPR2_FIRE, 2, {NULL}, 0, 0, S_FANG_FIRE3, 0}, // S_FANG_FIRE2
+ {SPR_PLAY, SPR2_FIRE, 16, {NULL}, 0, 0, S_FANG_FIREREPEAT, 0}, // S_FANG_FIRE3
+ {SPR_PLAY, 0, 0, {A_Repeat}, 3, S_FANG_FIRE1, S_FANG_WAIT1, 0}, // S_FANG_FIREREPEAT // End of loop
+
+ {SPR_PLAY, SPR2_MSC3, 14, {A_LookForBetter}, 1, 0, S_FANG_LOBSHOT1, 0}, // S_FANG_LOBSHOT0
+ {SPR_PLAY, SPR2_MSC3, 2, {A_LookForBetter}, 1, 0, S_FANG_LOBSHOT2, 0}, // S_FANG_LOBSHOT1
+ {SPR_PLAY, SPR2_MSC3, 2, {A_LookForBetter}, 1, 0, S_FANG_LOBSHOT3, 0}, // S_FANG_LOBSHOT2
+ {SPR_PLAY, SPR2_MSC3, 18, {A_BrakLobShot}, MT_FBOMB, 32+(1<<16), S_FANG_WAIT1, 0}, // S_FANG_LOBSHOT3
+
+ {SPR_PLAY, SPR2_MLEL|FF_ANIMATE, 70, {NULL}, 0, 5, S_FANG_WAIT2, 0}, // S_FANG_WAIT1
+ {SPR_PLAY, SPR2_STND, 35, {A_Look}, 1, 0, S_FANG_IDLE1, 0}, // S_FANG_WAIT2
+
+ {SPR_PLAY, SPR2_FALL, 1, {A_Boss5CheckOnGround}, S_FANG_PATHINGSTART2, S_FANG_PINCHPATHINGSTART1, S_FANG_WALLHIT, 0}, // S_FANG_WALLHIT
+
+ {SPR_PLAY, 0, 0, {A_PrepareRepeat}, 1, 0, S_FANG_PINCHPATHINGSTART2, 0}, // S_FANG_PINCHPATHINGSTART1
+ {SPR_PLAY, 0, 0, {A_PlayActiveSound}, 0, 0, S_FANG_PINCHPATHING, 0}, // S_FANG_PINCHPATHINGSTART2
+ {SPR_PLAY, 0, 0, {A_Boss5FindWaypoint}, 1, 0, S_FANG_PINCHBOUNCE0, 0}, // S_FANG_PINCHPATHING
+ {SPR_PLAY, 0, 0, {A_SetObjectFlags}, MF_NOCLIP|MF_NOCLIPHEIGHT, 2, S_FANG_PINCHBOUNCE1, 0}, // S_FANG_PINCHBOUNCE0
+ {SPR_PLAY, SPR2_LAND, 2, {A_Thrust}, 0, 1, S_FANG_PINCHBOUNCE2, 0}, // S_FANG_PINCHBOUNCE1
+ {SPR_PLAY, SPR2_LAND, 2, {NULL}, 0, 0, S_FANG_PINCHBOUNCE3, 0}, // S_FANG_PINCHBOUNCE2
+ {SPR_PLAY, SPR2_LAND, 2, {A_Boss5Jump}, 0, 0, S_FANG_PINCHBOUNCE4, 0}, // S_FANG_PINCHBOUNCE3
+ {SPR_PLAY, SPR2_BNCE, 1, {A_Boss5CheckFalling}, S_FANG_PINCHSKID1, S_FANG_PINCHFALL0, S_FANG_PINCHBOUNCE4, 0}, // S_FANG_PINCHBOUNCE4
+ {SPR_PLAY, 0, 0, {A_SetObjectFlags}, MF_NOCLIP|MF_NOCLIPHEIGHT, 1, S_FANG_PINCHFALL1, 0}, // S_FANG_PINCHFALL0
+ {SPR_PLAY, SPR2_FALL, 1, {A_Boss5CheckOnGround}, S_FANG_PINCHSKID1, 0, S_FANG_PINCHFALL2, 0}, // S_FANG_PINCHFALL1
+ {SPR_PLAY, SPR2_FALL, 1, {A_Boss5CheckOnGround}, S_FANG_PINCHSKID1, 0, S_FANG_PINCHFALL1, 0}, // S_FANG_PINCHFALL2
+ {SPR_PLAY, 0, 0, {A_PlayAttackSound}, 0, 0, S_FANG_PINCHSKID2, 0}, // S_FANG_PINCHSKID1
+ {SPR_PLAY, SPR2_SKID, 1, {A_DoNPCSkid}, S_FANG_PINCHLOBSHOT0, 0, S_FANG_PINCHSKID2, 0}, // S_FANG_PINCHSKID2
+ {SPR_PLAY, SPR2_MSC3, 16, {A_FaceTarget}, 1, 5, S_FANG_PINCHLOBSHOT1, 0}, // S_FANG_PINCHLOBSHOT0
+ {SPR_PLAY, SPR2_MSC3, 2, {A_FaceTarget}, 3, 0, S_FANG_PINCHLOBSHOT2, 0}, // S_FANG_PINCHLOBSHOT1
+ {SPR_PLAY, SPR2_MSC3, 2, {A_FaceTarget}, 3, 0, S_FANG_PINCHLOBSHOT3, 0}, // S_FANG_PINCHLOBSHOT2
+ {SPR_PLAY, SPR2_MSC3, 30, {A_Boss5MakeItRain}, MT_FBOMB, -16, S_FANG_PINCHLOBSHOT4, 0}, // S_FANG_PINCHLOBSHOT3
+ {SPR_PLAY, SPR2_STND, 18, {A_LinedefExecuteFromArg}, 4, 0, S_FANG_PINCHLOBSHOT5, 0}, // S_FANG_PINCHLOBSHOT4
+ {SPR_PLAY, 0, 0, {A_Boss5Calm}, 0, 0, S_FANG_PATHINGSTART1, 0}, // S_FANG_PINCHLOBSHOT5
+
+ {SPR_PLAY, 0, 0, {A_DoNPCPain}, 0, 0, S_FANG_DIE2, 0}, // S_FANG_DIE1
+ {SPR_PLAY, SPR2_MSC4, 1, {A_Boss5CheckOnGround}, S_FANG_DIE3, 0, S_FANG_DIE2, 0}, // S_FANG_DIE2
+
+ {SPR_PLAY, 0, 0, {A_Scream}, 0, 0, S_FANG_DIE4, 0}, // S_FANG_DIE3
+ {SPR_PLAY, SPR2_MSC5, -1, {A_SetFuse}, 70, 0, S_FANG_DIE5, 0}, // S_FANG_DIE4
+
+ {SPR_PLAY, 0, 0, {A_PlaySound}, sfx_jump, 0, S_FANG_DIE6, 0}, // S_FANG_DIE5
+ {SPR_PLAY, SPR2_JUMP, 1, {A_ZThrust}, 6, (1<<16)|1, S_FANG_DIE7, 0}, // S_FANG_DIE6
+ {SPR_PLAY, SPR2_JUMP, 1, {A_Boss5CheckFalling}, S_FANG_FLEEPATHING1, S_FANG_DIE8, S_FANG_DIE7, 0}, // S_FANG_DIE7
+ {SPR_PLAY, SPR2_FALL, 1, {A_Boss5CheckOnGround}, S_FANG_FLEEPATHING1, 0, S_FANG_DIE8, 0}, // S_FANG_DIE8
+
+ {SPR_PLAY, 0, 0, {A_PlayActiveSound}, 0, 0, S_FANG_FLEEPATHING2, 0}, // S_FANG_FLEEPATHING1
+ {SPR_PLAY, SPR2_LAND, 2, {A_Boss5FindWaypoint}, 2, 0, S_FANG_FLEEBOUNCE1, 0}, // S_FANG_FLEEPATHING2
+ {SPR_PLAY, SPR2_LAND, 2, {NULL}, 0, 0, S_FANG_FLEEBOUNCE2, 0}, // S_FANG_FLEEBOUNCE1
+ {SPR_PLAY, SPR2_LAND, -1, {A_BossDeath}, 0, 0, S_NULL, 0}, // S_FANG_FLEEBOUNCE2
+
+ {SPR_PLAY, SPR2_DEAD, 7*TICRATE, {NULL}, 0, 0, S_NULL, 0}, // S_FANG_KO
{SPR_NULL, 0, -1, {A_RandomStateRange}, S_BROKENROBOTA, S_BROKENROBOTF, S_NULL, 0}, // S_BROKENROBOTRANDOM
{SPR_BRKN, FF_ANIMATE|FF_RANDOMANIM, -1, {NULL}, 3, 4, S_NULL, 0}, // S_BROKENROBOTA
@@ -1760,22 +1790,22 @@ state_t states[NUMSTATES] =
// Metal Sonic
{SPR_PLAY, SPR2_STND, -1, {NULL}, 0, 0, S_METALSONIC_RACE, 0}, // S_METALSONIC_RACE
- {SPR_METL, 4, -1, {NULL}, 0, 0, S_METALSONIC_FLOAT, 0}, // S_METALSONIC_FLOAT
- {SPR_METL, 16|FF_FULLBRIGHT, -1, {NULL}, 0, 0, S_METALSONIC_STUN, 0}, // S_METALSONIC_VECTOR
- {SPR_METL, 15, -1, {NULL}, 0, 0, S_METALSONIC_FLOAT, 0}, // S_METALSONIC_STUN
- {SPR_METL, 17, 20, {NULL}, 0, 0, S_METALSONIC_GATHER, 0},// S_METALSONIC_RAISE
- {SPR_METL, 18, -1, {NULL}, 0, 0, S_METALSONIC_FLOAT, 0}, // S_METALSONIC_GATHER
- {SPR_METL, 6|FF_FULLBRIGHT|FF_ANIMATE|FF_GLOBALANIM, -1, {NULL}, 1, 2, S_METALSONIC_BOUNCE, 0},// S_METALSONIC_DASH
- {SPR_METL, 18|FF_FULLBRIGHT|FF_ANIMATE|FF_GLOBALANIM, -1, {NULL}, 1, 2, S_METALSONIC_FLOAT, 0}, // S_METALSONIC_BOUNCE
- {SPR_METL, 14, -1, {NULL}, 0, 0, S_METALSONIC_FLOAT, 0}, // S_METALSONIC_BADBOUNCE
- {SPR_METL, 17, -1, {NULL}, 0, 0, S_METALSONIC_GATHER, 0},// S_METALSONIC_SHOOT
- {SPR_METL, 15, 40, {A_Pain}, 0, 0, S_METALSONIC_FLOAT, 0}, // S_METALSONIC_PAIN
- {SPR_METL, 17, 2, {A_Fall}, 0, 0, S_METALSONIC_DEATH2, 0},// S_METALSONIC_DEATH1
- {SPR_METL, 17, 4, {A_BossScream}, 0, 0, S_METALSONIC_DEATH3, 0},// S_METALSONIC_DEATH2
- {SPR_METL, 17, 0, {A_Repeat}, 17, S_METALSONIC_DEATH2, S_METALSONIC_DEATH4, 0}, // S_METALSONIC_DEATH3
- {SPR_METL, 17, -1, {A_BossDeath}, 0, 0, S_NULL, 0}, // S_METALSONIC_DEATH4
- {SPR_METL, 15, 1, {A_BossScream}, 0, 0, S_METALSONIC_FLEE2, 0}, // S_METALSONIC_FLEE1
- {SPR_METL, 15, 7, {NULL}, 0, 0, S_METALSONIC_FLEE1, 0}, // S_METALSONIC_FLEE2
+ {SPR_PLAY, SPR2_WALK, -1, {NULL}, 0, 0, S_METALSONIC_FLOAT, 0}, // S_METALSONIC_FLOAT
+ {SPR_PLAY, SPR2_MSC1|FF_FULLBRIGHT, -1, {NULL}, 0, 0, S_METALSONIC_STUN, 0}, // S_METALSONIC_VECTOR
+ {SPR_PLAY, SPR2_MSC0, -1, {NULL}, 0, 0, S_METALSONIC_FLOAT, 0},// S_METALSONIC_STUN
+ {SPR_PLAY, SPR2_SPNG, 20, {NULL}, 0, 0, S_METALSONIC_GATHER, 0}, // S_METALSONIC_RAISE
+ {SPR_PLAY, SPR2_MSC2, -1, {NULL}, 0, 0, S_METALSONIC_FLOAT, 0}, // S_METALSONIC_GATHER
+ {SPR_PLAY, SPR2_DASH|FF_FULLBRIGHT, -1, {NULL}, 1, 2, S_METALSONIC_BOUNCE, 0}, // S_METALSONIC_DASH
+ {SPR_PLAY, SPR2_MSC2|FF_FULLBRIGHT, -1, {NULL}, 1, 2, S_METALSONIC_FLOAT, 0}, // S_METALSONIC_BOUNCE
+ {SPR_PLAY, SPR2_PAIN, -1, {NULL}, 0, 0, S_METALSONIC_FLOAT, 0}, // S_METALSONIC_BADBOUNCE
+ {SPR_PLAY, SPR2_SPNG, -1, {NULL}, 0, 0, S_METALSONIC_GATHER, 0}, // S_METALSONIC_SHOOT
+ {SPR_PLAY, SPR2_FLT, 40, {A_Pain}, 0, 0, S_METALSONIC_FLOAT, 0}, // S_METALSONIC_PAIN
+ {SPR_PLAY, SPR2_SPNG, 2, {A_Fall}, 0, 0, S_METALSONIC_DEATH2, 0}, // S_METALSONIC_DEATH1
+ {SPR_PLAY, SPR2_SPNG, 4, {A_BossScream}, 0, 0, S_METALSONIC_DEATH3, 0}, // S_METALSONIC_DEATH2
+ {SPR_PLAY, SPR2_SPNG, 0, {A_Repeat}, 17, S_METALSONIC_DEATH2, S_METALSONIC_DEATH4, 0}, // S_METALSONIC_DEATH3
+ {SPR_PLAY, SPR2_SPNG, -1, {A_BossDeath}, 0, 0, S_NULL, 0}, // S_METALSONIC_DEATH4
+ {SPR_PLAY, SPR2_FLT, 1, {A_BossScream}, 0, 0, S_METALSONIC_FLEE2, 0}, // S_METALSONIC_FLEE1
+ {SPR_PLAY, SPR2_FLT, 7, {NULL}, 0, 0, S_METALSONIC_FLEE1, 0}, // S_METALSONIC_FLEE2
{SPR_MSCF, FF_FULLBRIGHT|FF_TRANS30|FF_ANIMATE, -1, {NULL}, 11, 1, S_NULL, 0}, // S_MSSHIELD_F1
{SPR_MSCF, FF_FULLBRIGHT|FF_ANIMATE|12, -1, {NULL}, 8, 2, S_NULL, 0}, // S_MSSHIELD_F2
@@ -1784,8 +1814,8 @@ state_t states[NUMSTATES] =
{SPR_RING, FF_ANIMATE|FF_GLOBALANIM, -1, {NULL}, 23, 1, S_RING, 0}, // S_RING
// Blue Sphere for special stages
- {SPR_SPHR, FF_FULLBRIGHT, -1, {NULL}, 0, 0, S_NULL, 0}, // S_BLUESPHERE
- {SPR_SPHR, FF_FULLBRIGHT
+ {SPR_SPHR, FF_SEMIBRIGHT, -1, {NULL}, 0, 0, S_NULL, 0}, // S_BLUESPHERE
+ {SPR_SPHR, FF_SEMIBRIGHT
#ifdef MANIASPHERES
|FF_ANIMATE|FF_RANDOMANIM
#endif
@@ -1794,13 +1824,13 @@ state_t states[NUMSTATES] =
// Bomb Sphere
{SPR_SPHR, FF_FULLBRIGHT|3, 2, {NULL}, 0, 0, S_BOMBSPHERE2, 0}, // S_BOMBSPHERE1
- {SPR_SPHR, FF_FULLBRIGHT|4, 1, {NULL}, 0, 0, S_BOMBSPHERE3, 0}, // S_BOMBSPHERE2
- {SPR_SPHR, FF_FULLBRIGHT|5, 2, {NULL}, 0, 0, S_BOMBSPHERE4, 0}, // S_BOMBSPHERE3
- {SPR_SPHR, FF_FULLBRIGHT|4, 1, {NULL}, 0, 0, S_BOMBSPHERE1, 0}, // S_BOMBSPHERE4
+ {SPR_SPHR, FF_SEMIBRIGHT|4, 1, {NULL}, 0, 0, S_BOMBSPHERE3, 0}, // S_BOMBSPHERE2
+ {SPR_SPHR, FF_SEMIBRIGHT|5, 2, {NULL}, 0, 0, S_BOMBSPHERE4, 0}, // S_BOMBSPHERE3
+ {SPR_SPHR, FF_SEMIBRIGHT|4, 1, {NULL}, 0, 0, S_BOMBSPHERE1, 0}, // S_BOMBSPHERE4
// NiGHTS Chip
- {SPR_NCHP, FF_FULLBRIGHT|FF_ANIMATE, -1, {NULL}, 15, 2, S_NULL, 0}, // S_NIGHTSCHIP
- {SPR_NCHP, FF_FULLBRIGHT|FF_ANIMATE|16, -1, {NULL}, 15, 2, S_NULL, 0}, // S_NIGHTSCHIPBONUS
+ {SPR_NCHP, FF_SEMIBRIGHT|FF_ANIMATE, -1, {NULL}, 15, 2, S_NULL, 0}, // S_NIGHTSCHIP
+ {SPR_NCHP, FF_SEMIBRIGHT|FF_ANIMATE|16, -1, {NULL}, 15, 2, S_NULL, 0}, // S_NIGHTSCHIPBONUS
// NiGHTS Star
{SPR_NSTR, FF_ANIMATE, -1, {NULL}, 14, 2, S_NULL, 0}, // S_NIGHTSSTAR
@@ -1858,9 +1888,9 @@ state_t states[NUMSTATES] =
{SPR_CEMG, FF_FULLBRIGHT|6, -1, {NULL}, 0, 0, S_NULL, 0}, // S_CEMG7
// Emerald hunt shards
- {SPR_SHRD, 0, -1, {NULL}, 0, 0, S_NULL, 0}, // S_SHRD1
- {SPR_SHRD, 1, -1, {NULL}, 0, 0, S_NULL, 0}, // S_SHRD2
- {SPR_SHRD, 2, -1, {NULL}, 0, 0, S_NULL, 0}, // S_SHRD3
+ {SPR_SHRD, FF_SEMIBRIGHT, -1, {NULL}, 0, 0, S_NULL, 0}, // S_SHRD1
+ {SPR_SHRD, FF_SEMIBRIGHT|1, -1, {NULL}, 0, 0, S_NULL, 0}, // S_SHRD2
+ {SPR_SHRD, FF_SEMIBRIGHT|2, -1, {NULL}, 0, 0, S_NULL, 0}, // S_SHRD3
// Bubble Source
{SPR_BBLS, 0, 8, {A_BubbleSpawn}, 2048, 0, S_BUBBLES2, 0}, // S_BUBBLES1
@@ -2629,6 +2659,10 @@ state_t states[NUMSTATES] =
{SPR_XMS4, 1, -1, {NULL}, 0, 0, S_NULL, 0}, // S_LAMPPOST2
{SPR_XMS5, 0, -1, {NULL}, 0, 0, S_NULL, 0}, // S_HANGSTAR
{SPR_XMS6, 0, -1, {NULL}, 0, 0, S_NULL, 0}, // S_MISTLETOE
+ {SPR_SNTT, 0, -1, {NULL}, 0, 0, S_NULL, 0}, // S_SSZTREE
+ {SPR_SNTT, 1|FF_PAPERSPRITE, -1, {NULL}, 0, 0, S_NULL, 0}, // S_SSZTREE_BRANCH
+ {SPR_SSTT, 0, -1, {NULL}, 0, 0, S_NULL, 0}, // S_SSZTREE2
+ {SPR_SSTT, 1|FF_PAPERSPRITE, -1, {NULL}, 0, 0, S_NULL, 0}, // S_SSZTREE2_BRANCH
// Xmas GFZ bushes
{SPR_BUS3, 1, -1, {NULL}, 0, 0, S_NULL, 0}, // S_XMASBLUEBERRYBUSH
{SPR_BUS1, 1, -1, {NULL}, 0, 0, S_NULL, 0}, // S_XMASBERRYBUSH
@@ -2636,16 +2670,15 @@ state_t states[NUMSTATES] =
// FHZ
{SPR_FHZI, 0, -1, {NULL}, 0, 0, S_NULL, 0}, // S_FHZICE1
{SPR_FHZI, 1, -1, {NULL}, 0, 0, S_NULL, 0}, // S_FHZICE2
- {SPR_ROSY, 16, 8, {NULL}, 0, 0, S_ROSY_IDLE2, 0}, // S_ROSY_IDLE1
- {SPR_ROSY, 17, 4, {NULL}, 0, 0, S_ROSY_IDLE3, 0}, // S_ROSY_IDLE2
- {SPR_ROSY, 18, 8, {NULL}, 0, 0, S_ROSY_IDLE4, 0}, // S_ROSY_IDLE3
- {SPR_ROSY, 17, 4, {NULL}, 0, 0, S_ROSY_IDLE1, 0}, // S_ROSY_IDLE4
- {SPR_ROSY, 14, -1, {NULL}, 1, 0, S_NULL, 0}, // S_ROSY_JUMP
- {SPR_ROSY, 5, -1, {NULL}, 7, 0, S_NULL, 0}, // S_ROSY_WALK
- {SPR_ROSY, 19, -1, {NULL}, 0, 0, S_NULL, 0}, // S_ROSY_HUG
- {SPR_ROSY, 13, -1, {NULL}, 0, 0, S_NULL, 0}, // S_ROSY_PAIN
- {SPR_ROSY, 1|FF_ANIMATE, -1, {NULL}, 3, 16, S_NULL, 0}, // S_ROSY_STND
- {SPR_ROSY, 20|FF_ANIMATE, TICRATE, {NULL}, 3, 4, S_ROSY_WALK, 0}, // S_ROSY_UNHAPPY
+ // Amy FHZ cameo
+ {SPR_PLAY, SPR2_CNT1|FF_ANIMATE, -1, {NULL}, 0, 0, S_NULL, 0}, // S_ROSY_IDLE
+ {SPR_PLAY, SPR2_MSC0, -1, {NULL}, 0, 0, S_NULL, 0}, // S_ROSY_JUMP
+ {SPR_PLAY, SPR2_MSC1, -1, {NULL}, 0, 0, S_NULL, 0}, // S_ROSY_FALL
+ {SPR_PLAY, SPR2_WALK, -1, {NULL}, 7, 0, S_NULL, 0}, // S_ROSY_WALK
+ {SPR_PLAY, SPR2_MSC2, -1, {NULL}, 0, 0, S_NULL, 0}, // S_ROSY_HUG
+ {SPR_PLAY, SPR2_PAIN, -1, {NULL}, 0, 0, S_NULL, 0}, // S_ROSY_PAIN
+ {SPR_PLAY, SPR2_WAIT|FF_ANIMATE, -1, {NULL}, 0, 5, S_NULL, 0}, // S_ROSY_STND
+ {SPR_PLAY, SPR2_MSC3|FF_ANIMATE, TICRATE, {NULL}, 0, 4, S_ROSY_WALK, 0}, // S_ROSY_UNHAPPY
// Halloween Scenery
// Pumpkins
@@ -2752,6 +2785,10 @@ state_t states[NUMSTATES] =
{SPR_ESTA, 1, -1, {NULL}, 0, 0, S_NULL, 0}, // S_EGGSTATUE2
+ {SPR_GINE, 0, -1, {NULL}, 0, 0, S_NULL, 0}, // S_GINE
+ {SPR_PPAL, 0, -1, {NULL}, 0, 0, S_NULL, 0}, // S_PPAL
+ {SPR_PPAL, 1, -1, {NULL}, 0, 0, S_NULL, 0}, // S_PPEL
+
// Shield Orb
{SPR_ARMA, FF_TRANS40 , 2, {NULL}, 0, 0, S_ARMA2 , 0}, // S_ARMA1
{SPR_ARMA, FF_TRANS40| 1, 2, {NULL}, 0, 0, S_ARMA3 , 0}, // S_ARMA2
@@ -3995,6 +4032,11 @@ state_t states[NUMSTATES] =
{SPR_BRIY, FF_ANIMATE|FF_RANDOMANIM, -1, {NULL}, 31, 1, S_NULL, 0}, // S_YELLOWBRICKDEBRIS
{SPR_NULL, 0, 1, {NULL}, 0, 0, S_NULL, 0}, // S_NAMECHECK
+
+ {SPR_OLDK, FF_ANIMATE, -1, {NULL}, 1, 16, S_NULL, 0}, // S_OLDK_STND
+ {SPR_OLDK, 2, 0, {A_ForceWin}, 0, 0, S_OLDK_DIE1, 0}, // S_OLDK_DIE0
+ {SPR_OLDK, 2, 0, {A_Scream}, 0, 0, S_OLDK_DIE2, 0}, // S_OLDK_DIE1
+ {SPR_OLDK, 2, -1, {A_ZThrust}, 14, 1|(1<<16), S_NULL, 0}, // S_OLDK_DIE2
};
mobjinfo_t mobjinfo[NUMMOBJTYPES] =
@@ -4145,7 +4187,7 @@ mobjinfo_t mobjinfo[NUMMOBJTYPES] =
S_NULL, // painstate
0, // painchance
sfx_None, // painsound
- S_NULL, // meleestate
+ S_JETFUMEFLASH, // meleestate
S_NULL, // missilestate
S_NULL, // deathstate
S_NULL, // xdeathstate
@@ -14523,6 +14565,114 @@ mobjinfo_t mobjinfo[NUMMOBJTYPES] =
S_NULL // raisestate
},
+ { // MT_SSZTREE
+ 1860, // doomednum
+ S_SSZTREE, // spawnstate
+ 1000, // spawnhealth
+ S_NULL, // seestate
+ sfx_None, // seesound
+ 8, // reactiontime
+ sfx_None, // attacksound
+ S_NULL, // painstate
+ 0, // painchance
+ sfx_None, // painsound
+ S_NULL, // meleestate
+ S_NULL, // missilestate
+ S_NULL, // deathstate
+ S_NULL, // xdeathstate
+ sfx_None, // deathsound
+ 0, // speed
+ 20*FRACUNIT, // radius
+ 256*FRACUNIT, // height
+ 0, // display offset
+ 100, // mass
+ 1, // damage
+ sfx_None, // activesound
+ MF_SOLID|MF_SCENERY, // flags
+ S_NULL // raisestate
+ },
+
+ { // MT_SSZTREE_BRANCH
+ -1, // doomednum
+ S_SSZTREE_BRANCH, // spawnstate
+ 1000, // spawnhealth
+ S_NULL, // seestate
+ sfx_None, // seesound
+ 8, // reactiontime
+ sfx_None, // attacksound
+ S_NULL, // painstate
+ 0, // painchance
+ sfx_None, // painsound
+ S_NULL, // meleestate
+ S_NULL, // missilestate
+ S_NULL, // deathstate
+ S_NULL, // xdeathstate
+ sfx_None, // deathsound
+ 0, // speed
+ 20*FRACUNIT, // radius
+ 256*FRACUNIT, // height
+ 0, // display offset
+ 100, // mass
+ 1, // damage
+ sfx_None, // activesound
+ MF_NOBLOCKMAP|MF_NOCLIP|MF_SCENERY, // flags
+ S_NULL // raisestate
+ },
+
+ { // MT_SSZTREE2
+ 1861, // doomednum
+ S_SSZTREE2, // spawnstate
+ 1000, // spawnhealth
+ S_NULL, // seestate
+ sfx_None, // seesound
+ 8, // reactiontime
+ sfx_None, // attacksound
+ S_NULL, // painstate
+ 0, // painchance
+ sfx_None, // painsound
+ S_NULL, // meleestate
+ S_NULL, // missilestate
+ S_NULL, // deathstate
+ S_NULL, // xdeathstate
+ sfx_None, // deathsound
+ 0, // speed
+ 20*FRACUNIT, // radius
+ 256*FRACUNIT, // height
+ 0, // display offset
+ 100, // mass
+ 1, // damage
+ sfx_None, // activesound
+ MF_SOLID|MF_SCENERY, // flags
+ S_NULL // raisestate
+ },
+
+ { // MT_SSZTREE2_BRANCH
+ -1, // doomednum
+ S_SSZTREE2_BRANCH, // spawnstate
+ 1000, // spawnhealth
+ S_NULL, // seestate
+ sfx_None, // seesound
+ 8, // reactiontime
+ sfx_None, // attacksound
+ S_NULL, // painstate
+ 0, // painchance
+ sfx_None, // painsound
+ S_NULL, // meleestate
+ S_NULL, // missilestate
+ S_NULL, // deathstate
+ S_NULL, // xdeathstate
+ sfx_None, // deathsound
+ 0, // speed
+ 20*FRACUNIT, // radius
+ 256*FRACUNIT, // height
+ 0, // display offset
+ 100, // mass
+ 1, // damage
+ sfx_None, // activesound
+ MF_NOBLOCKMAP|MF_NOCLIP|MF_SCENERY, // flags
+ S_NULL // raisestate
+ },
+
{ // MT_XMASBLUEBERRYBUSH
1859, // doomednum
S_XMASBLUEBERRYBUSH, // spawnstate
@@ -14660,7 +14810,7 @@ mobjinfo_t mobjinfo[NUMMOBJTYPES] =
{ // MT_ROSY
2104, // doomednum
- S_ROSY_IDLE1, // spawnstate
+ S_ROSY_IDLE, // spawnstate
1000, // spawnhealth
S_NULL, // seestate
sfx_None, // seesound
@@ -16362,6 +16512,87 @@ mobjinfo_t mobjinfo[NUMMOBJTYPES] =
S_NULL // raisestate
},
+ { // MT_GINE
+ 3048, // doomednum
+ S_GINE, // spawnstate
+ 1000, // spawnhealth
+ S_NULL, // seestate
+ sfx_None, // seesound
+ 8, // reactiontime
+ sfx_None, // attacksound
+ S_NULL, // painstate
+ 0, // painchance
+ sfx_None, // painsound
+ S_NULL, // meleestate
+ S_NULL, // missilestate
+ S_NULL, // deathstate
+ S_NULL, // xdeathstate
+ sfx_None, // deathsound
+ 0, // speed
+ 32*FRACUNIT, // radius
+ 628*FRACUNIT, // height
+ 0, // display offset
+ 100, // mass
+ 1, // damage
+ sfx_None, // activesound
+ MF_SOLID|MF_SCENERY, // flags
+ S_NULL // raisestate
+ },
+
+ { // MT_PPAL
+ 3050, // doomednum
+ S_PPAL, // spawnstate
+ 1000, // spawnhealth
+ S_NULL, // seestate
+ sfx_None, // seesound
+ 8, // reactiontime
+ sfx_None, // attacksound
+ S_NULL, // painstate
+ 0, // painchance
+ sfx_None, // painsound
+ S_NULL, // meleestate
+ S_NULL, // missilestate
+ S_NULL, // deathstate
+ S_NULL, // xdeathstate
+ sfx_None, // deathsound
+ 0, // speed
+ 16*FRACUNIT, // radius
+ 626*FRACUNIT, // height
+ 0, // display offset
+ 100, // mass
+ 1, // damage
+ sfx_None, // activesound
+ MF_SOLID|MF_SCENERY, // flags
+ S_NULL // raisestate
+ },
+
+ { // MT_PPEL
+ 3051, // doomednum
+ S_PPEL, // spawnstate
+ 1000, // spawnhealth
+ S_NULL, // seestate
+ sfx_None, // seesound
+ 8, // reactiontime
+ sfx_None, // attacksound
+ S_NULL, // painstate
+ 0, // painchance
+ sfx_None, // painsound
+ S_NULL, // meleestate
+ S_NULL, // missilestate
+ S_NULL, // deathstate
+ S_NULL, // xdeathstate
+ sfx_None, // deathsound
+ 0, // speed
+ 16*FRACUNIT, // radius
+ 517*FRACUNIT, // height
+ 0, // display offset
+ 100, // mass
+ 1, // damage
+ sfx_None, // activesound
+ MF_SOLID|MF_SCENERY, // flags
+ S_NULL // raisestate
+ },
+
{ // MT_ELEMENTAL_ORB
-1, // doomednum
S_ELEM1, // spawnstate
@@ -21604,6 +21835,33 @@ mobjinfo_t mobjinfo[NUMMOBJTYPES] =
MF_NOBLOCKMAP|MF_NOSECTOR|MF_NOCLIP|MF_NOCLIPHEIGHT|MF_NOGRAVITY|MF_SCENERY, // flags
S_NULL // raisestate
},
+
+ { // MT_OLDK
+ 666, // doomednum
+ S_OLDK_STND, // spawnstate
+ 1, // spawnhealth
+ S_NULL, // seestate
+ sfx_None, // seesound
+ 32, // reactiontime
+ sfx_None, // attacksound
+ S_OLDK_DIE0, // painstate
+ 128, // painchance
+ sfx_s3k35, // painsound
+ S_NULL, // meleestate
+ S_NULL, // missilestate
+ S_OLDK_DIE0, // deathstate
+ S_NULL, // xdeathstate
+ sfx_s3k35, // deathsound
+ 2*FRACUNIT, // speed
+ 32*FRACUNIT, // radius
+ 64*FRACUNIT, // height
+ 0, // display offset
+ 1000, // mass
+ 0, // damage
+ sfx_None, // activesound
+ MF_SPECIAL|MF_SHOOTABLE|MF_NOGRAVITY|MF_BOSS, // flags
+ S_NULL // raisestate
+ },
};
skincolor_t skincolors[MAXSKINCOLORS] = {
@@ -21639,15 +21897,15 @@ skincolor_t skincolors[MAXSKINCOLORS] = {
{"Moss", {0x58, 0x58, 0x59, 0x59, 0x5a, 0x5a, 0x5b, 0x5b, 0x5b, 0x5c, 0x5d, 0x5d, 0x5e, 0x5e, 0x5f, 0x5f}, SKINCOLOR_BEIGE, 13, V_GREENMAP, true}, // SKINCOLOR_MOSS
{"Azure", {0x90, 0x90, 0x91, 0x91, 0xaa, 0xaa, 0xab, 0xab, 0xab, 0xac, 0xad, 0xad, 0xae, 0xae, 0xaf, 0xaf}, SKINCOLOR_PINK, 5, V_AZUREMAP, true}, // SKINCOLOR_AZURE
{"Eggplant", { 4, 8, 11, 11, 16, 195, 195, 195, 196, 186, 187, 187, 254, 254, 30, 31}, SKINCOLOR_ROSEBUSH, 5, V_PURPLEMAP, true}, // SKINCOLOR_EGGPLANT
- {"Lavender", {0xc0, 0xc0, 0xc1, 0xc1, 0xc2, 0xc2, 0xc3, 0xc3, 0xc3, 0xc4, 0xc5, 0xc5, 0xc6, 0xc6, 0xc7, 0xc7}, SKINCOLOR_GOLD, 4, V_PURPLEMAP, true}, // SKINCOLOR_LAVENDER
+ {"Lavender", {0xc0, 0xc0, 0xc1, 0xc1, 0xc2, 0xc2, 0xc3, 0xc3, 0xc3, 0xc4, 0xc5, 0xc5, 0xc6, 0xc6, 0xc7, 0xc7}, SKINCOLOR_HEADLIGHT, 8, V_PURPLEMAP, true}, // SKINCOLOR_LAVENDER
// Viv's vivid colours (toast 21/07/17)
// Tweaks & additions (Lach, Chrispy, sphere, Alice, MotorRoach & Saneko 26/10/22)
{"Ruby", {0xb0, 0xb0, 0xc9, 0xca, 0xcc, 0x26, 0x27, 0x28, 0x29, 0x2a, 0xb9, 0xb9, 0xba, 0xba, 0xbb, 0xfd}, SKINCOLOR_EMERALD, 10, V_REDMAP, true}, // SKINCOLOR_RUBY
{"Cherry", { 202, 203, 204, 205, 206, 40, 41, 42, 43, 44, 186, 187, 28, 29, 30, 31}, SKINCOLOR_MIDNIGHT, 10, V_REDMAP, true}, // SKINCOLOR_CHERRY
{"Salmon", {0xd0, 0xd0, 0xd1, 0xd2, 0x20, 0x21, 0x24, 0x25, 0x26, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e}, SKINCOLOR_FOREST, 6, V_REDMAP, true}, // SKINCOLOR_SALMON
- {"Pepper", { 210, 32, 33, 34, 35, 35, 36, 37, 38, 39, 41, 43, 45, 45, 46, 47}, SKINCOLOR_MASTER, 8, V_REDMAP, true}, // SKINCOLOR_PEPPER
- {"Red", {0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x47, 0x2e, 0x2f}, SKINCOLOR_GREEN, 10, V_REDMAP, true}, // SKINCOLOR_RED
+ {"Pepper", { 210, 32, 33, 34, 35, 35, 36, 37, 38, 39, 41, 43, 45, 45, 46, 47}, SKINCOLOR_GREEN, 10, V_REDMAP, true}, // SKINCOLOR_PEPPER
+ {"Red", {0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x47, 0x2e, 0x2f}, SKINCOLOR_MASTER, 8, V_REDMAP, true}, // SKINCOLOR_RED
{"Crimson", {0x27, 0x27, 0x28, 0x28, 0x29, 0x2a, 0x2b, 0x2b, 0x2c, 0x2d, 0x2e, 0x2e, 0x2e, 0x2f, 0x2f, 0x1f}, SKINCOLOR_ICY, 10, V_REDMAP, true}, // SKINCOLOR_CRIMSON
{"Flame", {0x31, 0x32, 0x33, 0x36, 0x22, 0x22, 0x25, 0x25, 0x25, 0xcd, 0xcf, 0xcf, 0xc5, 0xc5, 0xc7, 0xc7}, SKINCOLOR_PURPLE, 8, V_REDMAP, true}, // SKINCOLOR_FLAME
{"Garnet", { 0, 83, 50, 53, 34, 35, 37, 38, 39, 40, 42, 44, 45, 46, 47, 47}, SKINCOLOR_AQUAMARINE, 6, V_REDMAP, true}, // SKINCOLOR_GARNET
@@ -21662,7 +21920,7 @@ skincolor_t skincolors[MAXSKINCOLORS] = {
{"Rust", {0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3c, 0x3d, 0x3d, 0x3d, 0x3f, 0x2c, 0x2d, 0x47, 0x2e, 0x2f, 0x2f}, SKINCOLOR_YOGURT, 8, V_ORANGEMAP, true}, // SKINCOLOR_RUST
{"Tangerine", { 81, 83, 64, 64, 51, 52, 53, 54, 56, 58, 60, 61, 63, 45, 46, 47}, SKINCOLOR_OCEAN, 12, V_ORANGEMAP, true}, // SKINCOLOR_TANGERINE
{"Topaz", { 0, 81, 83, 73, 74, 74, 65, 52, 53, 54, 56, 58, 60, 42, 43, 45}, SKINCOLOR_MOONSTONE, 10, V_YELLOWMAP, true}, // SKINCOLOR_TOPAZ
- {"Gold", {0x51, 0x51, 0x54, 0x54, 0x41, 0x42, 0x43, 0x43, 0x44, 0x45, 0x46, 0x3f, 0x2d, 0x2e, 0x2f, 0x2f}, SKINCOLOR_LAVENDER, 10, V_YELLOWMAP, true}, // SKINCOLOR_GOLD
+ {"Gold", {0x51, 0x51, 0x54, 0x54, 0x41, 0x42, 0x43, 0x43, 0x44, 0x45, 0x46, 0x3f, 0x2d, 0x2e, 0x2f, 0x2f}, SKINCOLOR_MAUVE, 8, V_YELLOWMAP, true}, // SKINCOLOR_GOLD
{"Sandy", {0x53, 0x40, 0x41, 0x42, 0x43, 0xe6, 0xe9, 0xe9, 0xea, 0xec, 0xec, 0xc6, 0xc6, 0xc7, 0xc7, 0xfe}, SKINCOLOR_SKY, 8, V_YELLOWMAP, true}, // SKINCOLOR_SANDY
{"Goldenrod", { 0, 80, 81, 81, 83, 73, 73, 64, 65, 66, 67, 68, 69, 62, 44, 45}, SKINCOLOR_MAJESTY, 8, V_YELLOWMAP, true}, // SKINCOLOR_GOLDENROD
{"Yellow", {0x52, 0x53, 0x49, 0x49, 0x4a, 0x4a, 0x4b, 0x4b, 0x4b, 0x4c, 0x4d, 0x4d, 0x4e, 0x4e, 0x4f, 0xed}, SKINCOLOR_CORNFLOWER, 8, V_YELLOWMAP, true}, // SKINCOLOR_YELLOW
@@ -21672,19 +21930,19 @@ skincolor_t skincolors[MAXSKINCOLORS] = {
{"Lime", {0x50, 0x51, 0x52, 0x53, 0x48, 0xbc, 0xbd, 0xbe, 0xbe, 0xbf, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f}, SKINCOLOR_MAGENTA, 9, V_PERIDOTMAP, true}, // SKINCOLOR_LIME
{"Peridot", {0x58, 0x58, 0xbc, 0xbc, 0xbd, 0xbd, 0xbe, 0xbe, 0xbe, 0xbf, 0x5e, 0x5e, 0x5f, 0x5f, 0x77, 0x77}, SKINCOLOR_COBALT, 2, V_PERIDOTMAP, true}, // SKINCOLOR_PERIDOT
{"Apple", {0x49, 0x49, 0xbc, 0xbd, 0xbe, 0xbe, 0xbe, 0x67, 0x69, 0x6a, 0x6b, 0x6b, 0x6c, 0x6d, 0x6d, 0x6d}, SKINCOLOR_RASPBERRY, 13, V_PERIDOTMAP, true}, // SKINCOLOR_APPLE
- {"Headlight", { 0, 80, 81, 82, 73, 84, 64, 65, 91, 91, 124, 125, 126, 137, 138, 139}, SKINCOLOR_MAUVE, 8, V_YELLOWMAP, true}, // SKINCOLOR_HEADLIGHT
+ {"Headlight", { 0, 80, 81, 82, 73, 84, 64, 65, 91, 91, 124, 125, 126, 137, 138, 139}, SKINCOLOR_LAVENDER, 10, V_YELLOWMAP, true}, // SKINCOLOR_HEADLIGHT
{"Chartreuse", { 80, 82, 72, 73, 188, 188, 113, 114, 114, 125, 126, 137, 138, 139, 253, 254}, SKINCOLOR_NOBLE, 9, V_PERIDOTMAP, true}, // SKINCOLOR_CHARTREUSE
- {"Green", {0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f}, SKINCOLOR_RED, 6, V_GREENMAP, true}, // SKINCOLOR_GREEN
+ {"Green", {0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f}, SKINCOLOR_PEPPER, 8, V_GREENMAP, true}, // SKINCOLOR_GREEN
{"Forest", {0x65, 0x66, 0x67, 0x68, 0x69, 0x69, 0x6a, 0x6b, 0x6b, 0x6c, 0x6d, 0x6d, 0x6e, 0x6e, 0x6e, 0x6f}, SKINCOLOR_SALMON, 9, V_GREENMAP, true}, // SKINCOLOR_FOREST
{"Shamrock", {0x70, 0x70, 0x71, 0x71, 0x72, 0x72, 0x73, 0x73, 0x73, 0x74, 0x75, 0x75, 0x76, 0x76, 0x77, 0x77}, SKINCOLOR_SIBERITE, 10, V_GREENMAP, true}, // SKINCOLOR_SHAMROCK
- {"Jade", { 128, 120, 121, 122, 122, 113, 114, 114, 115, 116, 117, 118, 119, 110, 111, 30}, SKINCOLOR_TAFFY, 10, V_GREENMAP, true}, // SKINCOLOR_JADE
+ {"Jade", { 128, 120, 121, 122, 122, 113, 114, 114, 115, 116, 117, 118, 119, 110, 111, 30}, SKINCOLOR_ROSY, 7, V_GREENMAP, true}, // SKINCOLOR_JADE
{"Mint", {0x00, 0x00, 0x58, 0x58, 0x59, 0x62, 0x62, 0x62, 0x64, 0x67, 0x7e, 0x7e, 0x8f, 0x8f, 0x8a, 0x8a}, SKINCOLOR_VIOLET, 5, V_GREENMAP, true}, // SKINCOLOR_MINT
- {"Master", { 0, 80, 88, 96, 112, 113, 99, 100, 124, 125, 126, 117, 107, 118, 119, 111}, SKINCOLOR_PEPPER, 8, V_GREENMAP, true}, // SKINCOLOR_MASTER
+ {"Master", { 0, 80, 88, 96, 112, 113, 99, 100, 124, 125, 126, 117, 107, 118, 119, 111}, SKINCOLOR_RED, 6, V_GREENMAP, true}, // SKINCOLOR_MASTER
{"Emerald", { 80, 96, 112, 113, 114, 114, 125, 125, 126, 126, 137, 137, 138, 138, 139, 139}, SKINCOLOR_RUBY, 9, V_GREENMAP, true}, // SKINCOLOR_EMERALD
{"Seafoam", {0x01, 0x58, 0x59, 0x5a, 0x7c, 0x7d, 0x7d, 0x7e, 0x7e, 0x8f, 0x8f, 0x8a, 0x8a, 0x8b, 0xfd, 0xfd}, SKINCOLOR_PLUM, 6, V_AQUAMAP, true}, // SKINCOLOR_SEAFOAM
{"Island", { 96, 97, 113, 113, 114, 124, 142, 136, 136, 150, 151, 153, 168, 168, 169, 169}, SKINCOLOR_GALAXY, 7, V_AQUAMAP, true}, // SKINCOLOR_ISLAND
{"Bottle", { 0, 1, 3, 4, 5, 140, 141, 141, 124, 125, 126, 127, 118, 119, 111, 111}, SKINCOLOR_LATTE, 14, V_AQUAMAP, true}, // SKINCOLOR_BOTTLE
- {"Aqua", {0x78, 0x79, 0x7a, 0x7a, 0x7b, 0x7b, 0x7c, 0x7c, 0x7c, 0x7d, 0x7e, 0x7e, 0x7f, 0x7f, 0x76, 0x77}, SKINCOLOR_ROSY, 7, V_AQUAMAP, true}, // SKINCOLOR_AQUA
+ {"Aqua", {0x78, 0x79, 0x7a, 0x7a, 0x7b, 0x7b, 0x7c, 0x7c, 0x7c, 0x7d, 0x7e, 0x7e, 0x7f, 0x7f, 0x76, 0x77}, SKINCOLOR_TAFFY, 10, V_AQUAMAP, true}, // SKINCOLOR_AQUA
{"Teal", {0x78, 0x78, 0x8c, 0x8c, 0x8d, 0x8d, 0x8d, 0x8e, 0x8e, 0x8f, 0x8f, 0x8f, 0x8a, 0x8a, 0x8a, 0x8a}, SKINCOLOR_PEACHY, 7, V_SKYMAP, true}, // SKINCOLOR_TEAL
{"Ocean", { 120, 121, 122, 122, 123, 141, 142, 142, 136, 137, 138, 138, 139, 139, 253, 253}, SKINCOLOR_TANGERINE, 4, V_AQUAMAP, true}, // SKINCOLOR_OCEAN
{"Wave", {0x00, 0x78, 0x78, 0x79, 0x8d, 0x87, 0x88, 0x89, 0x89, 0xae, 0xa8, 0xa8, 0xa9, 0xa9, 0xfd, 0xfd}, SKINCOLOR_QUAIL, 5, V_SKYMAP, true}, // SKINCOLOR_WAVE
@@ -21718,12 +21976,12 @@ skincolor_t skincolors[MAXSKINCOLORS] = {
{"Violet", {0xd0, 0xd1, 0xd2, 0xca, 0xcc, 0xb8, 0xb9, 0xb9, 0xba, 0xa8, 0xa8, 0xa9, 0xa9, 0xfd, 0xfe, 0xfe}, SKINCOLOR_MINT, 6, V_MAGENTAMAP, true}, // SKINCOLOR_VIOLET
{"Royal", { 208, 209, 192, 192, 192, 193, 193, 194, 194, 172, 173, 174, 175, 175, 139, 139}, SKINCOLOR_FANCY, 9, V_PURPLEMAP, true}, // SKINCOLOR_ROYAL
{"Lilac", {0x00, 0xd0, 0xd1, 0xd2, 0xd3, 0xc1, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc5, 0xc6, 0xc6, 0xfe, 0x1f}, SKINCOLOR_VAPOR, 4, V_ROSYMAP, true}, // SKINCOLOR_LILAC
- {"Mauve", { 176, 177, 178, 192, 193, 194, 195, 195, 196, 185, 185, 186, 186, 187, 187, 253}, SKINCOLOR_HEADLIGHT, 8, V_PURPLEMAP, true}, // SKINCOLOR_MAUVE
+ {"Mauve", { 176, 177, 178, 192, 193, 194, 195, 195, 196, 185, 185, 186, 186, 187, 187, 253}, SKINCOLOR_GOLD, 4, V_PURPLEMAP, true}, // SKINCOLOR_MAUVE
{"Eventide", { 51, 52, 53, 33, 34, 204, 183, 183, 184, 184, 166, 167, 168, 169, 253, 254}, SKINCOLOR_DAYBREAK, 13, V_MAGENTAMAP, true}, // SKINCOLOR_EVENTIDE
{"Plum", {0xc8, 0xd3, 0xd5, 0xd6, 0xd7, 0xce, 0xcf, 0xb9, 0xb9, 0xba, 0xba, 0xa9, 0xa9, 0xa9, 0xfd, 0xfe}, SKINCOLOR_MINT, 7, V_ROSYMAP, true}, // SKINCOLOR_PLUM
{"Raspberry", {0xc8, 0xc9, 0xca, 0xcb, 0xcb, 0xcc, 0xcd, 0xcd, 0xce, 0xb9, 0xb9, 0xba, 0xba, 0xbb, 0xfe, 0xfe}, SKINCOLOR_APPLE, 13, V_ROSYMAP, true}, // SKINCOLOR_RASPBERRY
- {"Taffy", { 1, 176, 176, 177, 178, 179, 202, 203, 204, 204, 205, 206, 207, 44, 45, 46}, SKINCOLOR_JADE, 8, V_ROSYMAP, true}, // SKINCOLOR_TAFFY
- {"Rosy", {0xfc, 0xc8, 0xc8, 0xc9, 0xc9, 0xca, 0xca, 0xcb, 0xcb, 0xcc, 0xcc, 0xcd, 0xcd, 0xce, 0xce, 0xcf}, SKINCOLOR_AQUA, 1, V_ROSYMAP, true}, // SKINCOLOR_ROSY
+ {"Taffy", { 1, 176, 176, 177, 178, 179, 202, 203, 204, 204, 205, 206, 207, 44, 45, 46}, SKINCOLOR_AQUA, 1, V_ROSYMAP, true}, // SKINCOLOR_TAFFY
+ {"Rosy", {0xfc, 0xc8, 0xc8, 0xc9, 0xc9, 0xca, 0xca, 0xcb, 0xcb, 0xcc, 0xcc, 0xcd, 0xcd, 0xce, 0xce, 0xcf}, SKINCOLOR_JADE, 8, V_ROSYMAP, true}, // SKINCOLOR_ROSY
{"Fancy", { 0, 208, 49, 210, 210, 202, 202, 203, 204, 204, 205, 206, 207, 207, 186, 186}, SKINCOLOR_ROYAL, 9, V_ROSYMAP, true}, // SKINCOLOR_FANCY
{"Sangria", { 210, 32, 33, 34, 34, 215, 215, 207, 207, 185, 186, 186, 186, 169, 169, 253}, SKINCOLOR_TURQUOISE, 12, V_ROSYMAP, true}, // SKINCOLOR_SANGRIA
{"Volcanic", { 54, 36, 42, 44, 45, 46, 46, 47, 28, 253, 253, 254, 254, 30, 31, 31}, SKINCOLOR_BRONZE, 9, V_REDMAP, true}, // SKINCOLOR_VOLCANIC
diff --git a/src/info.h b/src/info.h
index f58aee07df70b3c6d72478b8b4c3448acfe615ab..94b0aeb48111178e2262a1f1144c7ff623fb3a43 100644
--- a/src/info.h
+++ b/src/info.h
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -857,6 +857,8 @@ typedef enum sprite
SPR_XMS4, // Lamppost
SPR_XMS5, // Hanging Star
SPR_XMS6, // Mistletoe
+ SPR_SNTT, // Silver Shiver tree
+ SPR_SSTT, // Silver Shiver tree with snow
SPR_FHZI, // FHZ Ice
SPR_ROSY,
@@ -890,6 +892,8 @@ typedef enum sprite
// Misc Scenery
SPR_STLG, // Stalagmites
SPR_DBAL, // Disco
+ SPR_GINE, // Crystalline Heights tree
+ SPR_PPAL, // Pristine Shores palm trees
// Powerup Indicators
SPR_ARMA, // Armageddon Shield Orb
@@ -1076,6 +1080,9 @@ typedef enum sprite
SPR_GWLG,
SPR_GWLR,
+ // LJ Knuckles
+ SPR_OLDK,
+
SPR_FIRSTFREESLOT,
SPR_LASTFREESLOT = SPR_FIRSTFREESLOT + NUMSPRITEFREESLOTS - 1,
NUMSPRITES
@@ -1149,6 +1156,18 @@ typedef enum playersprite
SPR2_TALB,
SPR2_TALC,
+ // Misc slots
+ SPR2_MSC0,
+ SPR2_MSC1,
+ SPR2_MSC2,
+ SPR2_MSC3,
+ SPR2_MSC4,
+ SPR2_MSC5,
+ SPR2_MSC6,
+ SPR2_MSC7,
+ SPR2_MSC8,
+ SPR2_MSC9,
+
SPR2_CNT1, // continue disappointment
SPR2_CNT2, // continue lift
SPR2_CNT3, // continue spin
@@ -1896,11 +1915,11 @@ typedef enum state
S_FANG_FIRE1,
S_FANG_FIRE2,
S_FANG_FIRE3,
- S_FANG_FIRE4,
S_FANG_FIREREPEAT,
S_FANG_LOBSHOT0,
S_FANG_LOBSHOT1,
S_FANG_LOBSHOT2,
+ S_FANG_LOBSHOT3,
S_FANG_WAIT1,
S_FANG_WAIT2,
S_FANG_WALLHIT,
@@ -1922,6 +1941,7 @@ typedef enum state
S_FANG_PINCHLOBSHOT2,
S_FANG_PINCHLOBSHOT3,
S_FANG_PINCHLOBSHOT4,
+ S_FANG_PINCHLOBSHOT5,
S_FANG_DIE1,
S_FANG_DIE2,
S_FANG_DIE3,
@@ -3060,6 +3080,10 @@ typedef enum state
S_LAMPPOST2, // with snow
S_HANGSTAR,
S_MISTLETOE,
+ S_SSZTREE,
+ S_SSZTREE_BRANCH,
+ S_SSZTREE2,
+ S_SSZTREE2_BRANCH,
// Xmas GFZ bushes
S_XMASBLUEBERRYBUSH,
S_XMASBERRYBUSH,
@@ -3067,11 +3091,9 @@ typedef enum state
// FHZ
S_FHZICE1,
S_FHZICE2,
- S_ROSY_IDLE1,
- S_ROSY_IDLE2,
- S_ROSY_IDLE3,
- S_ROSY_IDLE4,
+ S_ROSY_IDLE,
S_ROSY_JUMP,
+ S_ROSY_FALL,
S_ROSY_WALK,
S_ROSY_HUG,
S_ROSY_PAIN,
@@ -3180,6 +3202,9 @@ typedef enum state
S_DBALL5,
S_DBALL6,
S_EGGSTATUE2,
+ S_GINE,
+ S_PPAL,
+ S_PPEL,
// Shield Orb
S_ARMA1,
@@ -4064,6 +4089,7 @@ typedef enum state
S_MARIOBUSH2,
S_TOAD,
+
// Nights-specific stuff
S_NIGHTSDRONE_MAN1,
S_NIGHTSDRONE_MAN2,
@@ -4368,6 +4394,12 @@ typedef enum state
S_NAMECHECK,
+ // LJ Knuckles
+ S_OLDK_STND,
+ S_OLDK_DIE0,
+ S_OLDK_DIE1,
+ S_OLDK_DIE2,
+
S_FIRSTFREESLOT,
S_LASTFREESLOT = S_FIRSTFREESLOT + NUMSTATEFREESLOTS - 1,
NUMSTATES
@@ -4859,6 +4891,10 @@ typedef enum mobj_type
MT_LAMPPOST2, // with snow
MT_HANGSTAR,
MT_MISTLETOE,
+ MT_SSZTREE,
+ MT_SSZTREE_BRANCH,
+ MT_SSZTREE2,
+ MT_SSZTREE2_BRANCH,
// Xmas GFZ bushes
MT_XMASBLUEBERRYBUSH,
MT_XMASBERRYBUSH,
@@ -4938,6 +4974,9 @@ typedef enum mobj_type
// Misc scenery
MT_DBALL,
MT_EGGSTATUE2,
+ MT_GINE,
+ MT_PPAL,
+ MT_PPEL,
// Powerup Indicators
MT_ELEMENTAL_ORB, // Elemental shield mobj
@@ -5166,6 +5205,8 @@ typedef enum mobj_type
MT_NAMECHECK,
MT_RAY, // General purpose mobj
+ MT_OLDK,
+
MT_FIRSTFREESLOT,
MT_LASTFREESLOT = MT_FIRSTFREESLOT + NUMMOBJFREESLOTS - 1,
NUMMOBJTYPES
diff --git a/src/lua_baselib.c b/src/lua_baselib.c
index 304c866c9c9ee6c8fc78b0c860a8a0ed09d83cb3..1ffa3968be16bf8ae67b04461f12b4a6d8d1f77b 100644
--- a/src/lua_baselib.c
+++ b/src/lua_baselib.c
@@ -1,7 +1,7 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
// Copyright (C) 2012-2016 by John "JTE" Muniz.
-// Copyright (C) 2012-2023 by Sonic Team Junior.
+// Copyright (C) 2012-2025 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -1730,12 +1730,11 @@ static int lib_pResetCamera(lua_State *L)
static int lib_pSuperReady(lua_State *L)
{
player_t *player = *((player_t **)luaL_checkudata(L, 1, META_PLAYER));
- boolean transform = (boolean)lua_opttrueboolean(L, 2);
//HUDSAFE
INLEVEL
if (!player)
return LUA_ErrInvalid(L, "player_t");
- lua_pushboolean(L, P_SuperReady(player, transform));
+ lua_pushboolean(L, P_SuperReady(player));
return 1;
}
@@ -1988,7 +1987,7 @@ static int lib_pLineIsBlocking(lua_State *L)
return LUA_ErrInvalid(L, "mobj_t");
if (!line)
return LUA_ErrInvalid(L, "line_t");
-
+
// P_LineOpening in P_LineIsBlocking sets these variables.
// We want to keep their old values after so that whatever
// map collision code uses them doesn't get messed up.
@@ -2001,9 +2000,9 @@ static int lib_pLineIsBlocking(lua_State *L)
pslope_t *oldopenbottomslope = openbottomslope;
ffloor_t *oldopenfloorrover = openfloorrover;
ffloor_t *oldopenceilingrover = openceilingrover;
-
+
lua_pushboolean(L, P_LineIsBlocking(mo, line));
-
+
opentop = oldopentop;
openbottom = oldopenbottom;
openrange = oldopenrange;
@@ -2013,7 +2012,7 @@ static int lib_pLineIsBlocking(lua_State *L)
openbottomslope = oldopenbottomslope;
openfloorrover = oldopenfloorrover;
openceilingrover = oldopenceilingrover;
-
+
return 1;
}
@@ -3167,7 +3166,10 @@ static int lib_rCheckTextureNumForName(lua_State *L)
{
const char *name = luaL_checkstring(L, 1);
//HUDSAFE
- lua_pushinteger(L, R_CheckTextureNumForName(name));
+ INT32 num = R_CheckTextureNumForName(name, TEXTURETYPE_TEXTURE);
+ if (num == -1)
+ num = R_CheckTextureNumForName(name, TEXTURETYPE_FLAT);
+ lua_pushinteger(L, num);
return 1;
}
@@ -3181,17 +3183,25 @@ static int lib_rTextureNumForName(lua_State *L)
static int lib_rCheckTextureNameForNum(lua_State *L)
{
+ char s[9];
INT32 num = (INT32)luaL_checkinteger(L, 1);
//HUDSAFE
- lua_pushstring(L, R_CheckTextureNameForNum(num));
+
+ M_Memcpy(s, R_CheckTextureNameForNum(num), 8);
+ s[8] = '\0';
+ lua_pushstring(L, s);
return 1;
}
static int lib_rTextureNameForNum(lua_State *L)
{
+ char s[9];
INT32 num = (INT32)luaL_checkinteger(L, 1);
//HUDSAFE
- lua_pushstring(L, R_TextureNameForNum(num));
+
+ M_Memcpy(s, R_TextureNameForNum(num), 8);
+ s[8] = '\0';
+ lua_pushstring(L, s);
return 1;
}
diff --git a/src/lua_blockmaplib.c b/src/lua_blockmaplib.c
index c29eadecc625214615c2546abd2216c9b6630254..f570c229b97b138d6d10e714c4c2cdd8175b1596 100644
--- a/src/lua_blockmaplib.c
+++ b/src/lua_blockmaplib.c
@@ -254,11 +254,10 @@ static int lib_searchBlockmap(lua_State *L)
}
else // mobj and function only - search around mobj's radius by default
{
- fixed_t radius = mobj->radius + MAXRADIUS;
- x1 = mobj->x - radius;
- x2 = mobj->x + radius;
- y1 = mobj->y - radius;
- y2 = mobj->y + radius;
+ x1 = mobj->x - mobj->radius;
+ x2 = mobj->x + mobj->radius;
+ y1 = mobj->y - mobj->radius;
+ y2 = mobj->y + mobj->radius;
}
lua_settop(L, 2); // pop everything except function, mobj
diff --git a/src/lua_colorlib.c b/src/lua_colorlib.c
index 3fab589b23ab083df72ae8b7e9d42aa3ee29673c..2743635edfefe88348a93dc45aa26f77d4702067 100644
--- a/src/lua_colorlib.c
+++ b/src/lua_colorlib.c
@@ -1,7 +1,7 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
-// Copyright (C) 2021-2022 by "Lactozilla".
-// Copyright (C) 2014-2023 by Sonic Team Junior.
+// Copyright (C) 2021-2024 by Lactozilla.
+// Copyright (C) 2014-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -593,7 +593,7 @@ static int extracolormap_set(lua_State *L)
|| exc->fadergba != old_fade_rgba
|| exc->fadestart != old_fade_start
|| exc->fadeend != old_fade_end)
- R_GenerateLightTable(exc, true);
+ R_UpdateLightTable(exc, true);
return 0;
}
diff --git a/src/lua_consolelib.c b/src/lua_consolelib.c
index 00e8d036d46098d622cef26b73a8e49e0ad4758a..51ade046319b23ad88d1165090828082b094bfb1 100644
--- a/src/lua_consolelib.c
+++ b/src/lua_consolelib.c
@@ -36,11 +36,27 @@ return luaL_error(L, "HUD rendering code should not call this function!");
static consvar_t *this_cvar;
+static void clear_lua_stack(void)
+{
+ if (gL) // check if Lua is actually turned on first, you dummmy -- Monster Iestyn 04/07/18
+ lua_settop(gL, 0); // clear stack
+}
+
void Got_Luacmd(UINT8 **cp, INT32 playernum)
{
UINT8 i, argc, flags;
+ const char *argv[256];
char buf[256];
+ argc = READUINT8(*cp);
+ argv[0] = (const char*)*cp;
+ SKIPSTRINGN(*cp, 255);
+ for (i = 1; i < argc; i++)
+ {
+ argv[i] = (const char*)*cp;
+ SKIPSTRINGN(*cp, 255);
+ }
+
// don't use I_Assert here, goto the deny code below
// to clean up and kick people who try nefarious exploits
// like sending random junk lua commands to crash the server
@@ -53,8 +69,7 @@ void Got_Luacmd(UINT8 **cp, INT32 playernum)
lua_getfield(gL, LUA_REGISTRYINDEX, "COM_Command"); // push COM_Command
if (!lua_istable(gL, -1)) goto deny;
- argc = READUINT8(*cp);
- READSTRINGN(*cp, buf, 255);
+ strlcpy(buf, argv[0], 255);
strlwr(buf); // must lowercase buffer
lua_getfield(gL, -1, buf); // push command info table
if (!lua_istable(gL, -1)) goto deny;
@@ -80,10 +95,17 @@ void Got_Luacmd(UINT8 **cp, INT32 playernum)
lua_remove(gL, -2); // pop command info table
+ if (!lua_checkstack(gL, argc)) // player + command arguments
+ {
+ clear_lua_stack();
+ CONS_Alert(CONS_WARNING, "lua command stack overflow from %s (%d, need %d more)\n", player_names[playernum], lua_gettop(gL), argc);
+ return;
+ }
+
LUA_PushUserdata(gL, &players[playernum], META_PLAYER);
for (i = 1; i < argc; i++)
{
- READSTRINGN(*cp, buf, 255);
+ strlcpy(buf, argv[i], 255);
lua_pushstring(gL, buf);
}
LUA_Call(gL, (int)argc, 0, 1); // argc is 1-based, so this will cover the player we passed too.
@@ -91,8 +113,7 @@ void Got_Luacmd(UINT8 **cp, INT32 playernum)
deny:
//must be hacked/buggy client
- if (gL) // check if Lua is actually turned on first, you dummmy -- Monster Iestyn 04/07/18
- lua_settop(gL, 0); // clear stack
+ clear_lua_stack();
CONS_Alert(CONS_WARNING, M_GetText("Illegal lua command received from %s\n"), player_names[playernum]);
if (server)
@@ -178,6 +199,11 @@ void COM_Lua_f(void)
I_Assert(lua_isfunction(gL, -1));
lua_remove(gL, -2); // pop command info table
+ if (!lua_checkstack(gL, COM_Argc() + 1))
+ {
+ CONS_Alert(CONS_WARNING, "lua command stack overflow (%d, need %s more)\n", lua_gettop(gL), sizeu1(COM_Argc() + 1));
+ return;
+ }
LUA_PushUserdata(gL, &players[playernum], META_PLAYER);
for (i = 1; i < COM_Argc(); i++)
lua_pushstring(gL, COM_Argv(i));
diff --git a/src/lua_hook.h b/src/lua_hook.h
index 17e0e99a0787d43fa12f817018b29acaac723495..ce79cd1cb70a2e81f9d531ed15094e7cf42b1e75 100644
--- a/src/lua_hook.h
+++ b/src/lua_hook.h
@@ -1,7 +1,7 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
// Copyright (C) 2012-2016 by John "JTE" Muniz.
-// Copyright (C) 2012-2023 by Sonic Team Junior.
+// Copyright (C) 2012-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -72,6 +72,7 @@ automatically.
X (MusicChange),\
X (PlayerHeight),/* override player height */\
X (PlayerCanEnterSpinGaps),\
+ X (AddonLoaded),\
X (KeyDown),\
X (KeyUp),\
diff --git a/src/lua_hooklib.c b/src/lua_hooklib.c
index 54381e4aedc47a64d89190f5582c3c5856634ba6..1bf3caf65fa502f70b447374b6b21600d6261c87 100644
--- a/src/lua_hooklib.c
+++ b/src/lua_hooklib.c
@@ -1,7 +1,7 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
// Copyright (C) 2012-2016 by John "JTE" Muniz.
-// Copyright (C) 2012-2023 by Sonic Team Junior.
+// Copyright (C) 2012-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -498,7 +498,25 @@ static int call_string_hooks(Hook_State *hook)
static int call_mobj_type_hooks(Hook_State *hook, mobjtype_t mobj_type)
{
- return call_mapped(hook, &mobjHookIds[mobj_type][hook->hook_type]);
+ int numCalls = call_mapped(hook, &mobjHookIds[mobj_type][hook->hook_type]);
+
+ if (numCalls > 0 && mobj_type == MT_NULL && (
+ hook->hook_type == MOBJ_HOOK(MobjThinker )
+ || hook->hook_type == MOBJ_HOOK(MobjCollide )
+ || hook->hook_type == MOBJ_HOOK(MobjLineCollide)
+ || hook->hook_type == MOBJ_HOOK(MobjMoveCollide)
+ || hook->hook_type == MOBJ_HOOK(MobjFuse )
+ || hook->hook_type == MOBJ_HOOK(MobjThinker )
+ || hook->hook_type == MOBJ_HOOK(BossThinker )
+ || hook->hook_type == MOBJ_HOOK(MobjMoveBlocked)
+ || hook->hook_type == MOBJ_HOOK(FollowMobj )
+ ))
+ LUA_UsageWarning(L, va(
+ "%s hooks not attached to a specific mobj type are deprecated and will be removed.",
+ mobjHookNames[hook->hook_type])
+ );
+
+ return numCalls;
}
static void call_hud_hooks
@@ -751,7 +769,7 @@ static void hook_think_frame(int type)
PS_SetThinkFrameHookInfo(hook_index, time_taken, ar.short_src);
else if (type == 6)
PS_SetPostThinkFrameHookInfo(hook_index, time_taken, ar.short_src);
-
+
hook_index++;
}
}
diff --git a/src/lua_hud.h b/src/lua_hud.h
index 36ce230ed2a384a73e1f988c41ef79d6d91986a5..ae938e28a9624ab8ced72337c83228daefcdf12f 100644
--- a/src/lua_hud.h
+++ b/src/lua_hud.h
@@ -1,7 +1,7 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
// Copyright (C) 2014-2016 by John "JTE" Muniz.
-// Copyright (C) 2014-2023 by Sonic Team Junior.
+// Copyright (C) 2014-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
diff --git a/src/lua_hudlib.c b/src/lua_hudlib.c
index d6771f1082a635e2bcb9e26ffb4349398113397c..c8327658a64cf8b87f7ee281b266e85ef65c4e3e 100644
--- a/src/lua_hudlib.c
+++ b/src/lua_hudlib.c
@@ -1,7 +1,7 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
// Copyright (C) 2014-2016 by John "JTE" Muniz.
-// Copyright (C) 2014-2023 by Sonic Team Junior.
+// Copyright (C) 2014-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -613,6 +613,10 @@ static int libd_getSprite2Patch(lua_State *L)
if (super)
j |= SPR2F_SUPER;
+ // If there is no "super" variation of this sprite, try with the normal one.
+ if (!P_IsValidSprite2(skins[i], j))
+ j &= ~SPR2F_SUPER;
+
sprdef = P_GetSkinSpritedef(skins[i], j);
// set frame number
diff --git a/src/lua_hudlib_drawlist.c b/src/lua_hudlib_drawlist.c
index cb58e628ea005217c819ddea922f4952f70961f0..358d615cfde8d1e26a0098737f8aaa5a39359b11 100644
--- a/src/lua_hudlib_drawlist.c
+++ b/src/lua_hudlib_drawlist.c
@@ -1,7 +1,7 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
// Copyright (C) 2014-2016 by John "JTE" Muniz.
-// Copyright (C) 2014-2023 by Sonic Team Junior.
+// Copyright (C) 2014-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
diff --git a/src/lua_infolib.c b/src/lua_infolib.c
index 511c20031f8ea82d74c70da608535146bfce8eb2..a65ee23ebc913a62711e9960990c5935662b8dfd 100644
--- a/src/lua_infolib.c
+++ b/src/lua_infolib.c
@@ -1,7 +1,7 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
// Copyright (C) 2012-2016 by John "JTE" Muniz.
-// Copyright (C) 2012-2023 by Sonic Team Junior.
+// Copyright (C) 2012-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
diff --git a/src/lua_libs.h b/src/lua_libs.h
index 90c7bba7c6f247c100dd619d05f54e57edc6d468..e1585f488a8a6205b1ee967dcfeffac125680fee 100644
--- a/src/lua_libs.h
+++ b/src/lua_libs.h
@@ -1,7 +1,7 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
// Copyright (C) 2012-2016 by John "JTE" Muniz.
-// Copyright (C) 2012-2023 by Sonic Team Junior.
+// Copyright (C) 2012-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
diff --git a/src/lua_maplib.c b/src/lua_maplib.c
index 9985e5631201752eddf1ba2abc71aa7304da8f62..c946b10ce220fd28e2415d46f68233fad4bc7f0b 100644
--- a/src/lua_maplib.c
+++ b/src/lua_maplib.c
@@ -1,7 +1,7 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
// Copyright (C) 2012-2016 by John "JTE" Muniz.
-// Copyright (C) 2012-2023 by Sonic Team Junior.
+// Copyright (C) 2012-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
diff --git a/src/lua_mobjlib.c b/src/lua_mobjlib.c
index eadcbe33b0b676447f43f6479693046e507c02b6..6bdebf774df50d0527e3f5713043e008f5c3e33e 100644
--- a/src/lua_mobjlib.c
+++ b/src/lua_mobjlib.c
@@ -1,7 +1,7 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
// Copyright (C) 2012-2016 by John "JTE" Muniz.
-// Copyright (C) 2012-2023 by Sonic Team Junior.
+// Copyright (C) 2012-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -198,12 +198,12 @@ static int mobj_get(lua_State *L)
enum mobj_e field = Lua_optoption(L, 2, -1, mobj_fields_ref);
lua_settop(L, 2);
- if (!mo || !ISINLEVEL) {
+ if (P_MobjWasRemoved(mo) || !ISINLEVEL) {
if (field == mobj_valid) {
lua_pushboolean(L, 0);
return 1;
}
- if (!mo) {
+ if (P_MobjWasRemoved(mo)) {
return LUA_ErrInvalid(L, "mobj_t");
} else
return luaL_error(L, "Do not access an mobj_t field outside a level!");
diff --git a/src/lua_playerlib.c b/src/lua_playerlib.c
index 744a56f7fe528031dd0777c06da35067fb59dde4..37b42fde5b907bd531514ce4376ddc5cb8680c18 100644
--- a/src/lua_playerlib.c
+++ b/src/lua_playerlib.c
@@ -1,7 +1,7 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
// Copyright (C) 2012-2016 by John "JTE" Muniz.
-// Copyright (C) 2012-2023 by Sonic Team Junior.
+// Copyright (C) 2012-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
diff --git a/src/lua_script.c b/src/lua_script.c
index 057899555480383611652c552e41bf41398b0e2b..686555a16d6b09b98d839cefec0ac0fc876181ae 100644
--- a/src/lua_script.c
+++ b/src/lua_script.c
@@ -1,7 +1,7 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
// Copyright (C) 2012-2016 by John "JTE" Muniz.
-// Copyright (C) 2012-2023 by Sonic Team Junior.
+// Copyright (C) 2012-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -1098,7 +1098,7 @@ static UINT8 GetUserdataArchType(int index)
return ARCH_NULL;
}
-static UINT8 ArchiveValue(int TABLESINDEX, int myindex)
+static UINT8 ArchiveValue(save_t *save_p, int TABLESINDEX, int myindex)
{
if (myindex < 0)
myindex = lua_gettop(gL)+1+myindex;
@@ -1106,34 +1106,34 @@ static UINT8 ArchiveValue(int TABLESINDEX, int myindex)
{
case LUA_TNONE:
case LUA_TNIL:
- WRITEUINT8(save_p, ARCH_NULL);
+ P_WriteUINT8(save_p, ARCH_NULL);
break;
// This might be a problem. D:
case LUA_TLIGHTUSERDATA:
case LUA_TTHREAD:
case LUA_TFUNCTION:
- WRITEUINT8(save_p, ARCH_NULL);
+ P_WriteUINT8(save_p, ARCH_NULL);
return 2;
case LUA_TBOOLEAN:
- WRITEUINT8(save_p, lua_toboolean(gL, myindex) ? ARCH_TRUE : ARCH_FALSE);
+ P_WriteUINT8(save_p, lua_toboolean(gL, myindex) ? ARCH_TRUE : ARCH_FALSE);
break;
case LUA_TNUMBER:
{
lua_Integer number = lua_tointeger(gL, myindex);
if (number >= INT8_MIN && number <= INT8_MAX)
{
- WRITEUINT8(save_p, ARCH_INT8);
- WRITESINT8(save_p, number);
+ P_WriteUINT8(save_p, ARCH_INT8);
+ P_WriteSINT8(save_p, number);
}
else if (number >= INT16_MIN && number <= INT16_MAX)
{
- WRITEUINT8(save_p, ARCH_INT16);
- WRITEINT16(save_p, number);
+ P_WriteUINT8(save_p, ARCH_INT16);
+ P_WriteINT16(save_p, number);
}
else
{
- WRITEUINT8(save_p, ARCH_INT32);
- WRITEFIXED(save_p, number);
+ P_WriteUINT8(save_p, ARCH_INT32);
+ P_WriteFixed(save_p, number);
}
break;
}
@@ -1144,23 +1144,23 @@ static UINT8 ArchiveValue(int TABLESINDEX, int myindex)
UINT32 i = 0;
// if you're wondering why we're writing a string to save_p this way,
// it turns out that Lua can have embedded zeros ('\0') in the strings,
- // so we can't use WRITESTRING as that cuts off when it finds a '\0'.
+ // so we can't use P_WriteString as that cuts off when it finds a '\0'.
// Saving the size of the string also allows us to get the size of the string on the other end,
// fixing the awful crashes previously encountered for reading strings longer than 1024
// (yes I know that's kind of a stupid thing to care about, but it'd be evil to trim or ignore them?)
// -- Monster Iestyn 05/08/18
if (len < 255)
{
- WRITEUINT8(save_p, ARCH_SMALLSTRING);
- WRITEUINT8(save_p, len); // save size of string
+ P_WriteUINT8(save_p, ARCH_SMALLSTRING);
+ P_WriteUINT8(save_p, len); // save size of string
}
else
{
- WRITEUINT8(save_p, ARCH_LARGESTRING);
- WRITEUINT32(save_p, len); // save size of string
+ P_WriteUINT8(save_p, ARCH_LARGESTRING);
+ P_WriteUINT32(save_p, len); // save size of string
}
while (i < len)
- WRITECHAR(save_p, s[i++]); // write chars individually, including the embedded zeros
+ P_WriteChar(save_p, s[i++]); // write chars individually, including the embedded zeros
break;
}
case LUA_TTABLE:
@@ -1186,13 +1186,13 @@ static UINT8 ArchiveValue(int TABLESINDEX, int myindex)
if (t == 0)
{
CONS_Alert(CONS_ERROR, "Too many tables to archive!\n");
- WRITEUINT8(save_p, ARCH_NULL);
+ P_WriteUINT8(save_p, ARCH_NULL);
return 0;
}
}
- WRITEUINT8(save_p, ARCH_TABLE);
- WRITEUINT16(save_p, t);
+ P_WriteUINT8(save_p, ARCH_TABLE);
+ P_WriteUINT16(save_p, t);
if (!found)
{
@@ -1208,25 +1208,25 @@ static UINT8 ArchiveValue(int TABLESINDEX, int myindex)
case ARCH_MOBJINFO:
{
mobjinfo_t *info = *((mobjinfo_t **)lua_touserdata(gL, myindex));
- WRITEUINT8(save_p, ARCH_MOBJINFO);
- WRITEUINT16(save_p, info - mobjinfo);
+ P_WriteUINT8(save_p, ARCH_MOBJINFO);
+ P_WriteUINT16(save_p, info - mobjinfo);
break;
}
case ARCH_STATE:
{
state_t *state = *((state_t **)lua_touserdata(gL, myindex));
- WRITEUINT8(save_p, ARCH_STATE);
- WRITEUINT16(save_p, state - states);
+ P_WriteUINT8(save_p, ARCH_STATE);
+ P_WriteUINT16(save_p, state - states);
break;
}
case ARCH_MOBJ:
{
mobj_t *mobj = *((mobj_t **)lua_touserdata(gL, myindex));
if (!mobj)
- WRITEUINT8(save_p, ARCH_NULL);
+ P_WriteUINT8(save_p, ARCH_NULL);
else {
- WRITEUINT8(save_p, ARCH_MOBJ);
- WRITEUINT32(save_p, mobj->mobjnum);
+ P_WriteUINT8(save_p, ARCH_MOBJ);
+ P_WriteUINT32(save_p, mobj->mobjnum);
}
break;
}
@@ -1234,10 +1234,10 @@ static UINT8 ArchiveValue(int TABLESINDEX, int myindex)
{
player_t *player = *((player_t **)lua_touserdata(gL, myindex));
if (!player)
- WRITEUINT8(save_p, ARCH_NULL);
+ P_WriteUINT8(save_p, ARCH_NULL);
else {
- WRITEUINT8(save_p, ARCH_PLAYER);
- WRITEUINT8(save_p, player - players);
+ P_WriteUINT8(save_p, ARCH_PLAYER);
+ P_WriteUINT8(save_p, player - players);
}
break;
}
@@ -1245,10 +1245,10 @@ static UINT8 ArchiveValue(int TABLESINDEX, int myindex)
{
mapthing_t *mapthing = *((mapthing_t **)lua_touserdata(gL, myindex));
if (!mapthing)
- WRITEUINT8(save_p, ARCH_NULL);
+ P_WriteUINT8(save_p, ARCH_NULL);
else {
- WRITEUINT8(save_p, ARCH_MAPTHING);
- WRITEUINT16(save_p, mapthing - mapthings);
+ P_WriteUINT8(save_p, ARCH_MAPTHING);
+ P_WriteUINT16(save_p, mapthing - mapthings);
}
break;
}
@@ -1256,10 +1256,10 @@ static UINT8 ArchiveValue(int TABLESINDEX, int myindex)
{
vertex_t *vertex = *((vertex_t **)lua_touserdata(gL, myindex));
if (!vertex)
- WRITEUINT8(save_p, ARCH_NULL);
+ P_WriteUINT8(save_p, ARCH_NULL);
else {
- WRITEUINT8(save_p, ARCH_VERTEX);
- WRITEUINT16(save_p, vertex - vertexes);
+ P_WriteUINT8(save_p, ARCH_VERTEX);
+ P_WriteUINT16(save_p, vertex - vertexes);
}
break;
}
@@ -1267,10 +1267,10 @@ static UINT8 ArchiveValue(int TABLESINDEX, int myindex)
{
line_t *line = *((line_t **)lua_touserdata(gL, myindex));
if (!line)
- WRITEUINT8(save_p, ARCH_NULL);
+ P_WriteUINT8(save_p, ARCH_NULL);
else {
- WRITEUINT8(save_p, ARCH_LINE);
- WRITEUINT16(save_p, line - lines);
+ P_WriteUINT8(save_p, ARCH_LINE);
+ P_WriteUINT16(save_p, line - lines);
}
break;
}
@@ -1278,10 +1278,10 @@ static UINT8 ArchiveValue(int TABLESINDEX, int myindex)
{
side_t *side = *((side_t **)lua_touserdata(gL, myindex));
if (!side)
- WRITEUINT8(save_p, ARCH_NULL);
+ P_WriteUINT8(save_p, ARCH_NULL);
else {
- WRITEUINT8(save_p, ARCH_SIDE);
- WRITEUINT16(save_p, side - sides);
+ P_WriteUINT8(save_p, ARCH_SIDE);
+ P_WriteUINT16(save_p, side - sides);
}
break;
}
@@ -1289,10 +1289,10 @@ static UINT8 ArchiveValue(int TABLESINDEX, int myindex)
{
subsector_t *subsector = *((subsector_t **)lua_touserdata(gL, myindex));
if (!subsector)
- WRITEUINT8(save_p, ARCH_NULL);
+ P_WriteUINT8(save_p, ARCH_NULL);
else {
- WRITEUINT8(save_p, ARCH_SUBSECTOR);
- WRITEUINT16(save_p, subsector - subsectors);
+ P_WriteUINT8(save_p, ARCH_SUBSECTOR);
+ P_WriteUINT16(save_p, subsector - subsectors);
}
break;
}
@@ -1300,10 +1300,10 @@ static UINT8 ArchiveValue(int TABLESINDEX, int myindex)
{
sector_t *sector = *((sector_t **)lua_touserdata(gL, myindex));
if (!sector)
- WRITEUINT8(save_p, ARCH_NULL);
+ P_WriteUINT8(save_p, ARCH_NULL);
else {
- WRITEUINT8(save_p, ARCH_SECTOR);
- WRITEUINT16(save_p, sector - sectors);
+ P_WriteUINT8(save_p, ARCH_SECTOR);
+ P_WriteUINT16(save_p, sector - sectors);
}
break;
}
@@ -1312,10 +1312,10 @@ static UINT8 ArchiveValue(int TABLESINDEX, int myindex)
{
seg_t *seg = *((seg_t **)lua_touserdata(gL, myindex));
if (!seg)
- WRITEUINT8(save_p, ARCH_NULL);
+ P_WriteUINT8(save_p, ARCH_NULL);
else {
- WRITEUINT8(save_p, ARCH_SEG);
- WRITEUINT16(save_p, seg - segs);
+ P_WriteUINT8(save_p, ARCH_SEG);
+ P_WriteUINT16(save_p, seg - segs);
}
break;
}
@@ -1323,10 +1323,10 @@ static UINT8 ArchiveValue(int TABLESINDEX, int myindex)
{
node_t *node = *((node_t **)lua_touserdata(gL, myindex));
if (!node)
- WRITEUINT8(save_p, ARCH_NULL);
+ P_WriteUINT8(save_p, ARCH_NULL);
else {
- WRITEUINT8(save_p, ARCH_NODE);
- WRITEUINT16(save_p, node - nodes);
+ P_WriteUINT8(save_p, ARCH_NODE);
+ P_WriteUINT16(save_p, node - nodes);
}
break;
}
@@ -1335,16 +1335,16 @@ static UINT8 ArchiveValue(int TABLESINDEX, int myindex)
{
ffloor_t *rover = *((ffloor_t **)lua_touserdata(gL, myindex));
if (!rover)
- WRITEUINT8(save_p, ARCH_NULL);
+ P_WriteUINT8(save_p, ARCH_NULL);
else {
UINT16 i = P_GetFFloorID(rover);
if (i == UINT16_MAX) // invalid ID
- WRITEUINT8(save_p, ARCH_NULL);
+ P_WriteUINT8(save_p, ARCH_NULL);
else
{
- WRITEUINT8(save_p, ARCH_FFLOOR);
- WRITEUINT16(save_p, rover->target - sectors);
- WRITEUINT16(save_p, i);
+ P_WriteUINT8(save_p, ARCH_FFLOOR);
+ P_WriteUINT16(save_p, rover->target - sectors);
+ P_WriteUINT16(save_p, i);
}
}
break;
@@ -1353,10 +1353,10 @@ static UINT8 ArchiveValue(int TABLESINDEX, int myindex)
{
polyobj_t *polyobj = *((polyobj_t **)lua_touserdata(gL, myindex));
if (!polyobj)
- WRITEUINT8(save_p, ARCH_NULL);
+ P_WriteUINT8(save_p, ARCH_NULL);
else {
- WRITEUINT8(save_p, ARCH_POLYOBJ);
- WRITEUINT16(save_p, polyobj-PolyObjects);
+ P_WriteUINT8(save_p, ARCH_POLYOBJ);
+ P_WriteUINT16(save_p, polyobj-PolyObjects);
}
break;
}
@@ -1364,10 +1364,10 @@ static UINT8 ArchiveValue(int TABLESINDEX, int myindex)
{
pslope_t *slope = *((pslope_t **)lua_touserdata(gL, myindex));
if (!slope)
- WRITEUINT8(save_p, ARCH_NULL);
+ P_WriteUINT8(save_p, ARCH_NULL);
else {
- WRITEUINT8(save_p, ARCH_SLOPE);
- WRITEUINT16(save_p, slope->id);
+ P_WriteUINT8(save_p, ARCH_SLOPE);
+ P_WriteUINT16(save_p, slope->id);
}
break;
}
@@ -1375,36 +1375,36 @@ static UINT8 ArchiveValue(int TABLESINDEX, int myindex)
{
mapheader_t *header = *((mapheader_t **)lua_touserdata(gL, myindex));
if (!header)
- WRITEUINT8(save_p, ARCH_NULL);
+ P_WriteUINT8(save_p, ARCH_NULL);
else {
- WRITEUINT8(save_p, ARCH_MAPHEADER);
- WRITEUINT16(save_p, header - *mapheaderinfo);
+ P_WriteUINT8(save_p, ARCH_MAPHEADER);
+ P_WriteUINT16(save_p, header - *mapheaderinfo);
}
break;
}
case ARCH_SKINCOLOR:
{
skincolor_t *info = *((skincolor_t **)lua_touserdata(gL, myindex));
- WRITEUINT8(save_p, ARCH_SKINCOLOR);
- WRITEUINT16(save_p, info - skincolors);
+ P_WriteUINT8(save_p, ARCH_SKINCOLOR);
+ P_WriteUINT16(save_p, info - skincolors);
break;
}
case ARCH_MOUSE:
{
mouse_t *m = *((mouse_t **)lua_touserdata(gL, myindex));
- WRITEUINT8(save_p, ARCH_MOUSE);
- WRITEUINT8(save_p, m == &mouse ? 1 : 2);
+ P_WriteUINT8(save_p, ARCH_MOUSE);
+ P_WriteUINT8(save_p, m == &mouse ? 1 : 2);
break;
}
case ARCH_SKIN:
{
skin_t *skin = *((skin_t **)lua_touserdata(gL, myindex));
- WRITEUINT8(save_p, ARCH_SKIN);
- WRITEUINT8(save_p, skin->skinnum); // UINT8 because MAXSKINS must be <= 256
+ P_WriteUINT8(save_p, ARCH_SKIN);
+ P_WriteUINT8(save_p, skin->skinnum); // UINT8 because MAXSKINS must be <= 256
break;
}
default:
- WRITEUINT8(save_p, ARCH_NULL);
+ P_WriteUINT8(save_p, ARCH_NULL);
return 2;
}
break;
@@ -1412,14 +1412,14 @@ static UINT8 ArchiveValue(int TABLESINDEX, int myindex)
return 0;
}
-static void ArchiveExtVars(void *pointer, const char *ptype)
+static void ArchiveExtVars(save_t *save_p, void *pointer, const char *ptype)
{
int TABLESINDEX;
UINT16 i;
if (!gL) {
if (fastcmp(ptype,"player")) // players must always be included, even if no vars
- WRITEUINT16(save_p, 0);
+ P_WriteUINT16(save_p, 0);
return;
}
@@ -1435,7 +1435,7 @@ static void ArchiveExtVars(void *pointer, const char *ptype)
{ // no extra values table
lua_pop(gL, 1);
if (fastcmp(ptype,"player")) // players must always be included, even if no vars
- WRITEUINT16(save_p, 0);
+ P_WriteUINT16(save_p, 0);
return;
}
@@ -1447,20 +1447,20 @@ static void ArchiveExtVars(void *pointer, const char *ptype)
if (i == 0)
{
if (fastcmp(ptype,"player")) // always include players even if they have no extra variables
- WRITEUINT16(save_p, 0);
+ P_WriteUINT16(save_p, 0);
lua_pop(gL, 1);
return;
}
if (fastcmp(ptype,"mobj")) // mobjs must write their mobjnum as a header
- WRITEUINT32(save_p, ((mobj_t *)pointer)->mobjnum);
- WRITEUINT16(save_p, i);
+ P_WriteUINT32(save_p, ((mobj_t *)pointer)->mobjnum);
+ P_WriteUINT16(save_p, i);
lua_pushnil(gL);
while (lua_next(gL, -2))
{
I_Assert(lua_type(gL, -2) == LUA_TSTRING);
- WRITESTRING(save_p, lua_tostring(gL, -2));
- if (ArchiveValue(TABLESINDEX, -1) == 2)
+ P_WriteString(save_p, lua_tostring(gL, -2));
+ if (ArchiveValue(save_p, TABLESINDEX, -1) == 2)
CONS_Alert(CONS_ERROR, "Type of value for %s entry '%s' (%s) could not be archived!\n", ptype, lua_tostring(gL, -2), luaL_typename(gL, -1));
lua_pop(gL, 1);
}
@@ -1468,16 +1468,19 @@ static void ArchiveExtVars(void *pointer, const char *ptype)
lua_pop(gL, 1);
}
+// FIXME: remove and pass as local variable
+static save_t *lua_save_p;
+
static int NetArchive(lua_State *L)
{
int TABLESINDEX = lua_upvalueindex(1);
int i, n = lua_gettop(L);
for (i = 1; i <= n; i++)
- ArchiveValue(TABLESINDEX, i);
+ ArchiveValue(lua_save_p, TABLESINDEX, i);
return n;
}
-static void ArchiveTables(void)
+static void ArchiveTables(save_t *save_p)
{
int TABLESINDEX;
UINT16 i, n;
@@ -1496,14 +1499,14 @@ static void ArchiveTables(void)
while (lua_next(gL, -2))
{
// Write key
- e = ArchiveValue(TABLESINDEX, -2); // key should be either a number or a string, ArchiveValue can handle this.
+ e = ArchiveValue(save_p, TABLESINDEX, -2); // key should be either a number or a string, ArchiveValue can handle this.
if (e == 1)
n++; // the table contained a new table we'll have to archive. :(
else if (e == 2) // invalid key type (function, thread, lightuserdata, or anything we don't recognise)
CONS_Alert(CONS_ERROR, "Index '%s' (%s) of table %d could not be archived!\n", lua_tostring(gL, -2), luaL_typename(gL, -2), i);
// Write value
- e = ArchiveValue(TABLESINDEX, -1);
+ e = ArchiveValue(save_p, TABLESINDEX, -1);
if (e == 1)
n++; // the table contained a new table we'll have to archive. :(
else if (e == 2) // invalid value type
@@ -1511,7 +1514,7 @@ static void ArchiveTables(void)
lua_pop(gL, 1);
}
- WRITEUINT8(save_p, ARCH_TEND);
+ P_WriteUINT8(save_p, ARCH_TEND);
// Write metatable ID
if (lua_getmetatable(gL, -1))
@@ -1520,19 +1523,19 @@ static void ArchiveTables(void)
lua_getfield(gL, LUA_REGISTRYINDEX, LREG_METATABLES);
lua_pushvalue(gL, -2);
lua_gettable(gL, -2);
- WRITEUINT16(save_p, lua_isnil(gL, -1) ? 0 : lua_tointeger(gL, -1));
+ P_WriteUINT16(save_p, lua_isnil(gL, -1) ? 0 : lua_tointeger(gL, -1));
lua_pop(gL, 3);
}
else
- WRITEUINT16(save_p, 0);
+ P_WriteUINT16(save_p, 0);
lua_pop(gL, 1);
}
}
-static UINT8 UnArchiveValue(int TABLESINDEX)
+static UINT8 UnArchiveValue(save_t *save_p, int TABLESINDEX)
{
- UINT8 type = READUINT8(save_p);
+ UINT8 type = P_ReadUINT8(save_p);
switch (type)
{
case ARCH_NULL:
@@ -1545,13 +1548,13 @@ static UINT8 UnArchiveValue(int TABLESINDEX)
lua_pushboolean(gL, false);
break;
case ARCH_INT8:
- lua_pushinteger(gL, READSINT8(save_p));
+ lua_pushinteger(gL, P_ReadSINT8(save_p));
break;
case ARCH_INT16:
- lua_pushinteger(gL, READINT16(save_p));
+ lua_pushinteger(gL, P_ReadINT16(save_p));
break;
case ARCH_INT32:
- lua_pushinteger(gL, READFIXED(save_p));
+ lua_pushinteger(gL, P_ReadFixed(save_p));
break;
case ARCH_SMALLSTRING:
case ARCH_LARGESTRING:
@@ -1562,23 +1565,23 @@ static UINT8 UnArchiveValue(int TABLESINDEX)
// See my comments in the ArchiveValue function;
// it's much the same for reading strings as writing them!
- // (i.e. we can't use READSTRING either)
+ // (i.e. we can't use P_ReadString either)
// -- Monster Iestyn 05/08/18
if (type == ARCH_SMALLSTRING)
- len = READUINT8(save_p); // length of string, including embedded zeros
+ len = P_ReadUINT8(save_p); // length of string, including embedded zeros
else
- len = READUINT32(save_p); // length of string, including embedded zeros
+ len = P_ReadUINT32(save_p); // length of string, including embedded zeros
value = malloc(len); // make temp buffer of size len
// now read the actual string
while (i < len)
- value[i++] = READCHAR(save_p); // read chars individually, including the embedded zeros
+ value[i++] = P_ReadChar(save_p); // read chars individually, including the embedded zeros
lua_pushlstring(gL, value, len); // push the string (note: this function supports embedded zeros)
free(value); // free the buffer
break;
}
case ARCH_TABLE:
{
- UINT16 tid = READUINT16(save_p);
+ UINT16 tid = P_ReadUINT16(save_p);
lua_rawgeti(gL, TABLESINDEX, tid);
if (lua_isnil(gL, -1))
{
@@ -1591,69 +1594,69 @@ static UINT8 UnArchiveValue(int TABLESINDEX)
break;
}
case ARCH_MOBJINFO:
- LUA_PushUserdata(gL, &mobjinfo[READUINT16(save_p)], META_MOBJINFO);
+ LUA_PushUserdata(gL, &mobjinfo[P_ReadUINT16(save_p)], META_MOBJINFO);
break;
case ARCH_STATE:
- LUA_PushUserdata(gL, &states[READUINT16(save_p)], META_STATE);
+ LUA_PushUserdata(gL, &states[P_ReadUINT16(save_p)], META_STATE);
break;
case ARCH_MOBJ:
- LUA_PushUserdata(gL, P_FindNewPosition(READUINT32(save_p)), META_MOBJ);
+ LUA_PushUserdata(gL, P_FindNewPosition(P_ReadUINT32(save_p)), META_MOBJ);
break;
case ARCH_PLAYER:
- LUA_PushUserdata(gL, &players[READUINT8(save_p)], META_PLAYER);
+ LUA_PushUserdata(gL, &players[P_ReadUINT8(save_p)], META_PLAYER);
break;
case ARCH_MAPTHING:
- LUA_PushUserdata(gL, &mapthings[READUINT16(save_p)], META_MAPTHING);
+ LUA_PushUserdata(gL, &mapthings[P_ReadUINT16(save_p)], META_MAPTHING);
break;
case ARCH_VERTEX:
- LUA_PushUserdata(gL, &vertexes[READUINT16(save_p)], META_VERTEX);
+ LUA_PushUserdata(gL, &vertexes[P_ReadUINT16(save_p)], META_VERTEX);
break;
case ARCH_LINE:
- LUA_PushUserdata(gL, &lines[READUINT16(save_p)], META_LINE);
+ LUA_PushUserdata(gL, &lines[P_ReadUINT16(save_p)], META_LINE);
break;
case ARCH_SIDE:
- LUA_PushUserdata(gL, &sides[READUINT16(save_p)], META_SIDE);
+ LUA_PushUserdata(gL, &sides[P_ReadUINT16(save_p)], META_SIDE);
break;
case ARCH_SUBSECTOR:
- LUA_PushUserdata(gL, &subsectors[READUINT16(save_p)], META_SUBSECTOR);
+ LUA_PushUserdata(gL, &subsectors[P_ReadUINT16(save_p)], META_SUBSECTOR);
break;
case ARCH_SECTOR:
- LUA_PushUserdata(gL, §ors[READUINT16(save_p)], META_SECTOR);
+ LUA_PushUserdata(gL, §ors[P_ReadUINT16(save_p)], META_SECTOR);
break;
#ifdef HAVE_LUA_SEGS
case ARCH_SEG:
- LUA_PushUserdata(gL, &segs[READUINT16(save_p)], META_SEG);
+ LUA_PushUserdata(gL, &segs[P_ReadUINT16(save_p)], META_SEG);
break;
case ARCH_NODE:
- LUA_PushUserdata(gL, &nodes[READUINT16(save_p)], META_NODE);
+ LUA_PushUserdata(gL, &nodes[P_ReadUINT16(save_p)], META_NODE);
break;
#endif
case ARCH_FFLOOR:
{
- sector_t *sector = §ors[READUINT16(save_p)];
- UINT16 id = READUINT16(save_p);
+ sector_t *sector = §ors[P_ReadUINT16(save_p)];
+ UINT16 id = P_ReadUINT16(save_p);
ffloor_t *rover = P_GetFFloorByID(sector, id);
if (rover)
LUA_PushUserdata(gL, rover, META_FFLOOR);
break;
}
case ARCH_POLYOBJ:
- LUA_PushUserdata(gL, &PolyObjects[READUINT16(save_p)], META_POLYOBJ);
+ LUA_PushUserdata(gL, &PolyObjects[P_ReadUINT16(save_p)], META_POLYOBJ);
break;
case ARCH_SLOPE:
- LUA_PushUserdata(gL, P_SlopeById(READUINT16(save_p)), META_SLOPE);
+ LUA_PushUserdata(gL, P_SlopeById(P_ReadUINT16(save_p)), META_SLOPE);
break;
case ARCH_MAPHEADER:
- LUA_PushUserdata(gL, mapheaderinfo[READUINT16(save_p)], META_MAPHEADER);
+ LUA_PushUserdata(gL, mapheaderinfo[P_ReadUINT16(save_p)], META_MAPHEADER);
break;
case ARCH_SKINCOLOR:
- LUA_PushUserdata(gL, &skincolors[READUINT16(save_p)], META_SKINCOLOR);
+ LUA_PushUserdata(gL, &skincolors[P_ReadUINT16(save_p)], META_SKINCOLOR);
break;
case ARCH_MOUSE:
- LUA_PushUserdata(gL, READUINT16(save_p) == 1 ? &mouse : &mouse2, META_MOUSE);
+ LUA_PushUserdata(gL, P_ReadUINT16(save_p) == 1 ? &mouse : &mouse2, META_MOUSE);
break;
case ARCH_SKIN:
- LUA_PushUserdata(gL, skins[READUINT8(save_p)], META_SKIN);
+ LUA_PushUserdata(gL, skins[P_ReadUINT8(save_p)], META_SKIN);
break;
case ARCH_TEND:
return 1;
@@ -1661,10 +1664,10 @@ static UINT8 UnArchiveValue(int TABLESINDEX)
return 0;
}
-static void UnArchiveExtVars(void *pointer)
+static void UnArchiveExtVars(save_t *save_p, void *pointer)
{
int TABLESINDEX;
- UINT16 field_count = READUINT16(save_p);
+ UINT16 field_count = P_ReadUINT16(save_p);
UINT16 i;
char field[1024];
@@ -1677,8 +1680,8 @@ static void UnArchiveExtVars(void *pointer)
for (i = 0; i < field_count; i++)
{
- READSTRING(save_p, field);
- UnArchiveValue(TABLESINDEX);
+ P_ReadString(save_p, field);
+ UnArchiveValue(save_p, TABLESINDEX);
lua_setfield(gL, -2, field);
}
@@ -1695,11 +1698,11 @@ static int NetUnArchive(lua_State *L)
int TABLESINDEX = lua_upvalueindex(1);
int i, n = lua_gettop(L);
for (i = 1; i <= n; i++)
- UnArchiveValue(TABLESINDEX);
+ UnArchiveValue(lua_save_p, TABLESINDEX);
return n;
}
-static void UnArchiveTables(void)
+static void UnArchiveTables(save_t *save_p)
{
int TABLESINDEX;
UINT16 i, n;
@@ -1716,13 +1719,13 @@ static void UnArchiveTables(void)
lua_rawgeti(gL, TABLESINDEX, i);
while (true)
{
- UINT8 e = UnArchiveValue(TABLESINDEX); // read key
+ UINT8 e = UnArchiveValue(save_p, TABLESINDEX); // read key
if (e == 1) // End of table
break;
else if (e == 2) // Key contains a new table
n++;
- if (UnArchiveValue(TABLESINDEX) == 2) // read value
+ if (UnArchiveValue(save_p, TABLESINDEX) == 2) // read value
n++;
if (lua_isnil(gL, -2)) // if key is nil (if a function etc was accidentally saved)
@@ -1734,7 +1737,7 @@ static void UnArchiveTables(void)
lua_rawset(gL, -3);
}
- metatableid = READUINT16(save_p);
+ metatableid = P_ReadUINT16(save_p);
if (metatableid)
{
// setmetatable(table, registry.metatables[metatableid])
@@ -1758,7 +1761,7 @@ void LUA_Step(void)
lua_gc(gL, LUA_GCSTEP, 1);
}
-void LUA_Archive(void)
+void LUA_Archive(save_t *save_p)
{
INT32 i;
thinker_t *th;
@@ -1771,29 +1774,30 @@ void LUA_Archive(void)
if (!playeringame[i] && i > 0) // dedicated servers...
continue;
// all players in game will be archived, even if they just add a 0.
- ArchiveExtVars(&players[i], "player");
+ ArchiveExtVars(save_p, &players[i], "player");
}
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
{
- if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (th->removing)
continue;
// archive function will determine when to skip mobjs,
// and write mobjnum in otherwise.
- ArchiveExtVars(th, "mobj");
+ ArchiveExtVars(save_p, th, "mobj");
}
- WRITEUINT32(save_p, UINT32_MAX); // end of mobjs marker, replaces mobjnum.
+ P_WriteUINT32(save_p, UINT32_MAX); // end of mobjs marker, replaces mobjnum.
+ lua_save_p = save_p;
LUA_HookNetArchive(NetArchive); // call the NetArchive hook in archive mode
- ArchiveTables();
+ ArchiveTables(save_p);
if (gL)
lua_pop(gL, 1); // pop tables
}
-void LUA_UnArchive(void)
+void LUA_UnArchive(save_t *save_p)
{
UINT32 mobjnum;
INT32 i;
@@ -1806,23 +1810,24 @@ void LUA_UnArchive(void)
{
if (!playeringame[i] && i > 0) // dedicated servers...
continue;
- UnArchiveExtVars(&players[i]);
+ UnArchiveExtVars(save_p, &players[i]);
}
do {
- mobjnum = READUINT32(save_p); // read a mobjnum
+ mobjnum = P_ReadUINT32(save_p); // read a mobjnum
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
{
- if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (th->removing)
continue;
if (((mobj_t *)th)->mobjnum != mobjnum) // find matching mobj
continue;
- UnArchiveExtVars(th); // apply variables
+ UnArchiveExtVars(save_p, th); // apply variables
}
} while(mobjnum != UINT32_MAX); // repeat until end of mobjs marker.
+ lua_save_p = save_p;
LUA_HookNetArchive(NetUnArchive); // call the NetArchive hook in unarchive mode
- UnArchiveTables();
+ UnArchiveTables(save_p);
if (gL)
lua_pop(gL, 1); // pop tables
diff --git a/src/lua_script.h b/src/lua_script.h
index 45d2a37ffd1a636f1e6aaf6848fa868a25fba74b..c5a5069ef1a392ab9010783dd48bde51367bf537 100644
--- a/src/lua_script.h
+++ b/src/lua_script.h
@@ -1,7 +1,7 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
// Copyright (C) 2012-2016 by John "JTE" Muniz.
-// Copyright (C) 2012-2023 by Sonic Team Junior.
+// Copyright (C) 2012-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -13,6 +13,7 @@
#ifndef LUA_SCRIPT_H
#define LUA_SCRIPT_H
+#include "p_saveg.h"
#include "m_fixed.h"
#include "doomtype.h"
#include "d_player.h"
@@ -52,8 +53,8 @@ void LUA_DumpFile(const char *filename);
#endif
fixed_t LUA_EvalMath(const char *word);
void LUA_Step(void);
-void LUA_Archive(void);
-void LUA_UnArchive(void);
+void LUA_Archive(save_t *save_p);
+void LUA_UnArchive(save_t *save_p);
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
diff --git a/src/lua_skinlib.c b/src/lua_skinlib.c
index 26f4011d34a6328b3b76bd3dde67ae275bfcd824..6650e60e6f353c3250644757c06d87ad1c1c7001 100644
--- a/src/lua_skinlib.c
+++ b/src/lua_skinlib.c
@@ -1,7 +1,7 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
// Copyright (C) 2014-2016 by John "JTE" Muniz.
-// Copyright (C) 2014-2023 by Sonic Team Junior.
+// Copyright (C) 2014-2025 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -368,7 +368,10 @@ static int lib_numSkinsSprites(lua_State *L)
static int lib_getSkinSpriteCompat(lua_State *L)
{
spritedef_t *sksprites = *(spritedef_t **)luaL_checkudata(L, 1, META_SKINSPRITESCOMPAT);
- playersprite_t i = luaL_checkinteger(L, 2);
+ INT32 i = luaL_checkinteger(L, 2) & (SPR2F_MASK | SPR2F_SUPER);
+
+ if (i & SPR2F_SUPER)
+ i = (i & ~SPR2F_SUPER) + NUMPLAYERSPRITES;
if (i < 0 || i >= NUMPLAYERSPRITES*2)
return luaL_error(L, "skin sprites index %d out of range (0 - %d)", i, (NUMPLAYERSPRITES*2)-1);
diff --git a/src/m_anigif.c b/src/m_anigif.c
index 6e6ec68aa49760ddc5ab9ffa025356e0a13ffee3..5ebc4892c2d6af8c9a2a31f446d11ef39736306c 100644
--- a/src/m_anigif.c
+++ b/src/m_anigif.c
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 2013-2016 by Matthew "Kaito Sinclaire" Walsh.
// Copyright (C) 2013 by "Ninji".
-// Copyright (C) 2013-2023 by Sonic Team Junior.
+// Copyright (C) 2013-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
diff --git a/src/m_cheat.c b/src/m_cheat.c
index 07f10071711025f93f91d7b7ea2d9d65f3d5ad1d..21ecc3312f2c5fa82f865600518d2863589ca986 100644
--- a/src/m_cheat.c
+++ b/src/m_cheat.c
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -562,7 +562,7 @@ void Command_Teleport_f(void)
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
{
- if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (th->removing)
continue;
mo2 = (mobj_t *)th;
@@ -1072,7 +1072,7 @@ static mapthing_t *OP_CreateNewMapThing(player_t *player, UINT16 type, boolean c
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
{
- if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (th->removing)
continue;
mo = (mobj_t *)th;
@@ -1110,9 +1110,9 @@ static mapthing_t *OP_CreateNewMapThing(player_t *player, UINT16 type, boolean c
mt->pitch = mt->roll = 0;
// Ignore offsets
- if (mt->type == MT_EMBLEM)
+ if (mt->type == mobjinfo[MT_EMBLEM].doomednum)
mt->args[1] = 1;
- else
+ else if (!(mt->type == mobjinfo[MT_METALSONIC_RACE].doomednum || mt->type == mobjinfo[MT_ROSY].doomednum))
mt->args[0] = 1;
return mt;
diff --git a/src/m_cheat.h b/src/m_cheat.h
index 564c6da77ff7e0761faaff529ac4ed7a87ff3734..6bd1546f85b9cf9d99656e5f3bd1b0d39cddb4ae 100644
--- a/src/m_cheat.h
+++ b/src/m_cheat.h
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
diff --git a/src/m_cond.c b/src/m_cond.c
index fa6cda223c376b2f458605ec4f99e23e1c28c2d2..9706f76c83e06c2537bf1d57051ed80f0b3f0f84 100644
--- a/src/m_cond.c
+++ b/src/m_cond.c
@@ -1,7 +1,7 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
// Copyright (C) 2012-2016 by Matthew "Kaito Sinclaire" Walsh.
-// Copyright (C) 2012-2023 by Sonic Team Junior.
+// Copyright (C) 2012-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -475,7 +475,7 @@ UINT8 M_MapLocked(INT32 mapnum, gamedata_t *data)
// that's better than making dedicated server's lives hell.
return false;
}
-
+
if (cv_debug || devparm)
return false; // Unlock every level when in devmode.
diff --git a/src/m_easing.c b/src/m_easing.c
index 48fe1efbc579aee27a0d20dc0dfb4900d447653d..60ca6e9b6328fff8ec7b0abb99d517dfe3a8dbbc 100644
--- a/src/m_easing.c
+++ b/src/m_easing.c
@@ -1,6 +1,6 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
-// Copyright (C) 2020-2023 by Jaime "Lactozilla" Passos.
+// Copyright (C) 2020-2023 by Lactozilla.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
diff --git a/src/m_easing.h b/src/m_easing.h
index eaa5d67735e02b831371ba6700d3e10dc8049628..6884833af68cb5b3671dc0cea70cdf734ac03d6b 100644
--- a/src/m_easing.h
+++ b/src/m_easing.h
@@ -1,6 +1,6 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
-// Copyright (C) 2020-2023 by Jaime "Lactozilla" Passos.
+// Copyright (C) 2020-2023 by Lactozilla.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
diff --git a/src/m_fixed.c b/src/m_fixed.c
index 19c1e80919315071fe40086dc93ec42b937ffb26..ace05fd3bd624b96320ccb1be6e4545094c4b32e 100644
--- a/src/m_fixed.c
+++ b/src/m_fixed.c
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
// Copyright (C) 2009 by Stephen McGranahan.
//
// This program is free software distributed under the
diff --git a/src/m_fixed.h b/src/m_fixed.h
index f40c7b30870baffdd978cec0ecb447b65f74ba6f..504b53a6eea3ba7d8070cdfd635662bb19628f8e 100644
--- a/src/m_fixed.h
+++ b/src/m_fixed.h
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
diff --git a/src/m_menu.c b/src/m_menu.c
index 9a865c00196cee5475eeea715b1c835067e90318..070d0f1b93d0838bb0b245e49cac8ccdde9c06cf 100644
--- a/src/m_menu.c
+++ b/src/m_menu.c
@@ -3,7 +3,7 @@
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
// Copyright (C) 2011-2016 by Matthew "Kaito Sinclaire" Walsh.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2025 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -141,7 +141,6 @@ static char *char_notes = NULL;
boolean menuactive = false;
boolean fromlevelselect = false;
-tic_t shieldprompt_timer = 0; // Show a prompt about the new Shield button for old configs // TODO: 2.3: Remove
typedef enum
{
@@ -1076,9 +1075,8 @@ static menuitem_t OP_ChangeControlsMenu[] =
{IT_CALL | IT_STRING2, NULL, "Move Backward", M_ChangeControl, GC_BACKWARD },
{IT_CALL | IT_STRING2, NULL, "Move Left", M_ChangeControl, GC_STRAFELEFT },
{IT_CALL | IT_STRING2, NULL, "Move Right", M_ChangeControl, GC_STRAFERIGHT },
- {IT_CALL | IT_STRING2, NULL, "Jump", M_ChangeControl, GC_JUMP },
- {IT_CALL | IT_STRING2, NULL, "Spin", M_ChangeControl, GC_SPIN },
- {IT_CALL | IT_STRING2, NULL, "Shield Ability", M_ChangeControl, GC_SHIELD },
+ {IT_CALL | IT_STRING2, NULL, "Jump", M_ChangeControl, GC_JUMP },
+ {IT_CALL | IT_STRING2, NULL, "Spin", M_ChangeControl, GC_SPIN },
{IT_HEADER, NULL, "Camera", NULL, 0},
{IT_SPACE, NULL, NULL, NULL, 0}, // padding
{IT_CALL | IT_STRING2, NULL, "Look Up", M_ChangeControl, GC_LOOKUP },
@@ -1127,15 +1125,13 @@ static menuitem_t OP_ChangeControlsMenu[] =
static menuitem_t OP_Joystick1Menu[] =
{
- {IT_STRING | IT_CALL, NULL, "Select Gamepad...", M_Setup1PJoystickMenu, 0},
-
- {IT_STRING | IT_CVAR, NULL, "Move \x17 Axis" , &cv_moveaxis , 20},
- {IT_STRING | IT_CVAR, NULL, "Move \x18 Axis" , &cv_sideaxis , 30},
- {IT_STRING | IT_CVAR, NULL, "Camera \x17 Axis" , &cv_lookaxis , 40},
- {IT_STRING | IT_CVAR, NULL, "Camera \x18 Axis" , &cv_turnaxis , 50},
- {IT_STRING | IT_CVAR, NULL, "Jump Axis" , &cv_jumpaxis , 60},
- {IT_STRING | IT_CVAR, NULL, "Spin Axis" , &cv_spinaxis , 70},
- {IT_STRING | IT_CVAR, NULL, "Shield Axis" , &cv_shieldaxis , 80},
+ {IT_STRING | IT_CALL, NULL, "Select Gamepad...", M_Setup1PJoystickMenu, 10},
+ {IT_STRING | IT_CVAR, NULL, "Move \x17 Axis" , &cv_moveaxis , 30},
+ {IT_STRING | IT_CVAR, NULL, "Move \x18 Axis" , &cv_sideaxis , 40},
+ {IT_STRING | IT_CVAR, NULL, "Camera \x17 Axis" , &cv_lookaxis , 50},
+ {IT_STRING | IT_CVAR, NULL, "Camera \x18 Axis" , &cv_turnaxis , 60},
+ {IT_STRING | IT_CVAR, NULL, "Jump Axis" , &cv_jumpaxis , 70},
+ {IT_STRING | IT_CVAR, NULL, "Spin Axis" , &cv_spinaxis , 80},
{IT_STRING | IT_CVAR, NULL, "Fire Axis" , &cv_fireaxis , 90},
{IT_STRING | IT_CVAR, NULL, "Fire Normal Axis" , &cv_firenaxis ,100},
@@ -1147,15 +1143,13 @@ static menuitem_t OP_Joystick1Menu[] =
static menuitem_t OP_Joystick2Menu[] =
{
- {IT_STRING | IT_CALL, NULL, "Select Gamepad...", M_Setup2PJoystickMenu, 0},
-
- {IT_STRING | IT_CVAR, NULL, "Move \x17 Axis" , &cv_moveaxis2 , 20},
- {IT_STRING | IT_CVAR, NULL, "Move \x18 Axis" , &cv_sideaxis2 , 30},
- {IT_STRING | IT_CVAR, NULL, "Camera \x17 Axis" , &cv_lookaxis2 , 40},
- {IT_STRING | IT_CVAR, NULL, "Camera \x18 Axis" , &cv_turnaxis2 , 50},
- {IT_STRING | IT_CVAR, NULL, "Jump Axis" , &cv_jumpaxis2 , 60},
- {IT_STRING | IT_CVAR, NULL, "Spin Axis" , &cv_spinaxis2 , 70},
- {IT_STRING | IT_CVAR, NULL, "Shield Axis" , &cv_shieldaxis2 , 80},
+ {IT_STRING | IT_CALL, NULL, "Select Gamepad...", M_Setup2PJoystickMenu, 10},
+ {IT_STRING | IT_CVAR, NULL, "Move \x17 Axis" , &cv_moveaxis2 , 30},
+ {IT_STRING | IT_CVAR, NULL, "Move \x18 Axis" , &cv_sideaxis2 , 40},
+ {IT_STRING | IT_CVAR, NULL, "Camera \x17 Axis" , &cv_lookaxis2 , 50},
+ {IT_STRING | IT_CVAR, NULL, "Camera \x18 Axis" , &cv_turnaxis2 , 60},
+ {IT_STRING | IT_CVAR, NULL, "Jump Axis" , &cv_jumpaxis2 , 70},
+ {IT_STRING | IT_CVAR, NULL, "Spin Axis" , &cv_spinaxis2 , 80},
{IT_STRING | IT_CVAR, NULL, "Fire Axis" , &cv_fireaxis2 , 90},
{IT_STRING | IT_CVAR, NULL, "Fire Normal Axis" , &cv_firenaxis2 ,100},
@@ -3186,7 +3180,6 @@ static void Command_Manual_f(void)
if (modeattacking)
return;
M_StartControlPanel();
- if (shieldprompt_timer) return; // TODO: 2.3: Delete this line
currentMenu = &MISC_HelpDef;
itemOn = 0;
}
@@ -3342,7 +3335,7 @@ boolean M_Responder(event_t *ev)
if (ch == -1)
return false;
- else if (ch == gamecontrol[GC_SYSTEMMENU][0] || ch == gamecontrol[GC_SYSTEMMENU][1]) // allow remappable ESC key
+ else if (ev->type != ev_text && (ch == gamecontrol[GC_SYSTEMMENU][0] || ch == gamecontrol[GC_SYSTEMMENU][1])) // allow remappable ESC key
ch = KEY_ESCAPE;
// F-Keys
@@ -3366,7 +3359,6 @@ boolean M_Responder(event_t *ev)
if (modeattacking)
return true;
M_StartControlPanel();
- if (shieldprompt_timer) return true; // TODO: 2.3: Delete this line
M_Options(0);
// Uncomment the below if you want the menu to reset to the top each time like before. M_SetupNextMenu will fix it automatically.
//OP_SoundOptionsDef.lastOn = 0;
@@ -3377,7 +3369,6 @@ boolean M_Responder(event_t *ev)
if (modeattacking)
return true;
M_StartControlPanel();
- if (shieldprompt_timer) return true; // TODO: 2.3: Delete this line
M_Options(0);
M_VideoModeMenu(0);
return true;
@@ -3389,7 +3380,6 @@ boolean M_Responder(event_t *ev)
if (modeattacking)
return true;
M_StartControlPanel();
- if (shieldprompt_timer) return true; // TODO: 2.3: Delete this line
M_Options(0);
M_SetupNextMenu(&OP_MainDef);
return true;
@@ -3423,9 +3413,16 @@ boolean M_Responder(event_t *ev)
// Handle menuitems which need a specific key handling
if (routine && (currentMenu->menuitems[itemOn].status & IT_TYPE) == IT_KEYHANDLER)
{
+ // block text input if ctrl is held, to allow using ctrl+c ctrl+v and ctrl+x
+ if (ctrldown)
+ {
+ routine(ch);
+ return true;
+ }
+
// ignore ev_keydown events if the key maps to a character, since
// the ev_text event will follow immediately after in that case.
- if (ev->type == ev_keydown && ch >= 32 && ch <= 127)
+ if (ev->type == ev_keydown && ((ch >= 32 && ch <= 127) || (ch >= KEY_KEYPAD7 && ch <= KEY_KPADDEL)))
return true;
routine(ch);
@@ -3453,7 +3450,7 @@ boolean M_Responder(event_t *ev)
{
// dirty hack: for customising controls, I want only buttons/keys, not moves
if (ev->type == ev_mouse || ev->type == ev_mouse2 || ev->type == ev_joystick
- || ev->type == ev_joystick2)
+ || ev->type == ev_joystick2 || ev->type == ev_text)
return true;
if (routine)
{
@@ -3660,230 +3657,6 @@ void M_Drawer(void)
}
}
-// Handle the "Do you want to assign Shield Ability now?" pop-up for old configs // TODO: 2.3: Remove this line...
-static UINT8 shieldprompt_currentchoice = 0; // ...and this line...
-
-static void M_ShieldPromptUseDefaults(void) // ...and this function
-{
- // With a default config from v2.2.10 to v2.2.13, the B button will be set to Custom 1,
- // and Controls per Key defaults to "One", so it will override the default Shield button.
- // A default config from v2.2.0 to v2.2.9 has Next Weapon on B, so it suffers from this too.
-
- // So for "Use default Shield Ability buttons", we should update old configs to mitigate gamepad conflicts
- // (even with "Several" Controls per Key!), and show a message with the default bindings
-
- for (setupcontrols = gamecontrol; true; setupcontrols = gamecontrolbis) // Do stuff for both P1 and P2
- {
- INT32 JOY1 = (setupcontrols == gamecontrol) ? KEY_JOY1 : KEY_2JOY1; // Is this for P1 or for P2?
-
- if ((setupcontrols[GC_CUSTOM1][0] == JOY1+1 || setupcontrols[GC_CUSTOM1][1] == JOY1+1)
- && (setupcontrols[GC_CUSTOM2][0] == JOY1+3 || setupcontrols[GC_CUSTOM2][1] == JOY1+3)
- && (setupcontrols[GC_CUSTOM3][0] == JOY1+8 || setupcontrols[GC_CUSTOM3][1] == JOY1+8))
- {
- // If the player has v2.2.13's default gamepad Custom 1/2/3 buttons,
- // shuffle Custom 1/2/3 around to make room for Shield Ability on B
- UINT8 shield_slot = (setupcontrols[GC_SHIELD ][0] == KEY_NULL ) ? 0 : 1;
- UINT8 custom1_slot = (setupcontrols[GC_CUSTOM1][0] == JOY1+1) ? 0 : 1;
- UINT8 custom2_slot = (setupcontrols[GC_CUSTOM2][0] == JOY1+3) ? 0 : 1;
- UINT8 custom3_slot = (setupcontrols[GC_CUSTOM3][0] == JOY1+8) ? 0 : 1;
-
- setupcontrols[GC_SHIELD ][shield_slot ] = JOY1+1; // Assign Shield Ability to B
- setupcontrols[GC_CUSTOM1][custom1_slot] = JOY1+3; // Move Custom 1 from B to Y
- setupcontrols[GC_CUSTOM2][custom2_slot] = JOY1+8; // Move Custom 2 from Y to LS
- setupcontrols[GC_CUSTOM3][custom3_slot] = KEY_NULL; // Unassign Custom 3 from LS...
- // (The alternative would be to check and update the ENTIRE gamepad layout.
- // That'd be nice, but it would mess with people that are used to the old defaults.)
- }
- else if ((setupcontrols[GC_WEAPONNEXT][0] == JOY1+1 || setupcontrols[GC_WEAPONNEXT][1] == JOY1+1)
- && (setupcontrols[GC_WEAPONPREV][0] == JOY1+2 || setupcontrols[GC_WEAPONPREV][1] == JOY1+2))
- {
- // Or if the user has a default config from v2.2.0 to v2.2.9,
- // the B button will be Next Weapon, and X will be Previous Weapon.
- // It's "safe" to discard one of them, you just have to press X multiple times to select in the other direction
- UINT8 shield_slot = (setupcontrols[GC_SHIELD ][0] == KEY_NULL ) ? 0 : 1;
- UINT8 nweapon_slot = (setupcontrols[GC_WEAPONNEXT][0] == JOY1+1) ? 0 : 1;
- UINT8 pweapon_slot = (setupcontrols[GC_WEAPONPREV][0] == JOY1+2) ? 0 : 1;
-
- setupcontrols[GC_SHIELD ][shield_slot ] = JOY1+1; // Assign Shield Ability to B
- setupcontrols[GC_WEAPONNEXT][nweapon_slot] = JOY1+3; // Move Next Weapon from B to X
- setupcontrols[GC_WEAPONPREV][pweapon_slot] = KEY_NULL; // Unassign Previous Weapon from X
- }
-
- if (setupcontrols == gamecontrolbis) // If we've already updated both players, break out
- break;
- }
-
-
- // Now, show a message about the default Shield Ability bindings
- if ((gamecontrol[GC_SHIELD][0] == KEY_LALT && gamecontrol[GC_SHIELD][1] == KEY_JOY1+1)
- || (gamecontrol[GC_SHIELD][0] == KEY_JOY1+1 && gamecontrol[GC_SHIELD][1] == KEY_LALT))
- {
- // Left Alt and the B button are both assigned
- M_StartMessage(M_GetText("Shield Ability defaults to\nthe \x82""Left Alt\x80"" key on keyboard,\nand the \x85""B button\x80"" on gamepads."
- "\n\nYou can always reassign it\nin the Options menu later."
- "\n\n\nPress 'Enter' to continue\n"),
- NULL, MM_NOTHING);
- MessageDef.x = 43; // Change the pop-up message's background position/width
- MessageDef.lastOn = (MessageDef.lastOn & ~0xFF) | 27;
- }
- else if (gamecontrol[GC_SHIELD][0] == KEY_LALT || gamecontrol[GC_SHIELD][1] == KEY_LALT)
- {
- // Left Alt is assigned, but the B button isn't.
- M_StartMessage(M_GetText("Shield Ability defaults to\nthe \x82""Left Alt\x80"" key on keyboard.\nThe \x85""B button\x80"" on gamepads was taken."
- "\n\nYou can always reassign it\nin the Options menu later."
- "\n\n\nPress 'Enter' to continue\n"),
- NULL, MM_NOTHING);
- MessageDef.x = 24; // Change the pop-up message's background position/width
- MessageDef.lastOn = (MessageDef.lastOn & ~0xFF) | 32;
- }
- else if (gamecontrol[GC_SHIELD][0] == KEY_JOY1+1 || gamecontrol[GC_SHIELD][1] == KEY_JOY1+1)
- {
- // The B button is assigned, but Left Alt isn't
- M_StartMessage(M_GetText("Shield Ability defaults to\nthe \x85""B button\x80"" on gamepads.\nThe \x82""Left Alt\x80"" key on keyboard was taken."
- "\n\nYou can always reassign it\nin the Options menu later."
- "\n\n\nPress 'Enter' to continue\n"),
- NULL, MM_NOTHING);
- MessageDef.x = 8; // Change the pop-up message's background position/width
- MessageDef.lastOn = (MessageDef.lastOn & ~0xFF) | 36;
- }
- else if (gamecontrol[GC_SHIELD][0] == KEY_NULL && gamecontrol[GC_SHIELD][1] == KEY_NULL)
- {
- // Neither Left Alt nor the B button are assigned
- M_StartMessage(M_GetText("Shield Ability is unassigned!\nThe \x82""Left Alt\x80"" key on keyboard and\nthe \x85""B button\x80"" on gamepads were taken."
- "\n\nYou should assign Shield Ability\nin the Options menu later."
- "\n\n\nPress 'Enter' to continue\n"),
- NULL, MM_NOTHING);
- MessageDef.x = 19; // Change the pop-up message's background position/width
- MessageDef.lastOn = (MessageDef.lastOn & ~0xFF) | 33;
- }
- else
- {
- // Neither Left Alt nor the B button are assigned... but something else is???
- // (This can technically happen if you edit your config or use setcontrol in the console before opening the menu)
- char keystr[16+16+2+7+1]; // Two 16-char keys + two colour codes + "' and '" + null
-
- if (gamecontrol[GC_SHIELD][0] != KEY_NULL && gamecontrol[GC_SHIELD][1] != KEY_NULL)
- STRBUFCPY(keystr, va("%s\x80""' and '\x82""%s",
- G_KeyNumToName(gamecontrol[GC_SHIELD][0]),
- G_KeyNumToName(gamecontrol[GC_SHIELD][1])));
- else if (gamecontrol[GC_SHIELD][0] != KEY_NULL)
- STRBUFCPY(keystr, G_KeyNumToName(gamecontrol[GC_SHIELD][0]));
- else //if (gamecontrol[GC_SHIELD][1] != KEY_NULL)
- STRBUFCPY(keystr, G_KeyNumToName(gamecontrol[GC_SHIELD][1]));
-
- M_StartMessage(va("Shield Ability is assigned to\n'\x82""%s\x80""'."
- "\n\nYou can always reassign it\nin the Options menu later."
- "\n\n\nPress 'Enter' to continue\n",
- keystr), NULL, MM_NOTHING);
- MessageDef.x = 23; // Change the pop-up message's background position/width
- MessageDef.lastOn = (MessageDef.lastOn & ~0xFF) | 32;
- }
-}
-
-static void M_HandleShieldPromptMenu(INT32 choice) // TODO: 2.3: Remove
-{
- switch (choice)
- {
- case KEY_ESCAPE:
- if (I_GetTime() <= shieldprompt_timer) // Don't mash past the pop-up by accident!
- break;
-
- S_StartSound(NULL, sfx_menu1);
- noFurtherInput = true;
- shieldprompt_timer = 0;
- M_ShieldPromptUseDefaults();
- break;
-
- case KEY_ENTER:
- if (I_GetTime() <= shieldprompt_timer) // Don't mash past the pop-up by accident!
- break;
-
- S_StartSound(NULL, sfx_menu1);
- noFurtherInput = true;
- shieldprompt_timer = 0;
-
- if (shieldprompt_currentchoice == 0)
- {
- OP_ChangeControlsDef.lastOn = 8; // Highlight Shield Ability in the controls menu
- M_Setup1PControlsMenu(0); // Set up P1's controls menu and call M_SetupNextMenu
- }
- else if (shieldprompt_currentchoice == 1) // Copy the Spin buttons to the Shield buttons
- {
- CV_SetValue(&cv_controlperkey, 2); // Make sure that Controls per Key is "Several"
-
- gamecontrol [GC_SHIELD][0] = gamecontrol [GC_SPIN][0];
- gamecontrol [GC_SHIELD][1] = gamecontrol [GC_SPIN][1];
- gamecontrolbis[GC_SHIELD][0] = gamecontrolbis[GC_SPIN][0];
- gamecontrolbis[GC_SHIELD][1] = gamecontrolbis[GC_SPIN][1];
- CV_SetValue(&cv_shieldaxis, cv_spinaxis.value);
- CV_SetValue(&cv_shieldaxis2, cv_spinaxis2.value);
-
- M_StartMessage(M_GetText("Spin and Shield Ability are now\nthe same button."
- "\n\nYou can always reassign them\nin the Options menu later."
- "\n\n\nPress 'Enter' to continue\n"),
- NULL, MM_NOTHING);
- MessageDef.x = 36; // Change the pop-up message's background position/width
- MessageDef.lastOn = (MessageDef.lastOn & ~0xFF) | 29;
- }
- else
- M_ShieldPromptUseDefaults();
- break;
-
- case KEY_UPARROW:
- S_StartSound(NULL, sfx_menu1);
- shieldprompt_currentchoice = (shieldprompt_currentchoice+2)%3;
- break;
-
- case KEY_DOWNARROW:
- S_StartSound(NULL, sfx_menu1);
- shieldprompt_currentchoice = (shieldprompt_currentchoice+1)%3;
- break;
- }
-
- MessageDef.prevMenu = &MainDef;
-}
-
-static void M_DrawShieldPromptMenu(void) // TODO: 2.3: Remove
-{
- INT16 cursorx = (BASEVIDWIDTH/2) - 24;
-
- V_DrawFill(10-3, 68-3, 300+6, 40+6, 159);
- // V_DrawCenteredString doesn't centre newlines, so we have to draw each line separately
- V_DrawCenteredString(BASEVIDWIDTH/2, 68, V_ALLOWLOWERCASE, "Welcome back! Since you last played,");
- V_DrawCenteredString(BASEVIDWIDTH/2, 76, V_ALLOWLOWERCASE, "Spin has been split into separate");
- V_DrawCenteredString(BASEVIDWIDTH/2, 84, V_ALLOWLOWERCASE, "\"Spin\" and \"Shield Ability\" controls.");
-
- V_DrawCenteredString(BASEVIDWIDTH/2, 98, V_ALLOWLOWERCASE, "Do you want to assign Shield Ability now?");
-
-
- V_DrawCenteredString(BASEVIDWIDTH/2, 164,
- (shieldprompt_currentchoice == 0) ? V_YELLOWMAP : 0, "Open Control Setup");
- V_DrawCenteredString(BASEVIDWIDTH/2, 172,
- (shieldprompt_currentchoice == 1) ? V_YELLOWMAP : 0, "Keep the old behaviour");
- V_DrawCenteredString(BASEVIDWIDTH/2, 180,
- (shieldprompt_currentchoice == 2) ? V_YELLOWMAP : 0, "Use default Shield Ability buttons");
-
- switch (shieldprompt_currentchoice)
- {
- case 0: cursorx -= V_StringWidth("Open Control Setup", 0)/2; break;
- case 1: cursorx -= V_StringWidth("Keep the old behaviour", 0)/2; break;
- default: cursorx -= V_StringWidth("Use default Shield Ability buttons", 0)/2; break;
- }
- V_DrawScaledPatch(cursorx, 164 + (shieldprompt_currentchoice*8), 0, W_CachePatchName("M_CURSOR", PU_PATCH));
-}
-
-static menuitem_t OP_ShieldPromptMenu[] = {{IT_KEYHANDLER | IT_NOTHING, NULL, "", M_HandleShieldPromptMenu, 0}}; // TODO: 2.3: Remove
-
-menu_t OP_ShieldPromptDef = { // TODO: 2.3: Remove
- MN_SPECIAL,
- NULL,
- 1,
- &MainDef,
- OP_ShieldPromptMenu,
- M_DrawShieldPromptMenu,
- 0, 0, 0, NULL
-};
-
//
// M_StartControlPanel
//
@@ -3915,15 +3688,6 @@ void M_StartControlPanel(void)
currentMenu = &MainDef;
itemOn = singleplr;
M_UpdateItemOn();
-
- if (shieldprompt_timer) // For old configs, show a pop-up about the new Shield button // TODO: 2.3: Remove
- {
- S_StartSound(NULL, sfx_strpst);
- noFurtherInput = true;
- shieldprompt_timer = I_GetTime() + TICRATE; // Don't mash past the pop-up by accident!
-
- M_SetupNextMenu(&OP_ShieldPromptDef);
- }
}
else if (modeattacking)
{
@@ -3934,12 +3698,16 @@ void M_StartControlPanel(void)
}
else if (!(netgame || multiplayer)) // Single Player
{
- // Devmode unlocks Pandora's Box in the pause menu
- boolean pandora = ((M_SecretUnlocked(SECRET_PANDORA, serverGamedata) || cv_debug || devparm) && !marathonmode);
+ // Devmode unlocks Pandora's Box and Level Select in the pause menu
+ boolean isforbidden = (marathonmode || ultimatemode);
+ boolean isdebug = ((cv_debug || devparm) && !isforbidden);
+ boolean pandora = ((M_SecretUnlocked(SECRET_PANDORA, serverGamedata) && !isforbidden) || isdebug);
+ boolean lselect = ((maplistoption != 0 && !isforbidden) || isdebug);
- if (gamestate != GS_LEVEL || ultimatemode) // intermission, so gray out stuff.
+ if (gamestate != GS_LEVEL) // intermission, so gray out stuff.
{
SPauseMenu[spause_pandora].status = (pandora) ? (IT_GRAYEDOUT) : (IT_DISABLED);
+ SPauseMenu[spause_levelselect].status = (lselect) ? (IT_STRING | IT_CALL) : (IT_DISABLED);
SPauseMenu[spause_retry].status = IT_GRAYEDOUT;
}
else
@@ -3949,6 +3717,11 @@ void M_StartControlPanel(void)
++numlives;
SPauseMenu[spause_pandora].status = (pandora) ? (IT_STRING | IT_CALL) : (IT_DISABLED);
+ SPauseMenu[spause_levelselect].status = (lselect) ? (IT_STRING | IT_CALL) : (IT_DISABLED);
+ if (ultimatemode)
+ {
+ SPauseMenu[spause_retry].status = IT_GRAYEDOUT;
+ }
// The list of things that can disable retrying is (was?) a little too complex
// for me to want to use the short if statement syntax
@@ -3958,13 +3731,6 @@ void M_StartControlPanel(void)
SPauseMenu[spause_retry].status = (IT_STRING | IT_CALL);
}
- // We can always use level select though. :33
- // Guarantee it if we have either it unlocked or devmode is enabled
- if ((maplistoption != 0 || M_SecretUnlocked(SECRET_LEVELSELECT, serverGamedata) || cv_debug || devparm) && !marathonmode)
- SPauseMenu[spause_levelselect].status = (IT_STRING | IT_CALL);
- else
- SPauseMenu[spause_levelselect].status = (IT_DISABLED);
-
// And emblem hints.
SPauseMenu[spause_hints].status = (M_SecretUnlocked(SECRET_EMBLEMHINTS, clientGamedata) && !marathonmode) ? (IT_STRING | IT_CALL) : (IT_DISABLED);
@@ -7857,13 +7623,9 @@ static void M_PauseLevelSelect(INT32 choice)
SP_PauseLevelSelectDef.prevMenu = currentMenu;
levellistmode = LLM_LEVELSELECT;
- // maplistoption is only specified if not set already
- // and we have the level select unlocked so that it
+ // maplistoption is NOT specified, so that this
// transfers the level select list from the menu
// used to enter the game to the pause menu.
- if (maplistoption == 0 && M_SecretUnlocked(SECRET_LEVELSELECT, serverGamedata))
- maplistoption = 1;
-
if (!M_PrepareLevelPlatter(-1, true))
{
M_StartMessage(M_GetText("No selectable levels found.\n"),NULL,MM_NOTHING);
@@ -8587,6 +8349,7 @@ static void M_StartTutorial(INT32 choice)
gamecomplete = 0;
cursaveslot = 0;
maplistoption = 0;
+ CV_StealthSet(&cv_skin, DEFAULTSKIN); // tutorial accounts for sonic only
G_DeferedInitNew(false, G_BuildMapName(tutorialmap), 0, false, false);
}
@@ -11441,7 +11204,7 @@ static void M_Refresh(INT32 choice)
// note: this is the one case where 0 is a valid room number
// because it corresponds to "All"
- CL_UpdateServerList(!(ms_RoomId < 0), ms_RoomId);
+ CL_UpdateServerList(cv_masterserver_room_id.value >= 0, cv_masterserver_room_id.value);
// first page of servers
serverlistpage = 0;
@@ -11527,7 +11290,7 @@ static void M_DrawConnectMenu(void)
numPages = 1;
// Room name
- if (ms_RoomId < 0)
+ if (cv_masterserver_room_id.value < 0)
V_DrawRightAlignedString(BASEVIDWIDTH - currentMenu->x, currentMenu->y + MP_ConnectMenu[mp_connect_room].alphaKey,
V_YELLOWMAP, (itemOn == mp_connect_room) ? "<Select to change>" : "<Unlisted Mode>");
else
@@ -11755,7 +11518,7 @@ static void M_ConnectMenu(INT32 choice)
// first page of servers
serverlistpage = 0;
- if (ms_RoomId < 0)
+ if (cv_masterserver_room_id.value < 0)
{
M_RoomMenu(0); // Select a room instead of staring at an empty list
// This prevents us from returning to the modified game alert.
@@ -11851,10 +11614,10 @@ static void M_ChooseRoom(INT32 choice)
#endif
if (choice == 0)
- ms_RoomId = -1;
+ CV_SetValue(&cv_masterserver_room_id, -1);
else
{
- ms_RoomId = roomIds[choice-1];
+ CV_SetValue(&cv_masterserver_room_id, roomIds[choice-1]);
menuRoomIndex = choice - 1;
}
@@ -11923,7 +11686,7 @@ static void M_DrawServerMenu(void)
if (currentMenu == &MP_ServerDef)
{
M_DrawLevelPlatterHeader(currentMenu->y - lsheadingheight/2, "Server settings", true, false);
- if (ms_RoomId < 0)
+ if (cv_masterserver_room_id.value < 0)
V_DrawRightAlignedString(BASEVIDWIDTH - currentMenu->x, currentMenu->y + MP_ServerMenu[mp_server_room].alphaKey,
V_YELLOWMAP, (itemOn == mp_server_room) ? "<Select to change>" : "<Unlisted Mode>");
else
@@ -12019,7 +11782,7 @@ static void M_ServerOptions(INT32 choice)
static void M_StartServerMenu(INT32 choice)
{
(void)choice;
- ms_RoomId = -1;
+ CV_SetValue(&cv_masterserver_room_id, -1);
levellistmode = LLM_CREATESERVER;
Newgametype_OnChange();
M_SetupNextMenu(&MP_ServerDef);
@@ -12191,8 +11954,7 @@ static void M_HandleConnectIP(INT32 choice)
if ( ctrldown ) {
switch (choice) {
- case 'v':
- case 'V': // ctrl+v, pasting
+ case 'v': // ctrl+v, pasting
{
const char *paste = I_ClipboardPaste();
@@ -12205,8 +11967,7 @@ static void M_HandleConnectIP(INT32 choice)
break;
}
case KEY_INS:
- case 'c':
- case 'C': // ctrl+c, ctrl+insert, copying
+ case 'c': // ctrl+c, ctrl+insert, copying
if (l != 0) // Don't replace the clipboard without any text
{
I_ClipboardCopy(setupm_ip, l);
@@ -12214,8 +11975,7 @@ static void M_HandleConnectIP(INT32 choice)
}
break;
- case 'x':
- case 'X': // ctrl+x, cutting
+ case 'x': // ctrl+x, cutting
if (l != 0) // Don't replace the clipboard without any text
{
I_ClipboardCopy(setupm_ip, l);
@@ -12271,15 +12031,6 @@ static void M_HandleConnectIP(INT32 choice)
setupm_ip[l] = (char)choice;
setupm_ip[l+1] = 0;
}
- else if (choice >= 199 && choice <= 211 && choice != 202 && choice != 206) //numpad too!
- {
- char keypad_translation[] = {'7','8','9','-','4','5','6','+','1','2','3','0','.'};
- choice = keypad_translation[choice - 199];
- S_StartSound(NULL,sfx_menu1); // Tails
- setupm_ip[l] = (char)choice;
- setupm_ip[l+1] = 0;
- }
-
break;
}
@@ -13648,23 +13399,23 @@ static void M_Setup1PControlsMenu(INT32 choice)
currentMenu->lastOn = itemOn;
// Unhide the nine non-P2 controls and their headers
- //OP_ChangeControlsMenu[19+0].status = IT_HEADER;
- //OP_ChangeControlsMenu[19+1].status = IT_SPACE;
+ //OP_ChangeControlsMenu[18+0].status = IT_HEADER;
+ //OP_ChangeControlsMenu[18+1].status = IT_SPACE;
// ...
- OP_ChangeControlsMenu[19+2].status = IT_CALL|IT_STRING2;
- OP_ChangeControlsMenu[19+3].status = IT_CALL|IT_STRING2;
- OP_ChangeControlsMenu[19+4].status = IT_CALL|IT_STRING2;
- OP_ChangeControlsMenu[19+5].status = IT_CALL|IT_STRING2;
- OP_ChangeControlsMenu[19+6].status = IT_CALL|IT_STRING2;
- //OP_ChangeControlsMenu[19+7].status = IT_CALL|IT_STRING2;
- //OP_ChangeControlsMenu[19+8].status = IT_CALL|IT_STRING2;
- OP_ChangeControlsMenu[19+9].status = IT_CALL|IT_STRING2;
+ OP_ChangeControlsMenu[18+2].status = IT_CALL|IT_STRING2;
+ OP_ChangeControlsMenu[18+3].status = IT_CALL|IT_STRING2;
+ OP_ChangeControlsMenu[18+4].status = IT_CALL|IT_STRING2;
+ OP_ChangeControlsMenu[18+5].status = IT_CALL|IT_STRING2;
+ OP_ChangeControlsMenu[18+6].status = IT_CALL|IT_STRING2;
+ //OP_ChangeControlsMenu[18+7].status = IT_CALL|IT_STRING2;
+ //OP_ChangeControlsMenu[18+8].status = IT_CALL|IT_STRING2;
+ OP_ChangeControlsMenu[18+9].status = IT_CALL|IT_STRING2;
// ...
- OP_ChangeControlsMenu[29+0].status = IT_HEADER;
- OP_ChangeControlsMenu[29+1].status = IT_SPACE;
+ OP_ChangeControlsMenu[28+0].status = IT_HEADER;
+ OP_ChangeControlsMenu[28+1].status = IT_SPACE;
// ...
- OP_ChangeControlsMenu[29+2].status = IT_CALL|IT_STRING2;
- OP_ChangeControlsMenu[29+3].status = IT_CALL|IT_STRING2;
+ OP_ChangeControlsMenu[28+2].status = IT_CALL|IT_STRING2;
+ OP_ChangeControlsMenu[28+3].status = IT_CALL|IT_STRING2;
OP_ChangeControlsDef.prevMenu = &OP_P1ControlsDef;
OP_ChangeControlsDef.menuid &= ~(((1 << MENUBITS) - 1) << MENUBITS); // remove second level
@@ -13680,23 +13431,23 @@ static void M_Setup2PControlsMenu(INT32 choice)
currentMenu->lastOn = itemOn;
// Hide the nine non-P2 controls and their headers
- //OP_ChangeControlsMenu[19+0].status = IT_GRAYEDOUT2;
- //OP_ChangeControlsMenu[19+1].status = IT_GRAYEDOUT2;
+ //OP_ChangeControlsMenu[18+0].status = IT_GRAYEDOUT2;
+ //OP_ChangeControlsMenu[18+1].status = IT_GRAYEDOUT2;
// ...
- OP_ChangeControlsMenu[19+2].status = IT_GRAYEDOUT2;
- OP_ChangeControlsMenu[19+3].status = IT_GRAYEDOUT2;
- OP_ChangeControlsMenu[19+4].status = IT_GRAYEDOUT2;
- OP_ChangeControlsMenu[19+5].status = IT_GRAYEDOUT2;
- OP_ChangeControlsMenu[19+6].status = IT_GRAYEDOUT2;
- //OP_ChangeControlsMenu[19+7].status = IT_GRAYEDOUT2;
- //OP_ChangeControlsMenu[19+8].status = IT_GRAYEDOUT2;
- OP_ChangeControlsMenu[19+9].status = IT_GRAYEDOUT2;
+ OP_ChangeControlsMenu[18+2].status = IT_GRAYEDOUT2;
+ OP_ChangeControlsMenu[18+3].status = IT_GRAYEDOUT2;
+ OP_ChangeControlsMenu[18+4].status = IT_GRAYEDOUT2;
+ OP_ChangeControlsMenu[18+5].status = IT_GRAYEDOUT2;
+ OP_ChangeControlsMenu[18+6].status = IT_GRAYEDOUT2;
+ //OP_ChangeControlsMenu[18+7].status = IT_GRAYEDOUT2;
+ //OP_ChangeControlsMenu[18+8].status = IT_GRAYEDOUT2;
+ OP_ChangeControlsMenu[18+9].status = IT_GRAYEDOUT2;
// ...
- OP_ChangeControlsMenu[29+0].status = IT_GRAYEDOUT2;
- OP_ChangeControlsMenu[29+1].status = IT_GRAYEDOUT2;
+ OP_ChangeControlsMenu[28+0].status = IT_GRAYEDOUT2;
+ OP_ChangeControlsMenu[28+1].status = IT_GRAYEDOUT2;
// ...
- OP_ChangeControlsMenu[29+2].status = IT_GRAYEDOUT2;
- OP_ChangeControlsMenu[29+3].status = IT_GRAYEDOUT2;
+ OP_ChangeControlsMenu[28+2].status = IT_GRAYEDOUT2;
+ OP_ChangeControlsMenu[28+3].status = IT_GRAYEDOUT2;
OP_ChangeControlsDef.prevMenu = &OP_P2ControlsDef;
OP_ChangeControlsDef.menuid &= ~(((1 << MENUBITS) - 1) << MENUBITS); // remove second level
@@ -14497,6 +14248,33 @@ static INT32 quitsounds[] =
sfx_chchng // Tails 11-09-99
};
+const char *QuitScreenMessages[3] = {
+ (
+ "Design and content in\n"
+ "SRB2 is copyright\n"
+ "1998-2025 by STJr. All\n"
+ "original material in\n"
+ "this game is copyrighted\n"
+ "by their respective\n"
+ "owners, and no copyright\n"
+ "infringement is\n"
+ "intended. STJr's staff\n"
+ "make no profit\n"
+ "whatsoever (in\n"
+ "fact, we lose\n"
+ "money)."
+ ),
+
+ (
+ "THIS GAME SHOULD NOT BE SOLD!"
+ ),
+
+ (
+ "STJr is in no way affiliated\n"
+ "with SEGA or Sonic Team."
+ )
+};
+
void M_QuitResponse(INT32 ch)
{
tic_t ptime;
@@ -14518,6 +14296,9 @@ void M_QuitResponse(INT32 ch)
while (ptime > I_GetTime())
{
V_DrawScaledPatch(0, 0, 0, W_CachePatchName("GAMEQUIT", PU_PATCH)); // Demo 3 Quit Screen Tails 06-16-2001
+ V_DrawCenteredString(2+(V_StringWidth(QuitScreenMessages[0], V_ALLOWLOWERCASE)/2), 4, V_ALLOWLOWERCASE, QuitScreenMessages[0]);
+ V_DrawCenteredString(160, 166, V_ALLOWLOWERCASE|V_REDMAP, QuitScreenMessages[1]);
+ V_DrawCenteredString(160, 176, V_ALLOWLOWERCASE, QuitScreenMessages[2]);
I_FinishUpdate(); // Update the screen with the image Tails 06-19-2001
I_Sleep(cv_sleep.value);
I_UpdateTime(cv_timescale.value);
diff --git a/src/m_menu.h b/src/m_menu.h
index a0c7b3d219410b78807a2a5a8cbd0758f6d80813..f14a2a3084619e5c26534438eac15ed0bbdcc592 100644
--- a/src/m_menu.h
+++ b/src/m_menu.h
@@ -3,7 +3,7 @@
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
// Copyright (C) 2011-2016 by Matthew "Kaito Sinclaire" Walsh.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2025 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -143,7 +143,7 @@ typedef enum
typedef struct
{
- char bgname[8]; // name for background gfx lump; lays over titlemap if this is set
+ char bgname[8+1]; // name for background gfx lump; lays over titlemap if this is set
SINT8 fadestrength; // darken background when displaying this menu, strength 0-31 or -1 for undefined
INT32 bgcolor; // fill color, overrides bg name. -1 means follow bg name rules.
INT32 titlescrollxspeed; // background gfx scroll per menu; inherits global setting
@@ -153,13 +153,13 @@ typedef struct
SINT8 hidetitlepics; // hide title gfx per menu; -1 means undefined, inherits global setting
ttmode_enum ttmode; // title wing animation mode; default TTMODE_OLD
UINT8 ttscale; // scale of title wing gfx (FRACUNIT / ttscale); -1 means undefined, inherits global setting
- char ttname[9]; // lump name of title wing gfx. If name length is <= 6, engine will attempt to load numbered frames (TTNAMExx)
+ char ttname[8+1]; // lump name of title wing gfx. If name length is <= 6, engine will attempt to load numbered frames (TTNAMExx)
INT16 ttx; // X position of title wing
INT16 tty; // Y position of title wing
INT16 ttloop; // # frame to loop; -1 means dont loop
UINT16 tttics; // # of tics per frame
- char musname[7]; ///< Music track to play. "" for no music.
+ char musname[6+1]; ///< Music track to play. "" for no music.
UINT16 mustrack; ///< Subsong to play. Only really relevant for music modules and specific formats supported by GME. 0 to ignore.
boolean muslooping; ///< Loop the music
boolean musstop; ///< Don't play any music
@@ -176,7 +176,6 @@ typedef struct
extern menupres_t menupres[NUMMENUTYPES];
extern UINT32 prevMenuId;
extern UINT32 activeMenuId;
-extern tic_t shieldprompt_timer; // Show a prompt about the new Shield button for old configs // TODO: 2.3: Remove
void M_InitMenuPresTables(void);
UINT8 M_GetYoungestChildMenu(void);
@@ -370,8 +369,8 @@ extern menu_t OP_JoystickSetDef;
typedef struct
{
boolean used;
- char notes[441];
- char picname[8];
+ char notes[440+1];
+ char picname[8+1];
char skinname[SKINNAMESIZE*2+2]; // skin&skin\0
patch_t *charpic;
UINT8 prev;
diff --git a/src/m_misc.c b/src/m_misc.c
index 724717aa681597b33a8b7bc573dc0be91220337f..24616e9db42e2b27bab8c4d359e5d92b3945f6d7 100644
--- a/src/m_misc.c
+++ b/src/m_misc.c
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -560,11 +560,6 @@ void M_FirstLoadConfig(void)
COM_BufInsertText(va("exec \"%s\"\n", configfile));
// no COM_BufExecute() needed; that does it right away
- // For configs loaded at startup only, check for pre-Shield-button configs // TODO: 2.3: Remove
- if (GETMAJOREXECVERSION(cv_execversion.value) < 55 // Pre-v2.2.14 configs
- && cv_execversion.value != 25) // Make sure that the config exists, too
- shieldprompt_timer = 1;
-
// don't filter anymore vars and don't let this convsvar be changed
COM_BufInsertText(va("%s \"%d\"\n", cv_execversion.name, EXECVERSION));
CV_ToggleExecVersion(false);
diff --git a/src/m_misc.h b/src/m_misc.h
index 04ac66ca65e1ff92d44172b12e1186cdaa04b648..63681094430950d90263165b052d9118e2240524 100644
--- a/src/m_misc.h
+++ b/src/m_misc.h
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
diff --git a/src/m_perfstats.c b/src/m_perfstats.c
index b9948bdc0c3284a3473e7e6e8b95b2e3bd8fb568..33a774acfbb4ca9781ff62a177b93f9bffca28f8 100644
--- a/src/m_perfstats.c
+++ b/src/m_perfstats.c
@@ -453,7 +453,7 @@ static int PS_DrawPerfRows(int x, int y, int color, perfstatrow_t *rows)
return draw_y;
}
-static void PS_UpdateMetricHistory(ps_metric_t *metric, boolean time_metric, boolean frame_metric, boolean set_user)
+static void PS_UpdateMetricHistory(ps_metric_t *metric, boolean time_metric, boolean frame_metric)
{
int index = frame_metric ? ps_frame_index : ps_tick_index;
@@ -461,7 +461,7 @@ static void PS_UpdateMetricHistory(ps_metric_t *metric, boolean time_metric, boo
{
// allocate history table
int value_size = time_metric ? sizeof(precise_t) : sizeof(INT32);
- void** memory_user = set_user ? &metric->history : NULL;
+ void** memory_user = &metric->history;
metric->history = Z_Calloc(value_size * cv_ps_samplesize.value, PU_PERFSTATS,
memory_user);
@@ -491,7 +491,7 @@ static void PS_UpdateRowHistories(perfstatrow_t *rows, boolean frame_metric)
for (row = rows; row->lores_label; row++)
{
if (PS_IsRowValid(row))
- PS_UpdateMetricHistory(row->metric, !!(row->flags & PS_TIME), frame_metric, true);
+ PS_UpdateMetricHistory(row->metric, !!(row->flags & PS_TIME), frame_metric);
}
}
@@ -584,7 +584,7 @@ static void PS_CountThinkers(void)
for (thinker = thlist[i].next; thinker != &thlist[i]; thinker = thinker->next)
{
ps_thinkercount.value.i++;
- if (thinker->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (thinker->removing)
ps_removecount.value.i++;
else if (i == THINK_POLYOBJ)
ps_polythcount.value.i++;
@@ -649,17 +649,17 @@ void PS_UpdateTickStats(void)
if (cv_perfstats.value == 3)
{
for (i = 0; i < thinkframe_hooks_length; i++)
- PS_UpdateMetricHistory(&thinkframe_hooks[i].time_taken, true, false, false);
+ PS_UpdateMetricHistory(&thinkframe_hooks[i].time_taken, true, false);
}
else if (cv_perfstats.value == 4)
{
for (i = 0; i < prethinkframe_hooks_length; i++)
- PS_UpdateMetricHistory(&prethinkframe_hooks[i].time_taken, true, false, false);
+ PS_UpdateMetricHistory(&prethinkframe_hooks[i].time_taken, true, false);
}
else if (cv_perfstats.value == 5)
{
for (i = 0; i < postthinkframe_hooks_length; i++)
- PS_UpdateMetricHistory(&postthinkframe_hooks[i].time_taken, true, false, false);
+ PS_UpdateMetricHistory(&postthinkframe_hooks[i].time_taken, true, false);
}
}
if (cv_perfstats.value)
diff --git a/src/m_random.c b/src/m_random.c
index 536fbfbbd1077abf6ae400bd4d8773a7574e4b08..a063e88f47ccc40f10ffa09d441016d3bd20c13b 100644
--- a/src/m_random.c
+++ b/src/m_random.c
@@ -193,9 +193,9 @@ INT32 M_RandomKey(INT32 a)
*/
INT32 M_RandomRange(INT32 a, INT32 b)
{
- if (b < a)
+ if (b < a)
{
- INT32 temp;
+ INT32 temp;
temp = a;
a = b;
diff --git a/src/m_tokenizer.c b/src/m_tokenizer.c
index 8bb094caea7ec94db70ccdffe57fd4191f5a9773..09f8915a52b2c476036f560c773118b3d5f823ff 100644
--- a/src/m_tokenizer.c
+++ b/src/m_tokenizer.c
@@ -1,6 +1,6 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
-// Copyright (C) 2013-2023 by Sonic Team Junior.
+// Copyright (C) 2013-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
diff --git a/src/m_tokenizer.h b/src/m_tokenizer.h
index 7ee856b3c9331d8dbb0b97711bd5e8bcae7ec2e7..4f03563a2da69c671edfc196ec478dc4715fa080 100644
--- a/src/m_tokenizer.h
+++ b/src/m_tokenizer.h
@@ -1,6 +1,6 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
-// Copyright (C) 2013-2023 by Sonic Team Junior.
+// Copyright (C) 2013-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
diff --git a/src/netcode/client_connection.c b/src/netcode/client_connection.c
index 917e32b598e03d86f8540b997329069f279817fb..c740d53a6a3845539bfe0637771e78827ae8b055 100644
--- a/src/netcode/client_connection.c
+++ b/src/netcode/client_connection.c
@@ -546,6 +546,7 @@ static void AbortConnection(void)
{
Snake_Free(&snake);
+ CURLAbortFile();
D_QuitNetGame();
CL_Reset();
D_StartTitle();
@@ -1062,10 +1063,6 @@ static boolean CL_ServerConnectionTicker(const char *tmpsave, tic_t *oldtic, tic
}
}
- // Rusty TODO: multithread
- if (filedownload.http_running)
- CURLGetFile();
-
if (waitmore)
break; // exit the case
diff --git a/src/netcode/commands.c b/src/netcode/commands.c
index f3bbc8a8616224b65a481559bd96eccbb3577f5e..8d6dab06b5da5628245f307a1519ef74a0ea9588 100644
--- a/src/netcode/commands.c
+++ b/src/netcode/commands.c
@@ -1,7 +1,7 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
diff --git a/src/netcode/d_clisrv.c b/src/netcode/d_clisrv.c
index 5fee506af320578b7228cb6e5616ebac238120f7..7a5fb06a6c37f4ff95cbef8abf25077a6c16d377 100644
--- a/src/netcode/d_clisrv.c
+++ b/src/netcode/d_clisrv.c
@@ -113,9 +113,11 @@ consvar_t cv_blamecfail = CVAR_INIT ("blamecfail", "Off", CV_SAVE|CV_NETVAR, CV_
static CV_PossibleValue_t playbackspeed_cons_t[] = {{1, "MIN"}, {10, "MAX"}, {0, NULL}};
consvar_t cv_playbackspeed = CVAR_INIT ("playbackspeed", "1", 0, playbackspeed_cons_t, NULL);
-consvar_t cv_idletime = CVAR_INIT ("idletime", "0", CV_SAVE, CV_Unsigned, NULL);
-consvar_t cv_idlespectate = CVAR_INIT ("idlespectate", "On", CV_SAVE, CV_OnOff, NULL);
-consvar_t cv_dedicatedidletime = CVAR_INIT ("dedicatedidletime", "10", CV_SAVE, CV_Unsigned, NULL);
+consvar_t cv_dedicatedidletime = CVAR_INIT ("dedicatedidletime", "10", CV_SAVE|CV_NETVAR, CV_Unsigned, NULL);
+
+static CV_PossibleValue_t idleaction_cons_t[] = {{1, "Kick"}, {2, "Spectate"}, {0, NULL}};
+consvar_t cv_idleaction = CVAR_INIT ("idleaction", "Spectate", CV_SAVE|CV_NETVAR, idleaction_cons_t, NULL);
+consvar_t cv_idletime = CVAR_INIT ("idletime", "3", CV_SAVE|CV_NETVAR, CV_Unsigned, NULL);
consvar_t cv_httpsource = CVAR_INIT ("http_source", "", CV_SAVE, NULL, NULL);
@@ -661,7 +663,7 @@ void D_QuitNetGame(void)
if (netnodes[i].ingame)
HSendPacket(i, true, 0, 0);
#ifdef MASTERSERVER
- if (serverrunning && ms_RoomId > 0)
+ if (serverrunning && cv_masterserver_room_id.value > 0)
UnregisterServer();
#endif
}
@@ -671,6 +673,7 @@ void D_QuitNetGame(void)
HSendPacket(servernode, true, 0, 0);
}
+ seenplayer = NULL;
D_CloseConnection();
ClearAdminPlayers();
@@ -795,7 +798,7 @@ void SV_SpawnServer(void)
{
I_NetOpenSocket();
#ifdef MASTERSERVER
- if (ms_RoomId > 0)
+ if (cv_masterserver_room_id.value > 0)
RegisterServer();
#endif
}
@@ -1373,7 +1376,7 @@ static void IdleUpdate(void)
if (cv_idletime.value && !IsPlayerAdmin(i) && i != serverplayer && !(players[i].pflags & PF_FINISHED) && players[i].lastinputtime > (tic_t)cv_idletime.value * TICRATE * 60)
{
players[i].lastinputtime = 0;
- if (cv_idlespectate.value && G_GametypeHasSpectators())
+ if (cv_idleaction.value == 2 && G_GametypeHasSpectators())
{
changeteam_union NetPacket;
UINT16 usvalue;
@@ -1384,7 +1387,7 @@ static void IdleUpdate(void)
usvalue = SHORT(NetPacket.value.l|NetPacket.value.b);
SendNetXCmd(XD_TEAMCHANGE, &usvalue, sizeof(usvalue));
}
- else
+ else if (cv_idleaction.value == 1)
{
SendKick(i, KICK_MSG_IDLE | KICK_MSG_KEEP_BODY);
}
@@ -1414,6 +1417,83 @@ static void IdleUpdate(void)
}
}
+static void DedicatedIdleUpdate(INT32 *realtics)
+{
+ const tic_t dedicatedidletime = cv_dedicatedidletime.value * TICRATE;
+ static tic_t dedicatedidletimeprev = 0;
+ static tic_t dedicatedidle = 0;
+
+ if (!server || !dedicated || gamestate != GS_LEVEL)
+ return;
+
+ if (dedicatedidletime > 0)
+ {
+ INT32 i;
+
+ boolean empty = true;
+ for (i = 0; i < MAXPLAYERS; i++)
+ if (playeringame[i])
+ {
+ empty = false;
+ break;
+ }
+
+ if (empty)
+ {
+ if (leveltime == 2)
+ {
+ // On next tick...
+ dedicatedidle = dedicatedidletime - 1;
+ }
+ else if (dedicatedidle >= dedicatedidletime)
+ {
+ if (D_GetExistingTextcmd(gametic, 0) || D_GetExistingTextcmd(gametic + 1, 0))
+ {
+ CONS_Printf("DEDICATED: Awakening from idle (Netxcmd detected...)\n");
+ dedicatedidle = 0;
+ }
+ else
+ {
+ (*realtics) = 0;
+ }
+ }
+ else
+ {
+ dedicatedidle += (*realtics);
+
+ if (dedicatedidle >= dedicatedidletime)
+ {
+ const char *idlereason = "at round start";
+ if (leveltime > 3)
+ idlereason = va("for %d seconds", dedicatedidle / TICRATE);
+
+ CONS_Printf("DEDICATED: No players %s, idling...\n", idlereason);
+ (*realtics) = 0;
+ dedicatedidle = dedicatedidletime;
+ }
+ }
+ }
+ else
+ {
+ if (dedicatedidle >= dedicatedidletime)
+ {
+ CONS_Printf("DEDICATED: Awakening from idle (Player detected...)\n");
+ }
+ dedicatedidle = 0;
+ }
+ }
+ else
+ {
+ if (dedicatedidletimeprev > 0 && dedicatedidle >= dedicatedidletimeprev)
+ {
+ CONS_Printf("DEDICATED: Awakening from idle (Idle disabled...)\n");
+ }
+ dedicatedidle = 0;
+ }
+
+ dedicatedidletimeprev = dedicatedidletime;
+}
+
// Handle timeouts to prevent definitive freezes from happenning
static void HandleNodeTimeouts(void)
{
@@ -1490,69 +1570,7 @@ void NetUpdate(void)
realtics = 5;
}
- if (server && dedicated && gamestate == GS_LEVEL)
- {
- const tic_t dedicatedidletime = cv_dedicatedidletime.value * TICRATE;
- static tic_t dedicatedidletimeprev = 0;
- static tic_t dedicatedidle = 0;
-
- if (dedicatedidletime > 0)
- {
- INT32 i;
-
- for (i = 1; i < MAXNETNODES; ++i)
- if (netnodes[i].ingame)
- {
- if (dedicatedidle >= dedicatedidletime)
- {
- CONS_Printf("DEDICATED: Awakening from idle (Node %d detected...)\n", i);
- dedicatedidle = 0;
- }
- break;
- }
-
- if (i == MAXNETNODES)
- {
- if (leveltime == 2)
- {
- // On next tick...
- dedicatedidle = dedicatedidletime-1;
- }
- else if (dedicatedidle >= dedicatedidletime)
- {
- if (D_GetExistingTextcmd(gametic, 0) || D_GetExistingTextcmd(gametic+1, 0))
- {
- CONS_Printf("DEDICATED: Awakening from idle (Netxcmd detected...)\n");
- dedicatedidle = 0;
- }
- else
- {
- realtics = 0;
- }
- }
- else if ((dedicatedidle += realtics) >= dedicatedidletime)
- {
- const char *idlereason = "at round start";
- if (leveltime > 3)
- idlereason = va("for %d seconds", dedicatedidle/TICRATE);
-
- CONS_Printf("DEDICATED: No nodes %s, idling...\n", idlereason);
- realtics = 0;
- dedicatedidle = dedicatedidletime;
- }
- }
- }
- else
- {
- if (dedicatedidletimeprev > 0 && dedicatedidle >= dedicatedidletimeprev)
- {
- CONS_Printf("DEDICATED: Awakening from idle (Idle disabled...)\n");
- }
- dedicatedidle = 0;
- }
-
- dedicatedidletimeprev = dedicatedidletime;
- }
+ DedicatedIdleUpdate(&realtics);
gametime = nowtime;
@@ -1799,7 +1817,7 @@ INT16 Consistancy(void)
{
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
{
- if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (th->removing)
continue;
mo = (mobj_t *)th;
diff --git a/src/netcode/d_clisrv.h b/src/netcode/d_clisrv.h
index 342173dff5bf575a762433a4cb2ad753a61685a0..86af61e9e02eb9528b759ce635970a96e3a28ee4 100644
--- a/src/netcode/d_clisrv.h
+++ b/src/netcode/d_clisrv.h
@@ -73,7 +73,7 @@ extern UINT32 realpingtable[MAXPLAYERS];
extern UINT32 playerpingtable[MAXPLAYERS];
extern tic_t servermaxping;
-extern consvar_t cv_netticbuffer, cv_resynchattempts, cv_blamecfail, cv_playbackspeed, cv_idletime, cv_idlespectate, cv_dedicatedidletime;
+extern consvar_t cv_netticbuffer, cv_resynchattempts, cv_blamecfail, cv_playbackspeed, cv_idletime, cv_idleaction, cv_dedicatedidletime;
extern consvar_t cv_httpsource;
// Used in d_net, the only dependence
diff --git a/src/netcode/d_net.c b/src/netcode/d_net.c
index b24409db158909970a73fb5bd7630500a4f3d63f..4860d8688b4a8b998b59523c6cf52502c69d10ca 100644
--- a/src/netcode/d_net.c
+++ b/src/netcode/d_net.c
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -62,16 +62,11 @@ static doomdata_t reboundstore[MAXREBOUND];
static INT16 reboundsize[MAXREBOUND];
static INT32 rebound_head, rebound_tail;
-/// \brief bandwith of netgame
-INT32 net_bandwidth;
-
/// \brief max length per packet
INT16 hardware_MAXPACKETLENGTH;
boolean (*I_NetGet)(void) = NULL;
void (*I_NetSend)(void) = NULL;
-boolean (*I_NetCanSend)(void) = NULL;
-boolean (*I_NetCanGet)(void) = NULL;
void (*I_NetCloseSocket)(void) = NULL;
void (*I_NetFreeNodenum)(INT32 nodenum) = NULL;
SINT8 (*I_NetMakeNodewPort)(const char *address, const char* port) = NULL;
@@ -996,15 +991,7 @@ boolean HSendPacket(INT32 node, boolean reliable, UINT8 acknum, size_t packetlen
netbuffer->ackreturn = 0;
if (reliable)
{
- if (I_NetCanSend && !I_NetCanSend())
- {
- if (netbuffer->packettype < PT_CANFAIL)
- GetFreeAcknum(&netbuffer->ack, true);
-
- DEBFILE("HSendPacket: Out of bandwidth\n");
- return false;
- }
- else if (!GetFreeAcknum(&netbuffer->ack, false))
+ if (!GetFreeAcknum(&netbuffer->ack, false))
return false;
}
else
@@ -1156,7 +1143,7 @@ static void Internal_FreeNodenum(INT32 nodenum)
char *I_NetSplitAddress(char *host, char **port)
{
- boolean v4 = (strchr(host, '.') != NULL);
+ boolean v4 = (host[0] != '[');
host = strtok(host, v4 ? ":" : "[]");
@@ -1189,10 +1176,7 @@ void D_SetDoomcom(void)
{
if (doomcom) return;
doomcom = Z_Calloc(sizeof (doomcom_t), PU_STATIC, NULL);
- doomcom->id = DOOMCOM_ID;
doomcom->numslots = doomcom->numnodes = 1;
- doomcom->gametype = 0;
- doomcom->consoleplayer = 0;
doomcom->extratics = 0;
}
@@ -1211,13 +1195,11 @@ boolean D_CheckNetGame(void)
I_NetGet = Internal_Get;
I_NetSend = Internal_Send;
- I_NetCanSend = NULL;
I_NetCloseSocket = NULL;
I_NetFreeNodenum = Internal_FreeNodenum;
I_NetMakeNodewPort = NULL;
hardware_MAXPACKETLENGTH = MAXPACKETLENGTH;
- net_bandwidth = 30000;
// I_InitNetwork sets doomcom and netgame
// check and initialize the network driver
multiplayer = false;
@@ -1237,7 +1219,6 @@ boolean D_CheckNetGame(void)
server = true; // WTF? server always true???
// no! The deault mode is server. Client is set elsewhere
// when the client executes connect command.
- doomcom->ticdup = 1;
if (M_CheckParm("-extratic"))
{
@@ -1248,21 +1229,6 @@ boolean D_CheckNetGame(void)
CONS_Printf(M_GetText("Set extratics to %d\n"), doomcom->extratics);
}
- if (M_CheckParm("-bandwidth"))
- {
- if (M_IsNextParm())
- {
- net_bandwidth = atoi(M_GetNextParm());
- if (net_bandwidth < 1000)
- net_bandwidth = 1000;
- if (net_bandwidth > 100000)
- hardware_MAXPACKETLENGTH = MAXPACKETLENGTH;
- CONS_Printf(M_GetText("Network bandwidth set to %d\n"), net_bandwidth);
- }
- else
- I_Error("usage: -bandwidth <byte_per_sec>");
- }
-
software_MAXPACKETLENGTH = hardware_MAXPACKETLENGTH;
if (M_CheckParm("-packetsize"))
{
@@ -1282,8 +1248,6 @@ boolean D_CheckNetGame(void)
if (netgame)
multiplayer = true;
- if (doomcom->id != DOOMCOM_ID)
- I_Error("Doomcom buffer invalid!");
if (doomcom->numnodes > MAXNETNODES)
I_Error("Too many nodes (%d), max:%d", doomcom->numnodes, MAXNETNODES);
@@ -1293,7 +1257,7 @@ boolean D_CheckNetGame(void)
if (M_CheckParm("-debugfile"))
{
char filename[21];
- INT32 k = doomcom->consoleplayer - 1;
+ INT32 k = consoleplayer - 1;
if (M_IsNextParm())
k = atoi(M_GetNextParm()) - 1;
while (!debugfile && k < MAXPLAYERS)
@@ -1400,7 +1364,6 @@ void D_CloseConnection(void)
I_NetGet = Internal_Get;
I_NetSend = Internal_Send;
- I_NetCanSend = NULL;
I_NetCloseSocket = NULL;
I_NetFreeNodenum = Internal_FreeNodenum;
I_NetMakeNodewPort = NULL;
diff --git a/src/netcode/d_netcmd.c b/src/netcode/d_netcmd.c
index 4134c633e5a32e23e6be085a32300bb308a694df..94170fa0df401064f5c1a2f9569cfceb0b0c490e 100644
--- a/src/netcode/d_netcmd.c
+++ b/src/netcode/d_netcmd.c
@@ -391,7 +391,7 @@ static CV_PossibleValue_t perfstats_cons_t[] = {
consvar_t cv_perfstats = CVAR_INIT ("perfstats", "Off", CV_CALL, perfstats_cons_t, PS_PerfStats_OnChange);
static CV_PossibleValue_t ps_samplesize_cons_t[] = {
{1, "MIN"}, {1000, "MAX"}, {0, NULL}};
-consvar_t cv_ps_samplesize = CVAR_INIT ("ps_samplesize", "1", CV_CALL, ps_samplesize_cons_t, PS_SampleSize_OnChange);
+consvar_t cv_ps_samplesize = CVAR_INIT ("ps_samplesize", "175", CV_CALL, ps_samplesize_cons_t, PS_SampleSize_OnChange);
static CV_PossibleValue_t ps_descriptor_cons_t[] = {
{1, "Average"}, {2, "SD"}, {3, "Minimum"}, {4, "Maximum"}, {0, NULL}};
consvar_t cv_ps_descriptor = CVAR_INIT ("ps_descriptor", "Average", 0, ps_descriptor_cons_t, NULL);
@@ -620,7 +620,7 @@ void D_RegisterServerCommands(void)
CV_RegisterVar(&cv_blamecfail);
CV_RegisterVar(&cv_dedicatedidletime);
CV_RegisterVar(&cv_idletime);
- CV_RegisterVar(&cv_idlespectate);
+ CV_RegisterVar(&cv_idleaction);
CV_RegisterVar(&cv_httpsource);
COM_AddCommand("ping", Command_Ping_f, COM_LUA);
@@ -824,8 +824,6 @@ void D_RegisterClientCommands(void)
CV_RegisterVar(&cv_jumpaxis2);
CV_RegisterVar(&cv_spinaxis);
CV_RegisterVar(&cv_spinaxis2);
- CV_RegisterVar(&cv_shieldaxis);
- CV_RegisterVar(&cv_shieldaxis2);
CV_RegisterVar(&cv_fireaxis);
CV_RegisterVar(&cv_fireaxis2);
CV_RegisterVar(&cv_firenaxis);
@@ -4799,12 +4797,11 @@ static void Command_Togglemodified_f(void)
modifiedgame = !modifiedgame;
}
-extern UINT8 *save_p;
static void Command_Archivetest_f(void)
{
- UINT8 *buf;
UINT32 i, wrote;
thinker_t *th;
+ save_t savebuffer;
if (gamestate != GS_LEVEL)
{
CONS_Printf("This command only works in-game, you dummy.\n");
@@ -4818,28 +4815,29 @@ static void Command_Archivetest_f(void)
((mobj_t *)th)->mobjnum = i++;
// allocate buffer
- buf = save_p = ZZ_Alloc(1024);
+ savebuffer.size = 1024;
+ savebuffer.buf = malloc(savebuffer.size);
+ savebuffer.pos = 0;
// test archive
CONS_Printf("LUA_Archive...\n");
- LUA_Archive();
- WRITEUINT8(save_p, 0x7F);
- wrote = (UINT32)(save_p-buf);
+ LUA_Archive(&savebuffer);
+ P_WriteUINT8(&savebuffer, 0x7F);
+ wrote = savebuffer.pos;
// clear Lua state, so we can really see what happens!
CONS_Printf("Clearing state!\n");
LUA_ClearExtVars();
// test unarchive
- save_p = buf;
CONS_Printf("LUA_UnArchive...\n");
- LUA_UnArchive();
- i = READUINT8(save_p);
- if (i != 0x7F || wrote != (UINT32)(save_p-buf))
- CONS_Printf("Savegame corrupted. (write %u, read %u)\n", wrote, (UINT32)(save_p-buf));
+ LUA_UnArchive(&savebuffer);
+ i = P_ReadUINT8(&savebuffer);
+ if (i != 0x7F || wrote != (UINT32)(savebuffer.pos))
+ CONS_Printf("Savegame corrupted. (write %u, read %u)\n", wrote, (UINT32)(savebuffer.pos));
// free buffer
- Z_Free(buf);
+ free(savebuffer.buf);
CONS_Printf("Done. No crash.\n");
}
#endif
@@ -4910,11 +4908,13 @@ static void Name2_OnChange(void)
static boolean Skin_CanChange(const char *valstr)
{
- (void)valstr;
-
if (!Playing())
return true; // do whatever you want
+ // You already are that skin.
+ if (stricmp(skins[players[consoleplayer].skin]->name, valstr) == 0)
+ return false;
+
if (!(multiplayer || netgame)) // In single player.
return true;
@@ -4929,11 +4929,13 @@ static boolean Skin_CanChange(const char *valstr)
static boolean Skin2_CanChange(const char *valstr)
{
- (void)valstr;
-
if (!Playing() || !splitscreen)
return true; // do whatever you want
+ // You already are that skin.
+ if (stricmp(skins[players[secondarydisplayplayer].skin]->name, valstr) == 0)
+ return false;
+
if (CanChangeSkin(secondarydisplayplayer) && !P_PlayerMoving(secondarydisplayplayer))
return true;
else
diff --git a/src/netcode/d_netcmd.h b/src/netcode/d_netcmd.h
index f92878a4e2e87efdae9c441ca30d61bcdb511ee5..c11575575fc025bcce4ad755651e3b77493233db 100644
--- a/src/netcode/d_netcmd.h
+++ b/src/netcode/d_netcmd.h
@@ -1,7 +1,7 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
diff --git a/src/netcode/d_netfil.c b/src/netcode/d_netfil.c
index a8a10d475d4afcc9c965573c1deaf59969c00b0f..bfb67838ff68e3831914e77dd029ffa19942eaac 100644
--- a/src/netcode/d_netfil.c
+++ b/src/netcode/d_netfil.c
@@ -95,6 +95,7 @@ static filetran_t transfer[MAXNETNODES];
INT32 fileneedednum; // Number of files needed to join the server
fileneeded_t *fileneeded; // List of needed files
static tic_t lasttimeackpacketsent = 0;
+static I_mutex downloadmutex;
char downloaddir[512] = "DOWNLOAD";
// For resuming failed downloads
@@ -606,7 +607,7 @@ void AddLuaFileTransfer(const char *filename, const char *mode)
prevnext = &((*prevnext)->next);
// Allocate file transfer information and append it to the transfer list
- filetransfer = malloc(sizeof(luafiletransfer_t));
+ filetransfer = calloc(1, sizeof(luafiletransfer_t));
if (!filetransfer)
I_Error("AddLuaFileTransfer: Out of memory\n");
*prevnext = filetransfer;
@@ -1033,7 +1034,6 @@ void FileSendTicker(void)
netbuffer->packettype = PT_FILEFRAGMENT;
- // (((sendbytes-nowsentbyte)*TICRATE)/(I_GetTime()-starttime)<(UINT32)net_bandwidth)
while (packetsent-- && filestosend != 0)
{
for (i = currentnode, j = 0; j < MAXNETNODES;
@@ -1345,9 +1345,9 @@ void PT_FileFragment(SINT8 node, INT32 netconsole)
if (!(strcmp(filename, "srb2.pk3")
&& strcmp(filename, "zones.pk3")
- && strcmp(filename, "player.dta")
+ && strcmp(filename, "characters.pk3")
&& strcmp(filename, "patch.pk3")
- && strcmp(filename, "music.dta")
+ && strcmp(filename, "music.pk3")
))
I_Error("Tried to download \"%s\"", filename);
@@ -1610,11 +1610,13 @@ boolean CURLPrepareFile(const char* url, int dfilenum)
I_Error("Attempted to download files in -nodownload mode");
#endif
- curl_global_init(CURL_GLOBAL_ALL);
+ if (!multi_handle)
+ {
+ curl_global_init(CURL_GLOBAL_ALL);
+ multi_handle = curl_multi_init();
+ }
http_handle = curl_easy_init();
- multi_handle = curl_multi_init();
-
if (http_handle && multi_handle)
{
I_mkdir(downloaddir, 0755);
@@ -1673,6 +1675,8 @@ boolean CURLPrepareFile(const char* url, int dfilenum)
filedownload.current = dfilenum;
filedownload.http_running = true;
+ I_spawn_thread("http-download", (I_thread_fn)CURLGetFile, NULL);
+
return true;
}
@@ -1681,103 +1685,119 @@ boolean CURLPrepareFile(const char* url, int dfilenum)
return false;
}
+void CURLAbortFile(void)
+{
+ filedownload.http_running = false;
+
+ // lock and unlock to wait for the download thread to exit
+ I_lock_mutex(&downloadmutex);
+ I_unlock_mutex(downloadmutex);
+}
+
void CURLGetFile(void)
{
+ I_lock_mutex(&downloadmutex);
CURLMcode mc; /* return code used by curl_multi_wait() */
CURLcode easyres; /* Return from easy interface */
- int numfds;
CURLMsg *m; /* for picking up messages with the transfer status */
CURL *e;
int msgs_left; /* how many messages are left */
const char *easy_handle_error;
+ boolean running = true;
- if (curl_runninghandles)
+ while (running && filedownload.http_running)
{
- curl_multi_perform(multi_handle, &curl_runninghandles);
+ if (curl_runninghandles)
+ {
+ curl_multi_perform(multi_handle, &curl_runninghandles);
- /* wait for activity, timeout or "nothing" */
- mc = curl_multi_wait(multi_handle, NULL, 0, 1000, &numfds);
+ /* wait for activity, timeout or "nothing" */
+ mc = curl_multi_wait(multi_handle, NULL, 0, 1000, NULL);
- if (mc != CURLM_OK)
- {
- CONS_Alert(CONS_WARNING, "curl_multi_wait() failed, code %d.\n", mc);
- return;
+ if (mc != CURLM_OK)
+ {
+ CONS_Alert(CONS_WARNING, "curl_multi_wait() failed, code %d.\n", mc);
+ continue;
+ }
+ curl_curfile->currentsize = curl_dlnow;
+ curl_curfile->totalsize = curl_dltotal;
}
- curl_curfile->currentsize = curl_dlnow;
- curl_curfile->totalsize = curl_dltotal;
- }
- /* See how the transfers went */
- while ((m = curl_multi_info_read(multi_handle, &msgs_left)))
- {
- if (m && (m->msg == CURLMSG_DONE))
+ /* See how the transfers went */
+ while ((m = curl_multi_info_read(multi_handle, &msgs_left)))
{
- e = m->easy_handle;
- easyres = m->data.result;
-
- char *filename = Z_StrDup(curl_realname);
- nameonly(filename);
-
- if (easyres != CURLE_OK)
+ if (m && (m->msg == CURLMSG_DONE))
{
- long response_code = 0;
+ running = false;
+ e = m->easy_handle;
+ easyres = m->data.result;
- if (easyres == CURLE_HTTP_RETURNED_ERROR)
- curl_easy_getinfo(e, CURLINFO_RESPONSE_CODE, &response_code);
+ char *filename = Z_StrDup(curl_realname);
+ nameonly(filename);
- if (response_code == 404)
- curl_curfile->failed = FDOWNLOAD_FAIL_NOTFOUND;
- else
- curl_curfile->failed = FDOWNLOAD_FAIL_OTHER;
-
- easy_handle_error = (response_code) ? va("HTTP response code %ld", response_code) : curl_easy_strerror(easyres);
- curl_curfile->status = FS_FALLBACK;
- curl_curfile->currentsize = curl_origfilesize;
- curl_curfile->totalsize = curl_origtotalfilesize;
- filedownload.http_failed = true;
- fclose(curl_curfile->file);
- remove(curl_curfile->filename);
- CONS_Alert(CONS_ERROR, M_GetText("Failed to download addon \"%s\" (%s)\n"), filename, easy_handle_error);
- }
- else
- {
- fclose(curl_curfile->file);
+ if (easyres != CURLE_OK)
+ {
+ long response_code = 0;
- CONS_Printf(M_GetText("Finished download of \"%s\"\n"), filename);
+ if (easyres == CURLE_HTTP_RETURNED_ERROR)
+ curl_easy_getinfo(e, CURLINFO_RESPONSE_CODE, &response_code);
- if (checkfilemd5(curl_curfile->filename, curl_curfile->md5sum) == FS_MD5SUMBAD)
- {
- CONS_Alert(CONS_WARNING, M_GetText("File \"%s\" does not match the version used by the server\n"), filename);
+ if (response_code == 404)
+ curl_curfile->failed = FDOWNLOAD_FAIL_NOTFOUND;
+ else
+ curl_curfile->failed = FDOWNLOAD_FAIL_OTHER;
+
+ easy_handle_error = (response_code) ? va("HTTP response code %ld", response_code) : curl_easy_strerror(easyres);
curl_curfile->status = FS_FALLBACK;
- curl_curfile->failed = FDOWNLOAD_FAIL_MD5SUMBAD;
+ curl_curfile->currentsize = curl_origfilesize;
+ curl_curfile->totalsize = curl_origtotalfilesize;
filedownload.http_failed = true;
+ fclose(curl_curfile->file);
+ remove(curl_curfile->filename);
+ CONS_Alert(CONS_ERROR, M_GetText("Failed to download addon \"%s\" (%s)\n"), filename, easy_handle_error);
}
else
{
- filedownload.completednum++;
- filedownload.completedsize += curl_curfile->totalsize;
- curl_curfile->status = FS_FOUND;
+ fclose(curl_curfile->file);
+
+ CONS_Printf(M_GetText("Finished download of \"%s\"\n"), filename);
+
+ if (checkfilemd5(curl_curfile->filename, curl_curfile->md5sum) == FS_MD5SUMBAD)
+ {
+ CONS_Alert(CONS_WARNING, M_GetText("File \"%s\" does not match the version used by the server\n"), filename);
+ curl_curfile->status = FS_FALLBACK;
+ curl_curfile->failed = FDOWNLOAD_FAIL_MD5SUMBAD;
+ filedownload.http_failed = true;
+ }
+ else
+ {
+ filedownload.completednum++;
+ filedownload.completedsize += curl_curfile->totalsize;
+ curl_curfile->status = FS_FOUND;
+ }
}
- }
- Z_Free(filename);
+ Z_Free(filename);
- curl_curfile->file = NULL;
- filedownload.http_running = false;
- filedownload.remaining--;
- curl_multi_remove_handle(multi_handle, e);
- curl_easy_cleanup(e);
+ curl_curfile->file = NULL;
+ filedownload.remaining--;
+ curl_multi_remove_handle(multi_handle, e);
+ curl_easy_cleanup(e);
- if (!filedownload.remaining)
- break;
+ if (!filedownload.remaining)
+ break;
+ }
}
}
- if (!filedownload.remaining)
+ if (!filedownload.remaining || !filedownload.http_running)
{
curl_multi_cleanup(multi_handle);
curl_global_cleanup();
+ multi_handle = NULL;
}
+ filedownload.http_running = false;
+ I_unlock_mutex(downloadmutex);
}
HTTP_login *
diff --git a/src/netcode/d_netfil.h b/src/netcode/d_netfil.h
index 4039b5e2d5cc4b0d81fbdc04e6d7c7bef46f724a..9f29d18bb79ff39dda69fffd68e2756f8d4f0db9 100644
--- a/src/netcode/d_netfil.h
+++ b/src/netcode/d_netfil.h
@@ -140,6 +140,7 @@ boolean CL_SendFileRequest(void);
void PT_RequestFile(SINT8 node);
boolean CURLPrepareFile(const char* url, int dfilenum);
+void CURLAbortFile(void);
void CURLGetFile(void);
HTTP_login * CURLGetLogin (const char *url, HTTP_login ***return_prev_next);
diff --git a/src/netcode/gamestate.c b/src/netcode/gamestate.c
index f36347c6d88e94a444fb186937d2672cfe3a0df9..967e23650e141fd231a9a740588cc822b6b00c0b 100644
--- a/src/netcode/gamestate.c
+++ b/src/netcode/gamestate.c
@@ -1,7 +1,7 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -54,30 +54,25 @@ boolean SV_ResendingSavegameToAnyone(void)
void SV_SendSaveGame(INT32 node, boolean resending)
{
size_t length, compressedlen;
- UINT8 *savebuffer;
+ save_t savebuffer;
UINT8 *compressedsave;
UINT8 *buffertosend;
// first save it in a malloced buffer
- savebuffer = (UINT8 *)malloc(SAVEGAMESIZE);
- if (!savebuffer)
+ savebuffer.size = SAVEGAMESIZE;
+ savebuffer.buf = (UINT8 *)malloc(savebuffer.size);
+ if (!savebuffer.buf)
{
CONS_Alert(CONS_ERROR, M_GetText("No more free memory for savegame\n"));
return;
}
// Leave room for the uncompressed length.
- save_p = savebuffer + sizeof(UINT32);
+ savebuffer.pos = sizeof(UINT32);
- P_SaveNetGame(resending);
+ P_SaveNetGame(&savebuffer, resending);
- length = save_p - savebuffer;
- if (length > SAVEGAMESIZE)
- {
- free(savebuffer);
- save_p = NULL;
- I_Error("Savegame buffer overrun");
- }
+ length = savebuffer.pos;
// Allocate space for compressed save: one byte fewer than for the
// uncompressed data to ensure that the compression is worthwhile.
@@ -85,15 +80,16 @@ void SV_SendSaveGame(INT32 node, boolean resending)
if (!compressedsave)
{
CONS_Alert(CONS_ERROR, M_GetText("No more free memory for savegame\n"));
+ free(savebuffer.buf);
return;
}
// Attempt to compress it.
- if((compressedlen = lzf_compress(savebuffer + sizeof(UINT32), length - sizeof(UINT32), compressedsave + sizeof(UINT32), length - sizeof(UINT32) - 1)))
+ if((compressedlen = lzf_compress(savebuffer.buf + sizeof(UINT32), length - sizeof(UINT32), compressedsave + sizeof(UINT32), length - sizeof(UINT32) - 1)))
{
// Compressing succeeded; send compressed data
- free(savebuffer);
+ free(savebuffer.buf);
// State that we're compressed.
buffertosend = compressedsave;
@@ -107,12 +103,12 @@ void SV_SendSaveGame(INT32 node, boolean resending)
free(compressedsave);
// State that we're not compressed
- buffertosend = savebuffer;
- WRITEUINT32(savebuffer, 0);
+ buffertosend = savebuffer.buf;
+ savebuffer.pos = 0;
+ P_WriteUINT32(&savebuffer, 0);
}
AddRamToSendQueue(node, buffertosend, length, SF_RAM, 0);
- save_p = NULL;
// Remember when we started sending the savegame so we can handle timeouts
netnodes[node].sendingsavegame = true;
@@ -125,8 +121,7 @@ static consvar_t cv_dumpconsistency = CVAR_INIT ("dumpconsistency", "Off", CV_SA
void SV_SavedGame(void)
{
- size_t length;
- UINT8 *savebuffer;
+ save_t savebuffer;
char tmpsave[256];
if (!cv_dumpconsistency.value)
@@ -135,29 +130,22 @@ void SV_SavedGame(void)
sprintf(tmpsave, "%s" PATHSEP TMPSAVENAME, srb2home);
// first save it in a malloced buffer
- save_p = savebuffer = (UINT8 *)malloc(SAVEGAMESIZE);
- if (!save_p)
+ savebuffer.size = SAVEGAMESIZE;
+ savebuffer.buf = (UINT8 *)malloc(savebuffer.size);
+ if (!savebuffer.buf)
{
CONS_Alert(CONS_ERROR, M_GetText("No more free memory for savegame\n"));
return;
}
+ savebuffer.pos = 0;
- P_SaveNetGame(false);
-
- length = save_p - savebuffer;
- if (length > SAVEGAMESIZE)
- {
- free(savebuffer);
- save_p = NULL;
- I_Error("Savegame buffer overrun");
- }
+ P_SaveNetGame(&savebuffer, false);
// then save it!
- if (!FIL_WriteFile(tmpsave, savebuffer, length))
+ if (!FIL_WriteFile(tmpsave, savebuffer.buf, savebuffer.pos))
CONS_Printf(M_GetText("Didn't save %s for netgame"), tmpsave);
- free(savebuffer);
- save_p = NULL;
+ free(savebuffer.pos);
}
#undef TMPSAVENAME
@@ -167,33 +155,34 @@ void SV_SavedGame(void)
void CL_LoadReceivedSavegame(boolean reloading)
{
- UINT8 *savebuffer = NULL;
- size_t length, decompressedlen;
+ save_t savebuffer;
+ size_t decompressedlen;
char tmpsave[256];
FreeFileNeeded();
sprintf(tmpsave, "%s" PATHSEP TMPSAVENAME, srb2home);
- length = FIL_ReadFile(tmpsave, &savebuffer);
+ savebuffer.size = FIL_ReadFile(tmpsave, &savebuffer.buf);
+ savebuffer.pos = 0;
- CONS_Printf(M_GetText("Loading savegame length %s\n"), sizeu1(length));
- if (!length)
+ CONS_Printf(M_GetText("Loading savegame length %s\n"), sizeu1(savebuffer.size));
+ if (!savebuffer.size)
{
I_Error("Can't read savegame sent");
return;
}
- save_p = savebuffer;
-
// Decompress saved game if necessary.
- decompressedlen = READUINT32(save_p);
+ decompressedlen = P_ReadUINT32(&savebuffer);
if(decompressedlen > 0)
{
UINT8 *decompressedbuffer = Z_Malloc(decompressedlen, PU_STATIC, NULL);
- lzf_decompress(save_p, length - sizeof(UINT32), decompressedbuffer, decompressedlen);
- Z_Free(savebuffer);
- save_p = savebuffer = decompressedbuffer;
+ lzf_decompress(savebuffer.buf + sizeof(UINT32), savebuffer.size - sizeof(UINT32), decompressedbuffer, decompressedlen);
+ Z_Free(savebuffer.buf);
+ savebuffer.buf = decompressedbuffer;
+ savebuffer.size = decompressedlen;
+ savebuffer.pos = 0;
}
paused = false;
@@ -203,7 +192,7 @@ void CL_LoadReceivedSavegame(boolean reloading)
automapactive = false;
// load a base level
- if (P_LoadNetGame(reloading))
+ if (P_LoadNetGame(&savebuffer, reloading))
{
const UINT8 actnum = mapheaderinfo[gamemap-1]->actnum;
CONS_Printf(M_GetText("Map is now \"%s"), G_BuildMapName(gamemap));
@@ -219,8 +208,7 @@ void CL_LoadReceivedSavegame(boolean reloading)
}
// done
- Z_Free(savebuffer);
- save_p = NULL;
+ Z_Free(savebuffer.buf);
if (unlink(tmpsave) == -1)
CONS_Alert(CONS_ERROR, M_GetText("Can't delete %s\n"), tmpsave);
consistancy[gametic%BACKUPTICS] = Consistancy();
diff --git a/src/netcode/http-mserv.c b/src/netcode/http-mserv.c
index 4a080498455234f234655f505e4bf0df956dd9a6..8ce20af956008d2e522a08dc0aa98756174252d8 100644
--- a/src/netcode/http-mserv.c
+++ b/src/netcode/http-mserv.c
@@ -426,7 +426,7 @@ HMS_register (void)
char *title;
- hms = HMS_connect(PROTO_V4, "rooms/%d/register", ms_RoomId);
+ hms = HMS_connect(PROTO_V4, "rooms/%d/register", cv_masterserver_room_id.value);
if (! hms)
return 0;
@@ -462,7 +462,7 @@ HMS_register (void)
if (!hms_allow_ipv6)
return ok;
- hms = HMS_connect(PROTO_V6, "rooms/%d/register", ms_RoomId);
+ hms = HMS_connect(PROTO_V6, "rooms/%d/register", cv_masterserver_room_id.value);
if (! hms)
return 0;
diff --git a/src/netcode/i_net.h b/src/netcode/i_net.h
index 09b842296c313cdd43623cfecd1d8da64534397b..a2039bd1902197d1c812f7490fad3e1493f60588 100644
--- a/src/netcode/i_net.h
+++ b/src/netcode/i_net.h
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -32,7 +32,6 @@
#define INETPACKETLENGTH 1024
extern INT16 hardware_MAXPACKETLENGTH;
-extern INT32 net_bandwidth; // in byte/s
#if defined(_MSC_VER)
#pragma pack(1)
@@ -40,36 +39,17 @@ extern INT32 net_bandwidth; // in byte/s
typedef struct
{
- /// Supposed to be DOOMCOM_ID
- INT32 id;
-
- /// SRB2 executes an INT32 to execute commands.
- INT16 intnum;
- /// Communication between SRB2 and the driver.
- /// Is CMD_SEND or CMD_GET.
- INT16 command;
/// Is dest for send, set by get (-1 = no packet).
INT16 remotenode;
-
/// Number of bytes in doomdata to be sent
INT16 datalength;
/// Info common to all nodes.
/// Console is always node 0.
INT16 numnodes;
- /// Flag: 1 = no duplication, 2-5 = dup for slow nets.
- INT16 ticdup;
/// Flag: 1 = send a backup tic in every packet.
INT16 extratics;
- /// kind of game
- INT16 gametype;
- /// Flag: -1 = new game, 0-5 = load savegame
- INT16 savegame;
- /// currect map
- INT16 map;
-
- /// Info specific to this node.
- INT16 consoleplayer;
+
/// Number of "slots": the highest player number in use plus one.
INT16 numslots;
@@ -87,18 +67,10 @@ extern doomcom_t *doomcom;
*/
extern boolean (*I_NetGet)(void);
-/** \brief ask to driver if there is data waiting
-*/
-extern boolean (*I_NetCanGet)(void);
-
/** \brief send packet within doomcom struct
*/
extern void (*I_NetSend)(void);
-/** \brief ask to driver if all is ok to send data now
-*/
-extern boolean (*I_NetCanSend)(void);
-
/** \brief close a connection
\param nodenum node to be closed
diff --git a/src/netcode/i_tcp.c b/src/netcode/i_tcp.c
index 24dfd7ec2797c190b0c0fdbf0343f19e33b001a0..256d9992eff6acdd614ac9bf99428e459884fe2a 100644
--- a/src/netcode/i_tcp.c
+++ b/src/netcode/i_tcp.c
@@ -1,7 +1,7 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -37,6 +37,7 @@
#endif
#include "../doomdef.h"
+#include "../z_zone.h"
#ifdef USE_WINSOCK1
#include <winsock.h>
@@ -87,6 +88,10 @@
#undef EHOSTUNREACH
#endif
#define EHOSTUNREACH WSAEHOSTUNREACH
+ #ifdef ENETUNREACH
+ #undef ENETUNREACH
+ #endif
+ #define ENETUNREACH WSAENETUNREACH
#ifndef IOC_VENDOR
#define IOC_VENDOR 0x18000000
#endif
@@ -120,8 +125,6 @@ typedef union
static boolean UPNP_support = true;
#endif // HAVE_MINIUPNC
-#define MAXBANS 100
-
#include "../i_system.h"
#include "i_net.h"
#include "d_net.h"
@@ -140,7 +143,6 @@ typedef union
#endif
#include "i_addrinfo.h"
-#define SELECTTEST
#define DEFAULTPORT "5029"
#ifdef USE_WINSOCK
@@ -169,8 +171,8 @@ static mysockaddr_t clientaddress[MAXNETNODES+1];
static mysockaddr_t broadcastaddress[MAXNETNODES+1];
static size_t broadcastaddresses = 0;
static boolean nodeconnected[MAXNETNODES+1];
-static mysockaddr_t banned[MAXBANS];
-static UINT8 bannedmask[MAXBANS];
+static mysockaddr_t *banned;
+static UINT8 *bannedmask;
static size_t numbans = 0;
static boolean SOCK_bannednode[MAXNETNODES+1]; /// \note do we really need the +1?
@@ -628,56 +630,6 @@ static boolean SOCK_Get(void)
return false;
}
-// check if we can send (do not go over the buffer)
-
-static fd_set masterset;
-
-#ifdef SELECTTEST
-static boolean FD_CPY(fd_set *src, fd_set *dst, SOCKET_TYPE *fd, size_t len)
-{
- boolean testset = false;
- FD_ZERO(dst);
- for (size_t i = 0; i < len;i++)
- {
- if(fd[i] != (SOCKET_TYPE)ERRSOCKET &&
- FD_ISSET(fd[i], src) && !FD_ISSET(fd[i], dst)) // no checking for dups
- {
- FD_SET(fd[i], dst);
- testset = true;
- }
- }
- return testset;
-}
-
-static boolean SOCK_CanSend(void)
-{
- struct timeval timeval_for_select = {0, 0};
- fd_set tset;
- int wselect;
-
- if(!FD_CPY(&masterset, &tset, mysockets, mysocketses))
- return false;
- wselect = select(255, NULL, &tset, NULL, &timeval_for_select);
- if (wselect >= 1)
- return true;
- return false;
-}
-
-static boolean SOCK_CanGet(void)
-{
- struct timeval timeval_for_select = {0, 0};
- fd_set tset;
- int rselect;
-
- if(!FD_CPY(&masterset, &tset, mysockets, mysocketses))
- return false;
- rselect = select(255, &tset, NULL, NULL, &timeval_for_select);
- if (rselect >= 1)
- return true;
- return false;
-}
-#endif
-
static inline ssize_t SOCK_SendToAddr(SOCKET_TYPE socket, mysockaddr_t *sockaddr)
{
socklen_t d4 = (socklen_t)sizeof(struct sockaddr_in);
@@ -685,7 +637,6 @@ static inline ssize_t SOCK_SendToAddr(SOCKET_TYPE socket, mysockaddr_t *sockaddr
socklen_t d6 = (socklen_t)sizeof(struct sockaddr_in6);
#endif
socklen_t d, da = (socklen_t)sizeof(mysockaddr_t);
- ssize_t status;
switch (sockaddr->any.sa_family)
{
@@ -696,14 +647,11 @@ static inline ssize_t SOCK_SendToAddr(SOCKET_TYPE socket, mysockaddr_t *sockaddr
default: d = da; break;
}
- status = sendto(socket, (char *)&doomcom->data, doomcom->datalength, 0, &sockaddr->any, d);
- if (status == -1)
- {
- CONS_Alert(CONS_WARNING, "Unable to send packet to %s: %s\n", SOCK_AddrToStr(sockaddr), strerror(errno));
- }
- return status;
+ return sendto(socket, (char *)&doomcom->data, doomcom->datalength, 0, &sockaddr->any, d);
}
+#define ALLOWEDERROR(x) ((x) == ECONNREFUSED || (x) == EWOULDBLOCK || (x) == EHOSTUNREACH || (x) == ENETUNREACH)
+
static void SOCK_Send(void)
{
ssize_t c = ERRSOCKET;
@@ -718,19 +666,25 @@ static void SOCK_Send(void)
for (size_t j = 0; j < broadcastaddresses; j++)
{
if (myfamily[i] == broadcastaddress[j].any.sa_family)
- SOCK_SendToAddr(mysockets[i], &broadcastaddress[j]);
+ {
+ c = SOCK_SendToAddr(mysockets[i], &broadcastaddress[j]);
+ if (c == ERRSOCKET && !ALLOWEDERROR(errno))
+ break;
+ }
}
}
- return;
}
else if (nodesocket[doomcom->remotenode] == (SOCKET_TYPE)ERRSOCKET)
{
for (size_t i = 0; i < mysocketses; i++)
{
if (myfamily[i] == clientaddress[doomcom->remotenode].any.sa_family)
- SOCK_SendToAddr(mysockets[i], &clientaddress[doomcom->remotenode]);
+ {
+ c = SOCK_SendToAddr(mysockets[i], &clientaddress[doomcom->remotenode]);
+ if (c == ERRSOCKET && !ALLOWEDERROR(errno))
+ break;
+ }
}
- return;
}
else
{
@@ -740,12 +694,14 @@ static void SOCK_Send(void)
if (c == ERRSOCKET)
{
int e = errno; // save error code so it can't be modified later
- if (e != ECONNREFUSED && e != EWOULDBLOCK && e != EHOSTUNREACH)
+ if (!ALLOWEDERROR(e))
I_Error("SOCK_Send, error sending to node %d (%s) #%u: %s", doomcom->remotenode,
SOCK_GetNodeAddress(doomcom->remotenode), e, strerror(e));
}
}
+#undef ALLOWEDERROR
+
static void SOCK_FreeNodenum(INT32 numnode)
{
// can't disconnect from self :)
@@ -915,7 +871,6 @@ static boolean UDP_Socket(void)
mysockets[s] = ERRSOCKET;
for (s = 0; s < MAXNETNODES+1; s++)
nodesocket[s] = ERRSOCKET;
- FD_ZERO(&masterset);
s = 0;
memset(&hints, 0x00, sizeof (hints));
@@ -942,7 +897,6 @@ static boolean UDP_Socket(void)
mysockets[s] = UDP_Bind(runp->ai_family, runp->ai_addr, (socklen_t)runp->ai_addrlen);
if (mysockets[s] != (SOCKET_TYPE)ERRSOCKET)
{
- FD_SET(mysockets[s], &masterset);
myfamily[s] = hints.ai_family;
s++;
}
@@ -963,7 +917,6 @@ static boolean UDP_Socket(void)
mysockets[s] = UDP_Bind(runp->ai_family, runp->ai_addr, (socklen_t)runp->ai_addrlen);
if (mysockets[s] != (SOCKET_TYPE)ERRSOCKET)
{
- FD_SET(mysockets[s], &masterset);
myfamily[s] = hints.ai_family;
s++;
#ifdef HAVE_MINIUPNPC
@@ -996,7 +949,6 @@ static boolean UDP_Socket(void)
mysockets[s] = UDP_Bind(runp->ai_family, runp->ai_addr, (socklen_t)runp->ai_addrlen);
if (mysockets[s] != (SOCKET_TYPE)ERRSOCKET)
{
- FD_SET(mysockets[s], &masterset);
myfamily[s] = hints.ai_family;
s++;
}
@@ -1017,7 +969,6 @@ static boolean UDP_Socket(void)
mysockets[s] = UDP_Bind(runp->ai_family, runp->ai_addr, (socklen_t)runp->ai_addrlen);
if (mysockets[s] != (SOCKET_TYPE)ERRSOCKET)
{
- FD_SET(mysockets[s], &masterset);
myfamily[s] = hints.ai_family;
s++;
}
@@ -1143,16 +1094,13 @@ boolean I_InitTcpDriver(void)
static void SOCK_CloseSocket(void)
{
- for (size_t i=0; i < MAXNETNODES+1; i++)
+ for (size_t i=0; i < mysocketses; i++)
{
- if (mysockets[i] != (SOCKET_TYPE)ERRSOCKET
- && FD_ISSET(mysockets[i], &masterset))
- {
- FD_CLR(mysockets[i], &masterset);
+ if (mysockets[i] != (SOCKET_TYPE)ERRSOCKET)
close(mysockets[i]);
- }
mysockets[i] = ERRSOCKET;
}
+ mysocketses = 0;
}
void I_ShutdownTcpDriver(void)
@@ -1204,11 +1152,7 @@ static SINT8 SOCK_NetMakeNodewPort(const char *address, const char *port)
// test ip address of server
for (i = 0; i < mysocketses; ++i)
{
- /* sendto tests that there is a network to this
- address */
- if (runp->ai_addr->sa_family == myfamily[i] &&
- sendto(mysockets[i], NULL, 0, 0,
- runp->ai_addr, runp->ai_addrlen) == 0)
+ if (runp->ai_addr->sa_family == myfamily[i])
{
memcpy(&clientaddress[newnode], runp->ai_addr, runp->ai_addrlen);
break;
@@ -1238,12 +1182,6 @@ static boolean SOCK_OpenSocket(void)
I_NetFreeNodenum = SOCK_FreeNodenum;
I_NetMakeNodewPort = SOCK_NetMakeNodewPort;
-#ifdef SELECTTEST
- // seem like not work with libsocket : (
- I_NetCanSend = SOCK_CanSend;
- I_NetCanGet = SOCK_CanGet;
-#endif
-
// build the socket but close it first
SOCK_CloseSocket();
return UDP_Socket();
@@ -1253,9 +1191,9 @@ static boolean SOCK_Ban(INT32 node)
{
if (node > MAXNETNODES)
return false;
- if (numbans == MAXBANS)
- return false;
+ banned = Z_Realloc(banned, sizeof(*banned) * (numbans+1), PU_STATIC, NULL);
+ bannedmask = Z_Realloc(bannedmask, sizeof(*bannedmask) * (numbans+1), PU_STATIC, NULL);
M_Memcpy(&banned[numbans], &clientaddress[node], sizeof (mysockaddr_t));
if (banned[numbans].any.sa_family == AF_INET)
{
@@ -1266,7 +1204,7 @@ static boolean SOCK_Ban(INT32 node)
else if (banned[numbans].any.sa_family == AF_INET6)
{
banned[numbans].ip6.sin6_port = 0;
- bannedmask[numbans] = 128;
+ bannedmask[numbans] = 64;
}
#endif
numbans++;
@@ -1278,7 +1216,7 @@ static boolean SOCK_SetBanAddress(const char *address, const char *mask)
struct my_addrinfo *ai, *runp, hints;
int gaie;
- if (numbans == MAXBANS || !address)
+ if (!address)
return false;
memset(&hints, 0x00, sizeof(hints));
@@ -1293,15 +1231,17 @@ static boolean SOCK_SetBanAddress(const char *address, const char *mask)
runp = ai;
- while(runp != NULL && numbans != MAXBANS)
+ while(runp != NULL)
{
+ banned = Z_Realloc(banned, sizeof(*banned) * (numbans+1), PU_STATIC, NULL);
+ bannedmask = Z_Realloc(bannedmask, sizeof(*bannedmask) * (numbans+1), PU_STATIC, NULL);
memcpy(&banned[numbans], runp->ai_addr, runp->ai_addrlen);
if (mask)
bannedmask[numbans] = (UINT8)atoi(mask);
#ifdef HAVE_IPV6
else if (runp->ai_family == AF_INET6)
- bannedmask[numbans] = 128;
+ bannedmask[numbans] = 64;
#endif
else
bannedmask[numbans] = 32;
@@ -1310,7 +1250,7 @@ static boolean SOCK_SetBanAddress(const char *address, const char *mask)
bannedmask[numbans] = 32;
#ifdef HAVE_IPV6
else if (bannedmask[numbans] > 128 && runp->ai_family == AF_INET6)
- bannedmask[numbans] = 128;
+ bannedmask[numbans] = 64;
#endif
numbans++;
runp = runp->ai_next;
@@ -1324,6 +1264,10 @@ static boolean SOCK_SetBanAddress(const char *address, const char *mask)
static void SOCK_ClearBans(void)
{
numbans = 0;
+ Z_Free(banned);
+ banned = NULL;
+ Z_Free(bannedmask);
+ bannedmask = NULL;
}
boolean I_InitTcpNetwork(void)
@@ -1378,7 +1322,6 @@ boolean I_InitTcpNetwork(void)
// FIXME:
// ??? and now ?
// server on a big modem ??? 4*isdn
- net_bandwidth = 16000;
hardware_MAXPACKETLENGTH = INETPACKETLENGTH;
ret = true;
@@ -1407,7 +1350,6 @@ boolean I_InitTcpNetwork(void)
// so we're on a LAN
COM_BufAddText("connect any\n");
- net_bandwidth = 800000;
hardware_MAXPACKETLENGTH = MAXPACKETLENGTH;
}
}
diff --git a/src/netcode/mserv.c b/src/netcode/mserv.c
index 74ee120f96e17ed6641adb48e0dc29f35d46c0c8..f17db4b6e32e59a08a7ac5c9c3a44e867c0ffff2 100644
--- a/src/netcode/mserv.c
+++ b/src/netcode/mserv.c
@@ -1,7 +1,7 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
// Copyright (C) 2020-2023 by James R.
//
// This program is free software distributed under the
@@ -55,6 +55,7 @@ static boolean ServerName_CanChange (const char*);
static void Update_parameters (void);
static void MasterServer_OnChange(void);
+static void RoomId_OnChange(void);
static CV_PossibleValue_t masterserver_update_rate_cons_t[] = {
{2, "MIN"},
@@ -66,8 +67,10 @@ consvar_t cv_masterserver = CVAR_INIT ("masterserver", "https://ds.ms.srb2.org/M
consvar_t cv_servername = CVAR_INIT_WITH_CALLBACKS ("servername", "SRB2 server", CV_SAVE|CV_NETVAR|CV_CALL|CV_NOINIT|CV_ALLOWLUA, NULL, Update_parameters, ServerName_CanChange);
consvar_t cv_masterserver_update_rate = CVAR_INIT ("masterserver_update_rate", "15", CV_SAVE|CV_CALL|CV_NOINIT, masterserver_update_rate_cons_t, Update_parameters);
+CV_PossibleValue_t cv_masterserver_room_values[] = {{-1, "MIN"}, {999999999, "MAX"}, {0, NULL}};
+consvar_t cv_masterserver_room_id = CVAR_INIT ("masterserver_room_id", "-1", CV_CALL, cv_masterserver_room_values, RoomId_OnChange);
-INT16 ms_RoomId = -1;
+static INT16 ms_RoomId = -1;
#if defined (MASTERSERVER) && defined (HAVE_THREADS)
int ms_QueryId;
@@ -92,6 +95,7 @@ void AddMServCommands(void)
{
CV_RegisterVar(&cv_masterserver);
CV_RegisterVar(&cv_masterserver_update_rate);
+ CV_RegisterVar(&cv_masterserver_room_id);
CV_RegisterVar(&cv_masterserver_timeout);
CV_RegisterVar(&cv_masterserver_debug);
CV_RegisterVar(&cv_masterserver_token);
@@ -446,7 +450,7 @@ void UnregisterServer(void)
static boolean
Online (void)
{
- return ( serverrunning && ms_RoomId > 0 );
+ return ( serverrunning && cv_masterserver_room_id.value > 0 );
}
static inline void SendPingToMasterServer(void)
@@ -534,6 +538,17 @@ Update_parameters (void)
#endif/*MASTERSERVER*/
}
+static void RoomId_OnChange(void)
+{
+ if (ms_RoomId != cv_masterserver_room_id.value)
+ {
+ UnregisterServer();
+ ms_RoomId = cv_masterserver_room_id.value;
+ if (Online())
+ RegisterServer();
+ }
+}
+
static void MasterServer_OnChange(void)
{
#ifdef MASTERSERVER
diff --git a/src/netcode/mserv.h b/src/netcode/mserv.h
index 0bc8c8e6b878a415887e2a9613188d3ceac30956..ed3c9b27b8f6d9f52b1c8cc4e2640b5501653dff 100644
--- a/src/netcode/mserv.h
+++ b/src/netcode/mserv.h
@@ -66,15 +66,11 @@ typedef struct
extern consvar_t cv_masterserver, cv_servername;
extern consvar_t cv_masterserver_update_rate;
+extern consvar_t cv_masterserver_room_id;
extern consvar_t cv_masterserver_timeout;
extern consvar_t cv_masterserver_debug;
extern consvar_t cv_masterserver_token;
-// < 0 to not connect (usually -1) (offline mode)
-// == 0 to show all rooms, not a valid hosting room
-// anything else is whatever room the MS assigns to that number (online mode)
-extern INT16 ms_RoomId;
-
#ifdef HAVE_THREADS
extern int ms_QueryId;
extern I_mutex ms_QueryId_mutex;
diff --git a/src/p_enemy.c b/src/p_enemy.c
index e1b21e295bf4226a632112a4b66fe3d4b849c485..7091af5429e834c098ba7d81ace6961cc238e37f 100644
--- a/src/p_enemy.c
+++ b/src/p_enemy.c
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -3744,7 +3744,7 @@ static void P_DoBossVictory(mobj_t *mo)
// scan the remaining thinkers to see if all bosses are dead
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
{
- if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (th->removing)
continue;
mo2 = (mobj_t *)th;
@@ -3922,7 +3922,7 @@ static void P_DoBoss5Death(mobj_t *mo)
pole->angle = mo->tracer->angle;
pole->momx = P_ReturnThrustX(pole, pole->angle, speed);
pole->momy = P_ReturnThrustY(pole, pole->angle, speed);
-
+
P_SetTarget(&pole->tracer, P_SpawnMobj(
pole->x, pole->y,
pole->z - 256*FRACUNIT,
@@ -5582,7 +5582,7 @@ void A_MinusDigging(mobj_t *actor)
minus = actor;
- P_DoBlockThingsIterate(xl, yl, xh, yh, PIT_MinusCarry);
+ P_DoBlockThingsIterate(xl, yl, xh, yh, PIT_MinusCarry, minus);
}
else
{
@@ -6449,7 +6449,7 @@ void A_RingExplode(mobj_t *actor)
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
{
- if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (th->removing)
continue;
mo2 = (mobj_t *)th;
@@ -8332,7 +8332,7 @@ void A_Shockwave(mobj_t *actor)
ang += interval;
sprev = shock;
}
-
+
S_StartSound(actor, shock->info->seesound);
}
@@ -8756,7 +8756,7 @@ void A_FindTarget(mobj_t *actor)
// scan the thinkers
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
{
- if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (th->removing)
continue;
mo2 = (mobj_t *)th;
@@ -8820,7 +8820,7 @@ void A_FindTracer(mobj_t *actor)
// scan the thinkers
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
{
- if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (th->removing)
continue;
mo2 = (mobj_t *)th;
@@ -9498,7 +9498,7 @@ void A_RemoteAction(mobj_t *actor)
// scan the thinkers
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
{
- if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (th->removing)
continue;
mo2 = (mobj_t *)th;
@@ -9761,7 +9761,7 @@ void A_SetObjectTypeState(mobj_t *actor)
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
{
- if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (th->removing)
continue;
mo2 = (mobj_t *)th;
@@ -10391,7 +10391,7 @@ void A_CheckThingCount(mobj_t *actor)
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
{
- if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (th->removing)
continue;
mo2 = (mobj_t *)th;
@@ -13726,7 +13726,7 @@ void A_DustDevilThink(mobj_t *actor)
dustdevil = actor;
- P_DoBlockThingsIterate(xl, yl, xh, yh, PIT_DustDevilLaunch);
+ P_DoBlockThingsIterate(xl, yl, xh, yh, PIT_DustDevilLaunch, dustdevil);
//Whirlwind sound effect.
if (leveltime % 70 == 0)
@@ -13842,7 +13842,7 @@ void A_TNTExplode(mobj_t *actor)
barrel = actor;
- P_DoBlockThingsIterate(xl, yl, xh, yh, PIT_TNTExplode);
+ P_DoBlockThingsIterate(xl, yl, xh, yh, PIT_TNTExplode, barrel);
// cause a quake -- P_StartQuake does not exist yet
epicenter.x = actor->x;
@@ -14395,7 +14395,7 @@ void A_LavafallLava(mobj_t *actor)
if (LUA_CallAction(A_LAVAFALLLAVA, actor))
return;
- if ((40 - actor->fuse) % (2*(actor->scale >> FRACBITS)))
+ if ((40 - actor->fuse) % max(2*(actor->scale >> FRACBITS), 1)) // avoid crashes if actor->scale < FRACUNIT
return;
// Don't spawn lava unless a player is nearby.
diff --git a/src/p_inter.c b/src/p_inter.c
index cbd56183df855ed0d8afc9e308bea5e05a7d0fee..27e612154dc87c1b88fec2e42e890af0d27c382e 100644
--- a/src/p_inter.c
+++ b/src/p_inter.c
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -101,7 +101,7 @@ void P_ClearStarPost(INT32 postnum)
// scan the thinkers
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
{
- if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (th->removing)
continue;
mo2 = (mobj_t *)th;
@@ -130,7 +130,7 @@ void P_ResetStarposts(void)
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
{
- if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (th->removing)
continue;
post = (mobj_t *)th;
@@ -538,14 +538,14 @@ void P_TouchSpecialThing(mobj_t *special, mobj_t *toucher, boolean heightcheck)
if ((P_MobjFlip(toucher)*toucher->momz < 0) && (elementalpierce != 1) && (!(player->powers[pw_strong] & STR_HEAVY)))
{
fixed_t setmomz = -toucher->momz; // Store this, momz get changed by P_DoJump within P_DoBubbleBounce
-
+
if (elementalpierce == 2) // Reset bubblewrap, part 1
P_DoBubbleBounce(player);
toucher->momz = setmomz;
if (elementalpierce == 2) // Reset bubblewrap, part 2
{
boolean underwater = toucher->eflags & MFE_UNDERWATER;
-
+
if (underwater)
toucher->momz /= 2;
toucher->momz -= (toucher->momz/(underwater ? 8 : 4)); // Cap the height!
@@ -836,7 +836,8 @@ void P_TouchSpecialThing(mobj_t *special, mobj_t *toucher, boolean heightcheck)
{
clientGamedata->collected[special->health-1] = true;
M_UpdateUnlockablesAndExtraEmblems(clientGamedata);
- G_SaveGameData(clientGamedata);
+ if (!prevCollected) // don't thrash the disk and wreak performance.
+ G_SaveGameData(clientGamedata);
}
if (netgame)
@@ -1002,7 +1003,7 @@ void P_TouchSpecialThing(mobj_t *special, mobj_t *toucher, boolean heightcheck)
// scan the thinkers to find the corresponding anchorpoint
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
{
- if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (th->removing)
continue;
mo2 = (mobj_t *)th;
@@ -1096,7 +1097,7 @@ void P_TouchSpecialThing(mobj_t *special, mobj_t *toucher, boolean heightcheck)
// scan the remaining thinkers
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
{
- if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (th->removing)
continue;
mo2 = (mobj_t *)th;
@@ -1146,7 +1147,7 @@ void P_TouchSpecialThing(mobj_t *special, mobj_t *toucher, boolean heightcheck)
// in from the paraloop. Isn't this just so efficient?
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
{
- if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (th->removing)
continue;
mo2 = (mobj_t *)th;
@@ -1521,7 +1522,7 @@ void P_TouchSpecialThing(mobj_t *special, mobj_t *toucher, boolean heightcheck)
// scan the remaining thinkers to find koopa
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
{
- if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (th->removing)
continue;
mo2 = (mobj_t *)th;
@@ -2019,7 +2020,7 @@ void P_TouchStarPost(mobj_t *post, player_t *player, boolean snaptopost)
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
{
- if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (th->removing)
continue;
mo2 = (mobj_t *)th;
@@ -2571,7 +2572,7 @@ void P_KillMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source, UINT8 damaget
if (!(target->flags2 & MF2_DONTRESPAWN))
{
if (!(netgame || multiplayer))
- target->fuse = atoi(cv_itemrespawntime.defaultvalue)*TICRATE + 2;
+ target->fuse = atoi(cv_itemrespawntime.defaultvalue)*TICRATE + 2;
else if (cv_itemrespawn.value)
target->fuse = cv_itemrespawntime.value*TICRATE + 2;
}
@@ -2869,7 +2870,7 @@ void P_KillMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source, UINT8 damaget
// scan the thinkers to make sure all the old pinch dummies are gone on death
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
{
- if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (th->removing)
continue;
mo = (mobj_t *)th;
diff --git a/src/p_local.h b/src/p_local.h
index 249c3cd4b6de5248140c00e2dfc2332081a5d00e..85a31cf8982114068b0da41c7a59971d011929ba 100644
--- a/src/p_local.h
+++ b/src/p_local.h
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -39,11 +39,6 @@
// Convenience macro to fix issue with collision along bottom/left edges of blockmap -Red
#define BMBOUNDFIX(xl, xh, yl, yh) {if (xl > xh) xl = 0; if (yl > yh) yl = 0;}
-// MAXRADIUS is for precalculated sector block boxes
-// the spider demon is larger,
-// but we do not have any moving sectors nearby
-#define MAXRADIUS (32*FRACUNIT)
-
// max Z move up or down without jumping
// above this, a height difference is considered as a 'dropoff'
#define MAXSTEPMOVE (24*FRACUNIT)
@@ -203,7 +198,7 @@ mobj_t *P_LookForEnemies(player_t *player, boolean nonenemies, boolean bullet);
void P_NukeEnemies(mobj_t *inflictor, mobj_t *source, fixed_t radius);
void P_Earthquake(mobj_t *inflictor, mobj_t *source, fixed_t radius);
boolean P_HomingAttack(mobj_t *source, mobj_t *enemy); /// \todo doesn't belong in p_user
-boolean P_SuperReady(player_t *player, boolean transform);
+boolean P_SuperReady(player_t *player);
void P_DoJump(player_t *player, boolean soundandstate, boolean allowflip);
void P_DoSpinDashDust(player_t *player);
#define P_AnalogMove(player) (P_ControlStyle(player) == CS_LMAOGALOG)
@@ -294,7 +289,6 @@ void P_RecalcPrecipInSector(sector_t *sector);
void P_PrecipitationEffects(void);
void P_RemoveMobj(mobj_t *th);
-boolean P_MobjWasRemoved(mobj_t *th);
void P_RemoveSavegameMobj(mobj_t *th);
boolean P_SetMobjState(mobj_t *mobj, statenum_t state);
void P_RunShields(void);
@@ -306,6 +300,12 @@ boolean P_CheckSkyHit(mobj_t *mo, line_t *line);
void P_PushableThinker(mobj_t *mobj);
void P_SceneryThinker(mobj_t *mobj);
+// This does not need to be added to Lua.
+// To test it in Lua, check mobj.valid
+FUNCINLINE static ATTRINLINE boolean P_MobjWasRemoved(mobj_t *mobj)
+{
+ return mobj == NULL || mobj->thinker.function.acp1 != (actionf_p1)P_MobjThinker;
+}
fixed_t P_MobjFloorZ(sector_t *sector, sector_t *boundsec, fixed_t x, fixed_t y, fixed_t radius, line_t *line, boolean lowest, boolean perfect);
fixed_t P_MobjCeilingZ(sector_t *sector, sector_t *boundsec, fixed_t x, fixed_t y, fixed_t radius, line_t *line, boolean lowest, boolean perfect);
diff --git a/src/p_map.c b/src/p_map.c
index b79f9d45c77ea069f079e1d2a50d6b45bfa1e646..337344b2fec2c966d0774513c02d9397b2974382 100644
--- a/src/p_map.c
+++ b/src/p_map.c
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -36,6 +36,9 @@
#include "m_perfstats.h" // ps_checkposition_calls
+// Formerly called MAXRADIUS
+#define MAXTRYMOVE (32*FRACUNIT)
+
fixed_t tmbbox[4];
mobj_t *tmthing;
static INT32 tmflags;
@@ -1465,13 +1468,13 @@ static unsigned PIT_DoCheckThing(mobj_t *thing)
}
// check for special pickup
- if (thing->flags & MF_SPECIAL)
+ if (thing->flags & MF_SPECIAL && (tmthing->player || (tmthing->flags & MF_PUSHABLE))) // MF_PUSHABLE added for steam jets
{
P_TouchSpecialThing(thing, tmthing, true); // can remove thing
return CHECKTHING_COLLIDE;
}
// check again for special pickup
- if (tmthing->flags & MF_SPECIAL)
+ if (tmthing->flags & MF_SPECIAL && (thing->player || (thing->flags & MF_PUSHABLE))) // MF_PUSHABLE added for steam jets
{
P_TouchSpecialThing(tmthing, thing, true); // can remove thing
return CHECKTHING_COLLIDE;
@@ -2165,15 +2168,10 @@ boolean P_CheckPosition(mobj_t *thing, fixed_t x, fixed_t y)
}
}
- // The bounding box is extended by MAXRADIUS
- // because mobj_ts are grouped into mapblocks
- // based on their origin point, and can overlap
- // into adjacent blocks by up to MAXRADIUS units.
-
- xl = (unsigned)(tmbbox[BOXLEFT] - bmaporgx - MAXRADIUS)>>MAPBLOCKSHIFT;
- xh = (unsigned)(tmbbox[BOXRIGHT] - bmaporgx + MAXRADIUS)>>MAPBLOCKSHIFT;
- yl = (unsigned)(tmbbox[BOXBOTTOM] - bmaporgy - MAXRADIUS)>>MAPBLOCKSHIFT;
- yh = (unsigned)(tmbbox[BOXTOP] - bmaporgy + MAXRADIUS)>>MAPBLOCKSHIFT;
+ xl = (unsigned)(tmbbox[BOXLEFT] - bmaporgx)>>MAPBLOCKSHIFT;
+ xh = (unsigned)(tmbbox[BOXRIGHT] - bmaporgx)>>MAPBLOCKSHIFT;
+ yl = (unsigned)(tmbbox[BOXBOTTOM] - bmaporgy)>>MAPBLOCKSHIFT;
+ yh = (unsigned)(tmbbox[BOXTOP] - bmaporgy)>>MAPBLOCKSHIFT;
BMBOUNDFIX(xl, xh, yl, yh);
@@ -2264,7 +2262,7 @@ boolean P_CheckPosition(mobj_t *thing, fixed_t x, fixed_t y)
for (bx = xl; bx <= xh; bx++)
for (by = yl; by <= yh; by++)
{
- if (!P_BlockThingsIterator(bx, by, PIT_CheckThing))
+ if (!P_BlockThingsIterator(bx, by, PIT_CheckThing, tmthing))
blockval = false;
else
tmhitthing = tmfloorthing;
@@ -2393,11 +2391,6 @@ boolean P_CheckCameraPosition(fixed_t x, fixed_t y, camera_t *thiscam)
}
}
- // The bounding box is extended by MAXRADIUS
- // because mobj_ts are grouped into mapblocks
- // based on their origin point, and can overlap
- // into adjacent blocks by up to MAXRADIUS units.
-
xl = (unsigned)(tmbbox[BOXLEFT] - bmaporgx)>>MAPBLOCKSHIFT;
xh = (unsigned)(tmbbox[BOXRIGHT] - bmaporgx)>>MAPBLOCKSHIFT;
yl = (unsigned)(tmbbox[BOXBOTTOM] - bmaporgy)>>MAPBLOCKSHIFT;
@@ -2528,16 +2521,16 @@ boolean P_TryCameraMove(fixed_t x, fixed_t y, camera_t *thiscam)
}
do {
- if (x-tryx > MAXRADIUS)
- tryx += MAXRADIUS;
- else if (x-tryx < -MAXRADIUS)
- tryx -= MAXRADIUS;
+ if (x-tryx > MAXTRYMOVE)
+ tryx += MAXTRYMOVE;
+ else if (x-tryx < -MAXTRYMOVE)
+ tryx -= MAXTRYMOVE;
else
tryx = x;
- if (y-tryy > MAXRADIUS)
- tryy += MAXRADIUS;
- else if (y-tryy < -MAXRADIUS)
- tryy -= MAXRADIUS;
+ if (y-tryy > MAXTRYMOVE)
+ tryy += MAXTRYMOVE;
+ else if (y-tryy < -MAXTRYMOVE)
+ tryy -= MAXTRYMOVE;
else
tryy = y;
@@ -2683,7 +2676,7 @@ increment_move
floatok = false;
// This makes sure that there are no freezes from computing extremely small movements.
- // Originally was MAXRADIUS/2, but that can cause some bad inconsistencies for small players.
+ // Originally was MAXTRYMOVE/2, but that can cause some bad inconsistencies for small players.
radius = max(radius, thing->scale);
// And we also have to prevent Big Large (tm) movements, as those can skip too far
@@ -2872,10 +2865,10 @@ boolean P_TryMove(mobj_t *thing, fixed_t x, fixed_t y, boolean allowdropoff)
{
INT32 xl, xh, yl, yh;
- yh = (unsigned)(thing->y + MAXRADIUS - bmaporgy)>>MAPBLOCKSHIFT;
- yl = (unsigned)(thing->y - MAXRADIUS - bmaporgy)>>MAPBLOCKSHIFT;
- xh = (unsigned)(thing->x + MAXRADIUS - bmaporgx)>>MAPBLOCKSHIFT;
- xl = (unsigned)(thing->x - MAXRADIUS - bmaporgx)>>MAPBLOCKSHIFT;
+ yh = (unsigned)(thing->y + thing->radius - bmaporgy)>>MAPBLOCKSHIFT;
+ yl = (unsigned)(thing->y - thing->radius - bmaporgy)>>MAPBLOCKSHIFT;
+ xh = (unsigned)(thing->x + thing->radius - bmaporgx)>>MAPBLOCKSHIFT;
+ xl = (unsigned)(thing->x - thing->radius - bmaporgx)>>MAPBLOCKSHIFT;
BMBOUNDFIX(xl, xh, yl, yh);
@@ -2883,7 +2876,7 @@ boolean P_TryMove(mobj_t *thing, fixed_t x, fixed_t y, boolean allowdropoff)
standx = x;
standy = y;
- P_DoBlockThingsIterate(xl, yl, xh, yh, PIT_PushableMoved);
+ P_DoBlockThingsIterate(xl, yl, xh, yh, PIT_PushableMoved, stand);
}
// Link the thing into its new position
@@ -2947,16 +2940,16 @@ boolean P_SceneryTryMove(mobj_t *thing, fixed_t x, fixed_t y)
tryx = thing->x;
tryy = thing->y;
do {
- if (x-tryx > MAXRADIUS)
- tryx += MAXRADIUS;
- else if (x-tryx < -MAXRADIUS)
- tryx -= MAXRADIUS;
+ if (x-tryx > MAXTRYMOVE)
+ tryx += MAXTRYMOVE;
+ else if (x-tryx < -MAXTRYMOVE)
+ tryx -= MAXTRYMOVE;
else
tryx = x;
- if (y-tryy > MAXRADIUS)
- tryy += MAXRADIUS;
- else if (y-tryy < -MAXRADIUS)
- tryy -= MAXRADIUS;
+ if (y-tryy > MAXTRYMOVE)
+ tryy += MAXTRYMOVE;
+ else if (y-tryy < -MAXTRYMOVE)
+ tryy -= MAXTRYMOVE;
else
tryy = y;
@@ -4215,7 +4208,8 @@ void P_RadiusAttack(mobj_t *spot, mobj_t *source, fixed_t damagedist, UINT8 dama
INT32 xl, xh, yl, yh;
fixed_t dist;
- dist = FixedMul(damagedist, spot->scale) + MAXRADIUS;
+ dist = FixedMul(damagedist, spot->scale);
+
yh = (unsigned)(spot->y + dist - bmaporgy)>>MAPBLOCKSHIFT;
yl = (unsigned)(spot->y - dist - bmaporgy)>>MAPBLOCKSHIFT;
xh = (unsigned)(spot->x + dist - bmaporgx)>>MAPBLOCKSHIFT;
@@ -4229,7 +4223,7 @@ void P_RadiusAttack(mobj_t *spot, mobj_t *source, fixed_t damagedist, UINT8 dama
bombdamagetype = damagetype;
bombsightcheck = sightcheck;
- P_DoBlockThingsIterate(xl, yl, xh, yh, PIT_RadiusAttack);
+ P_DoBlockThingsIterate(xl, yl, xh, yh, PIT_RadiusAttack, bombspot);
}
//
@@ -4385,15 +4379,15 @@ static boolean P_CheckSectorPolyObjects(sector_t *sector, boolean realcrush, boo
{
mobj_t *mo;
blocknode_t *block;
+ blocknode_t *next = NULL;
if (x < 0 || y < 0 || x >= bmapwidth || y >= bmapheight)
continue;
- block = blocklinks[y * bmapwidth + x];
-
- for (; block; block = block->mnext)
+ for (block = blocklinks[y * bmapwidth + x]; block != NULL; block = next)
{
mo = block->mobj;
+ next = block->mnext;
// Monster Iestyn: do we need to check if a mobj has already been checked? ...probably not I suspect
if (!P_MobjInsidePolyobj(po, mo))
diff --git a/src/p_maputl.c b/src/p_maputl.c
index 200b89cff93c815bac281c8b270ae4975de219c6..3e30c5d6e3f45fdb08018fbe0ef7c3b8d414f982 100644
--- a/src/p_maputl.c
+++ b/src/p_maputl.c
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -1050,47 +1050,39 @@ boolean P_BlockLinesIterator(INT32 x, INT32 y, boolean (*func)(line_t *))
//
// P_BlockThingsIterator
//
-boolean P_BlockThingsIterator(INT32 x, INT32 y, boolean (*func)(mobj_t *))
+boolean P_BlockThingsIterator(INT32 x, INT32 y, boolean (*func)(mobj_t *), mobj_t *thing)
{
- mobj_t *bnext = NULL;
blocknode_t *block, *next = NULL;
+
+ boolean checkthing = false;
+ if (thing)
+ checkthing = true;
if (x < 0 || y < 0 || x >= bmapwidth || y >= bmapheight)
return true;
// Check interaction with the objects in the blockmap.
- for (block = blocklinks[y*bmapwidth + x]; block; block = next)
+ for (block = blocklinks[y*bmapwidth + x]; block != NULL; block = next)
{
- next = block->mnext;
- if (next)
- P_SetTarget(&bnext, next->mobj); // We want to note our reference to bnext here in case it is MF_NOTHINK and gets removed!
+ next = block->mnext; // We want to note our reference to mnext here!
if (!func(block->mobj))
- {
- P_SetTarget(&bnext, NULL);
return false;
- }
- if (P_MobjWasRemoved(tmthing) // func just popped our tmthing, cannot continue.
- || (bnext && P_MobjWasRemoved(bnext))) // func just broke blockmap chain, cannot continue.
- {
- P_SetTarget(&bnext, NULL);
+ if (checkthing && P_MobjWasRemoved(thing)) // func just popped our tmthing, cannot continue.
return true;
- }
}
- P_SetTarget(&bnext, NULL);
-
return true;
}
-boolean P_DoBlockThingsIterate(int x1, int y1, int x2, int y2, boolean (*func)(mobj_t *))
+boolean P_DoBlockThingsIterate(int x1, int y1, int x2, int y2, boolean (*func)(mobj_t *), mobj_t *thing)
{
boolean status = true;
for (INT32 bx = x1; bx <= x2; bx++)
for (INT32 by = y1; by <= y2; by++)
- if (!P_BlockThingsIterator(bx, by, func))
+ if (!P_BlockThingsIterator(bx, by, func, thing))
status = false;
return status;
@@ -1463,7 +1455,7 @@ boolean P_PathTraverse(fixed_t px1, fixed_t py1, fixed_t px2, fixed_t py2,
INT32 flags, traverser_t trav)
{
fixed_t xt1, yt1, xt2, yt2;
- fixed_t xstep, ystep, partial, xintercept, yintercept;
+ fixed_t xstep, ystep, partialx, partialy, xintercept, yintercept;
INT32 mapx, mapy, mapxstep, mapystep, count;
earlyout = flags & PT_EARLYOUT;
@@ -1481,57 +1473,83 @@ boolean P_PathTraverse(fixed_t px1, fixed_t py1, fixed_t px2, fixed_t py2,
trace.y = py1;
trace.dx = px2 - px1;
trace.dy = py2 - py1;
-
- px1 -= bmaporgx;
- py1 -= bmaporgy;
- xt1 = (unsigned)px1>>MAPBLOCKSHIFT;
- yt1 = (unsigned)py1>>MAPBLOCKSHIFT;
-
- px2 -= bmaporgx;
- py2 -= bmaporgy;
- xt2 = (unsigned)px2>>MAPBLOCKSHIFT;
- yt2 = (unsigned)py2>>MAPBLOCKSHIFT;
+
+ xt1 = px1>>MAPBLOCKSHIFT;
+ yt1 = py2>>MAPBLOCKSHIFT;
+ px1 = (unsigned)(px1 - bmaporgx);
+ py1 = (unsigned)(py1 - bmaporgy);
+
+ xt2 = px2>>MAPBLOCKSHIFT;
+ yt2 = py2>>MAPBLOCKSHIFT;
+ px2 = (unsigned)(px2 - bmaporgx);
+ py2 = (unsigned)(py2 - bmaporgy);
if (xt2 > xt1)
{
mapxstep = 1;
- partial = FRACUNIT - ((px1>>MAPBTOFRAC) & FRACMASK);
+ partialx = FRACUNIT - (((unsigned)px1>>MAPBTOFRAC) & FRACMASK);
ystep = FixedDiv(py2 - py1, abs(px2 - px1));
}
else if (xt2 < xt1)
{
mapxstep = -1;
- partial = (px1>>MAPBTOFRAC) & FRACMASK;
+ partialx = ((unsigned)px1>>MAPBTOFRAC) & FRACMASK;
ystep = FixedDiv(py2 - py1, abs(px2 - px1));
}
else
{
mapxstep = 0;
- partial = FRACUNIT;
+ partialx = FRACUNIT;
ystep = 256*FRACUNIT;
}
- yintercept = (py1>>MAPBTOFRAC) + FixedMul(partial, ystep);
+ yintercept = ((unsigned)py1>>MAPBTOFRAC) + FixedMul(partialx, ystep);
if (yt2 > yt1)
{
mapystep = 1;
- partial = FRACUNIT - ((py1>>MAPBTOFRAC) & FRACMASK);
+ partialy = FRACUNIT - (((unsigned)py1>>MAPBTOFRAC) & FRACMASK);
xstep = FixedDiv(px2 - px1, abs(py2 - py1));
}
else if (yt2 < yt1)
{
mapystep = -1;
- partial = (py1>>MAPBTOFRAC) & FRACMASK;
+ partialy = ((unsigned)py1>>MAPBTOFRAC) & FRACMASK;
xstep = FixedDiv(px2 - px1, abs(py2 - py1));
}
else
{
mapystep = 0;
- partial = FRACUNIT;
+ partialy = FRACUNIT;
xstep = 256*FRACUNIT;
}
- xintercept = (px1>>MAPBTOFRAC) + FixedMul(partial, xstep);
+ xintercept = ((unsigned)px1>>MAPBTOFRAC) + FixedMul(partialy, xstep);
+
+ // [RH] Fix for traces that pass only through blockmap corners. In that case,
+ // xintercept and yintercept can both be set ahead of mapx and mapy, so the
+ // for loop would never advance anywhere.
+
+ if (abs(xstep) == 1 && abs(ystep) == 1)
+ {
+ if (ystep < 0)
+ {
+ partialx = FRACUNIT - partialx;
+ }
+ if (xstep < 0)
+ {
+ partialy = FRACUNIT - partialy;
+ }
+ if (partialx == partialy)
+ {
+ xintercept = xt1;
+ yintercept = yt1;
+ }
+ }
+
+ xt1 = (unsigned)px1>>MAPBLOCKSHIFT;
+ yt1 = (unsigned)py1>>MAPBLOCKSHIFT;
+ xt2 = (unsigned)px2>>MAPBLOCKSHIFT;
+ yt2 = (unsigned)py2>>MAPBLOCKSHIFT;
// Step through map blocks.
// Count is present to prevent a round off error
@@ -1546,21 +1564,64 @@ boolean P_PathTraverse(fixed_t px1, fixed_t py1, fixed_t px2, fixed_t py2,
return false; // early out
if (flags & PT_ADDTHINGS)
- if (!P_BlockThingsIterator(mapx, mapy, PIT_AddThingIntercepts))
+ if (!P_BlockThingsIterator(mapx, mapy, PIT_AddThingIntercepts, NULL))
return false; // early out
- if (mapx == xt2 && mapy == yt2)
+ // both coordinates reached the end, so end the traversing.
+ if ((mapxstep | mapystep) == 0)
break;
- if ((yintercept >> FRACBITS) == mapy)
- {
- yintercept += ystep;
- mapx += mapxstep;
- }
- else if ((xintercept >> FRACBITS) == mapx)
+ // [RH] Handle corner cases properly instead of pretending they don't exist.
+ switch ((((yintercept >> FRACBITS) == mapy) << 1) | ((xintercept >> FRACBITS) == mapx))
{
- xintercept += xstep;
- mapy += mapystep;
+ case 0: // neither xintercept nor yintercept match!
+ count = 64; // Stop traversing, because somebody screwed up.
+ break;
+
+ case 1: // xintercept matches
+ xintercept += xstep;
+ mapy += mapystep;
+ if (mapy == yt2)
+ mapystep = 0;
+ break;
+
+ case 2: // yintercept matches
+ yintercept += ystep;
+ mapx += mapxstep;
+ if (mapx == xt2)
+ mapxstep = 0;
+ break;
+
+ case 3: // xintercept and yintercept both match
+ // The trace is exiting a block through its corner. Not only does the block
+ // being entered need to be checked (which will happen when this loop
+ // continues), but the other two blocks adjacent to the corner also need to
+ // be checked.
+ if (flags & PT_ADDLINES)
+ {
+ if (!P_BlockLinesIterator(mapx + mapxstep, mapy, PIT_AddLineIntercepts))
+ return false; // early out
+ if (!P_BlockLinesIterator(mapx, mapy + mapystep, PIT_AddLineIntercepts))
+ return false; // early out
+ }
+
+ if (flags & PT_ADDTHINGS)
+ {
+ if (!P_BlockThingsIterator(mapx + mapxstep, mapy, PIT_AddThingIntercepts, NULL))
+ return false; // early out
+ if (!P_BlockThingsIterator(mapx, mapy + mapystep, PIT_AddThingIntercepts, NULL))
+ return false; // early out
+ }
+
+ xintercept += xstep;
+ yintercept += ystep;
+ mapx += mapxstep;
+ mapy += mapystep;
+ if (mapx == xt2)
+ mapxstep = 0;
+ if (mapy == yt2)
+ mapystep = 0;
+ break;
}
}
// Go through the sorted list
diff --git a/src/p_maputl.h b/src/p_maputl.h
index e894c08a2461caf82397c569549e5bd3213ae3b7..11cc90c59099c6a0c28cfa7db171c126993512f2 100644
--- a/src/p_maputl.h
+++ b/src/p_maputl.h
@@ -1,7 +1,7 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -61,7 +61,7 @@ extern ffloor_t *openfloorrover, *openceilingrover;
void P_LineOpening(line_t *plinedef, mobj_t *mobj);
boolean P_BlockLinesIterator(INT32 x, INT32 y, boolean(*func)(line_t *));
-boolean P_BlockThingsIterator(INT32 x, INT32 y, boolean(*func)(mobj_t *));
+boolean P_BlockThingsIterator(INT32 x, INT32 y, boolean(*func)(mobj_t *), mobj_t *thing);
void P_ClearBlockNodes(void);
@@ -94,7 +94,7 @@ typedef struct bthingit_s
bthingit_t *P_NewBlockThingsIterator(int x1, int y1, int x2, int y2);
mobj_t *P_BlockThingsIteratorNext(bthingit_t *it, boolean centeronly);
void P_FreeBlockThingsIterator(bthingit_t *it);
-boolean P_DoBlockThingsIterate(int x1, int y1, int x2, int y2, boolean (*func)(mobj_t *));
+boolean P_DoBlockThingsIterate(int x1, int y1, int x2, int y2, boolean (*func)(mobj_t *), mobj_t *thing);
#define PT_ADDLINES 1
#define PT_ADDTHINGS 2
diff --git a/src/p_mobj.c b/src/p_mobj.c
index 1ec09ab8582adea2716db0d817b670bf4aba0d2c..6a116a04488bfcb5244957dc2cb5174436433cb3 100644
--- a/src/p_mobj.c
+++ b/src/p_mobj.c
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -90,17 +90,21 @@ static void P_SetupStateAnimation(mobj_t *mobj, state_t *st)
if (mobj->sprite == SPR_PLAY && mobj->skin)
{
spritedef_t *spritedef = P_GetSkinSpritedef(mobj->skin, mobj->sprite2);
- animlength = (INT32)(spritedef->numframes);
+ animlength = (INT32)(spritedef->numframes) - 1;
}
else
animlength = st->var1;
if (!(st->frame & FF_ANIMATE))
+ {
+ mobj->anim_duration = 0;
return;
+ }
if (animlength <= 0 || st->var2 == 0)
{
mobj->frame &= ~FF_ANIMATE;
+ mobj->anim_duration = 0;
return; // Crash/stupidity prevention
}
@@ -174,27 +178,6 @@ static void P_CycleMobjState(mobj_t *mobj)
}
}
-//
-// P_CycleMobjState for players.
-//
-static void P_CyclePlayerMobjState(mobj_t *mobj)
-{
- // state animations
- P_CycleStateAnimation(mobj);
-
- // cycle through states,
- // calling action functions at transitions
- if (mobj->tics != -1)
- {
- mobj->tics--;
-
- // you can cycle through multiple states in a tic
- if (!mobj->tics && mobj->state)
- if (!P_SetMobjState(mobj, mobj->state->nextstate))
- return; // freed itself
- }
-}
-
//
// P_SetPlayerMobjState
// Returns true if the mobj is still present.
@@ -340,8 +323,10 @@ static boolean P_SetPlayerMobjState(mobj_t *mobj, statenum_t state)
mobj->state = st;
mobj->tics = st->tics;
- // Adjust the player's animation speed to match their velocity.
- if (player->panim == PA_EDGE && (player->charflags & SF_FASTEDGE))
+ // Adjust the player's animation speed
+ if (state == S_PLAY_WAIT && (player->charflags & SF_FASTWAIT))
+ mobj->tics = 5;
+ else if (player->panim == PA_EDGE && (player->charflags & SF_FASTEDGE))
mobj->tics = 2;
else if (!(disableSpeedAdjust || player->charflags & SF_NOSPEEDADJUST))
{
@@ -765,7 +750,7 @@ void P_EmeraldManager(void)
for (think = thlist[THINK_MOBJ].next; think != &thlist[THINK_MOBJ]; think = think->next)
{
- if (think->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (think->removing)
continue;
mo = (mobj_t *)think;
@@ -3455,7 +3440,7 @@ void P_DestroyRobots(void)
for (think = thlist[THINK_MOBJ].next; think != &thlist[THINK_MOBJ]; think = think->next)
{
- if (think->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (think->removing)
continue;
mo = (mobj_t *)think;
@@ -3799,7 +3784,7 @@ static void P_PlayerMobjThinker(mobj_t *mobj)
}
animonly:
- P_CyclePlayerMobjState(mobj);
+ P_CycleMobjState(mobj);
}
static void CalculatePrecipFloor(precipmobj_t *mobj)
@@ -4254,7 +4239,7 @@ static void P_Boss3Thinker(mobj_t *mobj)
// this can happen if the boss was hurt earlier than expected
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
{
- if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (th->removing)
continue;
mo2 = (mobj_t *)th;
@@ -5343,7 +5328,7 @@ static void P_Boss9Thinker(mobj_t *mobj)
// Build a hoop linked list of 'em!
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
{
- if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (th->removing)
continue;
mo2 = (mobj_t *)th;
@@ -6045,7 +6030,7 @@ mobj_t *P_GetClosestAxis(mobj_t *source)
// scan the thinkers to find the closest axis point
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
{
- if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (th->removing)
continue;
mo2 = (mobj_t *)th;
@@ -6656,12 +6641,12 @@ static boolean P_ShieldLook(mobj_t *thing, shieldtype_t shield)
if (scale < 1) {
P_SetScale(thing, thing->target->scale, true);
thing->old_scale = thing->target->old_scale;
-
+
thing->flags2 |= (MF2_DONTDRAW|MF2_JUSTATTACKED); //Hide and indicate we're hidden
} else {
P_SetScale(thing, scale, true);
thing->old_scale = FixedMul(thing->target->old_scale, thing->target->player->shieldscale);
-
+
//Only unhide if we were hidden by the above code
if (thing->flags2 & MF2_JUSTATTACKED)
thing->flags2 &= ~(MF2_DONTDRAW|MF2_JUSTATTACKED);
@@ -6790,6 +6775,12 @@ void P_RunOverlays(void)
else
zoffs = 0;
+ // hide the overlay as well if we're part of a hidden shield
+ if ((mo->target->flags2 & (MF2_JUSTATTACKED|MF2_DONTDRAW)) == (MF2_JUSTATTACKED|MF2_DONTDRAW))
+ mo->flags2 |= (MF2_DONTDRAW|MF2_JUSTATTACKED);
+ else if (mo->flags2 & MF2_JUSTATTACKED)
+ mo->flags2 &= ~(MF2_DONTDRAW|MF2_JUSTATTACKED);
+
P_UnsetThingPosition(mo);
mo->x = mo->target->x;
mo->y = mo->target->y;
@@ -7318,7 +7309,7 @@ static void P_RosySceneryThink(mobj_t *mobj)
player = &players[i];
}
- if (stat == S_ROSY_JUMP || stat == S_ROSY_PAIN)
+ if (stat == S_ROSY_JUMP || stat == S_ROSY_FALL || stat == S_ROSY_PAIN)
{
if (P_IsObjectOnGround(mobj))
{
@@ -7329,16 +7320,16 @@ static void P_RosySceneryThink(mobj_t *mobj)
stat = S_ROSY_WALK;
P_SetMobjState(mobj, stat);
}
- else if (P_MobjFlip(mobj)*mobj->momz < 0)
- mobj->frame = mobj->state->frame + mobj->state->var1;
+ else if (P_MobjFlip(mobj)*mobj->momz < 0 && stat == S_ROSY_JUMP)
+ P_SetMobjState(mobj, S_ROSY_FALL);
}
if (!player)
{
- if ((stat < S_ROSY_IDLE1 || stat > S_ROSY_IDLE4) && stat != S_ROSY_JUMP)
+ if (stat != S_ROSY_IDLE && stat != S_ROSY_JUMP && stat != S_ROSY_FALL)
{
mobj->momx = mobj->momy = 0;
- P_SetMobjState(mobj, S_ROSY_IDLE1);
+ P_SetMobjState(mobj, S_ROSY_IDLE);
}
}
else
@@ -7352,13 +7343,11 @@ static void P_RosySceneryThink(mobj_t *mobj)
switch (stat)
{
- case S_ROSY_IDLE1:
- case S_ROSY_IDLE2:
- case S_ROSY_IDLE3:
- case S_ROSY_IDLE4:
+ case S_ROSY_IDLE:
dojump = true;
break;
case S_ROSY_JUMP:
+ case S_ROSY_FALL:
case S_ROSY_PAIN:
// handled above
break;
@@ -7384,8 +7373,7 @@ static void P_RosySceneryThink(mobj_t *mobj)
max = pdist;
if ((--mobj->extravalue1) <= 0)
{
- if (++mobj->frame > mobj->state->frame + mobj->state->var1)
- mobj->frame = mobj->state->frame;
+ P_SetMobjState(mobj, S_ROSY_WALK);
if (mom > 12*mobj->scale)
mobj->extravalue1 = 2;
else if (mom > 6*mobj->scale)
@@ -8061,6 +8049,10 @@ static boolean P_MobjBossThink(mobj_t *mobj)
case MT_METALSONIC_BATTLE:
P_Boss9Thinker(mobj);
break;
+ case MT_OLDK:
+ if (mobj->health <= 0)
+ mobj->momz -= (2*FRACUNIT)/3;
+ break;
default: // Generic SOC-made boss
if (mobj->flags2 & MF2_SKULLFLY)
P_SpawnGhostMobj(mobj);
@@ -9337,12 +9329,12 @@ static void P_PointPushThink(mobj_t *mobj)
radius = mobj->spawnpoint->args[0] << FRACBITS;
pushmobj = mobj;
- xl = (unsigned)(mobj->x - radius - bmaporgx - MAXRADIUS)>>MAPBLOCKSHIFT;
- xh = (unsigned)(mobj->x + radius - bmaporgx + MAXRADIUS)>>MAPBLOCKSHIFT;
- yl = (unsigned)(mobj->y - radius - bmaporgy - MAXRADIUS)>>MAPBLOCKSHIFT;
- yh = (unsigned)(mobj->y + radius - bmaporgy + MAXRADIUS)>>MAPBLOCKSHIFT;
+ xl = (unsigned)(mobj->x - radius - bmaporgx)>>MAPBLOCKSHIFT;
+ xh = (unsigned)(mobj->x + radius - bmaporgx)>>MAPBLOCKSHIFT;
+ yl = (unsigned)(mobj->y - radius - bmaporgy)>>MAPBLOCKSHIFT;
+ yh = (unsigned)(mobj->y + radius - bmaporgy)>>MAPBLOCKSHIFT;
- P_DoBlockThingsIterate(xl, yl, xh, yh, PIT_PushThing);
+ P_DoBlockThingsIterate(xl, yl, xh, yh, PIT_PushThing, pushmobj);
}
static boolean P_MobjRegularThink(mobj_t *mobj)
@@ -10326,10 +10318,7 @@ void P_MobjThinker(mobj_t *mobj)
}
// Can end up here if a player dies.
- if (mobj->player)
- P_CyclePlayerMobjState(mobj);
- else
- P_CycleMobjState(mobj);
+ P_CycleMobjState(mobj);
if (P_MobjWasRemoved(mobj))
return;
@@ -10619,6 +10608,19 @@ static fixed_t P_DefaultMobjShadowScale (mobj_t *thing)
}
}
+static INT32 P_SetupNPC(mobj_t *mobj, const char *name)
+{
+ INT32 skinnum = R_SkinAvailable(name);
+
+ if (skinnum != -1)
+ {
+ mobj->skin = skins[skinnum];
+ mobj->color = skins[skinnum]->prefcolor;
+ }
+
+ return skinnum;
+}
+
//
// P_SpawnMobj
//
@@ -10972,17 +10974,14 @@ mobj_t *P_SpawnMobj(fixed_t x, fixed_t y, fixed_t z, mobjtype_t type, ...)
nummaprings++;
break;
case MT_METALSONIC_RACE:
- mobj->skin = skins[5];
- /* FALLTHRU */
case MT_METALSONIC_BATTLE:
- mobj->color = skins[5]->prefcolor;
- sc = 5;
+ sc = P_SetupNPC(mobj, "metalsonic");
break;
case MT_FANG:
- sc = 4;
+ sc = P_SetupNPC(mobj, "fang");
break;
case MT_ROSY:
- sc = 3;
+ sc = P_SetupNPC(mobj, "amy");
break;
case MT_CORK:
mobj->flags2 |= MF2_SUPERFIRE;
@@ -11012,13 +11011,6 @@ mobj_t *P_SpawnMobj(fixed_t x, fixed_t y, fixed_t z, mobjtype_t type, ...)
mcsolid->angle = mobj->angle + ANGLE_90;
}
break;
- case MT_TORCHFLOWER:
- {
- mobj_t *fire = P_SpawnMobjFromMobj(mobj, 0, 0, 46*FRACUNIT, MT_FLAME);
- if (!P_MobjWasRemoved(fire))
- P_SetTarget(&mobj->target, fire);
- break;
- }
case MT_PYREFLY:
mobj->extravalue1 = (FixedHypot(mobj->x, mobj->y)/FRACUNIT) % 360;
mobj->extravalue2 = 0;
@@ -11183,17 +11175,16 @@ tic_t itemrespawntime[ITEMQUESIZE];
size_t iquehead, iquetail;
#ifdef PARANOIA
-#define SCRAMBLE_REMOVED // Force debug build to crash when Removed mobj is accessed
+#define SCRAMBLE_REMOVED // Force debug build to crash when a removed mobj is accessed
#endif
void P_RemoveMobj(mobj_t *mobj)
{
I_Assert(mobj != NULL);
- if (P_MobjWasRemoved(mobj))
- return; // something already removing this mobj.
+ if (P_MobjWasRemoved(mobj) || mobj->thinker.removing)
+ return; // Something already removed or is removing this mobj.
- mobj->thinker.function.acp1 = (actionf_p1)P_RemoveThinkerDelayed; // shh. no recursing.
+ mobj->thinker.removing = true; // Set earlier to avoid recursion.
LUA_HookMobj(mobj, MOBJ_HOOK(MobjRemoved));
- mobj->thinker.function.acp1 = (actionf_p1)P_MobjThinker; // needed for P_UnsetThingPosition, etc. to work.
// Rings only, please!
if (mobj->spawnpoint &&
@@ -11291,15 +11282,6 @@ void P_RemoveMobj(mobj_t *mobj)
#endif
}
-// This does not need to be added to Lua.
-// To test it in Lua, check mobj.valid
-boolean P_MobjWasRemoved(mobj_t *mobj)
-{
- if (mobj && mobj->thinker.function.acp1 == (actionf_p1)P_MobjThinker)
- return false;
- return true;
-}
-
void P_RemovePrecipMobj(precipmobj_t *mobj)
{
// unlink from sector and block lists
@@ -12863,7 +12845,7 @@ static boolean P_MapAlreadyHasStarPost(mobj_t *mobj)
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
{
- if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (th->removing)
continue;
mo2 = (mobj_t *)th;
@@ -13012,6 +12994,13 @@ static boolean P_SetupSpawnedMapThing(mapthing_t *mthing, mobj_t *mobj, boolean
}
}
break;
+ case MT_TORCHFLOWER:
+ {
+ mobj_t *fire = P_SpawnMobjFromMobj(mobj, 0, 0, 46*FRACUNIT, MT_FLAME);
+ if (!P_MobjWasRemoved(fire))
+ P_SetTarget(&mobj->target, fire);
+ break;
+ }
case MT_CANDLE:
case MT_CANDLEPRICKET:
if (mthing->args[0])
@@ -13150,6 +13139,32 @@ static boolean P_SetupSpawnedMapThing(mapthing_t *mthing, mobj_t *mobj, boolean
banner->angle = mobjangle + ANGLE_90;
}
break;
+ case MT_SSZTREE:
+ { // Spawn the branches
+ INT32 i;
+ mobj_t *branch;
+ for (i = 0; i < 5; i++)
+ {
+ branch = P_SpawnMobjFromMobj(mobj, 0, 0, 0, MT_SSZTREE_BRANCH);
+ if (P_MobjWasRemoved(branch))
+ continue;
+ branch->angle = mobj->angle + FixedAngle(i*72*FRACUNIT);
+ }
+ }
+ break;
+ case MT_SSZTREE2:
+ { // Spawn the branches
+ INT32 i;
+ mobj_t *branch;
+ for (i = 0; i < 5; i++)
+ {
+ branch = P_SpawnMobjFromMobj(mobj, 0, 0, 0, MT_SSZTREE2_BRANCH);
+ if (P_MobjWasRemoved(branch))
+ continue;
+ branch->angle = mobj->angle + FixedAngle(i*72*FRACUNIT);
+ }
+ }
+ break;
case MT_HHZTREE_TOP:
{ // Spawn the branches
angle_t mobjangle = FixedAngle(mthing->angle << FRACBITS) & (ANGLE_90 - 1);
diff --git a/src/p_mobj.h b/src/p_mobj.h
index f281410f6ddc7ece41acc963afe63a6b23420269..4a842766999d205eb46f15250034e523236302d5 100644
--- a/src/p_mobj.h
+++ b/src/p_mobj.h
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -539,6 +539,8 @@ boolean P_SceneryZMovement(mobj_t *mo);
void P_PlayerZMovement(mobj_t *mo);
void P_EmeraldManager(void);
+mobj_t *P_FindNewPosition(UINT32 oldposition);
+
extern INT32 modulothing;
#define MAXHUNTEMERALDS 64
diff --git a/src/p_polyobj.c b/src/p_polyobj.c
index e779956e8d92092bf41a97db8efa5a7e7fd1d973..3d1a38d36ff9d9b8f7324df0b18029e35519870d 100644
--- a/src/p_polyobj.c
+++ b/src/p_polyobj.c
@@ -1,7 +1,7 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
// Copyright (C) 2006 by James Haley
-// Copyright (C) 2006-2023 by Sonic Team Junior.
+// Copyright (C) 2006-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -878,15 +878,15 @@ static void Polyobj_carryThings(polyobj_t *po, fixed_t dx, fixed_t dy)
{
mobj_t *mo;
blocknode_t *block;
+ blocknode_t *next = NULL;
if (x < 0 || y < 0 || x >= bmapwidth || y >= bmapheight)
continue;
- block = blocklinks[y * bmapwidth + x];
-
- for (; block; block = block->mnext)
+ for (block = blocklinks[y * bmapwidth + x]; block != NULL; block = next)
{
mo = block->mobj;
+ next = block->mnext;
if (mo->lastlook == pomovecount)
continue;
@@ -927,11 +927,11 @@ static INT32 Polyobj_clipThings(polyobj_t *po, line_t *line)
if (!(po->flags & POF_SOLID))
return hitflags;
- // adjust linedef bounding box to blockmap, extend by MAXRADIUS
- linebox[BOXLEFT] = (unsigned)(line->bbox[BOXLEFT] - bmaporgx - MAXRADIUS) >> MAPBLOCKSHIFT;
- linebox[BOXRIGHT] = (unsigned)(line->bbox[BOXRIGHT] - bmaporgx + MAXRADIUS) >> MAPBLOCKSHIFT;
- linebox[BOXBOTTOM] = (unsigned)(line->bbox[BOXBOTTOM] - bmaporgy - MAXRADIUS) >> MAPBLOCKSHIFT;
- linebox[BOXTOP] = (unsigned)(line->bbox[BOXTOP] - bmaporgy + MAXRADIUS) >> MAPBLOCKSHIFT;
+ // adjust linedef bounding box to blockmap
+ linebox[BOXLEFT] = (unsigned)(line->bbox[BOXLEFT] - bmaporgx) >> MAPBLOCKSHIFT;
+ linebox[BOXRIGHT] = (unsigned)(line->bbox[BOXRIGHT] - bmaporgx) >> MAPBLOCKSHIFT;
+ linebox[BOXBOTTOM] = (unsigned)(line->bbox[BOXBOTTOM] - bmaporgy) >> MAPBLOCKSHIFT;
+ linebox[BOXTOP] = (unsigned)(line->bbox[BOXTOP] - bmaporgy) >> MAPBLOCKSHIFT;
// check all mobj blockmap cells the line contacts
for (y = linebox[BOXBOTTOM]; y <= linebox[BOXTOP]; ++y)
@@ -942,9 +942,11 @@ static INT32 Polyobj_clipThings(polyobj_t *po, line_t *line)
{
mobj_t *mo = NULL;
blocknode_t *block = blocklinks[y * bmapwidth + x];
+ blocknode_t *next = NULL;
- for (; block; block = block->mnext)
+ for (; block != NULL; block = next)
{
+ next = block->mnext;
mo = block->mobj;
// Don't scroll objects that aren't affected by gravity
@@ -1115,15 +1117,15 @@ static void Polyobj_rotateThings(polyobj_t *po, vector2_t origin, angle_t delta,
{
mobj_t *mo;
blocknode_t *block;
+ blocknode_t *next = NULL;
if (x < 0 || y < 0 || x >= bmapwidth || y >= bmapheight)
continue;
- block = blocklinks[y * bmapwidth + x];
-
- for (; block; block = block->mnext)
+ for (block = blocklinks[y * bmapwidth + x]; block != NULL; block = next)
{
mo = block->mobj;
+ next = block->mnext;
if (mo->lastlook == pomovecount)
continue;
@@ -1316,7 +1318,7 @@ void Polyobj_InitLevel(void)
// the mobj_t pointers on a queue for use below.
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
{
- if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (th->removing)
continue;
mo = (mobj_t *)th;
diff --git a/src/p_pspr.h b/src/p_pspr.h
index 6510190f118fb639c52a22576dd911023d3b134c..5e1c1e05e8772c01d53871eca52d3b939fc66413 100644
--- a/src/p_pspr.h
+++ b/src/p_pspr.h
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
diff --git a/src/p_saveg.c b/src/p_saveg.c
index da73dd8a0e1470a1fafd4f5285923ea29c70b7fb..650622f59f8130a896257748eb56a4116e963f7e 100644
--- a/src/p_saveg.c
+++ b/src/p_saveg.c
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -35,9 +35,249 @@
#include "p_polyobj.h"
#include "lua_script.h"
#include "p_slopes.h"
+#include "hu_stuff.h"
savedata_t savedata;
-UINT8 *save_p;
+
+#define ALLOC_SIZE(p, z) \
+ if ((p)->pos + (z) > (p)->size) \
+ { \
+ while ((p)->pos + (z) > (p)->size) \
+ (p)->size <<= 1; \
+ (p)->buf = realloc((p)->buf, (p)->size); \
+ }
+
+void P_WriteUINT8(save_t *p, UINT8 v)
+{
+ ALLOC_SIZE(p, sizeof(v));
+ memcpy(&p->buf[p->pos], &v, sizeof(v));
+ p->pos += sizeof(v);
+}
+
+void P_WriteSINT8(save_t *p, SINT8 v)
+{
+ ALLOC_SIZE(p, sizeof(v));
+ memcpy(&p->buf[p->pos], &v, sizeof(v));
+ p->pos += sizeof(v);
+}
+
+void P_WriteUINT16(save_t *p, UINT16 v)
+{
+ ALLOC_SIZE(p, sizeof(v));
+ memcpy(&p->buf[p->pos], &v, sizeof(v));
+ p->pos += sizeof(v);
+}
+
+void P_WriteINT16(save_t *p, INT16 v)
+{
+ ALLOC_SIZE(p, sizeof(v));
+ memcpy(&p->buf[p->pos], &v, sizeof(v));
+ p->pos += sizeof(v);
+}
+
+void P_WriteUINT32(save_t *p, UINT32 v)
+{
+ ALLOC_SIZE(p, sizeof(v));
+ memcpy(&p->buf[p->pos], &v, sizeof(v));
+ p->pos += sizeof(v);
+}
+
+void P_WriteINT32(save_t *p, INT32 v)
+{
+ ALLOC_SIZE(p, sizeof(v));
+ memcpy(&p->buf[p->pos], &v, sizeof(v));
+ p->pos += sizeof(v);
+}
+
+void P_WriteChar(save_t *p, char v)
+{
+ ALLOC_SIZE(p, sizeof(v));
+ memcpy(&p->buf[p->pos], &v, sizeof(v));
+ p->pos += sizeof(v);
+}
+
+void P_WriteFixed(save_t *p, fixed_t v)
+{
+ ALLOC_SIZE(p, sizeof(v));
+ memcpy(&p->buf[p->pos], &v, sizeof(v));
+ p->pos += sizeof(v);
+}
+
+void P_WriteAngle(save_t *p, angle_t v)
+{
+ ALLOC_SIZE(p, sizeof(v));
+ memcpy(&p->buf[p->pos], &v, sizeof(v));
+ p->pos += sizeof(v);
+}
+
+void P_WriteStringN(save_t *p, char const *s, size_t n)
+{
+ size_t i;
+
+ for (i = 0; i < n && s[i] != '\0'; i++)
+ P_WriteChar(p, s[i]);
+
+ if (i < n)
+ P_WriteChar(p, '\0');
+}
+
+void P_WriteStringL(save_t *p, char const *s, size_t n)
+{
+ size_t i;
+
+ for (i = 0; i < n - 1 && s[i] != '\0'; i++)
+ P_WriteChar(p, s[i]);
+
+ P_WriteChar(p, '\0');
+}
+
+void P_WriteString(save_t *p, char const *s)
+{
+ size_t i;
+
+ for (i = 0; s[i] != '\0'; i++)
+ P_WriteChar(p, s[i]);
+
+ P_WriteChar(p, '\0');
+}
+
+void P_WriteMem(save_t *p, void const *s, size_t n)
+{
+ ALLOC_SIZE(p, n);
+ memcpy(&p->buf[p->pos], s, n);
+ p->pos += n;
+}
+
+void P_SkipStringN(save_t *p, size_t n)
+{
+ size_t i;
+ for (i = 0; p->pos < p->size && i < n && P_ReadChar(p) != '\0'; i++);
+}
+
+void P_SkipStringL(save_t *p, size_t n)
+{
+ P_SkipStringN(p, n);
+}
+
+void P_SkipString(save_t *p)
+{
+ P_SkipStringN(p, SIZE_MAX);
+}
+
+UINT8 P_ReadUINT8(save_t *p)
+{
+ UINT8 v;
+ if (p->pos + sizeof(v) > p->size)
+ return 0;
+ memcpy(&v, &p->buf[p->pos], sizeof(v));
+ p->pos += sizeof(v);
+ return v;
+}
+
+SINT8 P_ReadSINT8(save_t *p)
+{
+ SINT8 v;
+ if (p->pos + sizeof(v) > p->size)
+ return 0;
+ memcpy(&v, &p->buf[p->pos], sizeof(v));
+ p->pos += sizeof(v);
+ return v;
+}
+
+UINT16 P_ReadUINT16(save_t *p)
+{
+ UINT16 v;
+ if (p->pos + sizeof(v) > p->size)
+ return 0;
+ memcpy(&v, &p->buf[p->pos], sizeof(v));
+ p->pos += sizeof(v);
+ return v;
+}
+
+INT16 P_ReadINT16(save_t *p)
+{
+ INT16 v;
+ if (p->pos + sizeof(v) > p->size)
+ return 0;
+ memcpy(&v, &p->buf[p->pos], sizeof(v));
+ p->pos += sizeof(v);
+ return v;
+}
+
+UINT32 P_ReadUINT32(save_t *p)
+{
+ UINT32 v;
+ if (p->pos + sizeof(v) > p->size)
+ return 0;
+ memcpy(&v, &p->buf[p->pos], sizeof(v));
+ p->pos += sizeof(v);
+ return v;
+}
+
+INT32 P_ReadINT32(save_t *p)
+{
+ INT32 v;
+ if (p->pos + sizeof(v) > p->size)
+ return 0;
+ memcpy(&v, &p->buf[p->pos], sizeof(v));
+ p->pos += sizeof(v);
+ return v;
+}
+
+char P_ReadChar(save_t *p)
+{
+ char v;
+ if (p->pos + sizeof(v) > p->size)
+ return 0;
+ memcpy(&v, &p->buf[p->pos], sizeof(v));
+ p->pos += sizeof(v);
+ return v;
+}
+
+fixed_t P_ReadFixed(save_t *p)
+{
+ fixed_t v;
+ if (p->pos + sizeof(v) > p->size)
+ return 0;
+ memcpy(&v, &p->buf[p->pos], sizeof(v));
+ p->pos += sizeof(v);
+ return v;
+}
+
+angle_t P_ReadAngle(save_t *p)
+{
+ angle_t v;
+ if (p->pos + sizeof(v) > p->size)
+ return 0;
+ memcpy(&v, &p->buf[p->pos], sizeof(v));
+ p->pos += sizeof(v);
+ return v;
+}
+
+void P_ReadStringN(save_t *p, char *s, size_t n)
+{
+ size_t i;
+ for (i = 0; p->pos < p->size && i < n && (s[i] = P_ReadChar(p)) != '\0'; i++);
+ s[i] = '\0';
+}
+
+void P_ReadStringL(save_t *p, char *s, size_t n)
+{
+ P_ReadStringN(p, s, n - 1);
+}
+
+void P_ReadString(save_t *p, char *s)
+{
+ P_ReadStringN(p, s, SIZE_MAX);
+}
+
+void P_ReadMem(save_t *p, void *s, size_t n)
+{
+ if (p->pos + n > p->size)
+ return;
+ memcpy(s, &p->buf[p->pos], n);
+ p->pos += n;
+}
// Block UINT32s to attempt to ensure that the correct data is
// being sent and received
@@ -62,7 +302,7 @@ typedef enum
DRONE = 0x80,
} player_saveflags;
-static inline void P_ArchivePlayer(void)
+static inline void P_ArchivePlayer(save_t *save_p)
{
const player_t *player = &players[consoleplayer];
SINT8 pllives = player->lives;
@@ -72,32 +312,32 @@ static inline void P_ArchivePlayer(void)
#ifdef NEWSKINSAVES
// Write a specific value into the old skininfo location.
// If we read something other than this, it's an older save file that used skin numbers.
- WRITEUINT16(save_p, NEWSKINSAVES);
+ P_WriteUINT16(save_p, NEWSKINSAVES);
#endif
// Write skin names, so that loading skins in different orders
// doesn't change who the save file is for!
- WRITESTRINGN(save_p, skins[player->skin]->name, SKINNAMESIZE);
+ P_WriteStringN(save_p, skins[player->skin]->name, SKINNAMESIZE);
if (botskin != 0)
{
- WRITESTRINGN(save_p, skins[botskin-1]->name, SKINNAMESIZE);
+ P_WriteStringN(save_p, skins[botskin-1]->name, SKINNAMESIZE);
}
else
{
- WRITESTRINGN(save_p, "\0", SKINNAMESIZE);
+ P_WriteStringN(save_p, "\0", SKINNAMESIZE);
}
- WRITEUINT8(save_p, numgameovers);
- WRITESINT8(save_p, pllives);
- WRITEUINT32(save_p, player->score);
- WRITEINT32(save_p, player->continues);
+ P_WriteUINT8(save_p, numgameovers);
+ P_WriteSINT8(save_p, pllives);
+ P_WriteUINT32(save_p, player->score);
+ P_WriteINT32(save_p, player->continues);
}
-static inline void P_UnArchivePlayer(void)
+static inline void P_UnArchivePlayer(save_t *save_p)
{
#ifdef NEWSKINSAVES
- INT16 backwardsCompat = READUINT16(save_p);
+ INT16 backwardsCompat = P_ReadUINT16(save_p);
if (backwardsCompat != NEWSKINSAVES)
{
@@ -111,30 +351,30 @@ static inline void P_UnArchivePlayer(void)
char ourSkinName[SKINNAMESIZE+1];
char botSkinName[SKINNAMESIZE+1];
- READSTRINGN(save_p, ourSkinName, SKINNAMESIZE);
+ P_ReadStringN(save_p, ourSkinName, SKINNAMESIZE);
savedata.skin = R_SkinAvailable(ourSkinName);
- READSTRINGN(save_p, botSkinName, SKINNAMESIZE);
+ P_ReadStringN(save_p, botSkinName, SKINNAMESIZE);
savedata.botskin = R_SkinAvailable(botSkinName) + 1;
}
- savedata.numgameovers = READUINT8(save_p);
- savedata.lives = READSINT8(save_p);
- savedata.score = READUINT32(save_p);
- savedata.continues = READINT32(save_p);
+ savedata.numgameovers = P_ReadUINT8(save_p);
+ savedata.lives = P_ReadSINT8(save_p);
+ savedata.score = P_ReadUINT32(save_p);
+ savedata.continues = P_ReadINT32(save_p);
}
-static void P_NetArchivePlayers(void)
+static void P_NetArchivePlayers(save_t *save_p)
{
INT32 i, j;
UINT16 flags;
// size_t q;
- WRITEUINT32(save_p, ARCHIVEBLOCK_PLAYERS);
+ P_WriteUINT32(save_p, ARCHIVEBLOCK_PLAYERS);
for (i = 0; i < MAXPLAYERS; i++)
{
- WRITESINT8(save_p, (SINT8)adminplayers[i]);
+ P_WriteSINT8(save_p, (SINT8)adminplayers[i]);
if (!playeringame[i])
continue;
@@ -143,142 +383,142 @@ static void P_NetArchivePlayers(void)
// no longer send ticcmds
- WRITESTRINGN(save_p, player_names[i], MAXPLAYERNAME);
- WRITEINT16(save_p, players[i].angleturn);
- WRITEINT16(save_p, players[i].oldrelangleturn);
- WRITEANGLE(save_p, players[i].aiming);
- WRITEANGLE(save_p, players[i].drawangle);
- WRITEANGLE(save_p, players[i].viewrollangle);
- WRITEANGLE(save_p, players[i].awayviewaiming);
- WRITEINT32(save_p, players[i].awayviewtics);
- WRITEINT16(save_p, players[i].rings);
- WRITEINT16(save_p, players[i].spheres);
-
- WRITESINT8(save_p, players[i].pity);
- WRITEINT32(save_p, players[i].currentweapon);
- WRITEINT32(save_p, players[i].ringweapons);
-
- WRITEUINT16(save_p, players[i].ammoremoval);
- WRITEUINT32(save_p, players[i].ammoremovaltimer);
- WRITEINT32(save_p, players[i].ammoremovaltimer);
+ P_WriteStringN(save_p, player_names[i], MAXPLAYERNAME);
+ P_WriteINT16(save_p, players[i].angleturn);
+ P_WriteINT16(save_p, players[i].oldrelangleturn);
+ P_WriteAngle(save_p, players[i].aiming);
+ P_WriteAngle(save_p, players[i].drawangle);
+ P_WriteAngle(save_p, players[i].viewrollangle);
+ P_WriteAngle(save_p, players[i].awayviewaiming);
+ P_WriteINT32(save_p, players[i].awayviewtics);
+ P_WriteINT16(save_p, players[i].rings);
+ P_WriteINT16(save_p, players[i].spheres);
+
+ P_WriteSINT8(save_p, players[i].pity);
+ P_WriteINT32(save_p, players[i].currentweapon);
+ P_WriteINT32(save_p, players[i].ringweapons);
+
+ P_WriteUINT16(save_p, players[i].ammoremoval);
+ P_WriteUINT32(save_p, players[i].ammoremovaltimer);
+ P_WriteINT32(save_p, players[i].ammoremovaltimer);
for (j = 0; j < NUMPOWERS; j++)
- WRITEUINT16(save_p, players[i].powers[j]);
-
- WRITEUINT8(save_p, players[i].playerstate);
- WRITEUINT32(save_p, players[i].pflags);
- WRITEUINT8(save_p, players[i].panim);
- WRITEUINT8(save_p, players[i].stronganim);
- WRITEUINT8(save_p, players[i].spectator);
- WRITEUINT8(save_p, players[i].muted);
-
- WRITEUINT16(save_p, players[i].flashpal);
- WRITEUINT16(save_p, players[i].flashcount);
-
- WRITEUINT16(save_p, players[i].skincolor);
- WRITEINT32(save_p, players[i].skin);
- WRITEUINT32(save_p, players[i].availabilities);
- WRITEUINT32(save_p, players[i].score);
- WRITEUINT32(save_p, players[i].recordscore);
- WRITEFIXED(save_p, players[i].dashspeed);
- WRITESINT8(save_p, players[i].lives);
- WRITESINT8(save_p, players[i].continues);
- WRITESINT8(save_p, players[i].xtralife);
- WRITEUINT8(save_p, players[i].gotcontinue);
- WRITEFIXED(save_p, players[i].speed);
- WRITEUINT8(save_p, players[i].secondjump);
- WRITEUINT8(save_p, players[i].fly1);
- WRITEUINT8(save_p, players[i].scoreadd);
- WRITEUINT32(save_p, players[i].glidetime);
- WRITEUINT8(save_p, players[i].climbing);
- WRITEINT32(save_p, players[i].deadtimer);
- WRITEUINT32(save_p, players[i].exiting);
- WRITEUINT8(save_p, players[i].homing);
- WRITEUINT32(save_p, players[i].dashmode);
- WRITEUINT32(save_p, players[i].skidtime);
+ P_WriteUINT16(save_p, players[i].powers[j]);
+
+ P_WriteUINT8(save_p, players[i].playerstate);
+ P_WriteUINT32(save_p, players[i].pflags);
+ P_WriteUINT8(save_p, players[i].panim);
+ P_WriteUINT8(save_p, players[i].stronganim);
+ P_WriteUINT8(save_p, players[i].spectator);
+ P_WriteUINT8(save_p, players[i].muted);
+
+ P_WriteUINT16(save_p, players[i].flashpal);
+ P_WriteUINT16(save_p, players[i].flashcount);
+
+ P_WriteUINT16(save_p, players[i].skincolor);
+ P_WriteINT32(save_p, players[i].skin);
+ P_WriteUINT32(save_p, players[i].availabilities);
+ P_WriteUINT32(save_p, players[i].score);
+ P_WriteUINT32(save_p, players[i].recordscore);
+ P_WriteFixed(save_p, players[i].dashspeed);
+ P_WriteSINT8(save_p, players[i].lives);
+ P_WriteSINT8(save_p, players[i].continues);
+ P_WriteSINT8(save_p, players[i].xtralife);
+ P_WriteUINT8(save_p, players[i].gotcontinue);
+ P_WriteFixed(save_p, players[i].speed);
+ P_WriteUINT8(save_p, players[i].secondjump);
+ P_WriteUINT8(save_p, players[i].fly1);
+ P_WriteUINT8(save_p, players[i].scoreadd);
+ P_WriteUINT32(save_p, players[i].glidetime);
+ P_WriteUINT8(save_p, players[i].climbing);
+ P_WriteINT32(save_p, players[i].deadtimer);
+ P_WriteUINT32(save_p, players[i].exiting);
+ P_WriteUINT8(save_p, players[i].homing);
+ P_WriteUINT32(save_p, players[i].dashmode);
+ P_WriteUINT32(save_p, players[i].skidtime);
//////////
// Bots //
//////////
- WRITEUINT8(save_p, players[i].bot);
- WRITEUINT8(save_p, players[i].botmem.lastForward);
- WRITEUINT8(save_p, players[i].botmem.lastBlocked);
- WRITEUINT8(save_p, players[i].botmem.catchup_tics);
- WRITEUINT8(save_p, players[i].botmem.thinkstate);
- WRITEUINT8(save_p, players[i].removing);
+ P_WriteUINT8(save_p, players[i].bot);
+ P_WriteUINT8(save_p, players[i].botmem.lastForward);
+ P_WriteUINT8(save_p, players[i].botmem.lastBlocked);
+ P_WriteUINT8(save_p, players[i].botmem.catchup_tics);
+ P_WriteUINT8(save_p, players[i].botmem.thinkstate);
+ P_WriteUINT8(save_p, players[i].removing);
- WRITEUINT8(save_p, players[i].blocked);
- WRITEUINT16(save_p, players[i].lastbuttons);
+ P_WriteUINT8(save_p, players[i].blocked);
+ P_WriteUINT16(save_p, players[i].lastbuttons);
////////////////////////////
// Conveyor Belt Movement //
////////////////////////////
- WRITEFIXED(save_p, players[i].cmomx); // Conveyor momx
- WRITEFIXED(save_p, players[i].cmomy); // Conveyor momy
- WRITEFIXED(save_p, players[i].rmomx); // "Real" momx (momx - cmomx)
- WRITEFIXED(save_p, players[i].rmomy); // "Real" momy (momy - cmomy)
+ P_WriteFixed(save_p, players[i].cmomx); // Conveyor momx
+ P_WriteFixed(save_p, players[i].cmomy); // Conveyor momy
+ P_WriteFixed(save_p, players[i].rmomx); // "Real" momx (momx - cmomx)
+ P_WriteFixed(save_p, players[i].rmomy); // "Real" momy (momy - cmomy)
/////////////////////
// Race Mode Stuff //
/////////////////////
- WRITEINT16(save_p, players[i].numboxes);
- WRITEINT16(save_p, players[i].totalring);
- WRITEUINT32(save_p, players[i].realtime);
- WRITEUINT8(save_p, players[i].laps);
+ P_WriteINT16(save_p, players[i].numboxes);
+ P_WriteINT16(save_p, players[i].totalring);
+ P_WriteUINT32(save_p, players[i].realtime);
+ P_WriteUINT8(save_p, players[i].laps);
////////////////////
// CTF Mode Stuff //
////////////////////
- WRITEINT32(save_p, players[i].ctfteam);
- WRITEUINT16(save_p, players[i].gotflag);
-
- WRITEINT32(save_p, players[i].weapondelay);
- WRITEINT32(save_p, players[i].tossdelay);
-
- WRITEUINT32(save_p, players[i].starposttime);
- WRITEINT16(save_p, players[i].starpostx);
- WRITEINT16(save_p, players[i].starposty);
- WRITEINT16(save_p, players[i].starpostz);
- WRITEINT32(save_p, players[i].starpostnum);
- WRITEANGLE(save_p, players[i].starpostangle);
- WRITEFIXED(save_p, players[i].starpostscale);
-
- WRITEANGLE(save_p, players[i].angle_pos);
- WRITEANGLE(save_p, players[i].old_angle_pos);
-
- WRITEINT32(save_p, players[i].flyangle);
- WRITEUINT32(save_p, players[i].drilltimer);
- WRITEINT32(save_p, players[i].linkcount);
- WRITEUINT32(save_p, players[i].linktimer);
- WRITEINT32(save_p, players[i].anotherflyangle);
- WRITEUINT32(save_p, players[i].nightstime);
- WRITEUINT32(save_p, players[i].bumpertime);
- WRITEINT32(save_p, players[i].drillmeter);
- WRITEUINT8(save_p, players[i].drilldelay);
- WRITEUINT8(save_p, players[i].bonustime);
- WRITEFIXED(save_p, players[i].oldscale);
- WRITEUINT8(save_p, players[i].mare);
- WRITEUINT8(save_p, players[i].marelap);
- WRITEUINT8(save_p, players[i].marebonuslap);
- WRITEUINT32(save_p, players[i].marebegunat);
- WRITEUINT32(save_p, players[i].lastmaretime);
- WRITEUINT32(save_p, players[i].startedtime);
- WRITEUINT32(save_p, players[i].finishedtime);
- WRITEUINT32(save_p, players[i].lapbegunat);
- WRITEUINT32(save_p, players[i].lapstartedtime);
- WRITEINT16(save_p, players[i].finishedspheres);
- WRITEINT16(save_p, players[i].finishedrings);
- WRITEUINT32(save_p, players[i].marescore);
- WRITEUINT32(save_p, players[i].lastmarescore);
- WRITEUINT32(save_p, players[i].totalmarescore);
- WRITEUINT8(save_p, players[i].lastmare);
- WRITEUINT8(save_p, players[i].lastmarelap);
- WRITEUINT8(save_p, players[i].lastmarebonuslap);
- WRITEUINT8(save_p, players[i].totalmarelap);
- WRITEUINT8(save_p, players[i].totalmarebonuslap);
- WRITEINT32(save_p, players[i].maxlink);
- WRITEUINT8(save_p, players[i].texttimer);
- WRITEUINT8(save_p, players[i].textvar);
+ P_WriteINT32(save_p, players[i].ctfteam);
+ P_WriteUINT16(save_p, players[i].gotflag);
+
+ P_WriteINT32(save_p, players[i].weapondelay);
+ P_WriteINT32(save_p, players[i].tossdelay);
+
+ P_WriteUINT32(save_p, players[i].starposttime);
+ P_WriteINT16(save_p, players[i].starpostx);
+ P_WriteINT16(save_p, players[i].starposty);
+ P_WriteINT16(save_p, players[i].starpostz);
+ P_WriteINT32(save_p, players[i].starpostnum);
+ P_WriteAngle(save_p, players[i].starpostangle);
+ P_WriteFixed(save_p, players[i].starpostscale);
+
+ P_WriteAngle(save_p, players[i].angle_pos);
+ P_WriteAngle(save_p, players[i].old_angle_pos);
+
+ P_WriteINT32(save_p, players[i].flyangle);
+ P_WriteUINT32(save_p, players[i].drilltimer);
+ P_WriteINT32(save_p, players[i].linkcount);
+ P_WriteUINT32(save_p, players[i].linktimer);
+ P_WriteINT32(save_p, players[i].anotherflyangle);
+ P_WriteUINT32(save_p, players[i].nightstime);
+ P_WriteUINT32(save_p, players[i].bumpertime);
+ P_WriteINT32(save_p, players[i].drillmeter);
+ P_WriteUINT8(save_p, players[i].drilldelay);
+ P_WriteUINT8(save_p, players[i].bonustime);
+ P_WriteFixed(save_p, players[i].oldscale);
+ P_WriteUINT8(save_p, players[i].mare);
+ P_WriteUINT8(save_p, players[i].marelap);
+ P_WriteUINT8(save_p, players[i].marebonuslap);
+ P_WriteUINT32(save_p, players[i].marebegunat);
+ P_WriteUINT32(save_p, players[i].lastmaretime);
+ P_WriteUINT32(save_p, players[i].startedtime);
+ P_WriteUINT32(save_p, players[i].finishedtime);
+ P_WriteUINT32(save_p, players[i].lapbegunat);
+ P_WriteUINT32(save_p, players[i].lapstartedtime);
+ P_WriteINT16(save_p, players[i].finishedspheres);
+ P_WriteINT16(save_p, players[i].finishedrings);
+ P_WriteUINT32(save_p, players[i].marescore);
+ P_WriteUINT32(save_p, players[i].lastmarescore);
+ P_WriteUINT32(save_p, players[i].totalmarescore);
+ P_WriteUINT8(save_p, players[i].lastmare);
+ P_WriteUINT8(save_p, players[i].lastmarelap);
+ P_WriteUINT8(save_p, players[i].lastmarebonuslap);
+ P_WriteUINT8(save_p, players[i].totalmarelap);
+ P_WriteUINT8(save_p, players[i].totalmarebonuslap);
+ P_WriteINT32(save_p, players[i].maxlink);
+ P_WriteUINT8(save_p, players[i].texttimer);
+ P_WriteUINT8(save_p, players[i].textvar);
if (players[i].capsule)
flags |= CAPSULE;
@@ -298,73 +538,73 @@ static void P_NetArchivePlayers(void)
if (players[i].drone)
flags |= DRONE;
- WRITEINT16(save_p, players[i].lastsidehit);
- WRITEINT16(save_p, players[i].lastlinehit);
+ P_WriteINT16(save_p, players[i].lastsidehit);
+ P_WriteINT16(save_p, players[i].lastlinehit);
- WRITEUINT32(save_p, players[i].losstime);
+ P_WriteUINT32(save_p, players[i].losstime);
- WRITEUINT8(save_p, players[i].timeshit);
+ P_WriteUINT8(save_p, players[i].timeshit);
- WRITEINT32(save_p, players[i].onconveyor);
+ P_WriteINT32(save_p, players[i].onconveyor);
- WRITEUINT32(save_p, players[i].jointime);
- WRITEUINT32(save_p, players[i].quittime);
+ P_WriteUINT32(save_p, players[i].jointime);
+ P_WriteUINT32(save_p, players[i].quittime);
- WRITEUINT16(save_p, flags);
+ P_WriteUINT16(save_p, flags);
if (flags & CAPSULE)
- WRITEUINT32(save_p, players[i].capsule->mobjnum);
+ P_WriteUINT32(save_p, players[i].capsule->mobjnum);
if (flags & FIRSTAXIS)
- WRITEUINT32(save_p, players[i].axis1->mobjnum);
+ P_WriteUINT32(save_p, players[i].axis1->mobjnum);
if (flags & SECONDAXIS)
- WRITEUINT32(save_p, players[i].axis2->mobjnum);
+ P_WriteUINT32(save_p, players[i].axis2->mobjnum);
if (flags & AWAYVIEW)
- WRITEUINT32(save_p, players[i].awayviewmobj->mobjnum);
+ P_WriteUINT32(save_p, players[i].awayviewmobj->mobjnum);
if (flags & FOLLOW)
- WRITEUINT32(save_p, players[i].followmobj->mobjnum);
+ P_WriteUINT32(save_p, players[i].followmobj->mobjnum);
if (flags & DRONE)
- WRITEUINT32(save_p, players[i].drone->mobjnum);
-
- WRITEFIXED(save_p, players[i].camerascale);
- WRITEFIXED(save_p, players[i].shieldscale);
-
- WRITEUINT8(save_p, players[i].charability);
- WRITEUINT8(save_p, players[i].charability2);
- WRITEUINT32(save_p, players[i].charflags);
- WRITEUINT32(save_p, (UINT32)players[i].thokitem);
- WRITEUINT32(save_p, (UINT32)players[i].spinitem);
- WRITEUINT32(save_p, (UINT32)players[i].revitem);
- WRITEUINT32(save_p, (UINT32)players[i].followitem);
- WRITEFIXED(save_p, players[i].actionspd);
- WRITEFIXED(save_p, players[i].mindash);
- WRITEFIXED(save_p, players[i].maxdash);
- WRITEFIXED(save_p, players[i].normalspeed);
- WRITEFIXED(save_p, players[i].runspeed);
- WRITEUINT8(save_p, players[i].thrustfactor);
- WRITEUINT8(save_p, players[i].accelstart);
- WRITEUINT8(save_p, players[i].acceleration);
- WRITEFIXED(save_p, players[i].jumpfactor);
- WRITEFIXED(save_p, players[i].height);
- WRITEFIXED(save_p, players[i].spinheight);
+ P_WriteUINT32(save_p, players[i].drone->mobjnum);
+
+ P_WriteFixed(save_p, players[i].camerascale);
+ P_WriteFixed(save_p, players[i].shieldscale);
+
+ P_WriteUINT8(save_p, players[i].charability);
+ P_WriteUINT8(save_p, players[i].charability2);
+ P_WriteUINT32(save_p, players[i].charflags);
+ P_WriteUINT32(save_p, (UINT32)players[i].thokitem);
+ P_WriteUINT32(save_p, (UINT32)players[i].spinitem);
+ P_WriteUINT32(save_p, (UINT32)players[i].revitem);
+ P_WriteUINT32(save_p, (UINT32)players[i].followitem);
+ P_WriteFixed(save_p, players[i].actionspd);
+ P_WriteFixed(save_p, players[i].mindash);
+ P_WriteFixed(save_p, players[i].maxdash);
+ P_WriteFixed(save_p, players[i].normalspeed);
+ P_WriteFixed(save_p, players[i].runspeed);
+ P_WriteUINT8(save_p, players[i].thrustfactor);
+ P_WriteUINT8(save_p, players[i].accelstart);
+ P_WriteUINT8(save_p, players[i].acceleration);
+ P_WriteFixed(save_p, players[i].jumpfactor);
+ P_WriteFixed(save_p, players[i].height);
+ P_WriteFixed(save_p, players[i].spinheight);
}
}
-static void P_NetUnArchivePlayers(void)
+static void P_NetUnArchivePlayers(save_t *save_p)
{
INT32 i, j;
UINT16 flags;
- if (READUINT32(save_p) != ARCHIVEBLOCK_PLAYERS)
+ if (P_ReadUINT32(save_p) != ARCHIVEBLOCK_PLAYERS)
I_Error("Bad $$$.sav at archive block Players");
for (i = 0; i < MAXPLAYERS; i++)
{
- adminplayers[i] = (INT32)READSINT8(save_p);
+ adminplayers[i] = (INT32)P_ReadSINT8(save_p);
// Do NOT memset player struct to 0
// other areas may initialize data elsewhere
@@ -374,198 +614,198 @@ static void P_NetUnArchivePlayers(void)
// NOTE: sending tics should (hopefully) no longer be necessary
- READSTRINGN(save_p, player_names[i], MAXPLAYERNAME);
- players[i].angleturn = READINT16(save_p);
- players[i].oldrelangleturn = READINT16(save_p);
- players[i].aiming = READANGLE(save_p);
- players[i].drawangle = READANGLE(save_p);
- players[i].viewrollangle = READANGLE(save_p);
- players[i].awayviewaiming = READANGLE(save_p);
- players[i].awayviewtics = READINT32(save_p);
- players[i].rings = READINT16(save_p);
- players[i].spheres = READINT16(save_p);
-
- players[i].pity = READSINT8(save_p);
- players[i].currentweapon = READINT32(save_p);
- players[i].ringweapons = READINT32(save_p);
-
- players[i].ammoremoval = READUINT16(save_p);
- players[i].ammoremovaltimer = READUINT32(save_p);
- players[i].ammoremovalweapon = READINT32(save_p);
+ P_ReadStringN(save_p, player_names[i], MAXPLAYERNAME);
+ players[i].angleturn = P_ReadINT16(save_p);
+ players[i].oldrelangleturn = P_ReadINT16(save_p);
+ players[i].aiming = P_ReadAngle(save_p);
+ players[i].drawangle = P_ReadAngle(save_p);
+ players[i].viewrollangle = P_ReadAngle(save_p);
+ players[i].awayviewaiming = P_ReadAngle(save_p);
+ players[i].awayviewtics = P_ReadINT32(save_p);
+ players[i].rings = P_ReadINT16(save_p);
+ players[i].spheres = P_ReadINT16(save_p);
+
+ players[i].pity = P_ReadSINT8(save_p);
+ players[i].currentweapon = P_ReadINT32(save_p);
+ players[i].ringweapons = P_ReadINT32(save_p);
+
+ players[i].ammoremoval = P_ReadUINT16(save_p);
+ players[i].ammoremovaltimer = P_ReadUINT32(save_p);
+ players[i].ammoremovalweapon = P_ReadINT32(save_p);
for (j = 0; j < NUMPOWERS; j++)
- players[i].powers[j] = READUINT16(save_p);
-
- players[i].playerstate = READUINT8(save_p);
- players[i].pflags = READUINT32(save_p);
- players[i].panim = READUINT8(save_p);
- players[i].stronganim = READUINT8(save_p);
- players[i].spectator = READUINT8(save_p);
- players[i].muted = READUINT8(save_p);
-
- players[i].flashpal = READUINT16(save_p);
- players[i].flashcount = READUINT16(save_p);
-
- players[i].skincolor = READUINT16(save_p);
- players[i].skin = READINT32(save_p);
- players[i].availabilities = READUINT32(save_p);
- players[i].score = READUINT32(save_p);
- players[i].recordscore = READUINT32(save_p);
- players[i].dashspeed = READFIXED(save_p); // dashing speed
- players[i].lives = READSINT8(save_p);
- players[i].continues = READSINT8(save_p); // continues that player has acquired
- players[i].xtralife = READSINT8(save_p); // Ring Extra Life counter
- players[i].gotcontinue = READUINT8(save_p); // got continue from stage
- players[i].speed = READFIXED(save_p); // Player's speed (distance formula of MOMX and MOMY values)
- players[i].secondjump = READUINT8(save_p);
- players[i].fly1 = READUINT8(save_p); // Tails flying
- players[i].scoreadd = READUINT8(save_p); // Used for multiple enemy attack bonus
- players[i].glidetime = READUINT32(save_p); // Glide counter for thrust
- players[i].climbing = READUINT8(save_p); // Climbing on the wall
- players[i].deadtimer = READINT32(save_p); // End game if game over lasts too long
- players[i].exiting = READUINT32(save_p); // Exitlevel timer
- players[i].homing = READUINT8(save_p); // Are you homing?
- players[i].dashmode = READUINT32(save_p); // counter for dashmode ability
- players[i].skidtime = READUINT32(save_p); // Skid timer
+ players[i].powers[j] = P_ReadUINT16(save_p);
+
+ players[i].playerstate = P_ReadUINT8(save_p);
+ players[i].pflags = P_ReadUINT32(save_p);
+ players[i].panim = P_ReadUINT8(save_p);
+ players[i].stronganim = P_ReadUINT8(save_p);
+ players[i].spectator = P_ReadUINT8(save_p);
+ players[i].muted = P_ReadUINT8(save_p);
+
+ players[i].flashpal = P_ReadUINT16(save_p);
+ players[i].flashcount = P_ReadUINT16(save_p);
+
+ players[i].skincolor = P_ReadUINT16(save_p);
+ players[i].skin = P_ReadINT32(save_p);
+ players[i].availabilities = P_ReadUINT32(save_p);
+ players[i].score = P_ReadUINT32(save_p);
+ players[i].recordscore = P_ReadUINT32(save_p);
+ players[i].dashspeed = P_ReadFixed(save_p); // dashing speed
+ players[i].lives = P_ReadSINT8(save_p);
+ players[i].continues = P_ReadSINT8(save_p); // continues that player has acquired
+ players[i].xtralife = P_ReadSINT8(save_p); // Ring Extra Life counter
+ players[i].gotcontinue = P_ReadUINT8(save_p); // got continue from stage
+ players[i].speed = P_ReadFixed(save_p); // Player's speed (distance formula of MOMX and MOMY values)
+ players[i].secondjump = P_ReadUINT8(save_p);
+ players[i].fly1 = P_ReadUINT8(save_p); // Tails flying
+ players[i].scoreadd = P_ReadUINT8(save_p); // Used for multiple enemy attack bonus
+ players[i].glidetime = P_ReadUINT32(save_p); // Glide counter for thrust
+ players[i].climbing = P_ReadUINT8(save_p); // Climbing on the wall
+ players[i].deadtimer = P_ReadINT32(save_p); // End game if game over lasts too long
+ players[i].exiting = P_ReadUINT32(save_p); // Exitlevel timer
+ players[i].homing = P_ReadUINT8(save_p); // Are you homing?
+ players[i].dashmode = P_ReadUINT32(save_p); // counter for dashmode ability
+ players[i].skidtime = P_ReadUINT32(save_p); // Skid timer
//////////
// Bots //
//////////
- players[i].bot = READUINT8(save_p);
+ players[i].bot = P_ReadUINT8(save_p);
- players[i].botmem.lastForward = READUINT8(save_p);
- players[i].botmem.lastBlocked = READUINT8(save_p);
- players[i].botmem.catchup_tics = READUINT8(save_p);
- players[i].botmem.thinkstate = READUINT8(save_p);
- players[i].removing = READUINT8(save_p);
+ players[i].botmem.lastForward = P_ReadUINT8(save_p);
+ players[i].botmem.lastBlocked = P_ReadUINT8(save_p);
+ players[i].botmem.catchup_tics = P_ReadUINT8(save_p);
+ players[i].botmem.thinkstate = P_ReadUINT8(save_p);
+ players[i].removing = P_ReadUINT8(save_p);
- players[i].blocked = READUINT8(save_p);
- players[i].lastbuttons = READUINT16(save_p);
+ players[i].blocked = P_ReadUINT8(save_p);
+ players[i].lastbuttons = P_ReadUINT16(save_p);
////////////////////////////
// Conveyor Belt Movement //
////////////////////////////
- players[i].cmomx = READFIXED(save_p); // Conveyor momx
- players[i].cmomy = READFIXED(save_p); // Conveyor momy
- players[i].rmomx = READFIXED(save_p); // "Real" momx (momx - cmomx)
- players[i].rmomy = READFIXED(save_p); // "Real" momy (momy - cmomy)
+ players[i].cmomx = P_ReadFixed(save_p); // Conveyor momx
+ players[i].cmomy = P_ReadFixed(save_p); // Conveyor momy
+ players[i].rmomx = P_ReadFixed(save_p); // "Real" momx (momx - cmomx)
+ players[i].rmomy = P_ReadFixed(save_p); // "Real" momy (momy - cmomy)
/////////////////////
// Race Mode Stuff //
/////////////////////
- players[i].numboxes = READINT16(save_p); // Number of item boxes obtained for Race Mode
- players[i].totalring = READINT16(save_p); // Total number of rings obtained for Race Mode
- players[i].realtime = READUINT32(save_p); // integer replacement for leveltime
- players[i].laps = READUINT8(save_p); // Number of laps (optional)
+ players[i].numboxes = P_ReadINT16(save_p); // Number of item boxes obtained for Race Mode
+ players[i].totalring = P_ReadINT16(save_p); // Total number of rings obtained for Race Mode
+ players[i].realtime = P_ReadUINT32(save_p); // integer replacement for leveltime
+ players[i].laps = P_ReadUINT8(save_p); // Number of laps (optional)
////////////////////
// CTF Mode Stuff //
////////////////////
- players[i].ctfteam = READINT32(save_p); // 1 == Red, 2 == Blue
- players[i].gotflag = READUINT16(save_p); // 1 == Red, 2 == Blue Do you have the flag?
-
- players[i].weapondelay = READINT32(save_p);
- players[i].tossdelay = READINT32(save_p);
-
- players[i].starposttime = READUINT32(save_p);
- players[i].starpostx = READINT16(save_p);
- players[i].starposty = READINT16(save_p);
- players[i].starpostz = READINT16(save_p);
- players[i].starpostnum = READINT32(save_p);
- players[i].starpostangle = READANGLE(save_p);
- players[i].starpostscale = READFIXED(save_p);
-
- players[i].angle_pos = READANGLE(save_p);
- players[i].old_angle_pos = READANGLE(save_p);
-
- players[i].flyangle = READINT32(save_p);
- players[i].drilltimer = READUINT32(save_p);
- players[i].linkcount = READINT32(save_p);
- players[i].linktimer = READUINT32(save_p);
- players[i].anotherflyangle = READINT32(save_p);
- players[i].nightstime = READUINT32(save_p);
- players[i].bumpertime = READUINT32(save_p);
- players[i].drillmeter = READINT32(save_p);
- players[i].drilldelay = READUINT8(save_p);
- players[i].bonustime = (boolean)READUINT8(save_p);
- players[i].oldscale = READFIXED(save_p);
- players[i].mare = READUINT8(save_p);
- players[i].marelap = READUINT8(save_p);
- players[i].marebonuslap = READUINT8(save_p);
- players[i].marebegunat = READUINT32(save_p);
- players[i].lastmaretime = READUINT32(save_p);
- players[i].startedtime = READUINT32(save_p);
- players[i].finishedtime = READUINT32(save_p);
- players[i].lapbegunat = READUINT32(save_p);
- players[i].lapstartedtime = READUINT32(save_p);
- players[i].finishedspheres = READINT16(save_p);
- players[i].finishedrings = READINT16(save_p);
- players[i].marescore = READUINT32(save_p);
- players[i].lastmarescore = READUINT32(save_p);
- players[i].totalmarescore = READUINT32(save_p);
- players[i].lastmare = READUINT8(save_p);
- players[i].lastmarelap = READUINT8(save_p);
- players[i].lastmarebonuslap = READUINT8(save_p);
- players[i].totalmarelap = READUINT8(save_p);
- players[i].totalmarebonuslap = READUINT8(save_p);
- players[i].maxlink = READINT32(save_p);
- players[i].texttimer = READUINT8(save_p);
- players[i].textvar = READUINT8(save_p);
-
- players[i].lastsidehit = READINT16(save_p);
- players[i].lastlinehit = READINT16(save_p);
-
- players[i].losstime = READUINT32(save_p);
-
- players[i].timeshit = READUINT8(save_p);
-
- players[i].onconveyor = READINT32(save_p);
-
- players[i].jointime = READUINT32(save_p);
- players[i].quittime = READUINT32(save_p);
-
- flags = READUINT16(save_p);
+ players[i].ctfteam = P_ReadINT32(save_p); // 1 == Red, 2 == Blue
+ players[i].gotflag = P_ReadUINT16(save_p); // 1 == Red, 2 == Blue Do you have the flag?
+
+ players[i].weapondelay = P_ReadINT32(save_p);
+ players[i].tossdelay = P_ReadINT32(save_p);
+
+ players[i].starposttime = P_ReadUINT32(save_p);
+ players[i].starpostx = P_ReadINT16(save_p);
+ players[i].starposty = P_ReadINT16(save_p);
+ players[i].starpostz = P_ReadINT16(save_p);
+ players[i].starpostnum = P_ReadINT32(save_p);
+ players[i].starpostangle = P_ReadAngle(save_p);
+ players[i].starpostscale = P_ReadFixed(save_p);
+
+ players[i].angle_pos = P_ReadAngle(save_p);
+ players[i].old_angle_pos = P_ReadAngle(save_p);
+
+ players[i].flyangle = P_ReadINT32(save_p);
+ players[i].drilltimer = P_ReadUINT32(save_p);
+ players[i].linkcount = P_ReadINT32(save_p);
+ players[i].linktimer = P_ReadUINT32(save_p);
+ players[i].anotherflyangle = P_ReadINT32(save_p);
+ players[i].nightstime = P_ReadUINT32(save_p);
+ players[i].bumpertime = P_ReadUINT32(save_p);
+ players[i].drillmeter = P_ReadINT32(save_p);
+ players[i].drilldelay = P_ReadUINT8(save_p);
+ players[i].bonustime = (boolean)P_ReadUINT8(save_p);
+ players[i].oldscale = P_ReadFixed(save_p);
+ players[i].mare = P_ReadUINT8(save_p);
+ players[i].marelap = P_ReadUINT8(save_p);
+ players[i].marebonuslap = P_ReadUINT8(save_p);
+ players[i].marebegunat = P_ReadUINT32(save_p);
+ players[i].lastmaretime = P_ReadUINT32(save_p);
+ players[i].startedtime = P_ReadUINT32(save_p);
+ players[i].finishedtime = P_ReadUINT32(save_p);
+ players[i].lapbegunat = P_ReadUINT32(save_p);
+ players[i].lapstartedtime = P_ReadUINT32(save_p);
+ players[i].finishedspheres = P_ReadINT16(save_p);
+ players[i].finishedrings = P_ReadINT16(save_p);
+ players[i].marescore = P_ReadUINT32(save_p);
+ players[i].lastmarescore = P_ReadUINT32(save_p);
+ players[i].totalmarescore = P_ReadUINT32(save_p);
+ players[i].lastmare = P_ReadUINT8(save_p);
+ players[i].lastmarelap = P_ReadUINT8(save_p);
+ players[i].lastmarebonuslap = P_ReadUINT8(save_p);
+ players[i].totalmarelap = P_ReadUINT8(save_p);
+ players[i].totalmarebonuslap = P_ReadUINT8(save_p);
+ players[i].maxlink = P_ReadINT32(save_p);
+ players[i].texttimer = P_ReadUINT8(save_p);
+ players[i].textvar = P_ReadUINT8(save_p);
+
+ players[i].lastsidehit = P_ReadINT16(save_p);
+ players[i].lastlinehit = P_ReadINT16(save_p);
+
+ players[i].losstime = P_ReadUINT32(save_p);
+
+ players[i].timeshit = P_ReadUINT8(save_p);
+
+ players[i].onconveyor = P_ReadINT32(save_p);
+
+ players[i].jointime = P_ReadUINT32(save_p);
+ players[i].quittime = P_ReadUINT32(save_p);
+
+ flags = P_ReadUINT16(save_p);
if (flags & CAPSULE)
- players[i].capsule = (mobj_t *)(size_t)READUINT32(save_p);
+ players[i].capsule = (mobj_t *)(size_t)P_ReadUINT32(save_p);
if (flags & FIRSTAXIS)
- players[i].axis1 = (mobj_t *)(size_t)READUINT32(save_p);
+ players[i].axis1 = (mobj_t *)(size_t)P_ReadUINT32(save_p);
if (flags & SECONDAXIS)
- players[i].axis2 = (mobj_t *)(size_t)READUINT32(save_p);
+ players[i].axis2 = (mobj_t *)(size_t)P_ReadUINT32(save_p);
if (flags & AWAYVIEW)
- players[i].awayviewmobj = (mobj_t *)(size_t)READUINT32(save_p);
+ players[i].awayviewmobj = (mobj_t *)(size_t)P_ReadUINT32(save_p);
if (flags & FOLLOW)
- players[i].followmobj = (mobj_t *)(size_t)READUINT32(save_p);
+ players[i].followmobj = (mobj_t *)(size_t)P_ReadUINT32(save_p);
if (flags & DRONE)
- players[i].drone = (mobj_t *)(size_t)READUINT32(save_p);
+ players[i].drone = (mobj_t *)(size_t)P_ReadUINT32(save_p);
- players[i].camerascale = READFIXED(save_p);
- players[i].shieldscale = READFIXED(save_p);
+ players[i].camerascale = P_ReadFixed(save_p);
+ players[i].shieldscale = P_ReadFixed(save_p);
//SetPlayerSkinByNum(i, players[i].skin);
- players[i].charability = READUINT8(save_p);
- players[i].charability2 = READUINT8(save_p);
- players[i].charflags = READUINT32(save_p);
- players[i].thokitem = (mobjtype_t)READUINT32(save_p);
- players[i].spinitem = (mobjtype_t)READUINT32(save_p);
- players[i].revitem = (mobjtype_t)READUINT32(save_p);
- players[i].followitem = (mobjtype_t)READUINT32(save_p);
- players[i].actionspd = READFIXED(save_p);
- players[i].mindash = READFIXED(save_p);
- players[i].maxdash = READFIXED(save_p);
- players[i].normalspeed = READFIXED(save_p);
- players[i].runspeed = READFIXED(save_p);
- players[i].thrustfactor = READUINT8(save_p);
- players[i].accelstart = READUINT8(save_p);
- players[i].acceleration = READUINT8(save_p);
- players[i].jumpfactor = READFIXED(save_p);
- players[i].height = READFIXED(save_p);
- players[i].spinheight = READFIXED(save_p);
+ players[i].charability = P_ReadUINT8(save_p);
+ players[i].charability2 = P_ReadUINT8(save_p);
+ players[i].charflags = P_ReadUINT32(save_p);
+ players[i].thokitem = P_ReadUINT32(save_p);
+ players[i].spinitem = P_ReadUINT32(save_p);
+ players[i].revitem = P_ReadUINT32(save_p);
+ players[i].followitem = P_ReadUINT32(save_p);
+ players[i].actionspd = P_ReadFixed(save_p);
+ players[i].mindash = P_ReadFixed(save_p);
+ players[i].maxdash = P_ReadFixed(save_p);
+ players[i].normalspeed = P_ReadFixed(save_p);
+ players[i].runspeed = P_ReadFixed(save_p);
+ players[i].thrustfactor = P_ReadUINT8(save_p);
+ players[i].accelstart = P_ReadUINT8(save_p);
+ players[i].acceleration = P_ReadUINT8(save_p);
+ players[i].jumpfactor = P_ReadFixed(save_p);
+ players[i].height = P_ReadFixed(save_p);
+ players[i].spinheight = P_ReadFixed(save_p);
players[i].viewheight = 41*players[i].height/48; // scale cannot be factored in at this point
}
@@ -668,12 +908,12 @@ static void ClearNetColormaps(void)
net_colormaps = NULL;
}
-static void P_NetArchiveColormaps(void)
+static void P_NetArchiveColormaps(save_t *save_p)
{
// We save and then we clean up our colormap mess
extracolormap_t *exc, *exc_next;
UINT32 i = 0;
- WRITEUINT32(save_p, num_net_colormaps); // save for safety
+ P_WriteUINT32(save_p, num_net_colormaps); // save for safety
for (exc = net_colormaps; i < num_net_colormaps; i++, exc = exc_next)
{
@@ -682,15 +922,15 @@ static void P_NetArchiveColormaps(void)
if (!exc)
exc = R_CreateDefaultColormap(false);
- WRITEUINT8(save_p, exc->fadestart);
- WRITEUINT8(save_p, exc->fadeend);
- WRITEUINT8(save_p, exc->flags);
+ P_WriteUINT8(save_p, exc->fadestart);
+ P_WriteUINT8(save_p, exc->fadeend);
+ P_WriteUINT8(save_p, exc->flags);
- WRITEINT32(save_p, exc->rgba);
- WRITEINT32(save_p, exc->fadergba);
+ P_WriteINT32(save_p, exc->rgba);
+ P_WriteINT32(save_p, exc->fadergba);
#ifdef EXTRACOLORMAPLUMPS
- WRITESTRINGN(save_p, exc->lumpname, 9);
+ P_WriteStringN(save_p, exc->lumpname, 9);
#endif
exc_next = exc->next;
@@ -702,7 +942,7 @@ static void P_NetArchiveColormaps(void)
net_colormaps = NULL;
}
-static void P_NetUnArchiveColormaps(void)
+static void P_NetUnArchiveColormaps(save_t *save_p)
{
// When we reach this point, we already populated our list with
// dummy colormaps. Now that we are loading the color data,
@@ -710,7 +950,7 @@ static void P_NetUnArchiveColormaps(void)
extracolormap_t *exc, *existing_exc, *exc_next = NULL;
UINT32 i = 0;
- num_net_colormaps = READUINT32(save_p);
+ num_net_colormaps = P_ReadUINT32(save_p);
for (exc = net_colormaps; i < num_net_colormaps; i++, exc = exc_next)
{
@@ -720,15 +960,15 @@ static void P_NetUnArchiveColormaps(void)
char lumpname[9];
#endif
- fadestart = READUINT8(save_p);
- fadeend = READUINT8(save_p);
- flags = READUINT8(save_p);
+ fadestart = P_ReadUINT8(save_p);
+ fadeend = P_ReadUINT8(save_p);
+ flags = P_ReadUINT8(save_p);
- rgba = READINT32(save_p);
- fadergba = READINT32(save_p);
+ rgba = P_ReadINT32(save_p);
+ fadergba = P_ReadINT32(save_p);
#ifdef EXTRACOLORMAPLUMPS
- READSTRINGN(save_p, lumpname, 9);
+ P_ReadStringN(save_p, lumpname, 9);
if (lumpname[0])
{
@@ -804,29 +1044,29 @@ static void P_NetUnArchiveColormaps(void)
net_colormaps = NULL;
}
-static void P_NetArchiveWaypoints(void)
+static void P_NetArchiveWaypoints(save_t *save_p)
{
INT32 i, j;
for (i = 0; i < NUMWAYPOINTSEQUENCES; i++)
{
- WRITEUINT16(save_p, numwaypoints[i]);
+ P_WriteUINT16(save_p, numwaypoints[i]);
for (j = 0; j < numwaypoints[i]; j++)
- WRITEUINT32(save_p, waypoints[i][j] ? waypoints[i][j]->mobjnum : 0);
+ P_WriteUINT32(save_p, waypoints[i][j] ? waypoints[i][j]->mobjnum : 0);
}
}
-static void P_NetUnArchiveWaypoints(void)
+static void P_NetUnArchiveWaypoints(save_t *save_p)
{
INT32 i, j;
UINT32 mobjnum;
for (i = 0; i < NUMWAYPOINTSEQUENCES; i++)
{
- numwaypoints[i] = READUINT16(save_p);
+ numwaypoints[i] = P_ReadUINT16(save_p);
for (j = 0; j < numwaypoints[i]; j++)
{
- mobjnum = READUINT32(save_p);
+ mobjnum = P_ReadUINT32(save_p);
waypoints[i][j] = (mobjnum == 0) ? NULL : P_FindNewPosition(mobjnum);
}
}
@@ -973,7 +1213,7 @@ static boolean CheckFFloorDiff(const sector_t *ss)
// Special case: save the stats of all modified ffloors along with their ffloor "number"s
// we don't bother with ffloors that haven't changed, that would just add to savegame even more than is really needed
-static void ArchiveFFloors(const sector_t *ss)
+static void ArchiveFFloors(save_t *save_p, const sector_t *ss)
{
size_t j = 0; // ss->ffloors is saved as ffloor #0, ss->ffloors->next is #1, etc
ffloor_t *rover;
@@ -988,19 +1228,19 @@ static void ArchiveFFloors(const sector_t *ss)
if (fflr_diff)
{
- WRITEUINT16(save_p, j); // save ffloor "number"
- WRITEUINT8(save_p, fflr_diff);
+ P_WriteUINT16(save_p, j); // save ffloor "number"
+ P_WriteUINT8(save_p, fflr_diff);
if (fflr_diff & FD_FLAGS)
- WRITEUINT32(save_p, rover->fofflags);
+ P_WriteUINT32(save_p, rover->fofflags);
if (fflr_diff & FD_ALPHA)
- WRITEINT16(save_p, rover->alpha);
+ P_WriteINT16(save_p, rover->alpha);
}
j++;
}
- WRITEUINT16(save_p, 0xffff);
+ P_WriteUINT16(save_p, 0xffff);
}
-static void UnArchiveFFloors(const sector_t *ss)
+static void UnArchiveFFloors(save_t *save_p, const sector_t *ss)
{
UINT16 j = 0; // number of current ffloor in loop
UINT16 fflr_i; // saved ffloor "number" of next modified ffloor
@@ -1011,7 +1251,7 @@ static void UnArchiveFFloors(const sector_t *ss)
if (!rover) // it is assumed sectors[i].ffloors actually exists, but just in case...
I_Error("Sector does not have any ffloors!");
- fflr_i = READUINT16(save_p); // get first modified ffloor's number ready
+ fflr_i = P_ReadUINT16(save_p); // get first modified ffloor's number ready
for (;;) // for some reason the usual for (rover = x; ...) thing doesn't work here?
{
if (fflr_i == 0xffff) // end of modified ffloors list, let's stop already
@@ -1026,21 +1266,21 @@ static void UnArchiveFFloors(const sector_t *ss)
continue;
}
- fflr_diff = READUINT8(save_p);
+ fflr_diff = P_ReadUINT8(save_p);
if (fflr_diff & FD_FLAGS)
- rover->fofflags = READUINT32(save_p);
+ rover->fofflags = P_ReadUINT32(save_p);
if (fflr_diff & FD_ALPHA)
- rover->alpha = READINT16(save_p);
+ rover->alpha = P_ReadINT16(save_p);
- fflr_i = READUINT16(save_p); // get next ffloor "number" ready
+ fflr_i = P_ReadUINT16(save_p); // get next ffloor "number" ready
j++;
rover = rover->next;
}
}
-static void ArchiveSectors(void)
+static void ArchiveSectors(save_t *save_p)
{
size_t i, j;
const sector_t *ss = sectors;
@@ -1134,102 +1374,102 @@ static void ArchiveSectors(void)
if (diff)
{
- WRITEUINT32(save_p, i);
- WRITEUINT8(save_p, diff);
+ P_WriteUINT32(save_p, i);
+ P_WriteUINT8(save_p, diff);
if (diff & SD_DIFF2)
- WRITEUINT8(save_p, diff2);
+ P_WriteUINT8(save_p, diff2);
if (diff2 & SD_DIFF3)
- WRITEUINT8(save_p, diff3);
+ P_WriteUINT8(save_p, diff3);
if (diff3 & SD_DIFF4)
- WRITEUINT8(save_p, diff4);
+ P_WriteUINT8(save_p, diff4);
if (diff4 & SD_DIFF5)
- WRITEUINT8(save_p, diff5);
+ P_WriteUINT8(save_p, diff5);
if (diff & SD_FLOORHT)
- WRITEFIXED(save_p, ss->floorheight);
+ P_WriteFixed(save_p, ss->floorheight);
if (diff & SD_CEILHT)
- WRITEFIXED(save_p, ss->ceilingheight);
+ P_WriteFixed(save_p, ss->ceilingheight);
if (diff & SD_FLOORPIC)
- WRITEMEM(save_p, levelflats[ss->floorpic].name, 8);
+ P_WriteMem(save_p, levelflats[ss->floorpic].name, 8);
if (diff & SD_CEILPIC)
- WRITEMEM(save_p, levelflats[ss->ceilingpic].name, 8);
+ P_WriteMem(save_p, levelflats[ss->ceilingpic].name, 8);
if (diff & SD_LIGHT)
- WRITEINT16(save_p, ss->lightlevel);
+ P_WriteINT16(save_p, ss->lightlevel);
if (diff & SD_SPECIAL)
- WRITEINT16(save_p, ss->special);
+ P_WriteINT16(save_p, ss->special);
if (diff2 & SD_FXOFFS)
- WRITEFIXED(save_p, ss->floorxoffset);
+ P_WriteFixed(save_p, ss->floorxoffset);
if (diff2 & SD_FYOFFS)
- WRITEFIXED(save_p, ss->flooryoffset);
+ P_WriteFixed(save_p, ss->flooryoffset);
if (diff2 & SD_CXOFFS)
- WRITEFIXED(save_p, ss->ceilingxoffset);
+ P_WriteFixed(save_p, ss->ceilingxoffset);
if (diff2 & SD_CYOFFS)
- WRITEFIXED(save_p, ss->ceilingyoffset);
+ P_WriteFixed(save_p, ss->ceilingyoffset);
if (diff2 & SD_FLOORANG)
- WRITEANGLE(save_p, ss->floorangle);
+ P_WriteAngle(save_p, ss->floorangle);
if (diff2 & SD_CEILANG)
- WRITEANGLE(save_p, ss->ceilingangle);
+ P_WriteAngle(save_p, ss->ceilingangle);
if (diff2 & SD_TAG)
{
- WRITEUINT32(save_p, ss->tags.count);
+ P_WriteUINT32(save_p, ss->tags.count);
for (j = 0; j < ss->tags.count; j++)
- WRITEINT16(save_p, ss->tags.tags[j]);
+ P_WriteINT16(save_p, ss->tags.tags[j]);
}
if (diff3 & SD_COLORMAP)
- WRITEUINT32(save_p, CheckAddNetColormapToList(ss->extra_colormap));
+ P_WriteUINT32(save_p, CheckAddNetColormapToList(ss->extra_colormap));
// returns existing index if already added, or appends to net_colormaps and returns new index
if (diff3 & SD_CRUMBLESTATE)
- WRITEINT32(save_p, ss->crumblestate);
+ P_WriteINT32(save_p, ss->crumblestate);
if (diff3 & SD_FLOORLIGHT)
{
- WRITEINT16(save_p, ss->floorlightlevel);
- WRITEUINT8(save_p, ss->floorlightabsolute);
+ P_WriteINT16(save_p, ss->floorlightlevel);
+ P_WriteUINT8(save_p, ss->floorlightabsolute);
}
if (diff3 & SD_CEILLIGHT)
{
- WRITEINT16(save_p, ss->ceilinglightlevel);
- WRITEUINT8(save_p, ss->ceilinglightabsolute);
+ P_WriteINT16(save_p, ss->ceilinglightlevel);
+ P_WriteUINT8(save_p, ss->ceilinglightabsolute);
}
if (diff3 & SD_FLAG)
- WRITEUINT32(save_p, ss->flags);
+ P_WriteUINT32(save_p, ss->flags);
if (diff3 & SD_SPECIALFLAG)
- WRITEUINT32(save_p, ss->specialflags);
+ P_WriteUINT32(save_p, ss->specialflags);
if (diff4 & SD_DAMAGETYPE)
- WRITEUINT8(save_p, ss->damagetype);
+ P_WriteUINT8(save_p, ss->damagetype);
if (diff4 & SD_TRIGGERTAG)
- WRITEINT16(save_p, ss->triggertag);
+ P_WriteINT16(save_p, ss->triggertag);
if (diff4 & SD_TRIGGERER)
- WRITEUINT8(save_p, ss->triggerer);
+ P_WriteUINT8(save_p, ss->triggerer);
if (diff4 & SD_FXSCALE)
- WRITEFIXED(save_p, ss->floorxscale);
+ P_WriteFixed(save_p, ss->floorxscale);
if (diff4 & SD_FYSCALE)
- WRITEFIXED(save_p, ss->flooryscale);
+ P_WriteFixed(save_p, ss->flooryscale);
if (diff4 & SD_CXSCALE)
- WRITEFIXED(save_p, ss->ceilingxscale);
+ P_WriteFixed(save_p, ss->ceilingxscale);
if (diff4 & SD_CYSCALE)
- WRITEFIXED(save_p, ss->ceilingyscale);
+ P_WriteFixed(save_p, ss->ceilingyscale);
if (diff5 & SD_GRAVITY)
- WRITEFIXED(save_p, ss->gravity);
+ P_WriteFixed(save_p, ss->gravity);
if (diff5 & SD_FLOORPORTAL)
- WRITEUINT32(save_p, ss->portal_floor);
+ P_WriteUINT32(save_p, ss->portal_floor);
if (diff5 & SD_CEILPORTAL)
- WRITEUINT32(save_p, ss->portal_ceiling);
+ P_WriteUINT32(save_p, ss->portal_ceiling);
if (diff & SD_FFLOORS)
- ArchiveFFloors(ss);
+ ArchiveFFloors(save_p, ss);
}
}
- WRITEUINT32(save_p, 0xffffffff);
+ P_WriteUINT32(save_p, 0xffffffff);
}
-static void UnArchiveSectors(void)
+static void UnArchiveSectors(save_t *save_p)
{
UINT32 i;
UINT16 j;
UINT8 diff, diff2, diff3, diff4, diff5;
for (;;)
{
- i = READUINT32(save_p);
+ i = P_ReadUINT32(save_p);
if (i == 0xffffffff)
break;
@@ -1237,58 +1477,58 @@ static void UnArchiveSectors(void)
if (i > numsectors)
I_Error("Invalid sector number %u from server (expected end at %s)", i, sizeu1(numsectors));
- diff = READUINT8(save_p);
+ diff = P_ReadUINT8(save_p);
if (diff & SD_DIFF2)
- diff2 = READUINT8(save_p);
+ diff2 = P_ReadUINT8(save_p);
else
diff2 = 0;
if (diff2 & SD_DIFF3)
- diff3 = READUINT8(save_p);
+ diff3 = P_ReadUINT8(save_p);
else
diff3 = 0;
if (diff3 & SD_DIFF4)
- diff4 = READUINT8(save_p);
+ diff4 = P_ReadUINT8(save_p);
else
diff4 = 0;
if (diff4 & SD_DIFF5)
- diff5 = READUINT8(save_p);
+ diff5 = P_ReadUINT8(save_p);
else
diff5 = 0;
if (diff & SD_FLOORHT)
- sectors[i].floorheight = READFIXED(save_p);
+ sectors[i].floorheight = P_ReadFixed(save_p);
if (diff & SD_CEILHT)
- sectors[i].ceilingheight = READFIXED(save_p);
+ sectors[i].ceilingheight = P_ReadFixed(save_p);
if (diff & SD_FLOORPIC)
{
- sectors[i].floorpic = P_AddLevelFlatRuntime((char *)save_p);
- save_p += 8;
+ sectors[i].floorpic = P_AddLevelFlatRuntime((char *)&save_p->buf[save_p->pos]);
+ save_p->pos += 8;
}
if (diff & SD_CEILPIC)
{
- sectors[i].ceilingpic = P_AddLevelFlatRuntime((char *)save_p);
- save_p += 8;
+ sectors[i].ceilingpic = P_AddLevelFlatRuntime((char *)&save_p->buf[save_p->pos]);
+ save_p->pos += 8;
}
if (diff & SD_LIGHT)
- sectors[i].lightlevel = READINT16(save_p);
+ sectors[i].lightlevel = P_ReadINT16(save_p);
if (diff & SD_SPECIAL)
- sectors[i].special = READINT16(save_p);
+ sectors[i].special = P_ReadINT16(save_p);
if (diff2 & SD_FXOFFS)
- sectors[i].floorxoffset = READFIXED(save_p);
+ sectors[i].floorxoffset = P_ReadFixed(save_p);
if (diff2 & SD_FYOFFS)
- sectors[i].flooryoffset = READFIXED(save_p);
+ sectors[i].flooryoffset = P_ReadFixed(save_p);
if (diff2 & SD_CXOFFS)
- sectors[i].ceilingxoffset = READFIXED(save_p);
+ sectors[i].ceilingxoffset = P_ReadFixed(save_p);
if (diff2 & SD_CYOFFS)
- sectors[i].ceilingyoffset = READFIXED(save_p);
+ sectors[i].ceilingyoffset = P_ReadFixed(save_p);
if (diff2 & SD_FLOORANG)
- sectors[i].floorangle = READANGLE(save_p);
+ sectors[i].floorangle = P_ReadAngle(save_p);
if (diff2 & SD_CEILANG)
- sectors[i].ceilingangle = READANGLE(save_p);
+ sectors[i].ceilingangle = P_ReadAngle(save_p);
if (diff2 & SD_TAG)
{
- size_t ncount = READUINT32(save_p);
+ size_t ncount = P_ReadUINT32(save_p);
// Remove entries from global lists.
for (j = 0; j < sectors[i].tags.count; j++)
@@ -1302,7 +1542,7 @@ static void UnArchiveSectors(void)
}
for (j = 0; j < ncount; j++)
- sectors[i].tags.tags[j] = READINT16(save_p);
+ sectors[i].tags.tags[j] = P_ReadINT16(save_p);
// Add new entries.
for (j = 0; j < sectors[i].tags.count; j++)
@@ -1311,49 +1551,49 @@ static void UnArchiveSectors(void)
if (diff3 & SD_COLORMAP)
- sectors[i].extra_colormap = GetNetColormapFromList(READUINT32(save_p));
+ sectors[i].extra_colormap = GetNetColormapFromList(P_ReadUINT32(save_p));
if (diff3 & SD_CRUMBLESTATE)
- sectors[i].crumblestate = READINT32(save_p);
+ sectors[i].crumblestate = P_ReadINT32(save_p);
if (diff3 & SD_FLOORLIGHT)
{
- sectors[i].floorlightlevel = READINT16(save_p);
- sectors[i].floorlightabsolute = READUINT8(save_p);
+ sectors[i].floorlightlevel = P_ReadINT16(save_p);
+ sectors[i].floorlightabsolute = P_ReadUINT8(save_p);
}
if (diff3 & SD_CEILLIGHT)
{
- sectors[i].ceilinglightlevel = READINT16(save_p);
- sectors[i].ceilinglightabsolute = READUINT8(save_p);
+ sectors[i].ceilinglightlevel = P_ReadINT16(save_p);
+ sectors[i].ceilinglightabsolute = P_ReadUINT8(save_p);
}
if (diff3 & SD_FLAG)
{
- sectors[i].flags = READUINT32(save_p);
+ sectors[i].flags = P_ReadUINT32(save_p);
CheckForReverseGravity |= (sectors[i].flags & MSF_GRAVITYFLIP);
}
if (diff3 & SD_SPECIALFLAG)
- sectors[i].specialflags = READUINT32(save_p);
+ sectors[i].specialflags = P_ReadUINT32(save_p);
if (diff4 & SD_DAMAGETYPE)
- sectors[i].damagetype = READUINT8(save_p);
+ sectors[i].damagetype = P_ReadUINT8(save_p);
if (diff4 & SD_TRIGGERTAG)
- sectors[i].triggertag = READINT16(save_p);
+ sectors[i].triggertag = P_ReadINT16(save_p);
if (diff4 & SD_TRIGGERER)
- sectors[i].triggerer = READUINT8(save_p);
+ sectors[i].triggerer = P_ReadUINT8(save_p);
if (diff4 & SD_FXSCALE)
- sectors[i].floorxscale = READFIXED(save_p);
+ sectors[i].floorxscale = P_ReadFixed(save_p);
if (diff4 & SD_FYSCALE)
- sectors[i].flooryscale = READFIXED(save_p);
+ sectors[i].flooryscale = P_ReadFixed(save_p);
if (diff4 & SD_CXSCALE)
- sectors[i].ceilingxscale = READFIXED(save_p);
+ sectors[i].ceilingxscale = P_ReadFixed(save_p);
if (diff4 & SD_CYSCALE)
- sectors[i].ceilingyscale = READFIXED(save_p);
+ sectors[i].ceilingyscale = P_ReadFixed(save_p);
if (diff5 & SD_GRAVITY)
- sectors[i].gravity = READFIXED(save_p);
+ sectors[i].gravity = P_ReadFixed(save_p);
if (diff5 & SD_FLOORPORTAL)
- sectors[i].portal_floor = READUINT32(save_p);
+ sectors[i].portal_floor = P_ReadUINT32(save_p);
if (diff5 & SD_CEILPORTAL)
- sectors[i].portal_ceiling = READUINT32(save_p);
+ sectors[i].portal_ceiling = P_ReadUINT32(save_p);
if (diff & SD_FFLOORS)
- UnArchiveFFloors(§ors[i]);
+ UnArchiveFFloors(save_p, §ors[i]);
}
}
@@ -1416,65 +1656,65 @@ static UINT32 GetSideDiff(const side_t *si, const side_t *spawnsi)
return diff;
}
-static void ArchiveSide(const side_t *si, UINT32 diff)
+static void ArchiveSide(save_t *save_p, const side_t *si, UINT32 diff)
{
- WRITEUINT32(save_p, diff);
+ P_WriteUINT32(save_p, diff);
if (diff & LD_SDTEXOFFX)
- WRITEFIXED(save_p, si->textureoffset);
+ P_WriteFixed(save_p, si->textureoffset);
if (diff & LD_SDTEXOFFY)
- WRITEFIXED(save_p, si->rowoffset);
+ P_WriteFixed(save_p, si->rowoffset);
if (diff & LD_SDTOPTEX)
- WRITEINT32(save_p, si->toptexture);
+ P_WriteINT32(save_p, si->toptexture);
if (diff & LD_SDBOTTEX)
- WRITEINT32(save_p, si->bottomtexture);
+ P_WriteINT32(save_p, si->bottomtexture);
if (diff & LD_SDMIDTEX)
- WRITEINT32(save_p, si->midtexture);
+ P_WriteINT32(save_p, si->midtexture);
if (diff & LD_SDTOPOFFX)
- WRITEFIXED(save_p, si->offsetx_top);
+ P_WriteFixed(save_p, si->offsetx_top);
if (diff & LD_SDMIDOFFX)
- WRITEFIXED(save_p, si->offsetx_mid);
+ P_WriteFixed(save_p, si->offsetx_mid);
if (diff & LD_SDBOTOFFX)
- WRITEFIXED(save_p, si->offsetx_bottom);
+ P_WriteFixed(save_p, si->offsetx_bottom);
if (diff & LD_SDTOPOFFY)
- WRITEFIXED(save_p, si->offsety_top);
+ P_WriteFixed(save_p, si->offsety_top);
if (diff & LD_SDMIDOFFY)
- WRITEFIXED(save_p, si->offsety_mid);
+ P_WriteFixed(save_p, si->offsety_mid);
if (diff & LD_SDBOTOFFY)
- WRITEFIXED(save_p, si->offsety_bottom);
+ P_WriteFixed(save_p, si->offsety_bottom);
if (diff & LD_SDTOPSCALEX)
- WRITEFIXED(save_p, si->scalex_top);
+ P_WriteFixed(save_p, si->scalex_top);
if (diff & LD_SDMIDSCALEX)
- WRITEFIXED(save_p, si->scalex_mid);
+ P_WriteFixed(save_p, si->scalex_mid);
if (diff & LD_SDBOTSCALEX)
- WRITEFIXED(save_p, si->scalex_bottom);
+ P_WriteFixed(save_p, si->scalex_bottom);
if (diff & LD_SDTOPSCALEY)
- WRITEFIXED(save_p, si->scaley_top);
+ P_WriteFixed(save_p, si->scaley_top);
if (diff & LD_SDMIDSCALEY)
- WRITEFIXED(save_p, si->scaley_mid);
+ P_WriteFixed(save_p, si->scaley_mid);
if (diff & LD_SDBOTSCALEY)
- WRITEFIXED(save_p, si->scaley_bottom);
+ P_WriteFixed(save_p, si->scaley_bottom);
if (diff & LD_SDREPEATCNT)
- WRITEINT16(save_p, si->repeatcnt);
+ P_WriteINT16(save_p, si->repeatcnt);
if (diff & LD_SDLIGHT)
- WRITEINT16(save_p, si->light);
+ P_WriteINT16(save_p, si->light);
if (diff & LD_SDTOPLIGHT)
- WRITEINT16(save_p, si->light_top);
+ P_WriteINT16(save_p, si->light_top);
if (diff & LD_SDMIDLIGHT)
- WRITEINT16(save_p, si->light_mid);
+ P_WriteINT16(save_p, si->light_mid);
if (diff & LD_SDBOTLIGHT)
- WRITEINT16(save_p, si->light_bottom);
+ P_WriteINT16(save_p, si->light_bottom);
if (diff & LD_SDLIGHTABS)
- WRITEUINT8(save_p, si->lightabsolute);
+ P_WriteUINT8(save_p, si->lightabsolute);
if (diff & LD_SDTOPLIGHTABS)
- WRITEUINT8(save_p, si->lightabsolute_top);
+ P_WriteUINT8(save_p, si->lightabsolute_top);
if (diff & LD_SDMIDLIGHTABS)
- WRITEUINT8(save_p, si->lightabsolute_mid);
+ P_WriteUINT8(save_p, si->lightabsolute_mid);
if (diff & LD_SDBOTLIGHTABS)
- WRITEUINT8(save_p, si->lightabsolute_bottom);
+ P_WriteUINT8(save_p, si->lightabsolute_bottom);
}
-static void ArchiveLines(void)
+static void ArchiveLines(save_t *save_p)
{
size_t i;
const line_t *li = lines;
@@ -1524,21 +1764,21 @@ static void ArchiveLines(void)
if (diff)
{
- WRITEUINT32(save_p, i);
- WRITEUINT8(save_p, diff);
+ P_WriteUINT32(save_p, i);
+ P_WriteUINT8(save_p, diff);
if (diff & LD_DIFF2)
- WRITEUINT8(save_p, diff2);
+ P_WriteUINT8(save_p, diff2);
if (diff & LD_FLAG)
- WRITEINT16(save_p, li->flags);
+ P_WriteINT16(save_p, li->flags);
if (diff & LD_SPECIAL)
- WRITEINT16(save_p, li->special);
+ P_WriteINT16(save_p, li->special);
if (diff & LD_CLLCOUNT)
- WRITEINT16(save_p, li->callcount);
+ P_WriteINT16(save_p, li->callcount);
if (diff & LD_ARGS)
{
UINT8 j;
for (j = 0; j < NUMLINEARGS; j++)
- WRITEINT32(save_p, li->args[j]);
+ P_WriteINT32(save_p, li->args[j]);
}
if (diff & LD_STRINGARGS)
{
@@ -1549,88 +1789,88 @@ static void ArchiveLines(void)
if (!li->stringargs[j])
{
- WRITEINT32(save_p, 0);
+ P_WriteINT32(save_p, 0);
continue;
}
len = strlen(li->stringargs[j]);
- WRITEINT32(save_p, len);
+ P_WriteINT32(save_p, len);
for (k = 0; k < len; k++)
- WRITECHAR(save_p, li->stringargs[j][k]);
+ P_WriteChar(save_p, li->stringargs[j][k]);
}
}
if (diff & LD_SIDE1)
- ArchiveSide(&sides[li->sidenum[0]], side1diff);
+ ArchiveSide(save_p, &sides[li->sidenum[0]], side1diff);
if (diff & LD_SIDE2)
- ArchiveSide(&sides[li->sidenum[1]], side2diff);
+ ArchiveSide(save_p, &sides[li->sidenum[1]], side2diff);
if (diff2 & LD_EXECUTORDELAY)
- WRITEINT32(save_p, li->executordelay);
+ P_WriteINT32(save_p, li->executordelay);
if (diff2 & LD_TRANSFPORTAL)
- WRITEUINT32(save_p, li->secportal);
+ P_WriteUINT32(save_p, li->secportal);
}
}
- WRITEUINT32(save_p, 0xffffffff);
+ P_WriteUINT32(save_p, 0xffffffff);
}
-static void UnArchiveSide(side_t *si)
+static void UnArchiveSide(save_t *save_p, side_t *si)
{
- UINT32 diff = READUINT32(save_p);
+ UINT32 diff = P_ReadUINT32(save_p);
if (diff & LD_SDTEXOFFX)
- si->textureoffset = READFIXED(save_p);
+ si->textureoffset = P_ReadFixed(save_p);
if (diff & LD_SDTEXOFFY)
- si->rowoffset = READFIXED(save_p);
+ si->rowoffset = P_ReadFixed(save_p);
if (diff & LD_SDTOPTEX)
- si->toptexture = READINT32(save_p);
+ si->toptexture = P_ReadINT32(save_p);
if (diff & LD_SDBOTTEX)
- si->bottomtexture = READINT32(save_p);
+ si->bottomtexture = P_ReadINT32(save_p);
if (diff & LD_SDMIDTEX)
- si->midtexture = READINT32(save_p);
+ si->midtexture = P_ReadINT32(save_p);
if (diff & LD_SDTOPOFFX)
- si->offsetx_top = READFIXED(save_p);
+ si->offsetx_top = P_ReadFixed(save_p);
if (diff & LD_SDMIDOFFX)
- si->offsetx_mid = READFIXED(save_p);
+ si->offsetx_mid = P_ReadFixed(save_p);
if (diff & LD_SDBOTOFFX)
- si->offsetx_bottom = READFIXED(save_p);
+ si->offsetx_bottom = P_ReadFixed(save_p);
if (diff & LD_SDTOPOFFY)
- si->offsety_top = READFIXED(save_p);
+ si->offsety_top = P_ReadFixed(save_p);
if (diff & LD_SDMIDOFFY)
- si->offsety_mid = READFIXED(save_p);
+ si->offsety_mid = P_ReadFixed(save_p);
if (diff & LD_SDBOTOFFY)
- si->offsety_bottom = READFIXED(save_p);
+ si->offsety_bottom = P_ReadFixed(save_p);
if (diff & LD_SDTOPSCALEX)
- si->scalex_top = READFIXED(save_p);
+ si->scalex_top = P_ReadFixed(save_p);
if (diff & LD_SDMIDSCALEX)
- si->scalex_mid = READFIXED(save_p);
+ si->scalex_mid = P_ReadFixed(save_p);
if (diff & LD_SDBOTSCALEX)
- si->scalex_bottom = READFIXED(save_p);
+ si->scalex_bottom = P_ReadFixed(save_p);
if (diff & LD_SDTOPSCALEY)
- si->scaley_top = READFIXED(save_p);
+ si->scaley_top = P_ReadFixed(save_p);
if (diff & LD_SDMIDSCALEY)
- si->scaley_mid = READFIXED(save_p);
+ si->scaley_mid = P_ReadFixed(save_p);
if (diff & LD_SDBOTSCALEY)
- si->scaley_bottom = READFIXED(save_p);
+ si->scaley_bottom = P_ReadFixed(save_p);
if (diff & LD_SDREPEATCNT)
- si->repeatcnt = READINT16(save_p);
+ si->repeatcnt = P_ReadINT16(save_p);
if (diff & LD_SDLIGHT)
- si->light = READINT16(save_p);
+ si->light = P_ReadINT16(save_p);
if (diff & LD_SDTOPLIGHT)
- si->light_top = READINT16(save_p);
+ si->light_top = P_ReadINT16(save_p);
if (diff & LD_SDMIDLIGHT)
- si->light_mid = READINT16(save_p);
+ si->light_mid = P_ReadINT16(save_p);
if (diff & LD_SDBOTLIGHT)
- si->light_bottom = READINT16(save_p);
+ si->light_bottom = P_ReadINT16(save_p);
if (diff & LD_SDLIGHTABS)
- si->lightabsolute = READUINT8(save_p);
+ si->lightabsolute = P_ReadUINT8(save_p);
if (diff & LD_SDTOPLIGHTABS)
- si->lightabsolute_top = READUINT8(save_p);
+ si->lightabsolute_top = P_ReadUINT8(save_p);
if (diff & LD_SDMIDLIGHTABS)
- si->lightabsolute_mid = READUINT8(save_p);
+ si->lightabsolute_mid = P_ReadUINT8(save_p);
if (diff & LD_SDBOTLIGHTABS)
- si->lightabsolute_bottom = READUINT8(save_p);
+ si->lightabsolute_bottom = P_ReadUINT8(save_p);
}
-static void UnArchiveLines(void)
+static void UnArchiveLines(save_t *save_p)
{
UINT32 i;
line_t *li;
@@ -1638,38 +1878,38 @@ static void UnArchiveLines(void)
for (;;)
{
- i = READUINT32(save_p);
+ i = P_ReadUINT32(save_p);
if (i == 0xffffffff)
break;
if (i > numlines)
I_Error("Invalid line number %u from server", i);
- diff = READUINT8(save_p);
+ diff = P_ReadUINT8(save_p);
if (diff & LD_DIFF2)
- diff2 = READUINT8(save_p);
+ diff2 = P_ReadUINT8(save_p);
else
diff2 = 0;
li = &lines[i];
if (diff & LD_FLAG)
- li->flags = READINT16(save_p);
+ li->flags = P_ReadINT16(save_p);
if (diff & LD_SPECIAL)
- li->special = READINT16(save_p);
+ li->special = P_ReadINT16(save_p);
if (diff & LD_CLLCOUNT)
- li->callcount = READINT16(save_p);
+ li->callcount = P_ReadINT16(save_p);
if (diff & LD_ARGS)
{
UINT8 j;
for (j = 0; j < NUMLINEARGS; j++)
- li->args[j] = READINT32(save_p);
+ li->args[j] = P_ReadINT32(save_p);
}
if (diff & LD_STRINGARGS)
{
UINT8 j;
for (j = 0; j < NUMLINESTRINGARGS; j++)
{
- size_t len = READINT32(save_p);
+ size_t len = P_ReadINT32(save_p);
size_t k;
if (!len)
@@ -1681,38 +1921,38 @@ static void UnArchiveLines(void)
li->stringargs[j] = Z_Realloc(li->stringargs[j], len + 1, PU_LEVEL, NULL);
for (k = 0; k < len; k++)
- li->stringargs[j][k] = READCHAR(save_p);
+ li->stringargs[j][k] = P_ReadChar(save_p);
li->stringargs[j][len] = '\0';
}
}
if (diff & LD_SIDE1)
- UnArchiveSide(&sides[li->sidenum[0]]);
+ UnArchiveSide(save_p, &sides[li->sidenum[0]]);
if (diff & LD_SIDE2)
- UnArchiveSide(&sides[li->sidenum[1]]);
+ UnArchiveSide(save_p, &sides[li->sidenum[1]]);
if (diff2 & LD_EXECUTORDELAY)
- li->executordelay = READINT32(save_p);
+ li->executordelay = P_ReadINT32(save_p);
if (diff2 & LD_TRANSFPORTAL)
- li->secportal = READUINT32(save_p);
+ li->secportal = P_ReadUINT32(save_p);
}
}
-static void P_NetArchiveWorld(void)
+static void P_NetArchiveWorld(save_t *save_p)
{
// initialize colormap vars because paranoia
ClearNetColormaps();
- WRITEUINT32(save_p, ARCHIVEBLOCK_WORLD);
+ P_WriteUINT32(save_p, ARCHIVEBLOCK_WORLD);
- ArchiveSectors();
- ArchiveLines();
+ ArchiveSectors(save_p);
+ ArchiveLines(save_p);
R_ClearTextureNumCache(false);
}
-static void P_NetUnArchiveWorld(void)
+static void P_NetUnArchiveWorld(save_t *save_p)
{
UINT16 i;
- if (READUINT32(save_p) != ARCHIVEBLOCK_WORLD)
+ if (P_ReadUINT32(save_p) != ARCHIVEBLOCK_WORLD)
I_Error("Bad $$$.sav at archive block World");
// initialize colormap vars because paranoia
@@ -1726,8 +1966,8 @@ static void P_NetUnArchiveWorld(void)
num_ffloors++;
}
- UnArchiveSectors();
- UnArchiveLines();
+ UnArchiveSectors(save_p);
+ UnArchiveLines(save_p);
}
//
@@ -1878,7 +2118,7 @@ static UINT32 SaveSlope(const pslope_t *slope)
return 0xFFFFFFFF;
}
-static void SaveMobjThinker(const thinker_t *th, const UINT8 type)
+static void SaveMobjThinker(save_t *save_p, const thinker_t *th, const UINT8 type)
{
const mobj_t *mobj = (const mobj_t *)th;
UINT32 diff;
@@ -2052,28 +2292,28 @@ static void SaveMobjThinker(const thinker_t *th, const UINT8 type)
if (mobj->type == MT_HOOPCENTER)
diff = MD_SPAWNPOINT;
- WRITEUINT8(save_p, type);
- WRITEUINT32(save_p, diff);
+ P_WriteUINT8(save_p, type);
+ P_WriteUINT32(save_p, diff);
if (diff & MD_MORE)
- WRITEUINT32(save_p, diff2);
+ P_WriteUINT32(save_p, diff2);
// save pointer, at load time we will search this pointer to reinitilize pointers
- WRITEUINT32(save_p, (size_t)mobj);
+ P_WriteUINT32(save_p, (size_t)mobj);
- WRITEFIXED(save_p, mobj->z); // Force this so 3dfloor problems don't arise.
- WRITEFIXED(save_p, mobj->floorz);
- WRITEFIXED(save_p, mobj->ceilingz);
+ P_WriteFixed(save_p, mobj->z); // Force this so 3dfloor problems don't arise.
+ P_WriteFixed(save_p, mobj->floorz);
+ P_WriteFixed(save_p, mobj->ceilingz);
if (diff2 & MD2_FLOORROVER)
{
- WRITEUINT32(save_p, SaveSector(mobj->floorrover->target));
- WRITEUINT16(save_p, P_GetFFloorID(mobj->floorrover));
+ P_WriteUINT32(save_p, SaveSector(mobj->floorrover->target));
+ P_WriteUINT16(save_p, P_GetFFloorID(mobj->floorrover));
}
if (diff2 & MD2_CEILINGROVER)
{
- WRITEUINT32(save_p, SaveSector(mobj->ceilingrover->target));
- WRITEUINT16(save_p, P_GetFFloorID(mobj->ceilingrover));
+ P_WriteUINT32(save_p, SaveSector(mobj->ceilingrover->target));
+ P_WriteUINT16(save_p, P_GetFFloorID(mobj->ceilingrover));
}
if (diff & MD_SPAWNPOINT)
@@ -2082,649 +2322,649 @@ static void SaveMobjThinker(const thinker_t *th, const UINT8 type)
for (z = 0; z < nummapthings; z++)
if (&mapthings[z] == mobj->spawnpoint)
- WRITEUINT16(save_p, z);
+ P_WriteUINT16(save_p, z);
if (mobj->type == MT_HOOPCENTER)
return;
}
if (diff & MD_TYPE)
- WRITEUINT32(save_p, mobj->type);
+ P_WriteUINT32(save_p, mobj->type);
if (diff & MD_POS)
{
- WRITEFIXED(save_p, mobj->x);
- WRITEFIXED(save_p, mobj->y);
- WRITEANGLE(save_p, mobj->angle);
- WRITEANGLE(save_p, mobj->pitch);
- WRITEANGLE(save_p, mobj->roll);
+ P_WriteFixed(save_p, mobj->x);
+ P_WriteFixed(save_p, mobj->y);
+ P_WriteAngle(save_p, mobj->angle);
+ P_WriteAngle(save_p, mobj->pitch);
+ P_WriteAngle(save_p, mobj->roll);
}
if (diff & MD_MOM)
{
- WRITEFIXED(save_p, mobj->momx);
- WRITEFIXED(save_p, mobj->momy);
- WRITEFIXED(save_p, mobj->momz);
- WRITEFIXED(save_p, mobj->pmomz);
+ P_WriteFixed(save_p, mobj->momx);
+ P_WriteFixed(save_p, mobj->momy);
+ P_WriteFixed(save_p, mobj->momz);
+ P_WriteFixed(save_p, mobj->pmomz);
}
if (diff & MD_RADIUS)
- WRITEFIXED(save_p, mobj->radius);
+ P_WriteFixed(save_p, mobj->radius);
if (diff & MD_HEIGHT)
- WRITEFIXED(save_p, mobj->height);
+ P_WriteFixed(save_p, mobj->height);
if (diff & MD_FLAGS)
- WRITEUINT32(save_p, mobj->flags);
+ P_WriteUINT32(save_p, mobj->flags);
if (diff & MD_FLAGS2)
- WRITEUINT32(save_p, mobj->flags2);
+ P_WriteUINT32(save_p, mobj->flags2);
if (diff & MD_HEALTH)
- WRITEINT32(save_p, mobj->health);
+ P_WriteINT32(save_p, mobj->health);
if (diff & MD_RTIME)
- WRITEINT32(save_p, mobj->reactiontime);
+ P_WriteINT32(save_p, mobj->reactiontime);
if (diff & MD_STATE)
- WRITEUINT16(save_p, mobj->state-states);
+ P_WriteUINT16(save_p, mobj->state-states);
if (diff & MD_TICS)
- WRITEINT32(save_p, mobj->tics);
+ P_WriteINT32(save_p, mobj->tics);
if (diff & MD_SPRITE) {
- WRITEUINT16(save_p, mobj->sprite);
+ P_WriteUINT16(save_p, mobj->sprite);
if (mobj->sprite == SPR_PLAY)
- WRITEUINT16(save_p, mobj->sprite2);
+ P_WriteUINT16(save_p, mobj->sprite2);
}
if (diff & MD_FRAME)
{
- WRITEUINT32(save_p, mobj->frame);
- WRITEUINT16(save_p, mobj->anim_duration);
+ P_WriteUINT32(save_p, mobj->frame);
+ P_WriteUINT16(save_p, mobj->anim_duration);
}
if (diff & MD_EFLAGS)
- WRITEUINT16(save_p, mobj->eflags);
+ P_WriteUINT16(save_p, mobj->eflags);
if (diff & MD_PLAYER)
- WRITEUINT8(save_p, mobj->player-players);
+ P_WriteUINT8(save_p, mobj->player-players);
if (diff & MD_MOVEDIR)
- WRITEANGLE(save_p, mobj->movedir);
+ P_WriteAngle(save_p, mobj->movedir);
if (diff & MD_MOVECOUNT)
- WRITEINT32(save_p, mobj->movecount);
+ P_WriteINT32(save_p, mobj->movecount);
if (diff & MD_THRESHOLD)
- WRITEINT32(save_p, mobj->threshold);
+ P_WriteINT32(save_p, mobj->threshold);
if (diff & MD_LASTLOOK)
- WRITEINT32(save_p, mobj->lastlook);
+ P_WriteINT32(save_p, mobj->lastlook);
if (diff & MD_TARGET)
- WRITEUINT32(save_p, mobj->target->mobjnum);
+ P_WriteUINT32(save_p, mobj->target->mobjnum);
if (diff & MD_TRACER)
- WRITEUINT32(save_p, mobj->tracer->mobjnum);
+ P_WriteUINT32(save_p, mobj->tracer->mobjnum);
if (diff & MD_FRICTION)
- WRITEFIXED(save_p, mobj->friction);
+ P_WriteFixed(save_p, mobj->friction);
if (diff & MD_MOVEFACTOR)
- WRITEFIXED(save_p, mobj->movefactor);
+ P_WriteFixed(save_p, mobj->movefactor);
if (diff & MD_FUSE)
- WRITEINT32(save_p, mobj->fuse);
+ P_WriteINT32(save_p, mobj->fuse);
if (diff & MD_WATERTOP)
- WRITEFIXED(save_p, mobj->watertop);
+ P_WriteFixed(save_p, mobj->watertop);
if (diff & MD_WATERBOTTOM)
- WRITEFIXED(save_p, mobj->waterbottom);
+ P_WriteFixed(save_p, mobj->waterbottom);
if (diff & MD_SCALE)
- WRITEFIXED(save_p, mobj->scale);
+ P_WriteFixed(save_p, mobj->scale);
if (diff & MD_DSCALE)
- WRITEFIXED(save_p, mobj->destscale);
+ P_WriteFixed(save_p, mobj->destscale);
if (diff2 & MD2_SCALESPEED)
- WRITEFIXED(save_p, mobj->scalespeed);
+ P_WriteFixed(save_p, mobj->scalespeed);
if (diff2 & MD2_CUSVAL)
- WRITEINT32(save_p, mobj->cusval);
+ P_WriteINT32(save_p, mobj->cusval);
if (diff2 & MD2_CVMEM)
- WRITEINT32(save_p, mobj->cvmem);
+ P_WriteINT32(save_p, mobj->cvmem);
if (diff2 & MD2_SKIN)
- WRITEUINT8(save_p, (UINT8)(((skin_t *)mobj->skin)->skinnum));
+ P_WriteUINT8(save_p, (UINT8)(((skin_t *)mobj->skin)->skinnum));
if (diff2 & MD2_COLOR)
- WRITEUINT16(save_p, mobj->color);
+ P_WriteUINT16(save_p, mobj->color);
if (diff2 & MD2_EXTVAL1)
- WRITEINT32(save_p, mobj->extravalue1);
+ P_WriteINT32(save_p, mobj->extravalue1);
if (diff2 & MD2_EXTVAL2)
- WRITEINT32(save_p, mobj->extravalue2);
+ P_WriteINT32(save_p, mobj->extravalue2);
if (diff2 & MD2_HNEXT)
- WRITEUINT32(save_p, mobj->hnext->mobjnum);
+ P_WriteUINT32(save_p, mobj->hnext->mobjnum);
if (diff2 & MD2_HPREV)
- WRITEUINT32(save_p, mobj->hprev->mobjnum);
+ P_WriteUINT32(save_p, mobj->hprev->mobjnum);
if (diff2 & MD2_SLOPE)
- WRITEUINT16(save_p, mobj->standingslope->id);
+ P_WriteUINT16(save_p, mobj->standingslope->id);
if (diff2 & MD2_COLORIZED)
- WRITEUINT8(save_p, mobj->colorized);
+ P_WriteUINT8(save_p, mobj->colorized);
if (diff2 & MD2_MIRRORED)
- WRITEUINT8(save_p, mobj->mirrored);
+ P_WriteUINT8(save_p, mobj->mirrored);
if (diff2 & MD2_SPRITEROLL)
- WRITEANGLE(save_p, mobj->spriteroll);
+ P_WriteAngle(save_p, mobj->spriteroll);
if (diff2 & MD2_SHADOWSCALE)
- WRITEFIXED(save_p, mobj->shadowscale);
+ P_WriteFixed(save_p, mobj->shadowscale);
if (diff2 & MD2_RENDERFLAGS)
- WRITEUINT32(save_p, mobj->renderflags);
+ P_WriteUINT32(save_p, mobj->renderflags);
if (diff2 & MD2_BLENDMODE)
- WRITEINT32(save_p, mobj->blendmode);
+ P_WriteINT32(save_p, mobj->blendmode);
if (diff2 & MD2_SPRITEXSCALE)
- WRITEFIXED(save_p, mobj->spritexscale);
+ P_WriteFixed(save_p, mobj->spritexscale);
if (diff2 & MD2_SPRITEYSCALE)
- WRITEFIXED(save_p, mobj->spriteyscale);
+ P_WriteFixed(save_p, mobj->spriteyscale);
if (diff2 & MD2_SPRITEXOFFSET)
- WRITEFIXED(save_p, mobj->spritexoffset);
+ P_WriteFixed(save_p, mobj->spritexoffset);
if (diff2 & MD2_SPRITEYOFFSET)
- WRITEFIXED(save_p, mobj->spriteyoffset);
+ P_WriteFixed(save_p, mobj->spriteyoffset);
if (diff2 & MD2_FLOORSPRITESLOPE)
{
pslope_t *slope = mobj->floorspriteslope;
- WRITEFIXED(save_p, slope->zdelta);
- WRITEANGLE(save_p, slope->zangle);
- WRITEANGLE(save_p, slope->xydirection);
+ P_WriteFixed(save_p, slope->zdelta);
+ P_WriteAngle(save_p, slope->zangle);
+ P_WriteAngle(save_p, slope->xydirection);
- WRITEFIXED(save_p, slope->o.x);
- WRITEFIXED(save_p, slope->o.y);
- WRITEFIXED(save_p, slope->o.z);
+ P_WriteFixed(save_p, slope->o.x);
+ P_WriteFixed(save_p, slope->o.y);
+ P_WriteFixed(save_p, slope->o.z);
- WRITEFIXED(save_p, slope->d.x);
- WRITEFIXED(save_p, slope->d.y);
+ P_WriteFixed(save_p, slope->d.x);
+ P_WriteFixed(save_p, slope->d.y);
- WRITEFIXED(save_p, slope->normal.x);
- WRITEFIXED(save_p, slope->normal.y);
- WRITEFIXED(save_p, slope->normal.z);
+ P_WriteFixed(save_p, slope->normal.x);
+ P_WriteFixed(save_p, slope->normal.y);
+ P_WriteFixed(save_p, slope->normal.z);
}
if (diff2 & MD2_DRAWONLYFORPLAYER)
- WRITEUINT8(save_p, mobj->drawonlyforplayer-players);
+ P_WriteUINT8(save_p, mobj->drawonlyforplayer-players);
if (diff2 & MD2_DONTDRAWFORVIEWMOBJ)
- WRITEUINT32(save_p, mobj->dontdrawforviewmobj->mobjnum);
+ P_WriteUINT32(save_p, mobj->dontdrawforviewmobj->mobjnum);
if (diff2 & MD2_DISPOFFSET)
- WRITEINT32(save_p, mobj->dispoffset);
+ P_WriteINT32(save_p, mobj->dispoffset);
if (diff2 & MD2_TRANSLATION)
- WRITEUINT16(save_p, mobj->translation);
+ P_WriteUINT16(save_p, mobj->translation);
if (diff2 & MD2_ALPHA)
- WRITEFIXED(save_p, mobj->alpha);
+ P_WriteFixed(save_p, mobj->alpha);
- WRITEUINT32(save_p, mobj->mobjnum);
+ P_WriteUINT32(save_p, mobj->mobjnum);
}
-static void SaveNoEnemiesThinker(const thinker_t *th, const UINT8 type)
+static void SaveNoEnemiesThinker(save_t *save_p, const thinker_t *th, const UINT8 type)
{
const noenemies_t *ht = (const void *)th;
- WRITEUINT8(save_p, type);
- WRITEUINT32(save_p, SaveLine(ht->sourceline));
+ P_WriteUINT8(save_p, type);
+ P_WriteUINT32(save_p, SaveLine(ht->sourceline));
}
-static void SaveBounceCheeseThinker(const thinker_t *th, const UINT8 type)
+static void SaveBounceCheeseThinker(save_t *save_p, const thinker_t *th, const UINT8 type)
{
const bouncecheese_t *ht = (const void *)th;
- WRITEUINT8(save_p, type);
- WRITEUINT32(save_p, SaveLine(ht->sourceline));
- WRITEUINT32(save_p, SaveSector(ht->sector));
- WRITEFIXED(save_p, ht->speed);
- WRITEFIXED(save_p, ht->distance);
- WRITEFIXED(save_p, ht->floorwasheight);
- WRITEFIXED(save_p, ht->ceilingwasheight);
- WRITECHAR(save_p, ht->low);
+ P_WriteUINT8(save_p, type);
+ P_WriteUINT32(save_p, SaveLine(ht->sourceline));
+ P_WriteUINT32(save_p, SaveSector(ht->sector));
+ P_WriteFixed(save_p, ht->speed);
+ P_WriteFixed(save_p, ht->distance);
+ P_WriteFixed(save_p, ht->floorwasheight);
+ P_WriteFixed(save_p, ht->ceilingwasheight);
+ P_WriteChar(save_p, ht->low);
}
-static void SaveContinuousFallThinker(const thinker_t *th, const UINT8 type)
+static void SaveContinuousFallThinker(save_t *save_p, const thinker_t *th, const UINT8 type)
{
const continuousfall_t *ht = (const void *)th;
- WRITEUINT8(save_p, type);
- WRITEUINT32(save_p, SaveSector(ht->sector));
- WRITEFIXED(save_p, ht->speed);
- WRITEINT32(save_p, ht->direction);
- WRITEFIXED(save_p, ht->floorstartheight);
- WRITEFIXED(save_p, ht->ceilingstartheight);
- WRITEFIXED(save_p, ht->destheight);
+ P_WriteUINT8(save_p, type);
+ P_WriteUINT32(save_p, SaveSector(ht->sector));
+ P_WriteFixed(save_p, ht->speed);
+ P_WriteINT32(save_p, ht->direction);
+ P_WriteFixed(save_p, ht->floorstartheight);
+ P_WriteFixed(save_p, ht->ceilingstartheight);
+ P_WriteFixed(save_p, ht->destheight);
}
-static void SaveMarioBlockThinker(const thinker_t *th, const UINT8 type)
+static void SaveMarioBlockThinker(save_t *save_p, const thinker_t *th, const UINT8 type)
{
const mariothink_t *ht = (const void *)th;
- WRITEUINT8(save_p, type);
- WRITEUINT32(save_p, SaveSector(ht->sector));
- WRITEFIXED(save_p, ht->speed);
- WRITEINT32(save_p, ht->direction);
- WRITEFIXED(save_p, ht->floorstartheight);
- WRITEFIXED(save_p, ht->ceilingstartheight);
- WRITEINT16(save_p, ht->tag);
+ P_WriteUINT8(save_p, type);
+ P_WriteUINT32(save_p, SaveSector(ht->sector));
+ P_WriteFixed(save_p, ht->speed);
+ P_WriteINT32(save_p, ht->direction);
+ P_WriteFixed(save_p, ht->floorstartheight);
+ P_WriteFixed(save_p, ht->ceilingstartheight);
+ P_WriteINT16(save_p, ht->tag);
}
-static void SaveMarioCheckThinker(const thinker_t *th, const UINT8 type)
+static void SaveMarioCheckThinker(save_t *save_p, const thinker_t *th, const UINT8 type)
{
const mariocheck_t *ht = (const void *)th;
- WRITEUINT8(save_p, type);
- WRITEUINT32(save_p, SaveLine(ht->sourceline));
- WRITEUINT32(save_p, SaveSector(ht->sector));
+ P_WriteUINT8(save_p, type);
+ P_WriteUINT32(save_p, SaveLine(ht->sourceline));
+ P_WriteUINT32(save_p, SaveSector(ht->sector));
}
-static void SaveThwompThinker(const thinker_t *th, const UINT8 type)
+static void SaveThwompThinker(save_t *save_p, const thinker_t *th, const UINT8 type)
{
const thwomp_t *ht = (const void *)th;
- WRITEUINT8(save_p, type);
- WRITEUINT32(save_p, SaveLine(ht->sourceline));
- WRITEUINT32(save_p, SaveSector(ht->sector));
- WRITEFIXED(save_p, ht->crushspeed);
- WRITEFIXED(save_p, ht->retractspeed);
- WRITEINT32(save_p, ht->direction);
- WRITEFIXED(save_p, ht->floorstartheight);
- WRITEFIXED(save_p, ht->ceilingstartheight);
- WRITEINT32(save_p, ht->delay);
- WRITEINT16(save_p, ht->tag);
- WRITEUINT16(save_p, ht->sound);
+ P_WriteUINT8(save_p, type);
+ P_WriteUINT32(save_p, SaveLine(ht->sourceline));
+ P_WriteUINT32(save_p, SaveSector(ht->sector));
+ P_WriteFixed(save_p, ht->crushspeed);
+ P_WriteFixed(save_p, ht->retractspeed);
+ P_WriteINT32(save_p, ht->direction);
+ P_WriteFixed(save_p, ht->floorstartheight);
+ P_WriteFixed(save_p, ht->ceilingstartheight);
+ P_WriteINT32(save_p, ht->delay);
+ P_WriteINT16(save_p, ht->tag);
+ P_WriteUINT16(save_p, ht->sound);
}
-static void SaveFloatThinker(const thinker_t *th, const UINT8 type)
+static void SaveFloatThinker(save_t *save_p, const thinker_t *th, const UINT8 type)
{
const floatthink_t *ht = (const void *)th;
- WRITEUINT8(save_p, type);
- WRITEUINT32(save_p, SaveLine(ht->sourceline));
- WRITEUINT32(save_p, SaveSector(ht->sector));
- WRITEINT16(save_p, ht->tag);
+ P_WriteUINT8(save_p, type);
+ P_WriteUINT32(save_p, SaveLine(ht->sourceline));
+ P_WriteUINT32(save_p, SaveSector(ht->sector));
+ P_WriteINT16(save_p, ht->tag);
}
-static void SaveEachTimeThinker(const thinker_t *th, const UINT8 type)
+static void SaveEachTimeThinker(save_t *save_p, const thinker_t *th, const UINT8 type)
{
const eachtime_t *ht = (const void *)th;
size_t i;
- WRITEUINT8(save_p, type);
- WRITEUINT32(save_p, SaveLine(ht->sourceline));
+ P_WriteUINT8(save_p, type);
+ P_WriteUINT32(save_p, SaveLine(ht->sourceline));
for (i = 0; i < MAXPLAYERS; i++)
{
- WRITECHAR(save_p, ht->playersInArea[i]);
+ P_WriteChar(save_p, ht->playersInArea[i]);
}
- WRITECHAR(save_p, ht->triggerOnExit);
+ P_WriteChar(save_p, ht->triggerOnExit);
}
-static void SaveRaiseThinker(const thinker_t *th, const UINT8 type)
+static void SaveRaiseThinker(save_t *save_p, const thinker_t *th, const UINT8 type)
{
const raise_t *ht = (const void *)th;
- WRITEUINT8(save_p, type);
- WRITEINT16(save_p, ht->tag);
- WRITEUINT32(save_p, SaveSector(ht->sector));
- WRITEFIXED(save_p, ht->ceilingbottom);
- WRITEFIXED(save_p, ht->ceilingtop);
- WRITEFIXED(save_p, ht->basespeed);
- WRITEFIXED(save_p, ht->extraspeed);
- WRITEUINT8(save_p, ht->shaketimer);
- WRITEUINT8(save_p, ht->flags);
+ P_WriteUINT8(save_p, type);
+ P_WriteINT16(save_p, ht->tag);
+ P_WriteUINT32(save_p, SaveSector(ht->sector));
+ P_WriteFixed(save_p, ht->ceilingbottom);
+ P_WriteFixed(save_p, ht->ceilingtop);
+ P_WriteFixed(save_p, ht->basespeed);
+ P_WriteFixed(save_p, ht->extraspeed);
+ P_WriteUINT8(save_p, ht->shaketimer);
+ P_WriteUINT8(save_p, ht->flags);
}
-static void SaveCeilingThinker(const thinker_t *th, const UINT8 type)
+static void SaveCeilingThinker(save_t *save_p, const thinker_t *th, const UINT8 type)
{
const ceiling_t *ht = (const void *)th;
- WRITEUINT8(save_p, type);
- WRITEUINT8(save_p, ht->type);
- WRITEUINT32(save_p, SaveSector(ht->sector));
- WRITEFIXED(save_p, ht->bottomheight);
- WRITEFIXED(save_p, ht->topheight);
- WRITEFIXED(save_p, ht->speed);
- WRITEFIXED(save_p, ht->delay);
- WRITEFIXED(save_p, ht->delaytimer);
- WRITEUINT8(save_p, ht->crush);
- WRITEINT32(save_p, ht->texture);
- WRITEINT32(save_p, ht->direction);
- WRITEINT16(save_p, ht->tag);
- WRITEFIXED(save_p, ht->origspeed);
- WRITEFIXED(save_p, ht->sourceline);
-}
-
-static void SaveFloormoveThinker(const thinker_t *th, const UINT8 type)
+ P_WriteUINT8(save_p, type);
+ P_WriteUINT8(save_p, ht->type);
+ P_WriteUINT32(save_p, SaveSector(ht->sector));
+ P_WriteFixed(save_p, ht->bottomheight);
+ P_WriteFixed(save_p, ht->topheight);
+ P_WriteFixed(save_p, ht->speed);
+ P_WriteFixed(save_p, ht->delay);
+ P_WriteFixed(save_p, ht->delaytimer);
+ P_WriteUINT8(save_p, ht->crush);
+ P_WriteINT32(save_p, ht->texture);
+ P_WriteINT32(save_p, ht->direction);
+ P_WriteINT16(save_p, ht->tag);
+ P_WriteFixed(save_p, ht->origspeed);
+ P_WriteFixed(save_p, ht->sourceline);
+}
+
+static void SaveFloormoveThinker(save_t *save_p, const thinker_t *th, const UINT8 type)
{
const floormove_t *ht = (const void *)th;
- WRITEUINT8(save_p, type);
- WRITEUINT8(save_p, ht->type);
- WRITEUINT8(save_p, ht->crush);
- WRITEUINT32(save_p, SaveSector(ht->sector));
- WRITEINT32(save_p, ht->direction);
- WRITEINT32(save_p, ht->texture);
- WRITEFIXED(save_p, ht->floordestheight);
- WRITEFIXED(save_p, ht->speed);
- WRITEFIXED(save_p, ht->origspeed);
- WRITEFIXED(save_p, ht->delay);
- WRITEFIXED(save_p, ht->delaytimer);
- WRITEINT16(save_p, ht->tag);
- WRITEFIXED(save_p, ht->sourceline);
-}
-
-static void SaveLightflashThinker(const thinker_t *th, const UINT8 type)
+ P_WriteUINT8(save_p, type);
+ P_WriteUINT8(save_p, ht->type);
+ P_WriteUINT8(save_p, ht->crush);
+ P_WriteUINT32(save_p, SaveSector(ht->sector));
+ P_WriteINT32(save_p, ht->direction);
+ P_WriteINT32(save_p, ht->texture);
+ P_WriteFixed(save_p, ht->floordestheight);
+ P_WriteFixed(save_p, ht->speed);
+ P_WriteFixed(save_p, ht->origspeed);
+ P_WriteFixed(save_p, ht->delay);
+ P_WriteFixed(save_p, ht->delaytimer);
+ P_WriteINT16(save_p, ht->tag);
+ P_WriteFixed(save_p, ht->sourceline);
+}
+
+static void SaveLightflashThinker(save_t *save_p, const thinker_t *th, const UINT8 type)
{
const lightflash_t *ht = (const void *)th;
- WRITEUINT8(save_p, type);
- WRITEUINT32(save_p, SaveSector(ht->sector));
- WRITEINT32(save_p, ht->maxlight);
- WRITEINT32(save_p, ht->minlight);
+ P_WriteUINT8(save_p, type);
+ P_WriteUINT32(save_p, SaveSector(ht->sector));
+ P_WriteINT32(save_p, ht->maxlight);
+ P_WriteINT32(save_p, ht->minlight);
}
-static void SaveStrobeThinker(const thinker_t *th, const UINT8 type)
+static void SaveStrobeThinker(save_t *save_p, const thinker_t *th, const UINT8 type)
{
const strobe_t *ht = (const void *)th;
- WRITEUINT8(save_p, type);
- WRITEUINT32(save_p, SaveSector(ht->sector));
- WRITEINT32(save_p, ht->count);
- WRITEINT16(save_p, ht->minlight);
- WRITEINT16(save_p, ht->maxlight);
- WRITEINT32(save_p, ht->darktime);
- WRITEINT32(save_p, ht->brighttime);
+ P_WriteUINT8(save_p, type);
+ P_WriteUINT32(save_p, SaveSector(ht->sector));
+ P_WriteINT32(save_p, ht->count);
+ P_WriteINT16(save_p, ht->minlight);
+ P_WriteINT16(save_p, ht->maxlight);
+ P_WriteINT32(save_p, ht->darktime);
+ P_WriteINT32(save_p, ht->brighttime);
}
-static void SaveGlowThinker(const thinker_t *th, const UINT8 type)
+static void SaveGlowThinker(save_t *save_p, const thinker_t *th, const UINT8 type)
{
const glow_t *ht = (const void *)th;
- WRITEUINT8(save_p, type);
- WRITEUINT32(save_p, SaveSector(ht->sector));
- WRITEINT16(save_p, ht->minlight);
- WRITEINT16(save_p, ht->maxlight);
- WRITEINT16(save_p, ht->direction);
- WRITEINT16(save_p, ht->speed);
+ P_WriteUINT8(save_p, type);
+ P_WriteUINT32(save_p, SaveSector(ht->sector));
+ P_WriteINT16(save_p, ht->minlight);
+ P_WriteINT16(save_p, ht->maxlight);
+ P_WriteINT16(save_p, ht->direction);
+ P_WriteINT16(save_p, ht->speed);
}
-static inline void SaveFireflickerThinker(const thinker_t *th, const UINT8 type)
+static inline void SaveFireflickerThinker(save_t *save_p, const thinker_t *th, const UINT8 type)
{
const fireflicker_t *ht = (const void *)th;
- WRITEUINT8(save_p, type);
- WRITEUINT32(save_p, SaveSector(ht->sector));
- WRITEINT32(save_p, ht->count);
- WRITEINT32(save_p, ht->resetcount);
- WRITEINT16(save_p, ht->maxlight);
- WRITEINT16(save_p, ht->minlight);
+ P_WriteUINT8(save_p, type);
+ P_WriteUINT32(save_p, SaveSector(ht->sector));
+ P_WriteINT32(save_p, ht->count);
+ P_WriteINT32(save_p, ht->resetcount);
+ P_WriteINT16(save_p, ht->maxlight);
+ P_WriteINT16(save_p, ht->minlight);
}
-static void SaveElevatorThinker(const thinker_t *th, const UINT8 type)
+static void SaveElevatorThinker(save_t *save_p, const thinker_t *th, const UINT8 type)
{
const elevator_t *ht = (const void *)th;
- WRITEUINT8(save_p, type);
- WRITEUINT8(save_p, ht->type);
- WRITEUINT32(save_p, SaveSector(ht->sector));
- WRITEUINT32(save_p, SaveSector(ht->actionsector));
- WRITEINT32(save_p, ht->direction);
- WRITEFIXED(save_p, ht->floordestheight);
- WRITEFIXED(save_p, ht->ceilingdestheight);
- WRITEFIXED(save_p, ht->speed);
- WRITEFIXED(save_p, ht->origspeed);
- WRITEFIXED(save_p, ht->low);
- WRITEFIXED(save_p, ht->high);
- WRITEFIXED(save_p, ht->distance);
- WRITEFIXED(save_p, ht->delay);
- WRITEFIXED(save_p, ht->delaytimer);
- WRITEFIXED(save_p, ht->floorwasheight);
- WRITEFIXED(save_p, ht->ceilingwasheight);
- WRITEUINT32(save_p, SaveLine(ht->sourceline));
-}
-
-static void SaveCrumbleThinker(const thinker_t *th, const UINT8 type)
+ P_WriteUINT8(save_p, type);
+ P_WriteUINT8(save_p, ht->type);
+ P_WriteUINT32(save_p, SaveSector(ht->sector));
+ P_WriteUINT32(save_p, SaveSector(ht->actionsector));
+ P_WriteINT32(save_p, ht->direction);
+ P_WriteFixed(save_p, ht->floordestheight);
+ P_WriteFixed(save_p, ht->ceilingdestheight);
+ P_WriteFixed(save_p, ht->speed);
+ P_WriteFixed(save_p, ht->origspeed);
+ P_WriteFixed(save_p, ht->low);
+ P_WriteFixed(save_p, ht->high);
+ P_WriteFixed(save_p, ht->distance);
+ P_WriteFixed(save_p, ht->delay);
+ P_WriteFixed(save_p, ht->delaytimer);
+ P_WriteFixed(save_p, ht->floorwasheight);
+ P_WriteFixed(save_p, ht->ceilingwasheight);
+ P_WriteUINT32(save_p, SaveLine(ht->sourceline));
+}
+
+static void SaveCrumbleThinker(save_t *save_p, const thinker_t *th, const UINT8 type)
{
const crumble_t *ht = (const void *)th;
- WRITEUINT8(save_p, type);
- WRITEUINT32(save_p, SaveLine(ht->sourceline));
- WRITEUINT32(save_p, SaveSector(ht->sector));
- WRITEUINT32(save_p, SaveSector(ht->actionsector));
- WRITEUINT32(save_p, SavePlayer(ht->player)); // was dummy
- WRITEINT32(save_p, ht->direction);
- WRITEINT32(save_p, ht->origalpha);
- WRITEINT32(save_p, ht->timer);
- WRITEFIXED(save_p, ht->speed);
- WRITEFIXED(save_p, ht->floorwasheight);
- WRITEFIXED(save_p, ht->ceilingwasheight);
- WRITEUINT8(save_p, ht->flags);
-}
-
-static inline void SaveScrollThinker(const thinker_t *th, const UINT8 type)
+ P_WriteUINT8(save_p, type);
+ P_WriteUINT32(save_p, SaveLine(ht->sourceline));
+ P_WriteUINT32(save_p, SaveSector(ht->sector));
+ P_WriteUINT32(save_p, SaveSector(ht->actionsector));
+ P_WriteUINT32(save_p, SavePlayer(ht->player)); // was dummy
+ P_WriteINT32(save_p, ht->direction);
+ P_WriteINT32(save_p, ht->origalpha);
+ P_WriteINT32(save_p, ht->timer);
+ P_WriteFixed(save_p, ht->speed);
+ P_WriteFixed(save_p, ht->floorwasheight);
+ P_WriteFixed(save_p, ht->ceilingwasheight);
+ P_WriteUINT8(save_p, ht->flags);
+}
+
+static inline void SaveScrollThinker(save_t *save_p, const thinker_t *th, const UINT8 type)
{
const scroll_t *ht = (const void *)th;
- WRITEUINT8(save_p, type);
- WRITEFIXED(save_p, ht->dx);
- WRITEFIXED(save_p, ht->dy);
- WRITEINT32(save_p, ht->affectee);
- WRITEINT32(save_p, ht->control);
- WRITEFIXED(save_p, ht->last_height);
- WRITEFIXED(save_p, ht->vdx);
- WRITEFIXED(save_p, ht->vdy);
- WRITEINT32(save_p, ht->accel);
- WRITEINT32(save_p, ht->exclusive);
- WRITEUINT8(save_p, ht->type);
+ P_WriteUINT8(save_p, type);
+ P_WriteFixed(save_p, ht->dx);
+ P_WriteFixed(save_p, ht->dy);
+ P_WriteINT32(save_p, ht->affectee);
+ P_WriteINT32(save_p, ht->control);
+ P_WriteFixed(save_p, ht->last_height);
+ P_WriteFixed(save_p, ht->vdx);
+ P_WriteFixed(save_p, ht->vdy);
+ P_WriteINT32(save_p, ht->accel);
+ P_WriteINT32(save_p, ht->exclusive);
+ P_WriteUINT8(save_p, ht->type);
}
-static inline void SaveFrictionThinker(const thinker_t *th, const UINT8 type)
+static inline void SaveFrictionThinker(save_t *save_p, const thinker_t *th, const UINT8 type)
{
const friction_t *ht = (const void *)th;
- WRITEUINT8(save_p, type);
- WRITEINT32(save_p, ht->friction);
- WRITEINT32(save_p, ht->movefactor);
- WRITEINT32(save_p, ht->affectee);
- WRITEINT32(save_p, ht->referrer);
- WRITEUINT8(save_p, ht->roverfriction);
+ P_WriteUINT8(save_p, type);
+ P_WriteINT32(save_p, ht->friction);
+ P_WriteINT32(save_p, ht->movefactor);
+ P_WriteINT32(save_p, ht->affectee);
+ P_WriteINT32(save_p, ht->referrer);
+ P_WriteUINT8(save_p, ht->roverfriction);
}
-static inline void SavePusherThinker(const thinker_t *th, const UINT8 type)
+static inline void SavePusherThinker(save_t *save_p, const thinker_t *th, const UINT8 type)
{
const pusher_t *ht = (const void *)th;
- WRITEUINT8(save_p, type);
- WRITEUINT8(save_p, ht->type);
- WRITEFIXED(save_p, ht->x_mag);
- WRITEFIXED(save_p, ht->y_mag);
- WRITEFIXED(save_p, ht->z_mag);
- WRITEINT32(save_p, ht->affectee);
- WRITEUINT8(save_p, ht->roverpusher);
- WRITEINT32(save_p, ht->referrer);
- WRITEINT32(save_p, ht->exclusive);
- WRITEINT32(save_p, ht->slider);
+ P_WriteUINT8(save_p, type);
+ P_WriteUINT8(save_p, ht->type);
+ P_WriteFixed(save_p, ht->x_mag);
+ P_WriteFixed(save_p, ht->y_mag);
+ P_WriteFixed(save_p, ht->z_mag);
+ P_WriteINT32(save_p, ht->affectee);
+ P_WriteUINT8(save_p, ht->roverpusher);
+ P_WriteINT32(save_p, ht->referrer);
+ P_WriteINT32(save_p, ht->exclusive);
+ P_WriteINT32(save_p, ht->slider);
}
-static void SaveLaserThinker(const thinker_t *th, const UINT8 type)
+static void SaveLaserThinker(save_t *save_p, const thinker_t *th, const UINT8 type)
{
const laserthink_t *ht = (const void *)th;
- WRITEUINT8(save_p, type);
- WRITEINT16(save_p, ht->tag);
- WRITEUINT32(save_p, SaveLine(ht->sourceline));
- WRITEUINT8(save_p, ht->nobosses);
+ P_WriteUINT8(save_p, type);
+ P_WriteINT16(save_p, ht->tag);
+ P_WriteUINT32(save_p, SaveLine(ht->sourceline));
+ P_WriteUINT8(save_p, ht->nobosses);
}
-static void SaveLightlevelThinker(const thinker_t *th, const UINT8 type)
+static void SaveLightlevelThinker(save_t *save_p, const thinker_t *th, const UINT8 type)
{
const lightlevel_t *ht = (const void *)th;
- WRITEUINT8(save_p, type);
- WRITEUINT32(save_p, SaveSector(ht->sector));
- WRITEINT16(save_p, ht->sourcelevel);
- WRITEINT16(save_p, ht->destlevel);
- WRITEFIXED(save_p, ht->fixedcurlevel);
- WRITEFIXED(save_p, ht->fixedpertic);
- WRITEINT32(save_p, ht->timer);
+ P_WriteUINT8(save_p, type);
+ P_WriteUINT32(save_p, SaveSector(ht->sector));
+ P_WriteINT16(save_p, ht->sourcelevel);
+ P_WriteINT16(save_p, ht->destlevel);
+ P_WriteFixed(save_p, ht->fixedcurlevel);
+ P_WriteFixed(save_p, ht->fixedpertic);
+ P_WriteINT32(save_p, ht->timer);
}
-static void SaveExecutorThinker(const thinker_t *th, const UINT8 type)
+static void SaveExecutorThinker(save_t *save_p, const thinker_t *th, const UINT8 type)
{
const executor_t *ht = (const void *)th;
- WRITEUINT8(save_p, type);
- WRITEUINT32(save_p, SaveLine(ht->line));
- WRITEUINT32(save_p, SaveMobjnum(ht->caller));
- WRITEUINT32(save_p, SaveSector(ht->sector));
- WRITEINT32(save_p, ht->timer);
+ P_WriteUINT8(save_p, type);
+ P_WriteUINT32(save_p, SaveLine(ht->line));
+ P_WriteUINT32(save_p, SaveMobjnum(ht->caller));
+ P_WriteUINT32(save_p, SaveSector(ht->sector));
+ P_WriteINT32(save_p, ht->timer);
}
-static void SaveDisappearThinker(const thinker_t *th, const UINT8 type)
+static void SaveDisappearThinker(save_t *save_p, const thinker_t *th, const UINT8 type)
{
const disappear_t *ht = (const void *)th;
- WRITEUINT8(save_p, type);
- WRITEUINT32(save_p, ht->appeartime);
- WRITEUINT32(save_p, ht->disappeartime);
- WRITEUINT32(save_p, ht->offset);
- WRITEUINT32(save_p, ht->timer);
- WRITEINT32(save_p, ht->affectee);
- WRITEINT32(save_p, ht->sourceline);
- WRITEINT32(save_p, ht->exists);
+ P_WriteUINT8(save_p, type);
+ P_WriteUINT32(save_p, ht->appeartime);
+ P_WriteUINT32(save_p, ht->disappeartime);
+ P_WriteUINT32(save_p, ht->offset);
+ P_WriteUINT32(save_p, ht->timer);
+ P_WriteINT32(save_p, ht->affectee);
+ P_WriteINT32(save_p, ht->sourceline);
+ P_WriteINT32(save_p, ht->exists);
}
-static void SaveFadeThinker(const thinker_t *th, const UINT8 type)
+static void SaveFadeThinker(save_t *save_p, const thinker_t *th, const UINT8 type)
{
const fade_t *ht = (const void *)th;
- WRITEUINT8(save_p, type);
- WRITEUINT32(save_p, CheckAddNetColormapToList(ht->dest_exc));
- WRITEUINT32(save_p, ht->sectornum);
- WRITEUINT32(save_p, ht->ffloornum);
- WRITEINT32(save_p, ht->alpha);
- WRITEINT16(save_p, ht->sourcevalue);
- WRITEINT16(save_p, ht->destvalue);
- WRITEINT16(save_p, ht->destlightlevel);
- WRITEINT16(save_p, ht->speed);
- WRITEUINT8(save_p, (UINT8)ht->ticbased);
- WRITEINT32(save_p, ht->timer);
- WRITEUINT8(save_p, ht->doexists);
- WRITEUINT8(save_p, ht->dotranslucent);
- WRITEUINT8(save_p, ht->dolighting);
- WRITEUINT8(save_p, ht->docolormap);
- WRITEUINT8(save_p, ht->docollision);
- WRITEUINT8(save_p, ht->doghostfade);
- WRITEUINT8(save_p, ht->exactalpha);
-}
-
-static void SaveFadeColormapThinker(const thinker_t *th, const UINT8 type)
+ P_WriteUINT8(save_p, type);
+ P_WriteUINT32(save_p, CheckAddNetColormapToList(ht->dest_exc));
+ P_WriteUINT32(save_p, ht->sectornum);
+ P_WriteUINT32(save_p, ht->ffloornum);
+ P_WriteINT32(save_p, ht->alpha);
+ P_WriteINT16(save_p, ht->sourcevalue);
+ P_WriteINT16(save_p, ht->destvalue);
+ P_WriteINT16(save_p, ht->destlightlevel);
+ P_WriteINT16(save_p, ht->speed);
+ P_WriteUINT8(save_p, (UINT8)ht->ticbased);
+ P_WriteINT32(save_p, ht->timer);
+ P_WriteUINT8(save_p, ht->doexists);
+ P_WriteUINT8(save_p, ht->dotranslucent);
+ P_WriteUINT8(save_p, ht->dolighting);
+ P_WriteUINT8(save_p, ht->docolormap);
+ P_WriteUINT8(save_p, ht->docollision);
+ P_WriteUINT8(save_p, ht->doghostfade);
+ P_WriteUINT8(save_p, ht->exactalpha);
+}
+
+static void SaveFadeColormapThinker(save_t *save_p, const thinker_t *th, const UINT8 type)
{
const fadecolormap_t *ht = (const void *)th;
- WRITEUINT8(save_p, type);
- WRITEUINT32(save_p, SaveSector(ht->sector));
- WRITEUINT32(save_p, CheckAddNetColormapToList(ht->source_exc));
- WRITEUINT32(save_p, CheckAddNetColormapToList(ht->dest_exc));
- WRITEUINT8(save_p, (UINT8)ht->ticbased);
- WRITEINT32(save_p, ht->duration);
- WRITEINT32(save_p, ht->timer);
+ P_WriteUINT8(save_p, type);
+ P_WriteUINT32(save_p, SaveSector(ht->sector));
+ P_WriteUINT32(save_p, CheckAddNetColormapToList(ht->source_exc));
+ P_WriteUINT32(save_p, CheckAddNetColormapToList(ht->dest_exc));
+ P_WriteUINT8(save_p, (UINT8)ht->ticbased);
+ P_WriteINT32(save_p, ht->duration);
+ P_WriteINT32(save_p, ht->timer);
}
-static void SavePlaneDisplaceThinker(const thinker_t *th, const UINT8 type)
+static void SavePlaneDisplaceThinker(save_t *save_p, const thinker_t *th, const UINT8 type)
{
const planedisplace_t *ht = (const void *)th;
- WRITEUINT8(save_p, type);
- WRITEINT32(save_p, ht->affectee);
- WRITEINT32(save_p, ht->control);
- WRITEFIXED(save_p, ht->last_height);
- WRITEFIXED(save_p, ht->speed);
- WRITEUINT8(save_p, ht->type);
+ P_WriteUINT8(save_p, type);
+ P_WriteINT32(save_p, ht->affectee);
+ P_WriteINT32(save_p, ht->control);
+ P_WriteFixed(save_p, ht->last_height);
+ P_WriteFixed(save_p, ht->speed);
+ P_WriteUINT8(save_p, ht->type);
}
-static inline void SaveDynamicLineSlopeThinker(const thinker_t *th, const UINT8 type)
+static inline void SaveDynamicLineSlopeThinker(save_t *save_p, const thinker_t *th, const UINT8 type)
{
const dynlineplanethink_t* ht = (const void*)th;
- WRITEUINT8(save_p, type);
- WRITEUINT8(save_p, ht->type);
- WRITEUINT32(save_p, SaveSlope(ht->slope));
- WRITEUINT32(save_p, SaveLine(ht->sourceline));
- WRITEFIXED(save_p, ht->extent);
+ P_WriteUINT8(save_p, type);
+ P_WriteUINT8(save_p, ht->type);
+ P_WriteUINT32(save_p, SaveSlope(ht->slope));
+ P_WriteUINT32(save_p, SaveLine(ht->sourceline));
+ P_WriteFixed(save_p, ht->extent);
}
-static inline void SaveDynamicVertexSlopeThinker(const thinker_t *th, const UINT8 type)
+static inline void SaveDynamicVertexSlopeThinker(save_t *save_p, const thinker_t *th, const UINT8 type)
{
size_t i;
const dynvertexplanethink_t* ht = (const void*)th;
- WRITEUINT8(save_p, type);
- WRITEUINT32(save_p, SaveSlope(ht->slope));
+ P_WriteUINT8(save_p, type);
+ P_WriteUINT32(save_p, SaveSlope(ht->slope));
for (i = 0; i < 3; i++)
- WRITEUINT32(save_p, SaveSector(ht->secs[i]));
- WRITEMEM(save_p, ht->vex, sizeof(ht->vex));
- WRITEMEM(save_p, ht->origsecheights, sizeof(ht->origsecheights));
- WRITEMEM(save_p, ht->origvecheights, sizeof(ht->origvecheights));
- WRITEUINT8(save_p, ht->relative);
+ P_WriteUINT32(save_p, SaveSector(ht->secs[i]));
+ P_WriteMem(save_p, ht->vex, sizeof(ht->vex));
+ P_WriteMem(save_p, ht->origsecheights, sizeof(ht->origsecheights));
+ P_WriteMem(save_p, ht->origvecheights, sizeof(ht->origvecheights));
+ P_WriteUINT8(save_p, ht->relative);
}
-static inline void SavePolyrotatetThinker(const thinker_t *th, const UINT8 type)
+static inline void SavePolyrotatetThinker(save_t *save_p, const thinker_t *th, const UINT8 type)
{
const polyrotate_t *ht = (const void *)th;
- WRITEUINT8(save_p, type);
- WRITEINT32(save_p, ht->polyObjNum);
- WRITEINT32(save_p, ht->speed);
- WRITEINT32(save_p, ht->distance);
- WRITEUINT8(save_p, ht->turnobjs);
+ P_WriteUINT8(save_p, type);
+ P_WriteINT32(save_p, ht->polyObjNum);
+ P_WriteINT32(save_p, ht->speed);
+ P_WriteINT32(save_p, ht->distance);
+ P_WriteUINT8(save_p, ht->turnobjs);
}
-static void SavePolymoveThinker(const thinker_t *th, const UINT8 type)
+static void SavePolymoveThinker(save_t *save_p, const thinker_t *th, const UINT8 type)
{
const polymove_t *ht = (const void *)th;
- WRITEUINT8(save_p, type);
- WRITEINT32(save_p, ht->polyObjNum);
- WRITEINT32(save_p, ht->speed);
- WRITEFIXED(save_p, ht->momx);
- WRITEFIXED(save_p, ht->momy);
- WRITEINT32(save_p, ht->distance);
- WRITEANGLE(save_p, ht->angle);
+ P_WriteUINT8(save_p, type);
+ P_WriteINT32(save_p, ht->polyObjNum);
+ P_WriteINT32(save_p, ht->speed);
+ P_WriteFixed(save_p, ht->momx);
+ P_WriteFixed(save_p, ht->momy);
+ P_WriteINT32(save_p, ht->distance);
+ P_WriteAngle(save_p, ht->angle);
}
-static void SavePolywaypointThinker(const thinker_t *th, UINT8 type)
+static void SavePolywaypointThinker(save_t *save_p, const thinker_t *th, UINT8 type)
{
const polywaypoint_t *ht = (const void *)th;
- WRITEUINT8(save_p, type);
- WRITEINT32(save_p, ht->polyObjNum);
- WRITEINT32(save_p, ht->speed);
- WRITEINT32(save_p, ht->sequence);
- WRITEINT32(save_p, ht->pointnum);
- WRITEINT32(save_p, ht->direction);
- WRITEUINT8(save_p, ht->returnbehavior);
- WRITEUINT8(save_p, ht->continuous);
- WRITEUINT8(save_p, ht->stophere);
+ P_WriteUINT8(save_p, type);
+ P_WriteINT32(save_p, ht->polyObjNum);
+ P_WriteINT32(save_p, ht->speed);
+ P_WriteINT32(save_p, ht->sequence);
+ P_WriteINT32(save_p, ht->pointnum);
+ P_WriteINT32(save_p, ht->direction);
+ P_WriteUINT8(save_p, ht->returnbehavior);
+ P_WriteUINT8(save_p, ht->continuous);
+ P_WriteUINT8(save_p, ht->stophere);
}
-static void SavePolyslidedoorThinker(const thinker_t *th, const UINT8 type)
+static void SavePolyslidedoorThinker(save_t *save_p, const thinker_t *th, const UINT8 type)
{
const polyslidedoor_t *ht = (const void *)th;
- WRITEUINT8(save_p, type);
- WRITEINT32(save_p, ht->polyObjNum);
- WRITEINT32(save_p, ht->delay);
- WRITEINT32(save_p, ht->delayCount);
- WRITEINT32(save_p, ht->initSpeed);
- WRITEINT32(save_p, ht->speed);
- WRITEINT32(save_p, ht->initDistance);
- WRITEINT32(save_p, ht->distance);
- WRITEUINT32(save_p, ht->initAngle);
- WRITEUINT32(save_p, ht->angle);
- WRITEUINT32(save_p, ht->revAngle);
- WRITEFIXED(save_p, ht->momx);
- WRITEFIXED(save_p, ht->momy);
- WRITEUINT8(save_p, ht->closing);
-}
-
-static void SavePolyswingdoorThinker(const thinker_t *th, const UINT8 type)
+ P_WriteUINT8(save_p, type);
+ P_WriteINT32(save_p, ht->polyObjNum);
+ P_WriteINT32(save_p, ht->delay);
+ P_WriteINT32(save_p, ht->delayCount);
+ P_WriteINT32(save_p, ht->initSpeed);
+ P_WriteINT32(save_p, ht->speed);
+ P_WriteINT32(save_p, ht->initDistance);
+ P_WriteINT32(save_p, ht->distance);
+ P_WriteUINT32(save_p, ht->initAngle);
+ P_WriteUINT32(save_p, ht->angle);
+ P_WriteUINT32(save_p, ht->revAngle);
+ P_WriteFixed(save_p, ht->momx);
+ P_WriteFixed(save_p, ht->momy);
+ P_WriteUINT8(save_p, ht->closing);
+}
+
+static void SavePolyswingdoorThinker(save_t *save_p, const thinker_t *th, const UINT8 type)
{
const polyswingdoor_t *ht = (const void *)th;
- WRITEUINT8(save_p, type);
- WRITEINT32(save_p, ht->polyObjNum);
- WRITEINT32(save_p, ht->delay);
- WRITEINT32(save_p, ht->delayCount);
- WRITEINT32(save_p, ht->initSpeed);
- WRITEINT32(save_p, ht->speed);
- WRITEINT32(save_p, ht->initDistance);
- WRITEINT32(save_p, ht->distance);
- WRITEUINT8(save_p, ht->closing);
+ P_WriteUINT8(save_p, type);
+ P_WriteINT32(save_p, ht->polyObjNum);
+ P_WriteINT32(save_p, ht->delay);
+ P_WriteINT32(save_p, ht->delayCount);
+ P_WriteINT32(save_p, ht->initSpeed);
+ P_WriteINT32(save_p, ht->speed);
+ P_WriteINT32(save_p, ht->initDistance);
+ P_WriteINT32(save_p, ht->distance);
+ P_WriteUINT8(save_p, ht->closing);
}
-static void SavePolydisplaceThinker(const thinker_t *th, const UINT8 type)
+static void SavePolydisplaceThinker(save_t *save_p, const thinker_t *th, const UINT8 type)
{
const polydisplace_t *ht = (const void *)th;
- WRITEUINT8(save_p, type);
- WRITEINT32(save_p, ht->polyObjNum);
- WRITEUINT32(save_p, SaveSector(ht->controlSector));
- WRITEFIXED(save_p, ht->dx);
- WRITEFIXED(save_p, ht->dy);
- WRITEFIXED(save_p, ht->oldHeights);
+ P_WriteUINT8(save_p, type);
+ P_WriteINT32(save_p, ht->polyObjNum);
+ P_WriteUINT32(save_p, SaveSector(ht->controlSector));
+ P_WriteFixed(save_p, ht->dx);
+ P_WriteFixed(save_p, ht->dy);
+ P_WriteFixed(save_p, ht->oldHeights);
}
-static void SavePolyrotdisplaceThinker(const thinker_t *th, const UINT8 type)
+static void SavePolyrotdisplaceThinker(save_t *save_p, const thinker_t *th, const UINT8 type)
{
const polyrotdisplace_t *ht = (const void *)th;
- WRITEUINT8(save_p, type);
- WRITEINT32(save_p, ht->polyObjNum);
- WRITEUINT32(save_p, SaveSector(ht->controlSector));
- WRITEFIXED(save_p, ht->rotscale);
- WRITEUINT8(save_p, ht->turnobjs);
- WRITEFIXED(save_p, ht->oldHeights);
+ P_WriteUINT8(save_p, type);
+ P_WriteINT32(save_p, ht->polyObjNum);
+ P_WriteUINT32(save_p, SaveSector(ht->controlSector));
+ P_WriteFixed(save_p, ht->rotscale);
+ P_WriteUINT8(save_p, ht->turnobjs);
+ P_WriteFixed(save_p, ht->oldHeights);
}
-static void SavePolyfadeThinker(const thinker_t *th, const UINT8 type)
+static void SavePolyfadeThinker(save_t *save_p, const thinker_t *th, const UINT8 type)
{
const polyfade_t *ht = (const void *)th;
- WRITEUINT8(save_p, type);
- WRITEINT32(save_p, ht->polyObjNum);
- WRITEINT32(save_p, ht->sourcevalue);
- WRITEINT32(save_p, ht->destvalue);
- WRITEUINT8(save_p, (UINT8)ht->docollision);
- WRITEUINT8(save_p, (UINT8)ht->doghostfade);
- WRITEUINT8(save_p, (UINT8)ht->ticbased);
- WRITEINT32(save_p, ht->duration);
- WRITEINT32(save_p, ht->timer);
+ P_WriteUINT8(save_p, type);
+ P_WriteINT32(save_p, ht->polyObjNum);
+ P_WriteINT32(save_p, ht->sourcevalue);
+ P_WriteINT32(save_p, ht->destvalue);
+ P_WriteUINT8(save_p, (UINT8)ht->docollision);
+ P_WriteUINT8(save_p, (UINT8)ht->doghostfade);
+ P_WriteUINT8(save_p, (UINT8)ht->ticbased);
+ P_WriteINT32(save_p, ht->duration);
+ P_WriteINT32(save_p, ht->timer);
}
-static void P_NetArchiveThinkers(void)
+static void P_NetArchiveThinkers(save_t *save_p)
{
const thinker_t *th;
UINT32 i;
- WRITEUINT32(save_p, ARCHIVEBLOCK_THINKERS);
+ P_WriteUINT32(save_p, ARCHIVEBLOCK_THINKERS);
for (i = 0; i < NUM_THINKERLISTS; i++)
{
@@ -2732,13 +2972,12 @@ static void P_NetArchiveThinkers(void)
// save off the current thinkers
for (th = thlist[i].next; th != &thlist[i]; th = th->next)
{
- if (!(th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed
- || th->function.acp1 == (actionf_p1)P_NullPrecipThinker))
+ if (!(th->removing || th->function.acp1 == (actionf_p1)P_NullPrecipThinker))
numsaved++;
if (th->function.acp1 == (actionf_p1)P_MobjThinker)
{
- SaveMobjThinker(th, tc_mobj);
+ SaveMobjThinker(save_p, th, tc_mobj);
continue;
}
#ifdef PARANOIA
@@ -2746,213 +2985,213 @@ static void P_NetArchiveThinkers(void)
#endif
else if (th->function.acp1 == (actionf_p1)T_MoveCeiling)
{
- SaveCeilingThinker(th, tc_ceiling);
+ SaveCeilingThinker(save_p, th, tc_ceiling);
continue;
}
else if (th->function.acp1 == (actionf_p1)T_CrushCeiling)
{
- SaveCeilingThinker(th, tc_crushceiling);
+ SaveCeilingThinker(save_p, th, tc_crushceiling);
continue;
}
else if (th->function.acp1 == (actionf_p1)T_MoveFloor)
{
- SaveFloormoveThinker(th, tc_floor);
+ SaveFloormoveThinker(save_p, th, tc_floor);
continue;
}
else if (th->function.acp1 == (actionf_p1)T_LightningFlash)
{
- SaveLightflashThinker(th, tc_flash);
+ SaveLightflashThinker(save_p, th, tc_flash);
continue;
}
else if (th->function.acp1 == (actionf_p1)T_StrobeFlash)
{
- SaveStrobeThinker(th, tc_strobe);
+ SaveStrobeThinker(save_p, th, tc_strobe);
continue;
}
else if (th->function.acp1 == (actionf_p1)T_Glow)
{
- SaveGlowThinker(th, tc_glow);
+ SaveGlowThinker(save_p, th, tc_glow);
continue;
}
else if (th->function.acp1 == (actionf_p1)T_FireFlicker)
{
- SaveFireflickerThinker(th, tc_fireflicker);
+ SaveFireflickerThinker(save_p, th, tc_fireflicker);
continue;
}
else if (th->function.acp1 == (actionf_p1)T_MoveElevator)
{
- SaveElevatorThinker(th, tc_elevator);
+ SaveElevatorThinker(save_p, th, tc_elevator);
continue;
}
else if (th->function.acp1 == (actionf_p1)T_ContinuousFalling)
{
- SaveContinuousFallThinker(th, tc_continuousfalling);
+ SaveContinuousFallThinker(save_p, th, tc_continuousfalling);
continue;
}
else if (th->function.acp1 == (actionf_p1)T_ThwompSector)
{
- SaveThwompThinker(th, tc_thwomp);
+ SaveThwompThinker(save_p, th, tc_thwomp);
continue;
}
else if (th->function.acp1 == (actionf_p1)T_NoEnemiesSector)
{
- SaveNoEnemiesThinker(th, tc_noenemies);
+ SaveNoEnemiesThinker(save_p, th, tc_noenemies);
continue;
}
else if (th->function.acp1 == (actionf_p1)T_EachTimeThinker)
{
- SaveEachTimeThinker(th, tc_eachtime);
+ SaveEachTimeThinker(save_p, th, tc_eachtime);
continue;
}
else if (th->function.acp1 == (actionf_p1)T_RaiseSector)
{
- SaveRaiseThinker(th, tc_raisesector);
+ SaveRaiseThinker(save_p, th, tc_raisesector);
continue;
}
else if (th->function.acp1 == (actionf_p1)T_CameraScanner)
{
- SaveElevatorThinker(th, tc_camerascanner);
+ SaveElevatorThinker(save_p, th, tc_camerascanner);
continue;
}
else if (th->function.acp1 == (actionf_p1)T_Scroll)
{
- SaveScrollThinker(th, tc_scroll);
+ SaveScrollThinker(save_p, th, tc_scroll);
continue;
}
else if (th->function.acp1 == (actionf_p1)T_Friction)
{
- SaveFrictionThinker(th, tc_friction);
+ SaveFrictionThinker(save_p, th, tc_friction);
continue;
}
else if (th->function.acp1 == (actionf_p1)T_Pusher)
{
- SavePusherThinker(th, tc_pusher);
+ SavePusherThinker(save_p, th, tc_pusher);
continue;
}
else if (th->function.acp1 == (actionf_p1)T_BounceCheese)
{
- SaveBounceCheeseThinker(th, tc_bouncecheese);
+ SaveBounceCheeseThinker(save_p, th, tc_bouncecheese);
continue;
}
else if (th->function.acp1 == (actionf_p1)T_StartCrumble)
{
- SaveCrumbleThinker(th, tc_startcrumble);
+ SaveCrumbleThinker(save_p, th, tc_startcrumble);
continue;
}
else if (th->function.acp1 == (actionf_p1)T_MarioBlock)
{
- SaveMarioBlockThinker(th, tc_marioblock);
+ SaveMarioBlockThinker(save_p, th, tc_marioblock);
continue;
}
else if (th->function.acp1 == (actionf_p1)T_MarioBlockChecker)
{
- SaveMarioCheckThinker(th, tc_marioblockchecker);
+ SaveMarioCheckThinker(save_p, th, tc_marioblockchecker);
continue;
}
else if (th->function.acp1 == (actionf_p1)T_FloatSector)
{
- SaveFloatThinker(th, tc_floatsector);
+ SaveFloatThinker(save_p, th, tc_floatsector);
continue;
}
else if (th->function.acp1 == (actionf_p1)T_LaserFlash)
{
- SaveLaserThinker(th, tc_laserflash);
+ SaveLaserThinker(save_p, th, tc_laserflash);
continue;
}
else if (th->function.acp1 == (actionf_p1)T_LightFade)
{
- SaveLightlevelThinker(th, tc_lightfade);
+ SaveLightlevelThinker(save_p, th, tc_lightfade);
continue;
}
else if (th->function.acp1 == (actionf_p1)T_ExecutorDelay)
{
- SaveExecutorThinker(th, tc_executor);
+ SaveExecutorThinker(save_p, th, tc_executor);
continue;
}
else if (th->function.acp1 == (actionf_p1)T_Disappear)
{
- SaveDisappearThinker(th, tc_disappear);
+ SaveDisappearThinker(save_p, th, tc_disappear);
continue;
}
else if (th->function.acp1 == (actionf_p1)T_Fade)
{
- SaveFadeThinker(th, tc_fade);
+ SaveFadeThinker(save_p, th, tc_fade);
continue;
}
else if (th->function.acp1 == (actionf_p1)T_FadeColormap)
{
- SaveFadeColormapThinker(th, tc_fadecolormap);
+ SaveFadeColormapThinker(save_p, th, tc_fadecolormap);
continue;
}
else if (th->function.acp1 == (actionf_p1)T_PlaneDisplace)
{
- SavePlaneDisplaceThinker(th, tc_planedisplace);
+ SavePlaneDisplaceThinker(save_p, th, tc_planedisplace);
continue;
}
else if (th->function.acp1 == (actionf_p1)T_PolyObjRotate)
{
- SavePolyrotatetThinker(th, tc_polyrotate);
+ SavePolyrotatetThinker(save_p, th, tc_polyrotate);
continue;
}
else if (th->function.acp1 == (actionf_p1)T_PolyObjMove)
{
- SavePolymoveThinker(th, tc_polymove);
+ SavePolymoveThinker(save_p, th, tc_polymove);
continue;
}
else if (th->function.acp1 == (actionf_p1)T_PolyObjWaypoint)
{
- SavePolywaypointThinker(th, tc_polywaypoint);
+ SavePolywaypointThinker(save_p, th, tc_polywaypoint);
continue;
}
else if (th->function.acp1 == (actionf_p1)T_PolyDoorSlide)
{
- SavePolyslidedoorThinker(th, tc_polyslidedoor);
+ SavePolyslidedoorThinker(save_p, th, tc_polyslidedoor);
continue;
}
else if (th->function.acp1 == (actionf_p1)T_PolyDoorSwing)
{
- SavePolyswingdoorThinker(th, tc_polyswingdoor);
+ SavePolyswingdoorThinker(save_p, th, tc_polyswingdoor);
continue;
}
else if (th->function.acp1 == (actionf_p1)T_PolyObjFlag)
{
- SavePolymoveThinker(th, tc_polyflag);
+ SavePolymoveThinker(save_p, th, tc_polyflag);
continue;
}
else if (th->function.acp1 == (actionf_p1)T_PolyObjDisplace)
{
- SavePolydisplaceThinker(th, tc_polydisplace);
+ SavePolydisplaceThinker(save_p, th, tc_polydisplace);
continue;
}
else if (th->function.acp1 == (actionf_p1)T_PolyObjRotDisplace)
{
- SavePolyrotdisplaceThinker(th, tc_polyrotdisplace);
+ SavePolyrotdisplaceThinker(save_p, th, tc_polyrotdisplace);
continue;
}
else if (th->function.acp1 == (actionf_p1)T_PolyObjFade)
{
- SavePolyfadeThinker(th, tc_polyfade);
+ SavePolyfadeThinker(save_p, th, tc_polyfade);
continue;
}
else if (th->function.acp1 == (actionf_p1)T_DynamicSlopeLine)
{
- SaveDynamicLineSlopeThinker(th, tc_dynslopeline);
+ SaveDynamicLineSlopeThinker(save_p, th, tc_dynslopeline);
continue;
}
else if (th->function.acp1 == (actionf_p1)T_DynamicSlopeVert)
{
- SaveDynamicVertexSlopeThinker(th, tc_dynslopevert);
+ SaveDynamicVertexSlopeThinker(save_p, th, tc_dynslopevert);
continue;
}
#ifdef PARANOIA
else
- I_Assert(th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed); // wait garbage collection
+ I_Assert(th->removing); // wait garbage collection
#endif
}
CONS_Debug(DBG_NETPLAY, "%u thinkers saved in list %d\n", numsaved, i);
- WRITEUINT8(save_p, tc_end);
+ P_WriteUINT8(save_p, tc_end);
}
}
@@ -2967,7 +3206,7 @@ mobj_t *P_FindNewPosition(UINT32 oldposition)
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
{
- if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (th->removing)
continue;
mobj = (mobj_t *)th;
@@ -3016,7 +3255,7 @@ static inline pslope_t *LoadSlope(UINT32 slopeid)
return NULL;
}
-static thinker_t* LoadMobjThinker(actionf_p1 thinker)
+static thinker_t* LoadMobjThinker(save_t *save_p, actionf_p1 thinker)
{
thinker_t *next;
mobj_t *mobj;
@@ -3026,35 +3265,35 @@ static thinker_t* LoadMobjThinker(actionf_p1 thinker)
fixed_t z, floorz, ceilingz;
ffloor_t *floorrover = NULL, *ceilingrover = NULL;
- diff = READUINT32(save_p);
+ diff = P_ReadUINT32(save_p);
if (diff & MD_MORE)
- diff2 = READUINT32(save_p);
+ diff2 = P_ReadUINT32(save_p);
else
diff2 = 0;
- next = (void *)(size_t)READUINT32(save_p);
+ next = (void *)(size_t)P_ReadUINT32(save_p);
- z = READFIXED(save_p); // Force this so 3dfloor problems don't arise.
- floorz = READFIXED(save_p);
- ceilingz = READFIXED(save_p);
+ z = P_ReadFixed(save_p); // Force this so 3dfloor problems don't arise.
+ floorz = P_ReadFixed(save_p);
+ ceilingz = P_ReadFixed(save_p);
if (diff2 & MD2_FLOORROVER)
{
- sector_t *sec = LoadSector(READUINT32(save_p));
- UINT16 id = READUINT16(save_p);
+ sector_t *sec = LoadSector(P_ReadUINT32(save_p));
+ UINT16 id = P_ReadUINT16(save_p);
floorrover = P_GetFFloorByID(sec, id);
}
if (diff2 & MD2_CEILINGROVER)
{
- sector_t *sec = LoadSector(READUINT32(save_p));
- UINT16 id = READUINT16(save_p);
+ sector_t *sec = LoadSector(P_ReadUINT32(save_p));
+ UINT16 id = P_ReadUINT16(save_p);
ceilingrover = P_GetFFloorByID(sec, id);
}
if (diff & MD_SPAWNPOINT)
{
- UINT16 spawnpointnum = READUINT16(save_p);
+ UINT16 spawnpointnum = P_ReadUINT16(save_p);
if (mapthings[spawnpointnum].type == 1713) // NiGHTS Hoop special case
{
@@ -3080,7 +3319,7 @@ static thinker_t* LoadMobjThinker(actionf_p1 thinker)
mobj->ceilingrover = ceilingrover;
if (diff & MD_TYPE)
- mobj->type = READUINT32(save_p);
+ mobj->type = P_ReadUINT32(save_p);
else
{
for (i = 0; i < NUMMOBJTYPES; i++)
@@ -3099,11 +3338,11 @@ static thinker_t* LoadMobjThinker(actionf_p1 thinker)
mobj->info = &mobjinfo[mobj->type];
if (diff & MD_POS)
{
- mobj->x = READFIXED(save_p);
- mobj->y = READFIXED(save_p);
- mobj->angle = READANGLE(save_p);
- mobj->pitch = READANGLE(save_p);
- mobj->roll = READANGLE(save_p);
+ mobj->x = P_ReadFixed(save_p);
+ mobj->y = P_ReadFixed(save_p);
+ mobj->angle = P_ReadAngle(save_p);
+ mobj->pitch = P_ReadAngle(save_p);
+ mobj->roll = P_ReadAngle(save_p);
}
else
{
@@ -3115,47 +3354,47 @@ static thinker_t* LoadMobjThinker(actionf_p1 thinker)
}
if (diff & MD_MOM)
{
- mobj->momx = READFIXED(save_p);
- mobj->momy = READFIXED(save_p);
- mobj->momz = READFIXED(save_p);
- mobj->pmomz = READFIXED(save_p);
+ mobj->momx = P_ReadFixed(save_p);
+ mobj->momy = P_ReadFixed(save_p);
+ mobj->momz = P_ReadFixed(save_p);
+ mobj->pmomz = P_ReadFixed(save_p);
} // otherwise they're zero, and the memset took care of it
if (diff & MD_RADIUS)
- mobj->radius = READFIXED(save_p);
+ mobj->radius = P_ReadFixed(save_p);
else
mobj->radius = mobj->info->radius;
if (diff & MD_HEIGHT)
- mobj->height = READFIXED(save_p);
+ mobj->height = P_ReadFixed(save_p);
else
mobj->height = mobj->info->height;
if (diff & MD_FLAGS)
- mobj->flags = READUINT32(save_p);
+ mobj->flags = P_ReadUINT32(save_p);
else
mobj->flags = mobj->info->flags;
if (diff & MD_FLAGS2)
- mobj->flags2 = READUINT32(save_p);
+ mobj->flags2 = P_ReadUINT32(save_p);
if (diff & MD_HEALTH)
- mobj->health = READINT32(save_p);
+ mobj->health = P_ReadINT32(save_p);
else
mobj->health = mobj->info->spawnhealth;
if (diff & MD_RTIME)
- mobj->reactiontime = READINT32(save_p);
+ mobj->reactiontime = P_ReadINT32(save_p);
else
mobj->reactiontime = mobj->info->reactiontime;
if (diff & MD_STATE)
- mobj->state = &states[READUINT16(save_p)];
+ mobj->state = &states[P_ReadUINT16(save_p)];
else
mobj->state = &states[mobj->info->spawnstate];
if (diff & MD_TICS)
- mobj->tics = READINT32(save_p);
+ mobj->tics = P_ReadINT32(save_p);
else
mobj->tics = mobj->state->tics;
if (diff & MD_SPRITE) {
- mobj->sprite = READUINT16(save_p);
+ mobj->sprite = P_ReadUINT16(save_p);
if (mobj->sprite == SPR_PLAY)
- mobj->sprite2 = READUINT16(save_p);
+ mobj->sprite2 = P_ReadUINT16(save_p);
}
else {
mobj->sprite = mobj->state->sprite;
@@ -3164,8 +3403,8 @@ static thinker_t* LoadMobjThinker(actionf_p1 thinker)
}
if (diff & MD_FRAME)
{
- mobj->frame = READUINT32(save_p);
- mobj->anim_duration = READUINT16(save_p);
+ mobj->frame = P_ReadUINT32(save_p);
+ mobj->anim_duration = P_ReadUINT16(save_p);
}
else
{
@@ -3173,130 +3412,130 @@ static thinker_t* LoadMobjThinker(actionf_p1 thinker)
mobj->anim_duration = (UINT16)mobj->state->var2;
}
if (diff & MD_EFLAGS)
- mobj->eflags = READUINT16(save_p);
+ mobj->eflags = P_ReadUINT16(save_p);
if (diff & MD_PLAYER)
{
- i = READUINT8(save_p);
+ i = P_ReadUINT8(save_p);
mobj->player = &players[i];
mobj->player->mo = mobj;
}
if (diff & MD_MOVEDIR)
- mobj->movedir = READANGLE(save_p);
+ mobj->movedir = P_ReadAngle(save_p);
if (diff & MD_MOVECOUNT)
- mobj->movecount = READINT32(save_p);
+ mobj->movecount = P_ReadINT32(save_p);
if (diff & MD_THRESHOLD)
- mobj->threshold = READINT32(save_p);
+ mobj->threshold = P_ReadINT32(save_p);
if (diff & MD_LASTLOOK)
- mobj->lastlook = READINT32(save_p);
+ mobj->lastlook = P_ReadINT32(save_p);
else
mobj->lastlook = -1;
if (diff & MD_TARGET)
- mobj->target = (mobj_t *)(size_t)READUINT32(save_p);
+ mobj->target = (mobj_t *)(size_t)P_ReadUINT32(save_p);
if (diff & MD_TRACER)
- mobj->tracer = (mobj_t *)(size_t)READUINT32(save_p);
+ mobj->tracer = (mobj_t *)(size_t)P_ReadUINT32(save_p);
if (diff & MD_FRICTION)
- mobj->friction = READFIXED(save_p);
+ mobj->friction = P_ReadFixed(save_p);
else
mobj->friction = ORIG_FRICTION;
if (diff & MD_MOVEFACTOR)
- mobj->movefactor = READFIXED(save_p);
+ mobj->movefactor = P_ReadFixed(save_p);
else
mobj->movefactor = FRACUNIT;
if (diff & MD_FUSE)
- mobj->fuse = READINT32(save_p);
+ mobj->fuse = P_ReadINT32(save_p);
if (diff & MD_WATERTOP)
- mobj->watertop = READFIXED(save_p);
+ mobj->watertop = P_ReadFixed(save_p);
if (diff & MD_WATERBOTTOM)
- mobj->waterbottom = READFIXED(save_p);
+ mobj->waterbottom = P_ReadFixed(save_p);
if (diff & MD_SCALE)
- mobj->scale = READFIXED(save_p);
+ mobj->scale = P_ReadFixed(save_p);
else
mobj->scale = FRACUNIT;
if (diff & MD_DSCALE)
- mobj->destscale = READFIXED(save_p);
+ mobj->destscale = P_ReadFixed(save_p);
else
mobj->destscale = mobj->scale;
if (diff2 & MD2_SCALESPEED)
- mobj->scalespeed = READFIXED(save_p);
+ mobj->scalespeed = P_ReadFixed(save_p);
else
mobj->scalespeed = FRACUNIT/12;
if (diff2 & MD2_CUSVAL)
- mobj->cusval = READINT32(save_p);
+ mobj->cusval = P_ReadINT32(save_p);
if (diff2 & MD2_CVMEM)
- mobj->cvmem = READINT32(save_p);
+ mobj->cvmem = P_ReadINT32(save_p);
if (diff2 & MD2_SKIN)
- mobj->skin = skins[READUINT8(save_p)];
+ mobj->skin = skins[P_ReadUINT8(save_p)];
if (diff2 & MD2_COLOR)
- mobj->color = READUINT16(save_p);
+ mobj->color = P_ReadUINT16(save_p);
if (diff2 & MD2_EXTVAL1)
- mobj->extravalue1 = READINT32(save_p);
+ mobj->extravalue1 = P_ReadINT32(save_p);
if (diff2 & MD2_EXTVAL2)
- mobj->extravalue2 = READINT32(save_p);
+ mobj->extravalue2 = P_ReadINT32(save_p);
if (diff2 & MD2_HNEXT)
- mobj->hnext = (mobj_t *)(size_t)READUINT32(save_p);
+ mobj->hnext = (mobj_t *)(size_t)P_ReadUINT32(save_p);
if (diff2 & MD2_HPREV)
- mobj->hprev = (mobj_t *)(size_t)READUINT32(save_p);
+ mobj->hprev = (mobj_t *)(size_t)P_ReadUINT32(save_p);
if (diff2 & MD2_SLOPE)
- mobj->standingslope = P_SlopeById(READUINT16(save_p));
+ mobj->standingslope = P_SlopeById(P_ReadUINT16(save_p));
if (diff2 & MD2_COLORIZED)
- mobj->colorized = READUINT8(save_p);
+ mobj->colorized = P_ReadUINT8(save_p);
if (diff2 & MD2_MIRRORED)
- mobj->mirrored = READUINT8(save_p);
+ mobj->mirrored = P_ReadUINT8(save_p);
if (diff2 & MD2_SPRITEROLL)
- mobj->spriteroll = READANGLE(save_p);
+ mobj->spriteroll = P_ReadAngle(save_p);
if (diff2 & MD2_SHADOWSCALE)
- mobj->shadowscale = READFIXED(save_p);
+ mobj->shadowscale = P_ReadFixed(save_p);
if (diff2 & MD2_RENDERFLAGS)
- mobj->renderflags = READUINT32(save_p);
+ mobj->renderflags = P_ReadUINT32(save_p);
if (diff2 & MD2_BLENDMODE)
- mobj->blendmode = READINT32(save_p);
+ mobj->blendmode = P_ReadINT32(save_p);
else
mobj->blendmode = AST_TRANSLUCENT;
if (diff2 & MD2_SPRITEXSCALE)
- mobj->spritexscale = READFIXED(save_p);
+ mobj->spritexscale = P_ReadFixed(save_p);
else
mobj->spritexscale = FRACUNIT;
if (diff2 & MD2_SPRITEYSCALE)
- mobj->spriteyscale = READFIXED(save_p);
+ mobj->spriteyscale = P_ReadFixed(save_p);
else
mobj->spriteyscale = FRACUNIT;
if (diff2 & MD2_SPRITEXOFFSET)
- mobj->spritexoffset = READFIXED(save_p);
+ mobj->spritexoffset = P_ReadFixed(save_p);
if (diff2 & MD2_SPRITEYOFFSET)
- mobj->spriteyoffset = READFIXED(save_p);
+ mobj->spriteyoffset = P_ReadFixed(save_p);
if (diff2 & MD2_FLOORSPRITESLOPE)
{
pslope_t *slope = (pslope_t *)P_CreateFloorSpriteSlope(mobj);
- slope->zdelta = READFIXED(save_p);
- slope->zangle = READANGLE(save_p);
- slope->xydirection = READANGLE(save_p);
+ slope->zdelta = P_ReadFixed(save_p);
+ slope->zangle = P_ReadAngle(save_p);
+ slope->xydirection = P_ReadAngle(save_p);
- slope->o.x = READFIXED(save_p);
- slope->o.y = READFIXED(save_p);
- slope->o.z = READFIXED(save_p);
+ slope->o.x = P_ReadFixed(save_p);
+ slope->o.y = P_ReadFixed(save_p);
+ slope->o.z = P_ReadFixed(save_p);
- slope->d.x = READFIXED(save_p);
- slope->d.y = READFIXED(save_p);
+ slope->d.x = P_ReadFixed(save_p);
+ slope->d.y = P_ReadFixed(save_p);
- slope->normal.x = READFIXED(save_p);
- slope->normal.y = READFIXED(save_p);
- slope->normal.z = READFIXED(save_p);
+ slope->normal.x = P_ReadFixed(save_p);
+ slope->normal.y = P_ReadFixed(save_p);
+ slope->normal.z = P_ReadFixed(save_p);
slope->moved = true;
}
if (diff2 & MD2_DRAWONLYFORPLAYER)
- mobj->drawonlyforplayer = &players[READUINT8(save_p)];
+ mobj->drawonlyforplayer = &players[P_ReadUINT8(save_p)];
if (diff2 & MD2_DONTDRAWFORVIEWMOBJ)
- mobj->dontdrawforviewmobj = (mobj_t *)(size_t)READUINT32(save_p);
+ mobj->dontdrawforviewmobj = (mobj_t *)(size_t)P_ReadUINT32(save_p);
if (diff2 & MD2_DISPOFFSET)
- mobj->dispoffset = READINT32(save_p);
+ mobj->dispoffset = P_ReadINT32(save_p);
else
mobj->dispoffset = mobj->info->dispoffset;
if (diff2 & MD2_TRANSLATION)
- mobj->translation = READUINT16(save_p);
+ mobj->translation = P_ReadUINT16(save_p);
if (diff2 & MD2_ALPHA)
- mobj->alpha = READFIXED(save_p);
+ mobj->alpha = P_ReadFixed(save_p);
else
mobj->alpha = FRACUNIT;
@@ -3314,7 +3553,7 @@ static thinker_t* LoadMobjThinker(actionf_p1 thinker)
// set sprev, snext, bprev, bnext, subsector
P_SetThingPosition(mobj);
- mobj->mobjnum = READUINT32(save_p);
+ mobj->mobjnum = P_ReadUINT32(save_p);
if (mobj->player)
{
@@ -3343,25 +3582,25 @@ static thinker_t* LoadMobjThinker(actionf_p1 thinker)
return &mobj->thinker;
}
-static thinker_t* LoadNoEnemiesThinker(actionf_p1 thinker)
+static thinker_t* LoadNoEnemiesThinker(save_t *save_p, actionf_p1 thinker)
{
noenemies_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
ht->thinker.function.acp1 = thinker;
- ht->sourceline = LoadLine(READUINT32(save_p));
+ ht->sourceline = LoadLine(P_ReadUINT32(save_p));
return &ht->thinker;
}
-static thinker_t* LoadBounceCheeseThinker(actionf_p1 thinker)
+static thinker_t* LoadBounceCheeseThinker(save_t *save_p, actionf_p1 thinker)
{
bouncecheese_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
ht->thinker.function.acp1 = thinker;
- ht->sourceline = LoadLine(READUINT32(save_p));
- ht->sector = LoadSector(READUINT32(save_p));
- ht->speed = READFIXED(save_p);
- ht->distance = READFIXED(save_p);
- ht->floorwasheight = READFIXED(save_p);
- ht->ceilingwasheight = READFIXED(save_p);
- ht->low = READCHAR(save_p);
+ ht->sourceline = LoadLine(P_ReadUINT32(save_p));
+ ht->sector = LoadSector(P_ReadUINT32(save_p));
+ ht->speed = P_ReadFixed(save_p);
+ ht->distance = P_ReadFixed(save_p);
+ ht->floorwasheight = P_ReadFixed(save_p);
+ ht->ceilingwasheight = P_ReadFixed(save_p);
+ ht->low = P_ReadChar(save_p);
if (ht->sector)
ht->sector->ceilingdata = ht;
@@ -3369,16 +3608,16 @@ static thinker_t* LoadBounceCheeseThinker(actionf_p1 thinker)
return &ht->thinker;
}
-static thinker_t* LoadContinuousFallThinker(actionf_p1 thinker)
+static thinker_t* LoadContinuousFallThinker(save_t *save_p, actionf_p1 thinker)
{
continuousfall_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
ht->thinker.function.acp1 = thinker;
- ht->sector = LoadSector(READUINT32(save_p));
- ht->speed = READFIXED(save_p);
- ht->direction = READINT32(save_p);
- ht->floorstartheight = READFIXED(save_p);
- ht->ceilingstartheight = READFIXED(save_p);
- ht->destheight = READFIXED(save_p);
+ ht->sector = LoadSector(P_ReadUINT32(save_p));
+ ht->speed = P_ReadFixed(save_p);
+ ht->direction = P_ReadINT32(save_p);
+ ht->floorstartheight = P_ReadFixed(save_p);
+ ht->ceilingstartheight = P_ReadFixed(save_p);
+ ht->destheight = P_ReadFixed(save_p);
if (ht->sector)
{
@@ -3389,16 +3628,16 @@ static thinker_t* LoadContinuousFallThinker(actionf_p1 thinker)
return &ht->thinker;
}
-static thinker_t* LoadMarioBlockThinker(actionf_p1 thinker)
+static thinker_t* LoadMarioBlockThinker(save_t *save_p, actionf_p1 thinker)
{
mariothink_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
ht->thinker.function.acp1 = thinker;
- ht->sector = LoadSector(READUINT32(save_p));
- ht->speed = READFIXED(save_p);
- ht->direction = READINT32(save_p);
- ht->floorstartheight = READFIXED(save_p);
- ht->ceilingstartheight = READFIXED(save_p);
- ht->tag = READINT16(save_p);
+ ht->sector = LoadSector(P_ReadUINT32(save_p));
+ ht->speed = P_ReadFixed(save_p);
+ ht->direction = P_ReadINT32(save_p);
+ ht->floorstartheight = P_ReadFixed(save_p);
+ ht->ceilingstartheight = P_ReadFixed(save_p);
+ ht->tag = P_ReadINT16(save_p);
if (ht->sector)
{
@@ -3409,29 +3648,29 @@ static thinker_t* LoadMarioBlockThinker(actionf_p1 thinker)
return &ht->thinker;
}
-static thinker_t* LoadMarioCheckThinker(actionf_p1 thinker)
+static thinker_t* LoadMarioCheckThinker(save_t *save_p, actionf_p1 thinker)
{
mariocheck_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
ht->thinker.function.acp1 = thinker;
- ht->sourceline = LoadLine(READUINT32(save_p));
- ht->sector = LoadSector(READUINT32(save_p));
+ ht->sourceline = LoadLine(P_ReadUINT32(save_p));
+ ht->sector = LoadSector(P_ReadUINT32(save_p));
return &ht->thinker;
}
-static thinker_t* LoadThwompThinker(actionf_p1 thinker)
+static thinker_t* LoadThwompThinker(save_t *save_p, actionf_p1 thinker)
{
thwomp_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
ht->thinker.function.acp1 = thinker;
- ht->sourceline = LoadLine(READUINT32(save_p));
- ht->sector = LoadSector(READUINT32(save_p));
- ht->crushspeed = READFIXED(save_p);
- ht->retractspeed = READFIXED(save_p);
- ht->direction = READINT32(save_p);
- ht->floorstartheight = READFIXED(save_p);
- ht->ceilingstartheight = READFIXED(save_p);
- ht->delay = READINT32(save_p);
- ht->tag = READINT16(save_p);
- ht->sound = READUINT16(save_p);
+ ht->sourceline = LoadLine(P_ReadUINT32(save_p));
+ ht->sector = LoadSector(P_ReadUINT32(save_p));
+ ht->crushspeed = P_ReadFixed(save_p);
+ ht->retractspeed = P_ReadFixed(save_p);
+ ht->direction = P_ReadINT32(save_p);
+ ht->floorstartheight = P_ReadFixed(save_p);
+ ht->ceilingstartheight = P_ReadFixed(save_p);
+ ht->delay = P_ReadINT32(save_p);
+ ht->tag = P_ReadINT16(save_p);
+ ht->sound = P_ReadUINT16(save_p);
if (ht->sector)
{
@@ -3442,163 +3681,163 @@ static thinker_t* LoadThwompThinker(actionf_p1 thinker)
return &ht->thinker;
}
-static thinker_t* LoadFloatThinker(actionf_p1 thinker)
+static thinker_t* LoadFloatThinker(save_t *save_p, actionf_p1 thinker)
{
floatthink_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
ht->thinker.function.acp1 = thinker;
- ht->sourceline = LoadLine(READUINT32(save_p));
- ht->sector = LoadSector(READUINT32(save_p));
- ht->tag = READINT16(save_p);
+ ht->sourceline = LoadLine(P_ReadUINT32(save_p));
+ ht->sector = LoadSector(P_ReadUINT32(save_p));
+ ht->tag = P_ReadINT16(save_p);
return &ht->thinker;
}
-static thinker_t* LoadEachTimeThinker(actionf_p1 thinker)
+static thinker_t* LoadEachTimeThinker(save_t *save_p, actionf_p1 thinker)
{
size_t i;
eachtime_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
ht->thinker.function.acp1 = thinker;
- ht->sourceline = LoadLine(READUINT32(save_p));
+ ht->sourceline = LoadLine(P_ReadUINT32(save_p));
for (i = 0; i < MAXPLAYERS; i++)
{
- ht->playersInArea[i] = READCHAR(save_p);
+ ht->playersInArea[i] = P_ReadChar(save_p);
}
- ht->triggerOnExit = READCHAR(save_p);
+ ht->triggerOnExit = P_ReadChar(save_p);
return &ht->thinker;
}
-static thinker_t* LoadRaiseThinker(actionf_p1 thinker)
+static thinker_t* LoadRaiseThinker(save_t *save_p, actionf_p1 thinker)
{
raise_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
ht->thinker.function.acp1 = thinker;
- ht->tag = READINT16(save_p);
- ht->sector = LoadSector(READUINT32(save_p));
- ht->ceilingbottom = READFIXED(save_p);
- ht->ceilingtop = READFIXED(save_p);
- ht->basespeed = READFIXED(save_p);
- ht->extraspeed = READFIXED(save_p);
- ht->shaketimer = READUINT8(save_p);
- ht->flags = READUINT8(save_p);
+ ht->tag = P_ReadINT16(save_p);
+ ht->sector = LoadSector(P_ReadUINT32(save_p));
+ ht->ceilingbottom = P_ReadFixed(save_p);
+ ht->ceilingtop = P_ReadFixed(save_p);
+ ht->basespeed = P_ReadFixed(save_p);
+ ht->extraspeed = P_ReadFixed(save_p);
+ ht->shaketimer = P_ReadUINT8(save_p);
+ ht->flags = P_ReadUINT8(save_p);
return &ht->thinker;
}
-static thinker_t* LoadCeilingThinker(actionf_p1 thinker)
+static thinker_t* LoadCeilingThinker(save_t *save_p, actionf_p1 thinker)
{
ceiling_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
ht->thinker.function.acp1 = thinker;
- ht->type = READUINT8(save_p);
- ht->sector = LoadSector(READUINT32(save_p));
- ht->bottomheight = READFIXED(save_p);
- ht->topheight = READFIXED(save_p);
- ht->speed = READFIXED(save_p);
- ht->delay = READFIXED(save_p);
- ht->delaytimer = READFIXED(save_p);
- ht->crush = READUINT8(save_p);
- ht->texture = READINT32(save_p);
- ht->direction = READINT32(save_p);
- ht->tag = READINT16(save_p);
- ht->origspeed = READFIXED(save_p);
- ht->sourceline = READFIXED(save_p);
+ ht->type = P_ReadUINT8(save_p);
+ ht->sector = LoadSector(P_ReadUINT32(save_p));
+ ht->bottomheight = P_ReadFixed(save_p);
+ ht->topheight = P_ReadFixed(save_p);
+ ht->speed = P_ReadFixed(save_p);
+ ht->delay = P_ReadFixed(save_p);
+ ht->delaytimer = P_ReadFixed(save_p);
+ ht->crush = P_ReadUINT8(save_p);
+ ht->texture = P_ReadINT32(save_p);
+ ht->direction = P_ReadINT32(save_p);
+ ht->tag = P_ReadINT16(save_p);
+ ht->origspeed = P_ReadFixed(save_p);
+ ht->sourceline = P_ReadFixed(save_p);
if (ht->sector)
ht->sector->ceilingdata = ht;
return &ht->thinker;
}
-static thinker_t* LoadFloormoveThinker(actionf_p1 thinker)
+static thinker_t* LoadFloormoveThinker(save_t *save_p, actionf_p1 thinker)
{
floormove_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
ht->thinker.function.acp1 = thinker;
- ht->type = READUINT8(save_p);
- ht->crush = READUINT8(save_p);
- ht->sector = LoadSector(READUINT32(save_p));
- ht->direction = READINT32(save_p);
- ht->texture = READINT32(save_p);
- ht->floordestheight = READFIXED(save_p);
- ht->speed = READFIXED(save_p);
- ht->origspeed = READFIXED(save_p);
- ht->delay = READFIXED(save_p);
- ht->delaytimer = READFIXED(save_p);
- ht->tag = READINT16(save_p);
- ht->sourceline = READFIXED(save_p);
+ ht->type = P_ReadUINT8(save_p);
+ ht->crush = P_ReadUINT8(save_p);
+ ht->sector = LoadSector(P_ReadUINT32(save_p));
+ ht->direction = P_ReadINT32(save_p);
+ ht->texture = P_ReadINT32(save_p);
+ ht->floordestheight = P_ReadFixed(save_p);
+ ht->speed = P_ReadFixed(save_p);
+ ht->origspeed = P_ReadFixed(save_p);
+ ht->delay = P_ReadFixed(save_p);
+ ht->delaytimer = P_ReadFixed(save_p);
+ ht->tag = P_ReadINT16(save_p);
+ ht->sourceline = P_ReadFixed(save_p);
if (ht->sector)
ht->sector->floordata = ht;
return &ht->thinker;
}
-static thinker_t* LoadLightflashThinker(actionf_p1 thinker)
+static thinker_t* LoadLightflashThinker(save_t *save_p, actionf_p1 thinker)
{
lightflash_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
ht->thinker.function.acp1 = thinker;
- ht->sector = LoadSector(READUINT32(save_p));
- ht->maxlight = READINT32(save_p);
- ht->minlight = READINT32(save_p);
+ ht->sector = LoadSector(P_ReadUINT32(save_p));
+ ht->maxlight = P_ReadINT32(save_p);
+ ht->minlight = P_ReadINT32(save_p);
if (ht->sector)
ht->sector->lightingdata = ht;
return &ht->thinker;
}
-static thinker_t* LoadStrobeThinker(actionf_p1 thinker)
+static thinker_t* LoadStrobeThinker(save_t *save_p, actionf_p1 thinker)
{
strobe_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
ht->thinker.function.acp1 = thinker;
- ht->sector = LoadSector(READUINT32(save_p));
- ht->count = READINT32(save_p);
- ht->minlight = READINT16(save_p);
- ht->maxlight = READINT16(save_p);
- ht->darktime = READINT32(save_p);
- ht->brighttime = READINT32(save_p);
+ ht->sector = LoadSector(P_ReadUINT32(save_p));
+ ht->count = P_ReadINT32(save_p);
+ ht->minlight = P_ReadINT16(save_p);
+ ht->maxlight = P_ReadINT16(save_p);
+ ht->darktime = P_ReadINT32(save_p);
+ ht->brighttime = P_ReadINT32(save_p);
if (ht->sector)
ht->sector->lightingdata = ht;
return &ht->thinker;
}
-static thinker_t* LoadGlowThinker(actionf_p1 thinker)
+static thinker_t* LoadGlowThinker(save_t *save_p, actionf_p1 thinker)
{
glow_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
ht->thinker.function.acp1 = thinker;
- ht->sector = LoadSector(READUINT32(save_p));
- ht->minlight = READINT16(save_p);
- ht->maxlight = READINT16(save_p);
- ht->direction = READINT16(save_p);
- ht->speed = READINT16(save_p);
+ ht->sector = LoadSector(P_ReadUINT32(save_p));
+ ht->minlight = P_ReadINT16(save_p);
+ ht->maxlight = P_ReadINT16(save_p);
+ ht->direction = P_ReadINT16(save_p);
+ ht->speed = P_ReadINT16(save_p);
if (ht->sector)
ht->sector->lightingdata = ht;
return &ht->thinker;
}
-static thinker_t* LoadFireflickerThinker(actionf_p1 thinker)
+static thinker_t* LoadFireflickerThinker(save_t *save_p, actionf_p1 thinker)
{
fireflicker_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
ht->thinker.function.acp1 = thinker;
- ht->sector = LoadSector(READUINT32(save_p));
- ht->count = READINT32(save_p);
- ht->resetcount = READINT32(save_p);
- ht->maxlight = READINT16(save_p);
- ht->minlight = READINT16(save_p);
+ ht->sector = LoadSector(P_ReadUINT32(save_p));
+ ht->count = P_ReadINT32(save_p);
+ ht->resetcount = P_ReadINT32(save_p);
+ ht->maxlight = P_ReadINT16(save_p);
+ ht->minlight = P_ReadINT16(save_p);
if (ht->sector)
ht->sector->lightingdata = ht;
return &ht->thinker;
}
-static thinker_t* LoadElevatorThinker(actionf_p1 thinker, boolean setplanedata)
+static thinker_t* LoadElevatorThinker(save_t *save_p, actionf_p1 thinker, boolean setplanedata)
{
elevator_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
ht->thinker.function.acp1 = thinker;
- ht->type = READUINT8(save_p);
- ht->sector = LoadSector(READUINT32(save_p));
- ht->actionsector = LoadSector(READUINT32(save_p));
- ht->direction = READINT32(save_p);
- ht->floordestheight = READFIXED(save_p);
- ht->ceilingdestheight = READFIXED(save_p);
- ht->speed = READFIXED(save_p);
- ht->origspeed = READFIXED(save_p);
- ht->low = READFIXED(save_p);
- ht->high = READFIXED(save_p);
- ht->distance = READFIXED(save_p);
- ht->delay = READFIXED(save_p);
- ht->delaytimer = READFIXED(save_p);
- ht->floorwasheight = READFIXED(save_p);
- ht->ceilingwasheight = READFIXED(save_p);
- ht->sourceline = LoadLine(READUINT32(save_p));
+ ht->type = P_ReadUINT8(save_p);
+ ht->sector = LoadSector(P_ReadUINT32(save_p));
+ ht->actionsector = LoadSector(P_ReadUINT32(save_p));
+ ht->direction = P_ReadINT32(save_p);
+ ht->floordestheight = P_ReadFixed(save_p);
+ ht->ceilingdestheight = P_ReadFixed(save_p);
+ ht->speed = P_ReadFixed(save_p);
+ ht->origspeed = P_ReadFixed(save_p);
+ ht->low = P_ReadFixed(save_p);
+ ht->high = P_ReadFixed(save_p);
+ ht->distance = P_ReadFixed(save_p);
+ ht->delay = P_ReadFixed(save_p);
+ ht->delaytimer = P_ReadFixed(save_p);
+ ht->floorwasheight = P_ReadFixed(save_p);
+ ht->ceilingwasheight = P_ReadFixed(save_p);
+ ht->sourceline = LoadLine(P_ReadUINT32(save_p));
if (ht->sector && setplanedata)
{
@@ -3609,21 +3848,21 @@ static thinker_t* LoadElevatorThinker(actionf_p1 thinker, boolean setplanedata)
return &ht->thinker;
}
-static thinker_t* LoadCrumbleThinker(actionf_p1 thinker)
+static thinker_t* LoadCrumbleThinker(save_t *save_p, actionf_p1 thinker)
{
crumble_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
ht->thinker.function.acp1 = thinker;
- ht->sourceline = LoadLine(READUINT32(save_p));
- ht->sector = LoadSector(READUINT32(save_p));
- ht->actionsector = LoadSector(READUINT32(save_p));
- ht->player = LoadPlayer(READUINT32(save_p));
- ht->direction = READINT32(save_p);
- ht->origalpha = READINT32(save_p);
- ht->timer = READINT32(save_p);
- ht->speed = READFIXED(save_p);
- ht->floorwasheight = READFIXED(save_p);
- ht->ceilingwasheight = READFIXED(save_p);
- ht->flags = READUINT8(save_p);
+ ht->sourceline = LoadLine(P_ReadUINT32(save_p));
+ ht->sector = LoadSector(P_ReadUINT32(save_p));
+ ht->actionsector = LoadSector(P_ReadUINT32(save_p));
+ ht->player = LoadPlayer(P_ReadUINT32(save_p));
+ ht->direction = P_ReadINT32(save_p);
+ ht->origalpha = P_ReadINT32(save_p);
+ ht->timer = P_ReadINT32(save_p);
+ ht->speed = P_ReadFixed(save_p);
+ ht->floorwasheight = P_ReadFixed(save_p);
+ ht->ceilingwasheight = P_ReadFixed(save_p);
+ ht->flags = P_ReadUINT8(save_p);
if (ht->sector)
ht->sector->floordata = ht;
@@ -3631,123 +3870,123 @@ static thinker_t* LoadCrumbleThinker(actionf_p1 thinker)
return &ht->thinker;
}
-static thinker_t* LoadScrollThinker(actionf_p1 thinker)
+static thinker_t* LoadScrollThinker(save_t *save_p, actionf_p1 thinker)
{
scroll_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
ht->thinker.function.acp1 = thinker;
- ht->dx = READFIXED(save_p);
- ht->dy = READFIXED(save_p);
- ht->affectee = READINT32(save_p);
- ht->control = READINT32(save_p);
- ht->last_height = READFIXED(save_p);
- ht->vdx = READFIXED(save_p);
- ht->vdy = READFIXED(save_p);
- ht->accel = READINT32(save_p);
- ht->exclusive = READINT32(save_p);
- ht->type = READUINT8(save_p);
+ ht->dx = P_ReadFixed(save_p);
+ ht->dy = P_ReadFixed(save_p);
+ ht->affectee = P_ReadINT32(save_p);
+ ht->control = P_ReadINT32(save_p);
+ ht->last_height = P_ReadFixed(save_p);
+ ht->vdx = P_ReadFixed(save_p);
+ ht->vdy = P_ReadFixed(save_p);
+ ht->accel = P_ReadINT32(save_p);
+ ht->exclusive = P_ReadINT32(save_p);
+ ht->type = P_ReadUINT8(save_p);
return &ht->thinker;
}
-static inline thinker_t* LoadFrictionThinker(actionf_p1 thinker)
+static inline thinker_t* LoadFrictionThinker(save_t *save_p, actionf_p1 thinker)
{
friction_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
ht->thinker.function.acp1 = thinker;
- ht->friction = READINT32(save_p);
- ht->movefactor = READINT32(save_p);
- ht->affectee = READINT32(save_p);
- ht->referrer = READINT32(save_p);
- ht->roverfriction = READUINT8(save_p);
+ ht->friction = P_ReadINT32(save_p);
+ ht->movefactor = P_ReadINT32(save_p);
+ ht->affectee = P_ReadINT32(save_p);
+ ht->referrer = P_ReadINT32(save_p);
+ ht->roverfriction = P_ReadUINT8(save_p);
return &ht->thinker;
}
-static thinker_t* LoadPusherThinker(actionf_p1 thinker)
+static thinker_t* LoadPusherThinker(save_t *save_p, actionf_p1 thinker)
{
pusher_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
ht->thinker.function.acp1 = thinker;
- ht->type = READUINT8(save_p);
- ht->x_mag = READFIXED(save_p);
- ht->y_mag = READFIXED(save_p);
- ht->z_mag = READFIXED(save_p);
- ht->affectee = READINT32(save_p);
- ht->roverpusher = READUINT8(save_p);
- ht->referrer = READINT32(save_p);
- ht->exclusive = READINT32(save_p);
- ht->slider = READINT32(save_p);
+ ht->type = P_ReadUINT8(save_p);
+ ht->x_mag = P_ReadFixed(save_p);
+ ht->y_mag = P_ReadFixed(save_p);
+ ht->z_mag = P_ReadFixed(save_p);
+ ht->affectee = P_ReadINT32(save_p);
+ ht->roverpusher = P_ReadUINT8(save_p);
+ ht->referrer = P_ReadINT32(save_p);
+ ht->exclusive = P_ReadINT32(save_p);
+ ht->slider = P_ReadINT32(save_p);
return &ht->thinker;
}
-static inline thinker_t* LoadLaserThinker(actionf_p1 thinker)
+static inline thinker_t* LoadLaserThinker(save_t *save_p, actionf_p1 thinker)
{
laserthink_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
ht->thinker.function.acp1 = thinker;
- ht->tag = READINT16(save_p);
- ht->sourceline = LoadLine(READUINT32(save_p));
- ht->nobosses = READUINT8(save_p);
+ ht->tag = P_ReadINT16(save_p);
+ ht->sourceline = LoadLine(P_ReadUINT32(save_p));
+ ht->nobosses = P_ReadUINT8(save_p);
return &ht->thinker;
}
-static inline thinker_t* LoadLightlevelThinker(actionf_p1 thinker)
+static inline thinker_t* LoadLightlevelThinker(save_t *save_p, actionf_p1 thinker)
{
lightlevel_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
ht->thinker.function.acp1 = thinker;
- ht->sector = LoadSector(READUINT32(save_p));
- ht->sourcelevel = READINT16(save_p);
- ht->destlevel = READINT16(save_p);
- ht->fixedcurlevel = READFIXED(save_p);
- ht->fixedpertic = READFIXED(save_p);
- ht->timer = READINT32(save_p);
+ ht->sector = LoadSector(P_ReadUINT32(save_p));
+ ht->sourcelevel = P_ReadINT16(save_p);
+ ht->destlevel = P_ReadINT16(save_p);
+ ht->fixedcurlevel = P_ReadFixed(save_p);
+ ht->fixedpertic = P_ReadFixed(save_p);
+ ht->timer = P_ReadINT32(save_p);
if (ht->sector)
ht->sector->lightingdata = ht;
return &ht->thinker;
}
-static inline thinker_t* LoadExecutorThinker(actionf_p1 thinker)
+static inline thinker_t* LoadExecutorThinker(save_t *save_p, actionf_p1 thinker)
{
executor_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
ht->thinker.function.acp1 = thinker;
- ht->line = LoadLine(READUINT32(save_p));
- ht->caller = LoadMobj(READUINT32(save_p));
- ht->sector = LoadSector(READUINT32(save_p));
- ht->timer = READINT32(save_p);
+ ht->line = LoadLine(P_ReadUINT32(save_p));
+ ht->caller = LoadMobj(P_ReadUINT32(save_p));
+ ht->sector = LoadSector(P_ReadUINT32(save_p));
+ ht->timer = P_ReadINT32(save_p);
return &ht->thinker;
}
-static inline thinker_t* LoadDisappearThinker(actionf_p1 thinker)
+static inline thinker_t* LoadDisappearThinker(save_t *save_p, actionf_p1 thinker)
{
disappear_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
ht->thinker.function.acp1 = thinker;
- ht->appeartime = READUINT32(save_p);
- ht->disappeartime = READUINT32(save_p);
- ht->offset = READUINT32(save_p);
- ht->timer = READUINT32(save_p);
- ht->affectee = READINT32(save_p);
- ht->sourceline = READINT32(save_p);
- ht->exists = READINT32(save_p);
+ ht->appeartime = P_ReadUINT32(save_p);
+ ht->disappeartime = P_ReadUINT32(save_p);
+ ht->offset = P_ReadUINT32(save_p);
+ ht->timer = P_ReadUINT32(save_p);
+ ht->affectee = P_ReadINT32(save_p);
+ ht->sourceline = P_ReadINT32(save_p);
+ ht->exists = P_ReadINT32(save_p);
return &ht->thinker;
}
-static inline thinker_t* LoadFadeThinker(actionf_p1 thinker)
+static inline thinker_t* LoadFadeThinker(save_t *save_p, actionf_p1 thinker)
{
sector_t *ss;
fade_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
ht->thinker.function.acp1 = thinker;
- ht->dest_exc = GetNetColormapFromList(READUINT32(save_p));
- ht->sectornum = READUINT32(save_p);
- ht->ffloornum = READUINT32(save_p);
- ht->alpha = READINT32(save_p);
- ht->sourcevalue = READINT16(save_p);
- ht->destvalue = READINT16(save_p);
- ht->destlightlevel = READINT16(save_p);
- ht->speed = READINT16(save_p);
- ht->ticbased = (boolean)READUINT8(save_p);
- ht->timer = READINT32(save_p);
- ht->doexists = READUINT8(save_p);
- ht->dotranslucent = READUINT8(save_p);
- ht->dolighting = READUINT8(save_p);
- ht->docolormap = READUINT8(save_p);
- ht->docollision = READUINT8(save_p);
- ht->doghostfade = READUINT8(save_p);
- ht->exactalpha = READUINT8(save_p);
+ ht->dest_exc = GetNetColormapFromList(P_ReadUINT32(save_p));
+ ht->sectornum = P_ReadUINT32(save_p);
+ ht->ffloornum = P_ReadUINT32(save_p);
+ ht->alpha = P_ReadINT32(save_p);
+ ht->sourcevalue = P_ReadINT16(save_p);
+ ht->destvalue = P_ReadINT16(save_p);
+ ht->destlightlevel = P_ReadINT16(save_p);
+ ht->speed = P_ReadINT16(save_p);
+ ht->ticbased = (boolean)P_ReadUINT8(save_p);
+ ht->timer = P_ReadINT32(save_p);
+ ht->doexists = P_ReadUINT8(save_p);
+ ht->dotranslucent = P_ReadUINT8(save_p);
+ ht->dolighting = P_ReadUINT8(save_p);
+ ht->docolormap = P_ReadUINT8(save_p);
+ ht->docollision = P_ReadUINT8(save_p);
+ ht->doghostfade = P_ReadUINT8(save_p);
+ ht->exactalpha = P_ReadUINT8(save_p);
ss = LoadSector(ht->sectornum);
if (ss)
@@ -3768,176 +4007,176 @@ static inline thinker_t* LoadFadeThinker(actionf_p1 thinker)
return &ht->thinker;
}
-static inline thinker_t* LoadFadeColormapThinker(actionf_p1 thinker)
+static inline thinker_t* LoadFadeColormapThinker(save_t *save_p, actionf_p1 thinker)
{
fadecolormap_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
ht->thinker.function.acp1 = thinker;
- ht->sector = LoadSector(READUINT32(save_p));
- ht->source_exc = GetNetColormapFromList(READUINT32(save_p));
- ht->dest_exc = GetNetColormapFromList(READUINT32(save_p));
- ht->ticbased = (boolean)READUINT8(save_p);
- ht->duration = READINT32(save_p);
- ht->timer = READINT32(save_p);
+ ht->sector = LoadSector(P_ReadUINT32(save_p));
+ ht->source_exc = GetNetColormapFromList(P_ReadUINT32(save_p));
+ ht->dest_exc = GetNetColormapFromList(P_ReadUINT32(save_p));
+ ht->ticbased = (boolean)P_ReadUINT8(save_p);
+ ht->duration = P_ReadINT32(save_p);
+ ht->timer = P_ReadINT32(save_p);
if (ht->sector)
ht->sector->fadecolormapdata = ht;
return &ht->thinker;
}
-static inline thinker_t* LoadPlaneDisplaceThinker(actionf_p1 thinker)
+static inline thinker_t* LoadPlaneDisplaceThinker(save_t *save_p, actionf_p1 thinker)
{
planedisplace_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
ht->thinker.function.acp1 = thinker;
- ht->affectee = READINT32(save_p);
- ht->control = READINT32(save_p);
- ht->last_height = READFIXED(save_p);
- ht->speed = READFIXED(save_p);
- ht->type = READUINT8(save_p);
+ ht->affectee = P_ReadINT32(save_p);
+ ht->control = P_ReadINT32(save_p);
+ ht->last_height = P_ReadFixed(save_p);
+ ht->speed = P_ReadFixed(save_p);
+ ht->type = P_ReadUINT8(save_p);
return &ht->thinker;
}
-static inline thinker_t* LoadDynamicLineSlopeThinker(actionf_p1 thinker)
+static inline thinker_t* LoadDynamicLineSlopeThinker(save_t *save_p, actionf_p1 thinker)
{
dynlineplanethink_t* ht = Z_Malloc(sizeof(*ht), PU_LEVSPEC, NULL);
ht->thinker.function.acp1 = thinker;
- ht->type = READUINT8(save_p);
- ht->slope = LoadSlope(READUINT32(save_p));
- ht->sourceline = LoadLine(READUINT32(save_p));
- ht->extent = READFIXED(save_p);
+ ht->type = P_ReadUINT8(save_p);
+ ht->slope = LoadSlope(P_ReadUINT32(save_p));
+ ht->sourceline = LoadLine(P_ReadUINT32(save_p));
+ ht->extent = P_ReadFixed(save_p);
return &ht->thinker;
}
-static inline thinker_t* LoadDynamicVertexSlopeThinker(actionf_p1 thinker)
+static inline thinker_t* LoadDynamicVertexSlopeThinker(save_t *save_p, actionf_p1 thinker)
{
size_t i;
dynvertexplanethink_t* ht = Z_Malloc(sizeof(*ht), PU_LEVSPEC, NULL);
ht->thinker.function.acp1 = thinker;
- ht->slope = LoadSlope(READUINT32(save_p));
+ ht->slope = LoadSlope(P_ReadUINT32(save_p));
for (i = 0; i < 3; i++)
- ht->secs[i] = LoadSector(READUINT32(save_p));
- READMEM(save_p, ht->vex, sizeof(ht->vex));
- READMEM(save_p, ht->origsecheights, sizeof(ht->origsecheights));
- READMEM(save_p, ht->origvecheights, sizeof(ht->origvecheights));
- ht->relative = READUINT8(save_p);
+ ht->secs[i] = LoadSector(P_ReadUINT32(save_p));
+ P_ReadMem(save_p, ht->vex, sizeof(ht->vex));
+ P_ReadMem(save_p, ht->origsecheights, sizeof(ht->origsecheights));
+ P_ReadMem(save_p, ht->origvecheights, sizeof(ht->origvecheights));
+ ht->relative = P_ReadUINT8(save_p);
return &ht->thinker;
}
-static inline thinker_t* LoadPolyrotatetThinker(actionf_p1 thinker)
+static inline thinker_t* LoadPolyrotatetThinker(save_t *save_p, actionf_p1 thinker)
{
polyrotate_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
ht->thinker.function.acp1 = thinker;
- ht->polyObjNum = READINT32(save_p);
- ht->speed = READINT32(save_p);
- ht->distance = READINT32(save_p);
- ht->turnobjs = READUINT8(save_p);
+ ht->polyObjNum = P_ReadINT32(save_p);
+ ht->speed = P_ReadINT32(save_p);
+ ht->distance = P_ReadINT32(save_p);
+ ht->turnobjs = P_ReadUINT8(save_p);
return &ht->thinker;
}
-static thinker_t* LoadPolymoveThinker(actionf_p1 thinker)
+static thinker_t* LoadPolymoveThinker(save_t *save_p, actionf_p1 thinker)
{
polymove_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
ht->thinker.function.acp1 = thinker;
- ht->polyObjNum = READINT32(save_p);
- ht->speed = READINT32(save_p);
- ht->momx = READFIXED(save_p);
- ht->momy = READFIXED(save_p);
- ht->distance = READINT32(save_p);
- ht->angle = READANGLE(save_p);
+ ht->polyObjNum = P_ReadINT32(save_p);
+ ht->speed = P_ReadINT32(save_p);
+ ht->momx = P_ReadFixed(save_p);
+ ht->momy = P_ReadFixed(save_p);
+ ht->distance = P_ReadINT32(save_p);
+ ht->angle = P_ReadAngle(save_p);
return &ht->thinker;
}
-static inline thinker_t* LoadPolywaypointThinker(actionf_p1 thinker)
+static inline thinker_t* LoadPolywaypointThinker(save_t *save_p, actionf_p1 thinker)
{
polywaypoint_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
ht->thinker.function.acp1 = thinker;
- ht->polyObjNum = READINT32(save_p);
- ht->speed = READINT32(save_p);
- ht->sequence = READINT32(save_p);
- ht->pointnum = READINT32(save_p);
- ht->direction = READINT32(save_p);
- ht->returnbehavior = READUINT8(save_p);
- ht->continuous = READUINT8(save_p);
- ht->stophere = READUINT8(save_p);
+ ht->polyObjNum = P_ReadINT32(save_p);
+ ht->speed = P_ReadINT32(save_p);
+ ht->sequence = P_ReadINT32(save_p);
+ ht->pointnum = P_ReadINT32(save_p);
+ ht->direction = P_ReadINT32(save_p);
+ ht->returnbehavior = P_ReadUINT8(save_p);
+ ht->continuous = P_ReadUINT8(save_p);
+ ht->stophere = P_ReadUINT8(save_p);
return &ht->thinker;
}
-static inline thinker_t* LoadPolyslidedoorThinker(actionf_p1 thinker)
+static inline thinker_t* LoadPolyslidedoorThinker(save_t *save_p, actionf_p1 thinker)
{
polyslidedoor_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
ht->thinker.function.acp1 = thinker;
- ht->polyObjNum = READINT32(save_p);
- ht->delay = READINT32(save_p);
- ht->delayCount = READINT32(save_p);
- ht->initSpeed = READINT32(save_p);
- ht->speed = READINT32(save_p);
- ht->initDistance = READINT32(save_p);
- ht->distance = READINT32(save_p);
- ht->initAngle = READUINT32(save_p);
- ht->angle = READUINT32(save_p);
- ht->revAngle = READUINT32(save_p);
- ht->momx = READFIXED(save_p);
- ht->momy = READFIXED(save_p);
- ht->closing = READUINT8(save_p);
+ ht->polyObjNum = P_ReadINT32(save_p);
+ ht->delay = P_ReadINT32(save_p);
+ ht->delayCount = P_ReadINT32(save_p);
+ ht->initSpeed = P_ReadINT32(save_p);
+ ht->speed = P_ReadINT32(save_p);
+ ht->initDistance = P_ReadINT32(save_p);
+ ht->distance = P_ReadINT32(save_p);
+ ht->initAngle = P_ReadUINT32(save_p);
+ ht->angle = P_ReadUINT32(save_p);
+ ht->revAngle = P_ReadUINT32(save_p);
+ ht->momx = P_ReadFixed(save_p);
+ ht->momy = P_ReadFixed(save_p);
+ ht->closing = P_ReadUINT8(save_p);
return &ht->thinker;
}
-static inline thinker_t* LoadPolyswingdoorThinker(actionf_p1 thinker)
+static inline thinker_t* LoadPolyswingdoorThinker(save_t *save_p, actionf_p1 thinker)
{
polyswingdoor_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
ht->thinker.function.acp1 = thinker;
- ht->polyObjNum = READINT32(save_p);
- ht->delay = READINT32(save_p);
- ht->delayCount = READINT32(save_p);
- ht->initSpeed = READINT32(save_p);
- ht->speed = READINT32(save_p);
- ht->initDistance = READINT32(save_p);
- ht->distance = READINT32(save_p);
- ht->closing = READUINT8(save_p);
+ ht->polyObjNum = P_ReadINT32(save_p);
+ ht->delay = P_ReadINT32(save_p);
+ ht->delayCount = P_ReadINT32(save_p);
+ ht->initSpeed = P_ReadINT32(save_p);
+ ht->speed = P_ReadINT32(save_p);
+ ht->initDistance = P_ReadINT32(save_p);
+ ht->distance = P_ReadINT32(save_p);
+ ht->closing = P_ReadUINT8(save_p);
return &ht->thinker;
}
-static inline thinker_t* LoadPolydisplaceThinker(actionf_p1 thinker)
+static inline thinker_t* LoadPolydisplaceThinker(save_t *save_p, actionf_p1 thinker)
{
polydisplace_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
ht->thinker.function.acp1 = thinker;
- ht->polyObjNum = READINT32(save_p);
- ht->controlSector = LoadSector(READUINT32(save_p));
- ht->dx = READFIXED(save_p);
- ht->dy = READFIXED(save_p);
- ht->oldHeights = READFIXED(save_p);
+ ht->polyObjNum = P_ReadINT32(save_p);
+ ht->controlSector = LoadSector(P_ReadUINT32(save_p));
+ ht->dx = P_ReadFixed(save_p);
+ ht->dy = P_ReadFixed(save_p);
+ ht->oldHeights = P_ReadFixed(save_p);
return &ht->thinker;
}
-static inline thinker_t* LoadPolyrotdisplaceThinker(actionf_p1 thinker)
+static inline thinker_t* LoadPolyrotdisplaceThinker(save_t *save_p, actionf_p1 thinker)
{
polyrotdisplace_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
ht->thinker.function.acp1 = thinker;
- ht->polyObjNum = READINT32(save_p);
- ht->controlSector = LoadSector(READUINT32(save_p));
- ht->rotscale = READFIXED(save_p);
- ht->turnobjs = READUINT8(save_p);
- ht->oldHeights = READFIXED(save_p);
+ ht->polyObjNum = P_ReadINT32(save_p);
+ ht->controlSector = LoadSector(P_ReadUINT32(save_p));
+ ht->rotscale = P_ReadFixed(save_p);
+ ht->turnobjs = P_ReadUINT8(save_p);
+ ht->oldHeights = P_ReadFixed(save_p);
return &ht->thinker;
}
-static thinker_t* LoadPolyfadeThinker(actionf_p1 thinker)
+static thinker_t* LoadPolyfadeThinker(save_t *save_p, actionf_p1 thinker)
{
polyfade_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
ht->thinker.function.acp1 = thinker;
- ht->polyObjNum = READINT32(save_p);
- ht->sourcevalue = READINT32(save_p);
- ht->destvalue = READINT32(save_p);
- ht->docollision = (boolean)READUINT8(save_p);
- ht->doghostfade = (boolean)READUINT8(save_p);
- ht->ticbased = (boolean)READUINT8(save_p);
- ht->duration = READINT32(save_p);
- ht->timer = READINT32(save_p);
+ ht->polyObjNum = P_ReadINT32(save_p);
+ ht->sourcevalue = P_ReadINT32(save_p);
+ ht->destvalue = P_ReadINT32(save_p);
+ ht->docollision = (boolean)P_ReadUINT8(save_p);
+ ht->doghostfade = (boolean)P_ReadUINT8(save_p);
+ ht->ticbased = (boolean)P_ReadUINT8(save_p);
+ ht->duration = P_ReadINT32(save_p);
+ ht->timer = P_ReadINT32(save_p);
return &ht->thinker;
}
-static void P_NetUnArchiveThinkers(void)
+static void P_NetUnArchiveThinkers(save_t *save_p)
{
thinker_t *currentthinker;
thinker_t *next;
@@ -3946,7 +4185,7 @@ static void P_NetUnArchiveThinkers(void)
UINT32 i;
UINT32 numloaded = 0;
- if (READUINT32(save_p) != ARCHIVEBLOCK_THINKERS)
+ if (P_ReadUINT32(save_p) != ARCHIVEBLOCK_THINKERS)
I_Error("Bad $$$.sav at archive block Thinkers");
// remove all the current thinkers
@@ -3984,7 +4223,7 @@ static void P_NetUnArchiveThinkers(void)
for (;;)
{
thinker_t* th = NULL;
- tclass = READUINT8(save_p);
+ tclass = P_ReadUINT8(save_p);
if (tclass == tc_end)
break; // leave the saved thinker reading loop
@@ -3993,167 +4232,167 @@ static void P_NetUnArchiveThinkers(void)
switch (tclass)
{
case tc_mobj:
- th = LoadMobjThinker((actionf_p1)P_MobjThinker);
+ th = LoadMobjThinker(save_p, (actionf_p1)P_MobjThinker);
break;
case tc_ceiling:
- th = LoadCeilingThinker((actionf_p1)T_MoveCeiling);
+ th = LoadCeilingThinker(save_p, (actionf_p1)T_MoveCeiling);
break;
case tc_crushceiling:
- th = LoadCeilingThinker((actionf_p1)T_CrushCeiling);
+ th = LoadCeilingThinker(save_p, (actionf_p1)T_CrushCeiling);
break;
case tc_floor:
- th = LoadFloormoveThinker((actionf_p1)T_MoveFloor);
+ th = LoadFloormoveThinker(save_p, (actionf_p1)T_MoveFloor);
break;
case tc_flash:
- th = LoadLightflashThinker((actionf_p1)T_LightningFlash);
+ th = LoadLightflashThinker(save_p, (actionf_p1)T_LightningFlash);
break;
case tc_strobe:
- th = LoadStrobeThinker((actionf_p1)T_StrobeFlash);
+ th = LoadStrobeThinker(save_p, (actionf_p1)T_StrobeFlash);
break;
case tc_glow:
- th = LoadGlowThinker((actionf_p1)T_Glow);
+ th = LoadGlowThinker(save_p, (actionf_p1)T_Glow);
break;
case tc_fireflicker:
- th = LoadFireflickerThinker((actionf_p1)T_FireFlicker);
+ th = LoadFireflickerThinker(save_p, (actionf_p1)T_FireFlicker);
break;
case tc_elevator:
- th = LoadElevatorThinker((actionf_p1)T_MoveElevator, true);
+ th = LoadElevatorThinker(save_p, (actionf_p1)T_MoveElevator, true);
break;
case tc_continuousfalling:
- th = LoadContinuousFallThinker((actionf_p1)T_ContinuousFalling);
+ th = LoadContinuousFallThinker(save_p, (actionf_p1)T_ContinuousFalling);
break;
case tc_thwomp:
- th = LoadThwompThinker((actionf_p1)T_ThwompSector);
+ th = LoadThwompThinker(save_p, (actionf_p1)T_ThwompSector);
break;
case tc_noenemies:
- th = LoadNoEnemiesThinker((actionf_p1)T_NoEnemiesSector);
+ th = LoadNoEnemiesThinker(save_p, (actionf_p1)T_NoEnemiesSector);
break;
case tc_eachtime:
- th = LoadEachTimeThinker((actionf_p1)T_EachTimeThinker);
+ th = LoadEachTimeThinker(save_p, (actionf_p1)T_EachTimeThinker);
break;
case tc_raisesector:
- th = LoadRaiseThinker((actionf_p1)T_RaiseSector);
+ th = LoadRaiseThinker(save_p, (actionf_p1)T_RaiseSector);
break;
case tc_camerascanner:
- th = LoadElevatorThinker((actionf_p1)T_CameraScanner, false);
+ th = LoadElevatorThinker(save_p, (actionf_p1)T_CameraScanner, false);
break;
case tc_bouncecheese:
- th = LoadBounceCheeseThinker((actionf_p1)T_BounceCheese);
+ th = LoadBounceCheeseThinker(save_p, (actionf_p1)T_BounceCheese);
break;
case tc_startcrumble:
- th = LoadCrumbleThinker((actionf_p1)T_StartCrumble);
+ th = LoadCrumbleThinker(save_p, (actionf_p1)T_StartCrumble);
break;
case tc_marioblock:
- th = LoadMarioBlockThinker((actionf_p1)T_MarioBlock);
+ th = LoadMarioBlockThinker(save_p, (actionf_p1)T_MarioBlock);
break;
case tc_marioblockchecker:
- th = LoadMarioCheckThinker((actionf_p1)T_MarioBlockChecker);
+ th = LoadMarioCheckThinker(save_p, (actionf_p1)T_MarioBlockChecker);
break;
case tc_floatsector:
- th = LoadFloatThinker((actionf_p1)T_FloatSector);
+ th = LoadFloatThinker(save_p, (actionf_p1)T_FloatSector);
break;
case tc_laserflash:
- th = LoadLaserThinker((actionf_p1)T_LaserFlash);
+ th = LoadLaserThinker(save_p, (actionf_p1)T_LaserFlash);
break;
case tc_lightfade:
- th = LoadLightlevelThinker((actionf_p1)T_LightFade);
+ th = LoadLightlevelThinker(save_p, (actionf_p1)T_LightFade);
break;
case tc_executor:
- th = LoadExecutorThinker((actionf_p1)T_ExecutorDelay);
+ th = LoadExecutorThinker(save_p, (actionf_p1)T_ExecutorDelay);
restoreNum = true;
break;
case tc_disappear:
- th = LoadDisappearThinker((actionf_p1)T_Disappear);
+ th = LoadDisappearThinker(save_p, (actionf_p1)T_Disappear);
break;
case tc_fade:
- th = LoadFadeThinker((actionf_p1)T_Fade);
+ th = LoadFadeThinker(save_p, (actionf_p1)T_Fade);
break;
case tc_fadecolormap:
- th = LoadFadeColormapThinker((actionf_p1)T_FadeColormap);
+ th = LoadFadeColormapThinker(save_p, (actionf_p1)T_FadeColormap);
break;
case tc_planedisplace:
- th = LoadPlaneDisplaceThinker((actionf_p1)T_PlaneDisplace);
+ th = LoadPlaneDisplaceThinker(save_p, (actionf_p1)T_PlaneDisplace);
break;
case tc_polyrotate:
- th = LoadPolyrotatetThinker((actionf_p1)T_PolyObjRotate);
+ th = LoadPolyrotatetThinker(save_p, (actionf_p1)T_PolyObjRotate);
break;
case tc_polymove:
- th = LoadPolymoveThinker((actionf_p1)T_PolyObjMove);
+ th = LoadPolymoveThinker(save_p, (actionf_p1)T_PolyObjMove);
break;
case tc_polywaypoint:
- th = LoadPolywaypointThinker((actionf_p1)T_PolyObjWaypoint);
+ th = LoadPolywaypointThinker(save_p, (actionf_p1)T_PolyObjWaypoint);
break;
case tc_polyslidedoor:
- th = LoadPolyslidedoorThinker((actionf_p1)T_PolyDoorSlide);
+ th = LoadPolyslidedoorThinker(save_p, (actionf_p1)T_PolyDoorSlide);
break;
case tc_polyswingdoor:
- th = LoadPolyswingdoorThinker((actionf_p1)T_PolyDoorSwing);
+ th = LoadPolyswingdoorThinker(save_p, (actionf_p1)T_PolyDoorSwing);
break;
case tc_polyflag:
- th = LoadPolymoveThinker((actionf_p1)T_PolyObjFlag);
+ th = LoadPolymoveThinker(save_p, (actionf_p1)T_PolyObjFlag);
break;
case tc_polydisplace:
- th = LoadPolydisplaceThinker((actionf_p1)T_PolyObjDisplace);
+ th = LoadPolydisplaceThinker(save_p, (actionf_p1)T_PolyObjDisplace);
break;
case tc_polyrotdisplace:
- th = LoadPolyrotdisplaceThinker((actionf_p1)T_PolyObjRotDisplace);
+ th = LoadPolyrotdisplaceThinker(save_p, (actionf_p1)T_PolyObjRotDisplace);
break;
case tc_polyfade:
- th = LoadPolyfadeThinker((actionf_p1)T_PolyObjFade);
+ th = LoadPolyfadeThinker(save_p, (actionf_p1)T_PolyObjFade);
break;
case tc_dynslopeline:
- th = LoadDynamicLineSlopeThinker((actionf_p1)T_DynamicSlopeLine);
+ th = LoadDynamicLineSlopeThinker(save_p, (actionf_p1)T_DynamicSlopeLine);
break;
case tc_dynslopevert:
- th = LoadDynamicVertexSlopeThinker((actionf_p1)T_DynamicSlopeVert);
+ th = LoadDynamicVertexSlopeThinker(save_p, (actionf_p1)T_DynamicSlopeVert);
break;
case tc_scroll:
- th = LoadScrollThinker((actionf_p1)T_Scroll);
+ th = LoadScrollThinker(save_p, (actionf_p1)T_Scroll);
break;
case tc_friction:
- th = LoadFrictionThinker((actionf_p1)T_Friction);
+ th = LoadFrictionThinker(save_p, (actionf_p1)T_Friction);
break;
case tc_pusher:
- th = LoadPusherThinker((actionf_p1)T_Pusher);
+ th = LoadPusherThinker(save_p, (actionf_p1)T_Pusher);
break;
default:
@@ -4193,29 +4432,29 @@ static void P_NetUnArchiveThinkers(void)
#define PD_FLAGS 0x01
#define PD_TRANS 0x02
-static inline void P_ArchivePolyObj(polyobj_t *po)
+static inline void P_ArchivePolyObj(save_t *save_p, polyobj_t *po)
{
UINT8 diff = 0;
- WRITEINT32(save_p, po->id);
- WRITEANGLE(save_p, po->angle);
+ P_WriteINT32(save_p, po->id);
+ P_WriteAngle(save_p, po->angle);
- WRITEFIXED(save_p, po->spawnSpot.x);
- WRITEFIXED(save_p, po->spawnSpot.y);
+ P_WriteFixed(save_p, po->spawnSpot.x);
+ P_WriteFixed(save_p, po->spawnSpot.y);
if (po->flags != po->spawnflags)
diff |= PD_FLAGS;
if (po->translucency != po->spawntrans)
diff |= PD_TRANS;
- WRITEUINT8(save_p, diff);
+ P_WriteUINT8(save_p, diff);
if (diff & PD_FLAGS)
- WRITEINT32(save_p, po->flags);
+ P_WriteINT32(save_p, po->flags);
if (diff & PD_TRANS)
- WRITEINT32(save_p, po->translucency);
+ P_WriteINT32(save_p, po->translucency);
}
-static inline void P_UnArchivePolyObj(polyobj_t *po)
+static inline void P_UnArchivePolyObj(save_t *save_p, polyobj_t *po)
{
INT32 id;
UINT32 angle;
@@ -4227,19 +4466,19 @@ static inline void P_UnArchivePolyObj(polyobj_t *po)
// when they first start to run.
po->thinker = NULL;
- id = READINT32(save_p);
+ id = P_ReadINT32(save_p);
- angle = READANGLE(save_p);
+ angle = P_ReadAngle(save_p);
- x = READFIXED(save_p);
- y = READFIXED(save_p);
+ x = P_ReadFixed(save_p);
+ y = P_ReadFixed(save_p);
- diff = READUINT8(save_p);
+ diff = P_ReadUINT8(save_p);
if (diff & PD_FLAGS)
- po->flags = READINT32(save_p);
+ po->flags = P_ReadINT32(save_p);
if (diff & PD_TRANS)
- po->translucency = READINT32(save_p);
+ po->translucency = P_ReadINT32(save_p);
// if the object is bad or isn't in the id hash, we can do nothing more
// with it, so return now
@@ -4250,33 +4489,33 @@ static inline void P_UnArchivePolyObj(polyobj_t *po)
Polyobj_MoveOnLoad(po, angle, x, y);
}
-static inline void P_ArchivePolyObjects(void)
+static inline void P_ArchivePolyObjects(save_t *save_p)
{
INT32 i;
- WRITEUINT32(save_p, ARCHIVEBLOCK_POBJS);
+ P_WriteUINT32(save_p, ARCHIVEBLOCK_POBJS);
// save number of polyobjects
- WRITEINT32(save_p, numPolyObjects);
+ P_WriteINT32(save_p, numPolyObjects);
for (i = 0; i < numPolyObjects; ++i)
- P_ArchivePolyObj(&PolyObjects[i]);
+ P_ArchivePolyObj(save_p, &PolyObjects[i]);
}
-static inline void P_UnArchivePolyObjects(void)
+static inline void P_UnArchivePolyObjects(save_t *save_p)
{
INT32 i, numSavedPolys;
- if (READUINT32(save_p) != ARCHIVEBLOCK_POBJS)
+ if (P_ReadUINT32(save_p) != ARCHIVEBLOCK_POBJS)
I_Error("Bad $$$.sav at archive block Pobjs");
- numSavedPolys = READINT32(save_p);
+ numSavedPolys = P_ReadINT32(save_p);
if (numSavedPolys != numPolyObjects)
I_Error("P_UnArchivePolyObjects: polyobj count inconsistency\n");
for (i = 0; i < numSavedPolys; ++i)
- P_UnArchivePolyObj(&PolyObjects[i]);
+ P_UnArchivePolyObj(save_p, &PolyObjects[i]);
}
static inline void P_FinishMobjs(void)
@@ -4288,7 +4527,7 @@ static inline void P_FinishMobjs(void)
for (currentthinker = thlist[THINK_MOBJ].next; currentthinker != &thlist[THINK_MOBJ];
currentthinker = currentthinker->next)
{
- if (currentthinker->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (currentthinker->removing)
continue;
mobj = (mobj_t *)currentthinker;
@@ -4306,7 +4545,7 @@ static void P_RelinkPointers(void)
for (currentthinker = thlist[THINK_MOBJ].next; currentthinker != &thlist[THINK_MOBJ];
currentthinker = currentthinker->next)
{
- if (currentthinker->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (currentthinker->removing)
continue;
mobj = (mobj_t *)currentthinker;
@@ -4394,11 +4633,11 @@ static void P_RelinkPointers(void)
}
}
-static inline void P_NetArchiveSpecials(void)
+static inline void P_NetArchiveSpecials(save_t *save_p)
{
size_t i, z;
- WRITEUINT32(save_p, ARCHIVEBLOCK_SPECIALS);
+ P_WriteUINT32(save_p, ARCHIVEBLOCK_SPECIALS);
// itemrespawn queue for deathmatch
i = iquetail;
@@ -4408,53 +4647,54 @@ static inline void P_NetArchiveSpecials(void)
{
if (&mapthings[z] == itemrespawnque[i])
{
- WRITEUINT32(save_p, z);
+ P_WriteUINT32(save_p, z);
break;
}
}
- WRITEUINT32(save_p, itemrespawntime[i]);
+ P_WriteUINT32(save_p, itemrespawntime[i]);
i = (i + 1) & (ITEMQUESIZE-1);
}
// end delimiter
- WRITEUINT32(save_p, 0xffffffff);
+ P_WriteUINT32(save_p, 0xffffffff);
// Sky number
- WRITEINT32(save_p, globallevelskynum);
+ P_WriteINT32(save_p, globallevelskynum);
// Current global weather type
- WRITEUINT8(save_p, globalweather);
+ P_WriteUINT8(save_p, globalweather);
if (metalplayback) // Is metal sonic running?
{
- WRITEUINT8(save_p, 0x01);
- G_SaveMetal(&save_p);
+ UINT8 *p = &save_p->buf[save_p->pos+1];
+ P_WriteUINT8(save_p, 0x01);
+ G_SaveMetal(&p);
}
else
- WRITEUINT8(save_p, 0x00);
+ P_WriteUINT8(save_p, 0x00);
}
-static void P_NetUnArchiveSpecials(void)
+static void P_NetUnArchiveSpecials(save_t *save_p)
{
size_t i;
INT32 j;
- if (READUINT32(save_p) != ARCHIVEBLOCK_SPECIALS)
+ if (P_ReadUINT32(save_p) != ARCHIVEBLOCK_SPECIALS)
I_Error("Bad $$$.sav at archive block Specials");
// BP: added save itemrespawn queue for deathmatch
iquetail = iquehead = 0;
- while ((i = READUINT32(save_p)) != 0xffffffff)
+ while ((i = P_ReadUINT32(save_p)) != 0xffffffff)
{
itemrespawnque[iquehead] = &mapthings[i];
- itemrespawntime[iquehead++] = READINT32(save_p);
+ itemrespawntime[iquehead++] = P_ReadINT32(save_p);
}
- j = READINT32(save_p);
+ j = P_ReadINT32(save_p);
if (j != globallevelskynum)
P_SetupLevelSky(j, true);
- globalweather = READUINT8(save_p);
+ globalweather = P_ReadUINT8(save_p);
if (globalweather)
{
@@ -4469,14 +4709,17 @@ static void P_NetUnArchiveSpecials(void)
P_SwitchWeather(globalweather);
}
- if (READUINT8(save_p) == 0x01) // metal sonic
- G_LoadMetal(&save_p);
+ if (P_ReadUINT8(save_p) == 0x01) // metal sonic
+ {
+ UINT8 *p = &save_p->buf[save_p->pos];
+ G_LoadMetal(&p);
+ }
}
// =======================================================================
// Misc
// =======================================================================
-static inline void P_ArchiveMisc(INT16 mapnum)
+static inline void P_ArchiveMisc(save_t *save_p, INT16 mapnum)
{
//lastmapsaved = mapnum;
lastmaploaded = mapnum;
@@ -4484,16 +4727,16 @@ static inline void P_ArchiveMisc(INT16 mapnum)
if (gamecomplete)
mapnum |= 8192;
- WRITEINT16(save_p, mapnum);
- WRITEUINT16(save_p, emeralds+357);
- WRITESTRINGN(save_p, timeattackfolder, sizeof(timeattackfolder));
+ P_WriteINT16(save_p, mapnum);
+ P_WriteUINT16(save_p, emeralds+357);
+ P_WriteStringN(save_p, timeattackfolder, sizeof(timeattackfolder));
}
-static inline void P_UnArchiveSPGame(INT16 mapoverride)
+static inline void P_UnArchiveSPGame(save_t *save_p, INT16 mapoverride)
{
char testname[sizeof(timeattackfolder)];
- gamemap = READINT16(save_p);
+ gamemap = P_ReadINT16(save_p);
if (mapoverride != 0)
{
@@ -4514,9 +4757,9 @@ static inline void P_UnArchiveSPGame(INT16 mapoverride)
tokenlist = 0;
token = 0;
- savedata.emeralds = READUINT16(save_p)-357;
+ savedata.emeralds = P_ReadUINT16(save_p)-357;
- READSTRINGN(save_p, testname, sizeof(testname));
+ P_ReadStringN(save_p, testname, sizeof(testname));
if (strcmp(testname, timeattackfolder))
{
@@ -4530,100 +4773,106 @@ static inline void P_UnArchiveSPGame(INT16 mapoverride)
playeringame[consoleplayer] = true;
}
-static void P_NetArchiveMisc(boolean resending)
+static void P_NetArchiveMisc(save_t *save_p, boolean resending)
{
INT32 i;
- WRITEUINT32(save_p, ARCHIVEBLOCK_MISC);
+ P_WriteUINT32(save_p, ARCHIVEBLOCK_MISC);
if (resending)
- WRITEUINT32(save_p, gametic);
- WRITEINT16(save_p, gamemap);
+ P_WriteUINT32(save_p, gametic);
+ P_WriteINT16(save_p, gamemap);
if (gamestate != GS_LEVEL)
- WRITEINT16(save_p, GS_WAITINGPLAYERS); // nice hack to put people back into waitingplayers
+ P_WriteINT16(save_p, GS_WAITINGPLAYERS); // nice hack to put people back into waitingplayers
else
- WRITEINT16(save_p, gamestate);
- WRITEINT16(save_p, gametype);
+ P_WriteINT16(save_p, gamestate);
+ P_WriteINT16(save_p, gametype);
{
UINT32 pig = 0;
for (i = 0; i < MAXPLAYERS; i++)
pig |= (playeringame[i] != 0)<<i;
- WRITEUINT32(save_p, pig);
+ P_WriteUINT32(save_p, pig);
}
- WRITEUINT32(save_p, P_GetRandSeed());
+ P_WriteUINT32(save_p, P_GetRandSeed());
- WRITEUINT32(save_p, tokenlist);
+ P_WriteUINT32(save_p, tokenlist);
- WRITEUINT32(save_p, leveltime);
- WRITEUINT32(save_p, ssspheres);
- WRITEINT16(save_p, lastmap);
- WRITEUINT16(save_p, bossdisabled);
+ P_WriteUINT32(save_p, leveltime);
+ P_WriteUINT32(save_p, ssspheres);
+ P_WriteINT16(save_p, lastmap);
+ P_WriteUINT16(save_p, bossdisabled);
- WRITEUINT16(save_p, emeralds);
+ P_WriteUINT16(save_p, emeralds);
{
UINT8 globools = 0;
if (stagefailed)
globools |= 1;
if (stoppedclock)
globools |= (1<<1);
- WRITEUINT8(save_p, globools);
+ P_WriteUINT8(save_p, globools);
}
- WRITEUINT32(save_p, token);
- WRITEINT32(save_p, sstimer);
- WRITEUINT32(save_p, bluescore);
- WRITEUINT32(save_p, redscore);
+ P_WriteUINT32(save_p, token);
+ P_WriteINT32(save_p, sstimer);
+ P_WriteUINT32(save_p, bluescore);
+ P_WriteUINT32(save_p, redscore);
- WRITEUINT16(save_p, skincolor_redteam);
- WRITEUINT16(save_p, skincolor_blueteam);
- WRITEUINT16(save_p, skincolor_redring);
- WRITEUINT16(save_p, skincolor_bluering);
+ P_WriteUINT16(save_p, skincolor_redteam);
+ P_WriteUINT16(save_p, skincolor_blueteam);
+ P_WriteUINT16(save_p, skincolor_redring);
+ P_WriteUINT16(save_p, skincolor_bluering);
- WRITEINT32(save_p, modulothing);
+ P_WriteINT32(save_p, modulothing);
- WRITEINT16(save_p, autobalance);
- WRITEINT16(save_p, teamscramble);
+ P_WriteINT16(save_p, autobalance);
+ P_WriteINT16(save_p, teamscramble);
for (i = 0; i < MAXPLAYERS; i++)
- WRITEINT16(save_p, scrambleplayers[i]);
+ P_WriteINT16(save_p, scrambleplayers[i]);
for (i = 0; i < MAXPLAYERS; i++)
- WRITEINT16(save_p, scrambleteams[i]);
+ P_WriteINT16(save_p, scrambleteams[i]);
- WRITEINT16(save_p, scrambletotal);
- WRITEINT16(save_p, scramblecount);
+ P_WriteINT16(save_p, scrambletotal);
+ P_WriteINT16(save_p, scramblecount);
- WRITEUINT32(save_p, countdown);
- WRITEUINT32(save_p, countdown2);
+ P_WriteUINT32(save_p, countdown);
+ P_WriteUINT32(save_p, countdown2);
- WRITEFIXED(save_p, gravity);
+ P_WriteFixed(save_p, gravity);
- WRITEUINT32(save_p, countdowntimer);
- WRITEUINT8(save_p, countdowntimeup);
+ P_WriteUINT32(save_p, countdowntimer);
+ P_WriteUINT8(save_p, countdowntimeup);
- WRITEUINT32(save_p, hidetime);
+ P_WriteUINT32(save_p, hidetime);
// Is it paused?
if (paused)
- WRITEUINT8(save_p, 0x2f);
+ P_WriteUINT8(save_p, 0x2f);
else
- WRITEUINT8(save_p, 0x2e);
+ P_WriteUINT8(save_p, 0x2e);
+
+ for (i = 0; i < MAXPLAYERS; i++)
+ {
+ P_WriteUINT8(save_p, spam_tokens[i]);
+ P_WriteUINT32(save_p, spam_tics[i]);
+ }
}
-static inline boolean P_NetUnArchiveMisc(boolean reloading)
+static inline boolean P_NetUnArchiveMisc(save_t *save_p, boolean reloading)
{
INT32 i;
- if (READUINT32(save_p) != ARCHIVEBLOCK_MISC)
+ if (P_ReadUINT32(save_p) != ARCHIVEBLOCK_MISC)
I_Error("Bad $$$.sav at archive block Misc");
if (reloading)
- gametic = READUINT32(save_p);
+ gametic = P_ReadUINT32(save_p);
- gamemap = READINT16(save_p);
+ gamemap = P_ReadINT16(save_p);
// gamemap changed; we assume that its map header is always valid,
// so make it so
@@ -4634,12 +4883,12 @@ static inline boolean P_NetUnArchiveMisc(boolean reloading)
// normally sets this flag
mapmusflags |= MUSIC_RELOADRESET;
- G_SetGamestate(READINT16(save_p));
+ G_SetGamestate(P_ReadINT16(save_p));
- gametype = READINT16(save_p);
+ gametype = P_ReadINT16(save_p);
{
- UINT32 pig = READUINT32(save_p);
+ UINT32 pig = P_ReadUINT32(save_p);
for (i = 0; i < MAXPLAYERS; i++)
{
playeringame[i] = (pig & (1<<i)) != 0;
@@ -4647,9 +4896,9 @@ static inline boolean P_NetUnArchiveMisc(boolean reloading)
}
}
- P_SetRandSeed(READUINT32(save_p));
+ P_SetRandSeed(P_ReadUINT32(save_p));
- tokenlist = READUINT32(save_p);
+ tokenlist = P_ReadUINT32(save_p);
if (!P_LoadLevel(true, reloading))
{
@@ -4658,83 +4907,89 @@ static inline boolean P_NetUnArchiveMisc(boolean reloading)
}
// get the time
- leveltime = READUINT32(save_p);
- ssspheres = READUINT32(save_p);
- lastmap = READINT16(save_p);
- bossdisabled = READUINT16(save_p);
+ leveltime = P_ReadUINT32(save_p);
+ ssspheres = P_ReadUINT32(save_p);
+ lastmap = P_ReadINT16(save_p);
+ bossdisabled = P_ReadUINT16(save_p);
- emeralds = READUINT16(save_p);
+ emeralds = P_ReadUINT16(save_p);
{
- UINT8 globools = READUINT8(save_p);
+ UINT8 globools = P_ReadUINT8(save_p);
stagefailed = !!(globools & 1);
stoppedclock = !!(globools & (1<<1));
}
- token = READUINT32(save_p);
- sstimer = READINT32(save_p);
- bluescore = READUINT32(save_p);
- redscore = READUINT32(save_p);
+ token = P_ReadUINT32(save_p);
+ sstimer = P_ReadINT32(save_p);
+ bluescore = P_ReadUINT32(save_p);
+ redscore = P_ReadUINT32(save_p);
- skincolor_redteam = READUINT16(save_p);
- skincolor_blueteam = READUINT16(save_p);
- skincolor_redring = READUINT16(save_p);
- skincolor_bluering = READUINT16(save_p);
+ skincolor_redteam = P_ReadUINT16(save_p);
+ skincolor_blueteam = P_ReadUINT16(save_p);
+ skincolor_redring = P_ReadUINT16(save_p);
+ skincolor_bluering = P_ReadUINT16(save_p);
- modulothing = READINT32(save_p);
+ modulothing = P_ReadINT32(save_p);
- autobalance = READINT16(save_p);
- teamscramble = READINT16(save_p);
+ autobalance = P_ReadINT16(save_p);
+ teamscramble = P_ReadINT16(save_p);
for (i = 0; i < MAXPLAYERS; i++)
- scrambleplayers[i] = READINT16(save_p);
+ scrambleplayers[i] = P_ReadINT16(save_p);
for (i = 0; i < MAXPLAYERS; i++)
- scrambleteams[i] = READINT16(save_p);
+ scrambleteams[i] = P_ReadINT16(save_p);
- scrambletotal = READINT16(save_p);
- scramblecount = READINT16(save_p);
+ scrambletotal = P_ReadINT16(save_p);
+ scramblecount = P_ReadINT16(save_p);
- countdown = READUINT32(save_p);
- countdown2 = READUINT32(save_p);
+ countdown = P_ReadUINT32(save_p);
+ countdown2 = P_ReadUINT32(save_p);
- gravity = READFIXED(save_p);
+ gravity = P_ReadFixed(save_p);
- countdowntimer = (tic_t)READUINT32(save_p);
- countdowntimeup = (boolean)READUINT8(save_p);
+ countdowntimer = (tic_t)P_ReadUINT32(save_p);
+ countdowntimeup = (boolean)P_ReadUINT8(save_p);
- hidetime = READUINT32(save_p);
+ hidetime = P_ReadUINT32(save_p);
// Is it paused?
- if (READUINT8(save_p) == 0x2f)
+ if (P_ReadUINT8(save_p) == 0x2f)
paused = true;
+ for (i = 0; i < MAXPLAYERS; i++)
+ {
+ spam_tokens[i] = P_ReadUINT8(save_p);
+ spam_tics[i] = P_ReadUINT32(save_p);
+ }
+
return true;
}
-static inline void P_NetArchiveEmblems(void)
+static inline void P_NetArchiveEmblems(save_t *save_p)
{
gamedata_t *data = serverGamedata;
INT32 i, j;
UINT8 btemp;
INT32 curmare;
- WRITEUINT32(save_p, ARCHIVEBLOCK_EMBLEMS);
+ P_WriteUINT32(save_p, ARCHIVEBLOCK_EMBLEMS);
// These should be synchronized before savegame loading by the wad files being the same anyway,
// but just in case, for now, we'll leave them here for testing. It would be very bad if they mismatch.
- WRITEUINT8(save_p, (UINT8)savemoddata);
- WRITEINT32(save_p, numemblems);
- WRITEINT32(save_p, numextraemblems);
+ P_WriteUINT8(save_p, (UINT8)savemoddata);
+ P_WriteINT32(save_p, numemblems);
+ P_WriteINT32(save_p, numextraemblems);
// The rest of this is lifted straight from G_SaveGameData in g_game.c
// TODO: Optimize this to only send information about emblems, unlocks, etc. which actually exist
// There is no need to go all the way up to MAXEMBLEMS when wads are guaranteed to be the same.
- WRITEUINT32(save_p, data->totalplaytime);
+ P_WriteUINT32(save_p, data->totalplaytime);
// TODO put another cipher on these things? meh, I don't care...
for (i = 0; i < NUMMAPS; i++)
- WRITEUINT8(save_p, (data->mapvisited[i] & MV_MAX));
+ P_WriteUINT8(save_p, (data->mapvisited[i] & MV_MAX));
// To save space, use one bit per collected/achieved/unlocked flag
for (i = 0; i < MAXEMBLEMS;)
@@ -4742,7 +4997,7 @@ static inline void P_NetArchiveEmblems(void)
btemp = 0;
for (j = 0; j < 8 && j+i < MAXEMBLEMS; ++j)
btemp |= (data->collected[j+i] << j);
- WRITEUINT8(save_p, btemp);
+ P_WriteUINT8(save_p, btemp);
i += j;
}
for (i = 0; i < MAXEXTRAEMBLEMS;)
@@ -4750,7 +5005,7 @@ static inline void P_NetArchiveEmblems(void)
btemp = 0;
for (j = 0; j < 8 && j+i < MAXEXTRAEMBLEMS; ++j)
btemp |= (data->extraCollected[j+i] << j);
- WRITEUINT8(save_p, btemp);
+ P_WriteUINT8(save_p, btemp);
i += j;
}
for (i = 0; i < MAXUNLOCKABLES;)
@@ -4758,7 +5013,7 @@ static inline void P_NetArchiveEmblems(void)
btemp = 0;
for (j = 0; j < 8 && j+i < MAXUNLOCKABLES; ++j)
btemp |= (data->unlocked[j+i] << j);
- WRITEUINT8(save_p, btemp);
+ P_WriteUINT8(save_p, btemp);
i += j;
}
for (i = 0; i < MAXCONDITIONSETS;)
@@ -4766,28 +5021,28 @@ static inline void P_NetArchiveEmblems(void)
btemp = 0;
for (j = 0; j < 8 && j+i < MAXCONDITIONSETS; ++j)
btemp |= (data->achieved[j+i] << j);
- WRITEUINT8(save_p, btemp);
+ P_WriteUINT8(save_p, btemp);
i += j;
}
- WRITEUINT32(save_p, data->timesBeaten);
- WRITEUINT32(save_p, data->timesBeatenWithEmeralds);
- WRITEUINT32(save_p, data->timesBeatenUltimate);
+ P_WriteUINT32(save_p, data->timesBeaten);
+ P_WriteUINT32(save_p, data->timesBeatenWithEmeralds);
+ P_WriteUINT32(save_p, data->timesBeatenUltimate);
// Main records
for (i = 0; i < NUMMAPS; i++)
{
if (data->mainrecords[i])
{
- WRITEUINT32(save_p, data->mainrecords[i]->score);
- WRITEUINT32(save_p, data->mainrecords[i]->time);
- WRITEUINT16(save_p, data->mainrecords[i]->rings);
+ P_WriteUINT32(save_p, data->mainrecords[i]->score);
+ P_WriteUINT32(save_p, data->mainrecords[i]->time);
+ P_WriteUINT16(save_p, data->mainrecords[i]->rings);
}
else
{
- WRITEUINT32(save_p, 0);
- WRITEUINT32(save_p, 0);
- WRITEUINT16(save_p, 0);
+ P_WriteUINT32(save_p, 0);
+ P_WriteUINT32(save_p, 0);
+ P_WriteUINT16(save_p, 0);
}
}
@@ -4796,43 +5051,43 @@ static inline void P_NetArchiveEmblems(void)
{
if (!data->nightsrecords[i] || !data->nightsrecords[i]->nummares)
{
- WRITEUINT8(save_p, 0);
+ P_WriteUINT8(save_p, 0);
continue;
}
- WRITEUINT8(save_p, data->nightsrecords[i]->nummares);
+ P_WriteUINT8(save_p, data->nightsrecords[i]->nummares);
for (curmare = 0; curmare < (data->nightsrecords[i]->nummares + 1); ++curmare)
{
- WRITEUINT32(save_p, data->nightsrecords[i]->score[curmare]);
- WRITEUINT8(save_p, data->nightsrecords[i]->grade[curmare]);
- WRITEUINT32(save_p, data->nightsrecords[i]->time[curmare]);
+ P_WriteUINT32(save_p, data->nightsrecords[i]->score[curmare]);
+ P_WriteUINT8(save_p, data->nightsrecords[i]->grade[curmare]);
+ P_WriteUINT32(save_p, data->nightsrecords[i]->time[curmare]);
}
}
// Mid-map stuff
- WRITEUINT32(save_p, unlocktriggers);
+ P_WriteUINT32(save_p, unlocktriggers);
for (i = 0; i < MAXPLAYERS; i++)
{
if (!ntemprecords[i].nummares)
{
- WRITEUINT8(save_p, 0);
+ P_WriteUINT8(save_p, 0);
continue;
}
- WRITEUINT8(save_p, ntemprecords[i].nummares);
+ P_WriteUINT8(save_p, ntemprecords[i].nummares);
for (curmare = 0; curmare < (ntemprecords[i].nummares + 1); ++curmare)
{
- WRITEUINT32(save_p, ntemprecords[i].score[curmare]);
- WRITEUINT8(save_p, ntemprecords[i].grade[curmare]);
- WRITEUINT32(save_p, ntemprecords[i].time[curmare]);
+ P_WriteUINT32(save_p, ntemprecords[i].score[curmare]);
+ P_WriteUINT8(save_p, ntemprecords[i].grade[curmare]);
+ P_WriteUINT32(save_p, ntemprecords[i].time[curmare]);
}
}
}
-static inline void P_NetUnArchiveEmblems(void)
+static inline void P_NetUnArchiveEmblems(save_t *save_p)
{
gamedata_t *data = serverGamedata;
INT32 i, j;
@@ -4843,14 +5098,14 @@ static inline void P_NetUnArchiveEmblems(void)
UINT8 recmares;
INT32 curmare;
- if (READUINT32(save_p) != ARCHIVEBLOCK_EMBLEMS)
+ if (P_ReadUINT32(save_p) != ARCHIVEBLOCK_EMBLEMS)
I_Error("Bad $$$.sav at archive block Emblems");
- savemoddata = (boolean)READUINT8(save_p); // this one is actually necessary because savemoddata stays false otherwise for some reason.
+ savemoddata = (boolean)P_ReadUINT8(save_p); // this one is actually necessary because savemoddata stays false otherwise for some reason.
- if (numemblems != READINT32(save_p))
+ if (numemblems != P_ReadINT32(save_p))
I_Error("Bad $$$.sav dearchiving Emblems (numemblems mismatch)");
- if (numextraemblems != READINT32(save_p))
+ if (numextraemblems != P_ReadINT32(save_p))
I_Error("Bad $$$.sav dearchiving Emblems (numextraemblems mismatch)");
// This shouldn't happen, but if something really fucked up happens and you transfer
@@ -4865,53 +5120,53 @@ static inline void P_NetUnArchiveEmblems(void)
// TODO: Optimize this to only read information about emblems, unlocks, etc. which actually exist
// There is no need to go all the way up to MAXEMBLEMS when wads are guaranteed to be the same.
- data->totalplaytime = READUINT32(save_p);
+ data->totalplaytime = P_ReadUINT32(save_p);
// TODO put another cipher on these things? meh, I don't care...
for (i = 0; i < NUMMAPS; i++)
- if ((data->mapvisited[i] = READUINT8(save_p)) > MV_MAX)
+ if ((data->mapvisited[i] = P_ReadUINT8(save_p)) > MV_MAX)
I_Error("Bad $$$.sav dearchiving Emblems (invalid visit flags)");
// To save space, use one bit per collected/achieved/unlocked flag
for (i = 0; i < MAXEMBLEMS;)
{
- rtemp = READUINT8(save_p);
+ rtemp = P_ReadUINT8(save_p);
for (j = 0; j < 8 && j+i < MAXEMBLEMS; ++j)
data->collected[j+i] = ((rtemp >> j) & 1);
i += j;
}
for (i = 0; i < MAXEXTRAEMBLEMS;)
{
- rtemp = READUINT8(save_p);
+ rtemp = P_ReadUINT8(save_p);
for (j = 0; j < 8 && j+i < MAXEXTRAEMBLEMS; ++j)
data->extraCollected[j+i] = ((rtemp >> j) & 1);
i += j;
}
for (i = 0; i < MAXUNLOCKABLES;)
{
- rtemp = READUINT8(save_p);
+ rtemp = P_ReadUINT8(save_p);
for (j = 0; j < 8 && j+i < MAXUNLOCKABLES; ++j)
data->unlocked[j+i] = ((rtemp >> j) & 1);
i += j;
}
for (i = 0; i < MAXCONDITIONSETS;)
{
- rtemp = READUINT8(save_p);
+ rtemp = P_ReadUINT8(save_p);
for (j = 0; j < 8 && j+i < MAXCONDITIONSETS; ++j)
data->achieved[j+i] = ((rtemp >> j) & 1);
i += j;
}
- data->timesBeaten = READUINT32(save_p);
- data->timesBeatenWithEmeralds = READUINT32(save_p);
- data->timesBeatenUltimate = READUINT32(save_p);
+ data->timesBeaten = P_ReadUINT32(save_p);
+ data->timesBeatenWithEmeralds = P_ReadUINT32(save_p);
+ data->timesBeatenUltimate = P_ReadUINT32(save_p);
// Main records
for (i = 0; i < NUMMAPS; ++i)
{
- recscore = READUINT32(save_p);
- rectime = (tic_t)READUINT32(save_p);
- recrings = READUINT16(save_p);
+ recscore = P_ReadUINT32(save_p);
+ rectime = (tic_t)P_ReadUINT32(save_p);
+ recrings = P_ReadUINT16(save_p);
if (recrings > 10000 || recscore > MAXSCORE)
I_Error("Bad $$$.sav dearchiving Emblems (invalid score)");
@@ -4928,16 +5183,16 @@ static inline void P_NetUnArchiveEmblems(void)
// Nights records
for (i = 0; i < NUMMAPS; ++i)
{
- if ((recmares = READUINT8(save_p)) == 0)
+ if ((recmares = P_ReadUINT8(save_p)) == 0)
continue;
G_AllocNightsRecordData((INT16)i, data);
for (curmare = 0; curmare < (recmares+1); ++curmare)
{
- data->nightsrecords[i]->score[curmare] = READUINT32(save_p);
- data->nightsrecords[i]->grade[curmare] = READUINT8(save_p);
- data->nightsrecords[i]->time[curmare] = (tic_t)READUINT32(save_p);
+ data->nightsrecords[i]->score[curmare] = P_ReadUINT32(save_p);
+ data->nightsrecords[i]->grade[curmare] = P_ReadUINT8(save_p);
+ data->nightsrecords[i]->time[curmare] = (tic_t)P_ReadUINT32(save_p);
if (data->nightsrecords[i]->grade[curmare] > GRADE_S)
{
@@ -4949,18 +5204,18 @@ static inline void P_NetUnArchiveEmblems(void)
}
// Mid-map stuff
- unlocktriggers = READUINT32(save_p);
+ unlocktriggers = P_ReadUINT32(save_p);
for (i = 0; i < MAXPLAYERS; ++i)
{
- if ((recmares = READUINT8(save_p)) == 0)
+ if ((recmares = P_ReadUINT8(save_p)) == 0)
continue;
for (curmare = 0; curmare < (recmares+1); ++curmare)
{
- ntemprecords[i].score[curmare] = READUINT32(save_p);
- ntemprecords[i].grade[curmare] = READUINT8(save_p);
- ntemprecords[i].time[curmare] = (tic_t)READUINT32(save_p);
+ ntemprecords[i].score[curmare] = P_ReadUINT32(save_p);
+ ntemprecords[i].grade[curmare] = P_ReadUINT8(save_p);
+ ntemprecords[i].time[curmare] = (tic_t)P_ReadUINT32(save_p);
if (ntemprecords[i].grade[curmare] > GRADE_S)
{
@@ -4972,37 +5227,37 @@ static inline void P_NetUnArchiveEmblems(void)
}
}
-static void P_NetArchiveSectorPortals(void)
+static void P_NetArchiveSectorPortals(save_t *save_p)
{
- WRITEUINT32(save_p, ARCHIVEBLOCK_SECPORTALS);
+ P_WriteUINT32(save_p, ARCHIVEBLOCK_SECPORTALS);
- WRITEUINT32(save_p, secportalcount);
+ P_WriteUINT32(save_p, secportalcount);
for (size_t i = 0; i < secportalcount; i++)
{
UINT8 type = secportals[i].type;
- WRITEUINT8(save_p, type);
- WRITEFIXED(save_p, secportals[i].origin.x);
- WRITEFIXED(save_p, secportals[i].origin.y);
+ P_WriteUINT8(save_p, type);
+ P_WriteUINT8(save_p, secportals[i].ceiling ? 1 : 0);
+ P_WriteUINT32(save_p, SaveSector(secportals[i].target));
switch (type)
{
case SECPORTAL_LINE:
- WRITEUINT32(save_p, SaveLine(secportals[i].line.start));
- WRITEUINT32(save_p, SaveLine(secportals[i].line.dest));
+ P_WriteUINT32(save_p, SaveLine(secportals[i].line.start));
+ P_WriteUINT32(save_p, SaveLine(secportals[i].line.dest));
break;
case SECPORTAL_PLANE:
case SECPORTAL_HORIZON:
case SECPORTAL_FLOOR:
case SECPORTAL_CEILING:
- WRITEUINT32(save_p, SaveSector(secportals[i].sector));
+ P_WriteUINT32(save_p, SaveSector(secportals[i].sector));
break;
case SECPORTAL_OBJECT:
- if (secportals[i].mobj && !P_MobjWasRemoved(secportals[i].mobj))
- SaveMobjnum(secportals[i].mobj);
+ if (!P_MobjWasRemoved(secportals[i].mobj))
+ P_WriteUINT32(save_p, SaveMobjnum(secportals[i].mobj));
else
- WRITEUINT32(save_p, 0);
+ P_WriteUINT32(save_p, 0);
break;
default:
break;
@@ -5010,15 +5265,15 @@ static void P_NetArchiveSectorPortals(void)
}
}
-static void P_NetUnArchiveSectorPortals(void)
+static void P_NetUnArchiveSectorPortals(save_t *save_p)
{
- if (READUINT32(save_p) != ARCHIVEBLOCK_SECPORTALS)
+ if (P_ReadUINT32(save_p) != ARCHIVEBLOCK_SECPORTALS)
I_Error("Bad $$$.sav at archive block Secportals");
Z_Free(secportals);
P_InitSectorPortals();
- UINT32 count = READUINT32(save_p);
+ UINT32 count = P_ReadUINT32(save_p);
for (UINT32 i = 0; i < count; i++)
{
@@ -5026,24 +5281,24 @@ static void P_NetUnArchiveSectorPortals(void)
sectorportal_t *secportal = &secportals[id];
- secportal->type = READUINT8(save_p);
- secportal->origin.x = READFIXED(save_p);
- secportal->origin.y = READFIXED(save_p);
+ secportal->type = P_ReadUINT8(save_p);
+ secportal->ceiling = (P_ReadUINT8(save_p) != 0) ? true : false;
+ secportal->target = LoadSector(P_ReadUINT32(save_p));
switch (secportal->type)
{
case SECPORTAL_LINE:
- secportal->line.start = LoadLine(READUINT32(save_p));
- secportal->line.dest = LoadLine(READUINT32(save_p));
+ secportal->line.start = LoadLine(P_ReadUINT32(save_p));
+ secportal->line.dest = LoadLine(P_ReadUINT32(save_p));
break;
case SECPORTAL_PLANE:
case SECPORTAL_HORIZON:
case SECPORTAL_FLOOR:
case SECPORTAL_CEILING:
- secportal->sector = LoadSector(READUINT32(save_p));
+ secportal->sector = LoadSector(P_ReadUINT32(save_p));
break;
case SECPORTAL_OBJECT:
- id = READUINT32(save_p);
+ id = P_ReadUINT32(save_p);
secportal->mobj = (id == 0) ? NULL : P_FindNewPosition(id);
break;
default:
@@ -5052,7 +5307,7 @@ static void P_NetUnArchiveSectorPortals(void)
}
}
-static inline void P_ArchiveLuabanksAndConsistency(void)
+static inline void P_ArchiveLuabanksAndConsistency(save_t *save_p)
{
UINT8 i, banksinuse = NUM_LUABANKS;
@@ -5061,30 +5316,30 @@ static inline void P_ArchiveLuabanksAndConsistency(void)
if (banksinuse)
{
- WRITEUINT8(save_p, 0xb7); // luabanks marker
- WRITEUINT8(save_p, banksinuse);
+ P_WriteUINT8(save_p, 0xb7); // luabanks marker
+ P_WriteUINT8(save_p, banksinuse);
for (i = 0; i < banksinuse; i++)
- WRITEINT32(save_p, luabanks[i]);
+ P_WriteINT32(save_p, luabanks[i]);
}
- WRITEUINT8(save_p, 0x1d); // consistency marker
+ P_WriteUINT8(save_p, 0x1d); // consistency marker
}
-static inline boolean P_UnArchiveLuabanksAndConsistency(void)
+static inline boolean P_UnArchiveLuabanksAndConsistency(save_t *save_p)
{
- switch (READUINT8(save_p))
+ switch (P_ReadUINT8(save_p))
{
case 0xb7: // luabanks marker
{
- UINT8 i, banksinuse = READUINT8(save_p);
+ UINT8 i, banksinuse = P_ReadUINT8(save_p);
if (banksinuse > NUM_LUABANKS)
{
CONS_Alert(CONS_ERROR, M_GetText("Corrupt Luabanks! (Too many banks in use)\n"));
return false;
}
for (i = 0; i < banksinuse; i++)
- luabanks[i] = READINT32(save_p);
- if (READUINT8(save_p) != 0x1d) // consistency marker
+ luabanks[i] = P_ReadINT32(save_p);
+ if (P_ReadUINT8(save_p) != 0x1d) // consistency marker
{
CONS_Alert(CONS_ERROR, M_GetText("Corrupt Luabanks! (Failed consistency check)\n"));
return false;
@@ -5100,27 +5355,27 @@ static inline boolean P_UnArchiveLuabanksAndConsistency(void)
return true;
}
-void P_SaveGame(INT16 mapnum)
+void P_SaveGame(save_t *save_p, INT16 mapnum)
{
- P_ArchiveMisc(mapnum);
- P_ArchivePlayer();
- P_ArchiveLuabanksAndConsistency();
+ P_ArchiveMisc(save_p, mapnum);
+ P_ArchivePlayer(save_p);
+ P_ArchiveLuabanksAndConsistency(save_p);
}
-void P_SaveNetGame(boolean resending)
+void P_SaveNetGame(save_t *save_p, boolean resending)
{
thinker_t *th;
mobj_t *mobj;
INT32 i = 1; // don't start from 0, it'd be confused with a blank pointer otherwise
- CV_SaveNetVars(&save_p);
- P_NetArchiveMisc(resending);
- P_NetArchiveEmblems();
+ CV_SaveNetVars(save_p);
+ P_NetArchiveMisc(save_p, resending);
+ P_NetArchiveEmblems(save_p);
// Assign the mobjnumber for pointer tracking
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
{
- if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (th->removing)
continue;
mobj = (mobj_t *)th;
@@ -5129,32 +5384,32 @@ void P_SaveNetGame(boolean resending)
mobj->mobjnum = i++;
}
- P_NetArchivePlayers();
+ P_NetArchivePlayers(save_p);
if (gamestate == GS_LEVEL)
{
- P_NetArchiveWorld();
- P_ArchivePolyObjects();
- P_NetArchiveThinkers();
- P_NetArchiveSpecials();
- P_NetArchiveColormaps();
- P_NetArchiveWaypoints();
- P_NetArchiveSectorPortals();
+ P_NetArchiveWorld(save_p);
+ P_ArchivePolyObjects(save_p);
+ P_NetArchiveThinkers(save_p);
+ P_NetArchiveSpecials(save_p);
+ P_NetArchiveColormaps(save_p);
+ P_NetArchiveWaypoints(save_p);
+ P_NetArchiveSectorPortals(save_p);
}
- LUA_Archive();
+ LUA_Archive(save_p);
- P_ArchiveLuabanksAndConsistency();
+ P_ArchiveLuabanksAndConsistency(save_p);
}
-boolean P_LoadGame(INT16 mapoverride)
+boolean P_LoadGame(save_t *save_p, INT16 mapoverride)
{
if (gamestate == GS_INTERMISSION)
Y_EndIntermission();
G_SetGamestate(GS_NULL); // should be changed in P_UnArchiveMisc
- P_UnArchiveSPGame(mapoverride);
- P_UnArchivePlayer();
+ P_UnArchiveSPGame(save_p, mapoverride);
+ P_UnArchivePlayer(save_p);
- if (!P_UnArchiveLuabanksAndConsistency())
+ if (!P_UnArchiveLuabanksAndConsistency(save_p))
return false;
// Only do this after confirming savegame is ok
@@ -5164,26 +5419,26 @@ boolean P_LoadGame(INT16 mapoverride)
return true;
}
-boolean P_LoadNetGame(boolean reloading)
+boolean P_LoadNetGame(save_t *save_p, boolean reloading)
{
- CV_LoadNetVars(&save_p);
- if (!P_NetUnArchiveMisc(reloading))
+ CV_LoadNetVars(save_p);
+ if (!P_NetUnArchiveMisc(save_p, reloading))
return false;
- P_NetUnArchiveEmblems();
- P_NetUnArchivePlayers();
+ P_NetUnArchiveEmblems(save_p);
+ P_NetUnArchivePlayers(save_p);
if (gamestate == GS_LEVEL)
{
- P_NetUnArchiveWorld();
- P_UnArchivePolyObjects();
- P_NetUnArchiveThinkers();
- P_NetUnArchiveSpecials();
- P_NetUnArchiveColormaps();
- P_NetUnArchiveWaypoints();
- P_NetUnArchiveSectorPortals();
+ P_NetUnArchiveWorld(save_p);
+ P_UnArchivePolyObjects(save_p);
+ P_NetUnArchiveThinkers(save_p);
+ P_NetUnArchiveSpecials(save_p);
+ P_NetUnArchiveColormaps(save_p);
+ P_NetUnArchiveWaypoints(save_p);
+ P_NetUnArchiveSectorPortals(save_p);
P_RelinkPointers();
P_FinishMobjs();
}
- LUA_UnArchive();
+ LUA_UnArchive(save_p);
// This is stupid and hacky, but maybe it'll work!
P_SetRandSeed(P_GetInitSeed());
@@ -5194,5 +5449,5 @@ boolean P_LoadNetGame(boolean reloading)
// precipitation when loading a netgame save. Instead, precip has to be spawned here.
// This is done in P_NetUnArchiveSpecials now.
- return P_UnArchiveLuabanksAndConsistency();
+ return P_UnArchiveLuabanksAndConsistency(save_p);
}
diff --git a/src/p_saveg.h b/src/p_saveg.h
index 545008e7efc6af656fe94864a4ebcf8ea28e5f27..05e82190aeb27bb8aa62f5bf4a2b2c8b889759fb 100644
--- a/src/p_saveg.h
+++ b/src/p_saveg.h
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -18,17 +18,24 @@
#pragma interface
#endif
+#include "tables.h"
+
#define NEWSKINSAVES (INT16_MAX) // TODO: 2.3: Delete (Purely for backwards compatibility)
// Persistent storage/archiving.
// These are the load / save game routines.
-void P_SaveGame(INT16 mapnum);
-void P_SaveNetGame(boolean resending);
-boolean P_LoadGame(INT16 mapoverride);
-boolean P_LoadNetGame(boolean reloading);
+typedef struct
+{
+ unsigned char *buf;
+ size_t size;
+ size_t pos;
+} save_t;
-mobj_t *P_FindNewPosition(UINT32 oldposition);
+void P_SaveGame(save_t *save_p, INT16 mapnum);
+void P_SaveNetGame(save_t *save_p, boolean resending);
+boolean P_LoadGame(save_t *save_p, INT16 mapoverride);
+boolean P_LoadNetGame(save_t *save_p, boolean reloading);
typedef struct
{
@@ -42,6 +49,37 @@ typedef struct
} savedata_t;
extern savedata_t savedata;
-extern UINT8 *save_p;
+
+void P_WriteUINT8(save_t *p, UINT8 v);
+void P_WriteSINT8(save_t *p, SINT8 v);
+void P_WriteUINT16(save_t *p, UINT16 v);
+void P_WriteINT16(save_t *p, INT16 v);
+void P_WriteUINT32(save_t *p, UINT32 v);
+void P_WriteINT32(save_t *p, INT32 v);
+void P_WriteChar(save_t *p, char v);
+void P_WriteFixed(save_t *p, fixed_t v);
+void P_WriteAngle(save_t *p, angle_t v);
+void P_WriteStringN(save_t *p, char const *s, size_t n);
+void P_WriteStringL(save_t *p, char const *s, size_t n);
+void P_WriteString(save_t *p, char const *s);
+void P_WriteMem(save_t *p, void const *s, size_t n);
+
+void P_SkipStringN(save_t *p, size_t n);
+void P_SkipStringL(save_t *p, size_t n);
+void P_SkipString(save_t *p);
+
+UINT8 P_ReadUINT8(save_t *p);
+SINT8 P_ReadSINT8(save_t *p);
+UINT16 P_ReadUINT16(save_t *p);
+INT16 P_ReadINT16(save_t *p);
+UINT32 P_ReadUINT32(save_t *p);
+INT32 P_ReadINT32(save_t *p);
+char P_ReadChar(save_t *p);
+fixed_t P_ReadFixed(save_t *p);
+angle_t P_ReadAngle(save_t *p);
+void P_ReadStringN(save_t *p, char *s, size_t n);
+void P_ReadStringL(save_t *p, char *s, size_t n);
+void P_ReadString(save_t *p, char *s);
+void P_ReadMem(save_t *p, void *s, size_t n);
#endif
diff --git a/src/p_setup.c b/src/p_setup.c
index b5ed485d8a7df9512ce24a4b78f61e950280b280..247587e11e63d813bf57410e29d276ac5b4125e3 100644
--- a/src/p_setup.c
+++ b/src/p_setup.c
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -530,7 +530,7 @@ UINT32 P_GetScoreForGradeOverall(INT16 map, UINT8 grade)
void P_AddNiGHTSTimes(INT16 i, char *gtext)
{
char *spos = gtext;
-
+
for (UINT8 n = 0; n < 8; n++)
{
if (spos != NULL)
@@ -609,15 +609,15 @@ Ploadflat (levelflat_t *levelflat, const char *flatname, boolean resize)
levelflat->type = LEVELFLAT_TEXTURE;
// Look for a flat
- int texturenum = R_CheckFlatNumForName(levelflat->name);
+ int texturenum = R_CheckTextureNumForName(levelflat->name, TEXTURETYPE_FLAT);
if (texturenum < 0)
{
// If we can't find a flat, try looking for a texture!
- texturenum = R_CheckTextureNumForName(levelflat->name);
+ texturenum = R_CheckTextureNumForName(levelflat->name, TEXTURETYPE_TEXTURE);
if (texturenum < 0)
{
// Use "not found" texture
- texturenum = R_CheckTextureNumForName("REDWALL");
+ texturenum = R_CheckTextureNumForName("REDWALL", TEXTURETYPE_TEXTURE);
// Give up?
if (texturenum < 0)
@@ -692,7 +692,7 @@ void P_ReloadRings(void)
// scan the thinkers to find rings/spheres/hoops to unset
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
{
- if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (th->removing)
continue;
mo = (mobj_t *)th;
@@ -750,7 +750,7 @@ void P_SwitchSpheresBonusMode(boolean bonustime)
// scan the thinkers to find spheres to switch
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
{
- if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (th->removing)
continue;
mo = (mobj_t *)th;
@@ -2995,7 +2995,7 @@ static void P_LoadTextmap(void)
side_t *sd;
mapthing_t *mt;
- CONS_Alert(CONS_NOTICE, "UDMF support is still a work-in-progress; its specs and features are prone to change until it is fully implemented.\n");
+ //CONS_Alert(CONS_NOTICE, "UDMF support is still a work-in-progress; its specs and features are prone to change until it is fully implemented.\n");
/// Given the UDMF specs, some fields are given a default value.
/// If an element's field has a default value set, it is omitted
@@ -3075,7 +3075,7 @@ static void P_LoadTextmap(void)
// TODO: remove this limitation in a backwards-compatible way (UDMF versioning?)
UINT8 lightalpha = (textmap_colormap.lightalpha * 102) / 10;
UINT8 fadealpha = (textmap_colormap.fadealpha * 102) / 10;
-
+
INT32 rgba = P_ColorToRGBA(textmap_colormap.lightcolor, lightalpha);
INT32 fadergba = P_ColorToRGBA(textmap_colormap.fadecolor, fadealpha);
sc->extra_colormap = sc->spawn_extra_colormap = R_CreateColormap(rgba, fadergba, textmap_colormap.fadestart, textmap_colormap.fadeend, textmap_colormap.flags);
@@ -7333,7 +7333,7 @@ void P_RespawnThings(void)
for (think = thlist[THINK_MOBJ].next; think != &thlist[THINK_MOBJ]; think = think->next)
{
- if (think->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (think->removing)
continue;
P_RemoveMobj((mobj_t *)think);
}
@@ -7369,11 +7369,11 @@ static void P_RunLevelScript(const char *scriptname)
return;
}
- COM_BufInsertText(W_CacheLumpNum(lumpnum, PU_CACHE));
+ COM_BufInsertTextEx(W_CacheLumpNum(lumpnum, PU_CACHE), COM_LUA);
}
else
{
- COM_BufAddText(va("exec %s\n", scriptname));
+ COM_ExecFile(scriptname, COM_LUA, false);
}
COM_BufExecute(); // Run it!
}
@@ -7645,20 +7645,20 @@ static void P_InitCamera(void)
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 (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);
+ if ((splitscreen && cv_useranalog[1].value) || botingame)
+ CV_SetValue(&cv_analog[1], true);
+ }
}
}
@@ -7853,6 +7853,10 @@ boolean P_LoadLevel(boolean fromnetsave, boolean reloadinggamestate)
maptol = mapheaderinfo[gamemap-1]->typeoflevel;
gametyperules = gametypedefaultrules[gametype];
+ // clear the target on map change, since the object will be invalidated
+ P_SetTarget(&ticcmd_ztargetfocus[0], NULL);
+ P_SetTarget(&ticcmd_ztargetfocus[1], NULL);
+
CON_Drawer(); // let the user know what we are going to do
I_FinishUpdate(); // page flip or blit buffer
@@ -8002,6 +8006,9 @@ boolean P_LoadLevel(boolean fromnetsave, boolean reloadinggamestate)
// Free GPU textures before freeing patches.
if (rendermode == render_opengl && (vid.glstate == VID_GL_LIBRARY_LOADED))
HWR_ClearAllTextures();
+
+ // Delete light table textures
+ HWR_ClearLightTables();
#endif
Patch_FreeTag(PU_PATCH_LOWPRIORITY);
diff --git a/src/p_setup.h b/src/p_setup.h
index da38d4c08b152f87fab59517706c3ccbc7544339..6b0218854362085c0ae77220d984b567096e2d93 100644
--- a/src/p_setup.h
+++ b/src/p_setup.h
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
diff --git a/src/p_slopes.c b/src/p_slopes.c
index ce276a6729a6bea818328821430366ffa920b18c..12d5afd02fb96d7f19965e6f445de1e5b122a6d9 100644
--- a/src/p_slopes.c
+++ b/src/p_slopes.c
@@ -1,7 +1,7 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
// Copyright (C) 2009 by Stephen McGranahan.
-// Copyright (C) 2015-2023 by Sonic Team Junior.
+// Copyright (C) 2015-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -181,7 +181,7 @@ void T_DynamicSlopeLine (dynlineplanethink_t* th)
{
pslope_t* slope = th->slope;
line_t* srcline = th->sourceline;
-
+
fixed_t zdelta, oldoz = slope->o.z;
switch(th->type) {
@@ -1046,15 +1046,37 @@ fixed_t P_GetWallTransferMomZ(mobj_t *mo, pslope_t *slope)
{
vector3_t slopemom, axis;
angle_t ang;
+ angle_t advanceAng = ANG15;
+ const boolean upwards = (slope->zangle < ANGLE_180);
if (slope->flags & SL_NOPHYSICS)
return 0;
// If there's physics, time for launching.
// Doesn't kill the vertical momentum as much as P_SlopeLaunch does.
- ang = slope->zangle + ANG15*((slope->zangle > 0) ? 1 : -1);
- if (ang > ANGLE_90 && ang < ANGLE_180)
- ang = ((slope->zangle > 0) ? ANGLE_90 : InvAngle(ANGLE_90)); // hard cap of directly upwards
+ ang = slope->zangle;
+
+ // for the time being, let's pretend the slope inclines upwards only
+ if (!upwards)
+ {
+ ang += ANGLE_180;
+ }
+
+ // angles past 90 degrees need to shrink to get closer to 90 degrees
+ if (ang > ANGLE_90)
+ {
+ advanceAng = InvAngle(advanceAng);
+ }
+
+ // now we set the actual final angle
+ if ((ang > ANGLE_90) != (ang + advanceAng > ANGLE_90)) // does advancing the angle push it past directly upwards?
+ {
+ ang = (upwards ? ANGLE_90 : InvAngle(ANGLE_90)); // hard cap of directly upwards
+ }
+ else
+ {
+ ang = slope->zangle + advanceAng;
+ }
slopemom.x = mo->momx;
slopemom.y = mo->momy;
diff --git a/src/p_slopes.h b/src/p_slopes.h
index fdc07f67e257ba05eef35fc481c3be3a0ebdfd7c..39b7ba56dbf2119e730b145e90d76bb18e9d7e70 100644
--- a/src/p_slopes.h
+++ b/src/p_slopes.h
@@ -1,7 +1,7 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
// Copyright (C) 2009 by Stephen McGranahan.
-// Copyright (C) 2015-2023 by Sonic Team Junior.
+// Copyright (C) 2015-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
diff --git a/src/p_spec.c b/src/p_spec.c
index d4939669a1ec5bce2ee873617b00edfce966829e..649f63518eed2017cbfd06817eb322d27280d52e 100644
--- a/src/p_spec.c
+++ b/src/p_spec.c
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -135,22 +135,24 @@ void P_ParseAnimationDefintion(SINT8 istexture);
static boolean P_FindTextureForAnimation(anim_t *anim, animdef_t *animdef)
{
- if (R_CheckTextureNumForName(animdef->startname) == -1)
+ INT32 start = R_CheckTextureNumForName(animdef->startname, TEXTURETYPE_TEXTURE);
+ if (start == -1)
return false;
- anim->picnum = R_TextureNumForName(animdef->endname);
- anim->basepic = R_TextureNumForName(animdef->startname);
+ anim->basepic = start;
+ anim->picnum = R_CheckTextureNumForName(animdef->endname, TEXTURETYPE_TEXTURE);
return true;
}
static boolean P_FindFlatForAnimation(anim_t *anim, animdef_t *animdef)
{
- if (R_CheckFlatNumForName(animdef->startname) == -1)
+ INT32 start = R_CheckTextureNumForName(animdef->startname, TEXTURETYPE_FLAT);
+ if (start == -1)
return false;
- anim->picnum = R_CheckFlatNumForName(animdef->endname);
- anim->basepic = R_CheckFlatNumForName(animdef->startname);
+ anim->basepic = start;
+ anim->picnum = R_CheckTextureNumForName(animdef->endname, TEXTURETYPE_FLAT);
return true;
}
@@ -2406,7 +2408,7 @@ static void P_ProcessLineSpecial(line_t *line, mobj_t *mo, sector_t *callsec)
z = line->args[4] << FRACBITS;
P_SetOrigin(mo, mo->x + x, mo->y + y, mo->z + z);
-
+
if (mo->player)
{
if (bot) // This might put poor Tails in a wall if he's too far behind! D: But okay, whatever! >:3
@@ -2546,7 +2548,7 @@ static void P_ProcessLineSpecial(line_t *line, mobj_t *mo, sector_t *callsec)
char *text = Z_Malloc(len + 1, PU_CACHE, NULL);
memcpy(text, lump, len);
text[len] = '\0';
- COM_BufInsertText(text);
+ COM_BufInsertTextEx(text, COM_LUA);
Z_Free(text);
}
}
@@ -3642,7 +3644,7 @@ static void P_ProcessLineSpecial(line_t *line, mobj_t *mo, sector_t *callsec)
if (mo2->type != MT_EGGTRAP)
continue;
- if (mo2->thinker.function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (mo2->thinker.removing)
continue;
P_KillMobj(mo2, NULL, mo, 0);
@@ -3854,7 +3856,7 @@ void P_SetupSignExit(player_t *player)
// spin all signposts in the level then.
for (think = thlist[THINK_MOBJ].next; think != &thlist[THINK_MOBJ]; think = think->next)
{
- if (think->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (think->removing)
continue;
thing = (mobj_t *)think;
@@ -3892,7 +3894,7 @@ boolean P_IsFlagAtBase(mobjtype_t flag)
for (think = thlist[THINK_MOBJ].next; think != &thlist[THINK_MOBJ]; think = think->next)
{
- if (think->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (think->removing)
continue;
mo = (mobj_t *)think;
@@ -4395,7 +4397,7 @@ static void P_ProcessEggCapsule(player_t *player, sector_t *sector)
// The chimps are my friends.. heeheeheheehehee..... - LouisJM
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
{
- if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (th->removing)
continue;
mo2 = (mobj_t *)th;
if (mo2->type != MT_EGGTRAP)
@@ -6236,7 +6238,7 @@ static void P_DoPortalCopyFromLine(sector_t *dest_sector, int plane_type, int ta
}
}
-static sectorportal_t *P_SectorGetPortalOrCreate(sector_t *sector, UINT32 *num, UINT32 *result)
+static sectorportal_t *P_SectorGetPortalOrCreate(sector_t *sector, UINT32 *num, UINT32 *result, boolean ceiling)
{
sectorportal_t *secportal = NULL;
@@ -6244,8 +6246,8 @@ static sectorportal_t *P_SectorGetPortalOrCreate(sector_t *sector, UINT32 *num,
{
*num = P_NewSectorPortal();
secportal = &secportals[*num];
- secportal->origin.x = sector->soundorg.x;
- secportal->origin.y = sector->soundorg.y;
+ secportal->target = sector;
+ secportal->ceiling = ceiling;
*result = *num;
}
else
@@ -6259,12 +6261,12 @@ static sectorportal_t *P_SectorGetPortalOrCreate(sector_t *sector, UINT32 *num,
static sectorportal_t *P_SectorGetFloorPortalOrCreate(sector_t *sector, UINT32 *result)
{
- return P_SectorGetPortalOrCreate(sector, §or->portal_floor, result);
+ return P_SectorGetPortalOrCreate(sector, §or->portal_floor, result, false);
}
static sectorportal_t *P_SectorGetCeilingPortalOrCreate(sector_t *sector, UINT32 *result)
{
- return P_SectorGetPortalOrCreate(sector, §or->portal_ceiling, result);
+ return P_SectorGetPortalOrCreate(sector, §or->portal_ceiling, result, true);
}
static void P_CopySectorPortalToLines(UINT32 portal_num, int sector_tag)
diff --git a/src/p_spec.h b/src/p_spec.h
index b9c3a2ca3c2055481b54cd2d2fce3217df244fe7..ba08781b636cdb0042368c5ff90b5fa0db8c193c 100644
--- a/src/p_spec.h
+++ b/src/p_spec.h
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
diff --git a/src/p_tick.c b/src/p_tick.c
index 56e0fd897bfbba718885a1104224d1554790f227..db8688484ac3dbcf56fafc293af6bc995190e0f9 100644
--- a/src/p_tick.c
+++ b/src/p_tick.c
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -162,7 +162,7 @@ void Command_CountMobjs_f(void)
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
{
- if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (th->removing)
continue;
if (((mobj_t *)th)->type == i)
@@ -182,7 +182,7 @@ void Command_CountMobjs_f(void)
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
{
- if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (th->removing)
continue;
if (((mobj_t *)th)->type == i)
@@ -348,6 +348,7 @@ void P_RemoveThinkerDelayed(thinker_t *thinker)
void P_RemoveThinker(thinker_t *thinker)
{
LUA_InvalidateUserdata(thinker);
+ thinker->removing = true;
thinker->function.acp1 = (actionf_p1)P_RemoveThinkerDelayed;
}
diff --git a/src/p_user.c b/src/p_user.c
index 3ee13aca96989a4c7f5b94a64c8e525f275f9882..25c68e5752afc82b28655f02d58b670706a4ac75 100644
--- a/src/p_user.c
+++ b/src/p_user.c
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2025 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -435,7 +435,7 @@ UINT8 P_FindLowestMare(void)
// to find the egg capsule with the lowest mare
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
{
- if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (th->removing)
continue;
mo2 = (mobj_t *)th;
@@ -488,7 +488,7 @@ boolean P_TransferToNextMare(player_t *player)
// to find the closest axis point
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
{
- if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (th->removing)
continue;
mo2 = (mobj_t *)th;
@@ -539,7 +539,7 @@ static mobj_t *P_FindAxis(INT32 mare, INT32 axisnum)
// to find the closest axis point
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
{
- if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (th->removing)
continue;
mo2 = (mobj_t *)th;
@@ -574,7 +574,7 @@ static mobj_t *P_FindAxisTransfer(INT32 mare, INT32 axisnum, mobjtype_t type)
// to find the closest axis point
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
{
- if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (th->removing)
continue;
mo2 = (mobj_t *)th;
@@ -615,7 +615,7 @@ void P_TransferToAxis(player_t *player, INT32 axisnum)
// to find the closest axis point
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
{
- if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (th->removing)
continue;
mo2 = (mobj_t *)th;
@@ -669,7 +669,7 @@ static void P_DeNightserizePlayer(player_t *player)
player->powers[pw_carry] = CR_NIGHTSFALL;
player->powers[pw_underwater] = 0;
- player->pflags &= ~(PF_SPINDOWN|PF_JUMPDOWN|PF_ATTACKDOWN|PF_SHIELDDOWN|PF_STARTDASH|PF_GLIDING|PF_STARTJUMP|PF_JUMPED|PF_NOJUMPDAMAGE|PF_THOKKED|PF_SPINNING|PF_DRILLING|PF_TRANSFERTOCLOSEST);
+ player->pflags &= ~(PF_SPINDOWN|PF_JUMPDOWN|PF_ATTACKDOWN|PF_STARTDASH|PF_GLIDING|PF_STARTJUMP|PF_JUMPED|PF_NOJUMPDAMAGE|PF_THOKKED|PF_SPINNING|PF_DRILLING|PF_TRANSFERTOCLOSEST);
player->secondjump = 0;
player->homing = 0;
player->climbing = 0;
@@ -716,7 +716,7 @@ static void P_DeNightserizePlayer(player_t *player)
// Check to see if the player should be killed.
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
{
- if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (th->removing)
continue;
mo2 = (mobj_t *)th;
@@ -802,7 +802,7 @@ void P_NightserizePlayer(player_t *player, INT32 nighttime)
if (mapheaderinfo[gamemap-1]->nightstimer[newmare] > 0)
nighttime = mapheaderinfo[gamemap-1]->nightstimer[newmare];
- player->pflags &= ~(PF_SPINDOWN|PF_JUMPDOWN|PF_ATTACKDOWN|PF_SHIELDDOWN|PF_STARTDASH|PF_GLIDING|PF_JUMPED|PF_NOJUMPDAMAGE|PF_THOKKED|PF_SHIELDABILITY|PF_SPINNING|PF_DRILLING);
+ player->pflags &= ~(PF_SPINDOWN|PF_JUMPDOWN|PF_ATTACKDOWN|PF_STARTDASH|PF_GLIDING|PF_JUMPED|PF_NOJUMPDAMAGE|PF_THOKKED|PF_SHIELDABILITY|PF_SPINNING|PF_DRILLING);
player->homing = 0;
player->mo->fuse = 0;
player->speed = 0;
@@ -978,7 +978,7 @@ boolean P_PlayerInPain(player_t *player)
{
if (P_MobjWasRemoved(player->mo))
return false;
-
+
// no silly, sliding isn't pain
if (!(player->pflags & PF_SLIDING) && player->mo->state == &states[player->mo->info->painstate] && player->powers[pw_flashing])
return true;
@@ -1362,6 +1362,8 @@ void P_DoSuperTransformation(player_t *player, boolean giverings)
if (!(mapheaderinfo[gamemap-1]->levelflags & LF_NOSSMUSIC) && P_IsLocalPlayer(player))
P_PlayJingle(player, JT_SUPER);
+ S_StartSound(NULL, sfx_supert); //let all players hear it -mattw_cfi
+
player->mo->momx = player->mo->momy = player->mo->momz = player->cmomx = player->cmomy = player->rmomx = player->rmomy = 0;
// Transformation animation
@@ -1378,11 +1380,8 @@ void P_DoSuperTransformation(player_t *player, boolean giverings)
player->powers[pw_sneakers] = 0;
}
- if (G_CoopGametype())
- S_StartSound(player->mo, sfx_supert); //only hear it near yourself in co-op
- else
+ if (!G_CoopGametype())
{
- S_StartSound(NULL, sfx_supert); //let all players hear it -mattw_cfi
HU_SetCEchoFlags(0);
HU_SetCEchoDuration(5);
HU_DoCEcho(va("%s\\is now super.\\\\\\\\", player_names[player-players]));
@@ -1417,7 +1416,7 @@ void P_DoSuperDetransformation(player_t *player)
if (!G_CoopGametype())
player->powers[pw_flashing] = flashingtics-1;
- if (player->mo->sprite2 & SPR2F_SUPER)
+ if (player->mo->sprite2 & FF_SPR2SUPER)
P_SetMobjState(player->mo, player->mo->state-states);
// Inform the netgame that the champion has fallen in the heat of battle.
@@ -1899,7 +1898,7 @@ void P_SpawnShieldOrb(player_t *player)
// blaze through the thinkers to see if an orb already exists!
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
{
- if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (th->removing)
continue;
shieldobj = (mobj_t *)th;
@@ -3311,6 +3310,7 @@ static void P_DoPlayerHeadSigns(player_t *player)
sign->frame = 2|FF_FULLBRIGHT;
}
}
+ }
if (!P_MobjWasRemoved(sign) && splitscreen) // Hide the sign from yourself in splitscreen - In single-screen, it wouldn't get spawned if it shouldn't be visible
{
@@ -3348,7 +3348,6 @@ static void P_DoPlayerHeadSigns(player_t *player)
}
#endif
}
- }
}
//
@@ -4126,7 +4125,7 @@ static void P_DoTeeter(player_t *player)
teeteryl = teeteryh = player->mo->y;
couldteeter = false;
solidteeter = teeter;
- if (!P_DoBlockThingsIterate(xl, yl, xh, yh, PIT_CheckSolidsTeeter))
+ if (!P_DoBlockThingsIterate(xl, yl, xh, yh, PIT_CheckSolidsTeeter, tmthing))
goto teeterdone; // we've found something that stops us teetering at all
teeterdone:
teeter = solidteeter;
@@ -4211,7 +4210,6 @@ static void P_DoFiring(player_t *player, ticcmd_t *cmd)
if (player->pflags & PF_ATTACKDOWN || player->climbing || (G_TagGametype() && !(player->pflags & PF_TAGIT)))
return;
- // Fire a fireball if we have the Fire Flower powerup!
if (((player->powers[pw_shield] & SH_STACK) == SH_FIREFLOWER) && !(player->weapondelay))
{
player->pflags |= PF_ATTACKDOWN;
@@ -4223,7 +4221,6 @@ static void P_DoFiring(player_t *player, ticcmd_t *cmd)
return;
}
- // No ringslinging outside of ringslinger!
if (!G_RingSlingerGametype() || player->weapondelay)
return;
@@ -4402,7 +4399,34 @@ static void P_DoSuperStuff(player_t *player)
// If you're super and not Sonic, de-superize!
if (!(ALL7EMERALDS(emeralds) && player->charflags & SF_SUPER))
{
- P_DoSuperDetransformation(player);
+ player->powers[pw_super] = 0;
+ P_SetMobjState(player->mo, S_PLAY_STND);
+ if (P_IsLocalPlayer(player))
+ {
+ music_stack_noposition = true; // HACK: Do not reposition next music
+ music_stack_fadeout = MUSICRATE/2; // HACK: Fade out current music
+ }
+ P_RestoreMusic(player);
+ P_SpawnShieldOrb(player);
+
+ // Restore color
+ if ((player->powers[pw_shield] & SH_STACK) == SH_FIREFLOWER)
+ {
+ player->mo->color = SKINCOLOR_WHITE;
+ G_GhostAddColor(GHC_FIREFLOWER);
+ }
+ else
+ {
+ player->mo->color = P_GetPlayerColor(player);
+ G_GhostAddColor(GHC_NORMAL);
+ }
+
+ if (!G_CoopGametype())
+ {
+ HU_SetCEchoFlags(0);
+ HU_SetCEchoDuration(5);
+ HU_DoCEcho(va("%s\\is no longer super.\\\\\\\\", player_names[player-players]));
+ }
return;
}
@@ -4429,37 +4453,28 @@ static void P_DoSuperStuff(player_t *player)
// Ran out of rings while super!
if (player->rings <= 0 || player->exiting)
+ {
P_DoSuperDetransformation(player);
+ }
}
}
//
// P_SuperReady
//
-// Returns true if player is ready to transform or detransform
+// Returns true if player is ready to turn super, duh
//
-boolean P_SuperReady(player_t *player, boolean transform)
+boolean P_SuperReady(player_t *player)
{
- if (!transform &&
- (player->powers[pw_super] < TICRATE*3/2
- || !G_CoopGametype())) // No turning back in competitive!
- return false;
- else if (transform
- && (player->powers[pw_super]
- || !ALL7EMERALDS(emeralds)
- || !(player->rings >= 50)))
- return false;
-
- if (player->mo
+ if (!player->powers[pw_super]
+ && !player->powers[pw_invulnerability]
&& !player->powers[pw_tailsfly]
- && !player->powers[pw_carry]
&& (player->charflags & SF_SUPER)
- && !P_PlayerInPain(player)
- && !player->climbing
- && !(player->pflags & (PF_JUMPSTASIS|PF_THOKKED|PF_STARTDASH|PF_GLIDING|PF_SLIDING|PF_SHIELDABILITY))
- && ((player->pflags & PF_JUMPED) || (P_IsObjectOnGround(player->mo) && (player->panim == PA_IDLE || player->panim == PA_EDGE
- || player->panim == PA_WALK || player->panim == PA_RUN || (player->charflags & SF_DASHMODE && player->panim == PA_DASH))))
- && !(maptol & TOL_NIGHTS))
+ && (player->pflags & PF_JUMPED)
+ && !(player->powers[pw_shield] & SH_NOSTACK)
+ && !(maptol & TOL_NIGHTS)
+ && ALL7EMERALDS(emeralds)
+ && (player->rings >= 50))
return true;
return false;
@@ -5112,7 +5127,7 @@ void P_Telekinesis(player_t *player, fixed_t thrust, fixed_t range)
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
{
- if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (th->removing)
continue;
mo2 = (mobj_t *)th;
@@ -5164,7 +5179,7 @@ static boolean P_PlayerShieldThink(player_t *player, ticcmd_t *cmd, mobj_t *lock
{
mobj_t *lockonshield = NULL;
- if ((player->powers[pw_shield] & SH_NOSTACK) && !player->powers[pw_super] && !(player->pflags & PF_SHIELDDOWN)
+ if ((player->powers[pw_shield] & SH_NOSTACK) && !player->powers[pw_super] && !(player->pflags & PF_SPINDOWN)
&& ((!(player->pflags & PF_THOKKED) || (((player->powers[pw_shield] & SH_NOSTACK) == SH_BUBBLEWRAP || (player->powers[pw_shield] & SH_NOSTACK) == SH_ATTRACT) && player->secondjump == UINT8_MAX) ))) // thokked is optional if you're bubblewrapped / 3dblasted
{
if ((player->powers[pw_shield] & SH_NOSTACK) == SH_ATTRACT && !(player->charflags & SF_NOSHIELDABILITY))
@@ -5194,7 +5209,7 @@ static boolean P_PlayerShieldThink(player_t *player, ticcmd_t *cmd, mobj_t *lock
}
}
}
- if ((!(player->charflags & SF_NOSHIELDABILITY)) && (cmd->buttons & BT_SHIELD && !LUA_HookPlayer(player, HOOK(ShieldSpecial)))) // Shield button effects
+ if ((!(player->charflags & SF_NOSHIELDABILITY)) && (cmd->buttons & BT_SPIN && !LUA_HookPlayer(player, HOOK(ShieldSpecial)))) // Spin button effects
{
// Force stop
if ((player->powers[pw_shield] & ~(SH_FORCEHP|SH_STACK)) == SH_FORCE)
@@ -5283,7 +5298,7 @@ static boolean P_PlayerShieldThink(player_t *player, ticcmd_t *cmd, mobj_t *lock
//
// Handles player jumping
//
-static void P_DoJumpStuff(player_t *player, ticcmd_t *cmd, boolean spinshieldhack)
+static void P_DoJumpStuff(player_t *player, ticcmd_t *cmd)
{
mobj_t *lockonthok = NULL, *visual = NULL;
@@ -5316,13 +5331,12 @@ static void P_DoJumpStuff(player_t *player, ticcmd_t *cmd, boolean spinshieldhac
;
else if (P_PlayerShieldThink(player, cmd, lockonthok, visual))
;
- else if (cmd->buttons & BT_SPIN)
+ else if ((cmd->buttons & BT_SPIN))
{
- if (spinshieldhack && !(player->pflags & PF_SPINDOWN) && P_SuperReady(player, true)
- && !player->powers[pw_invulnerability] && !(player->powers[pw_shield] & SH_NOSTACK)) // These two checks are no longer in P_SuperReady
+ if (!(player->pflags & PF_SPINDOWN) && P_SuperReady(player))
{
- // If you're using two-button play, can turn Super and aren't already,
- // and you don't have a shield, then turn Super!
+ // If you can turn super and aren't already,
+ // and you don't have a shield, do it!
P_DoSuperTransformation(player, false);
}
else if (!LUA_HookPlayer(player, HOOK(JumpSpinSpecial)))
@@ -5425,6 +5439,12 @@ static void P_DoJumpStuff(player_t *player, ticcmd_t *cmd, boolean spinshieldhac
}
else if (player->pflags & PF_SLIDING || ((gametyperules & GTR_TEAMFLAGS) && player->gotflag) || player->pflags & PF_SHIELDABILITY)
;
+ /*else if (P_SuperReady(player))
+ {
+ // If you can turn super and aren't already,
+ // and you don't have a shield, do it!
+ P_DoSuperTransformation(player, false);
+ }*/
else if (player->pflags & PF_JUMPED)
{
if (!LUA_HookPlayer(player, HOOK(AbilitySpecial)))
@@ -6479,7 +6499,7 @@ static void P_NightsTransferPoints(player_t *player, fixed_t xspeed, fixed_t rad
// Find next waypoint
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
{
- if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (th->removing)
continue;
mo2 = (mobj_t *)th;
@@ -6515,7 +6535,7 @@ static void P_NightsTransferPoints(player_t *player, fixed_t xspeed, fixed_t rad
{
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
{
- if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (th->removing)
continue;
mo2 = (mobj_t *)th;
@@ -6544,7 +6564,7 @@ static void P_NightsTransferPoints(player_t *player, fixed_t xspeed, fixed_t rad
{
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
{
- if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (th->removing)
continue;
mo2 = (mobj_t *)th;
@@ -7276,7 +7296,7 @@ static void P_NiGHTSMovement(player_t *player)
// to find the closest axis point
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
{
- if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (th->removing)
continue;
mo2 = (mobj_t *)th;
@@ -8077,7 +8097,6 @@ void P_MovePlayer(player_t *player)
{
ticcmd_t *cmd;
INT32 i;
- boolean spinshieldhack = false; // Hack: Is Spin and Shield bound to the same button (pressed on the same tic)?
fixed_t runspd;
@@ -8176,7 +8195,7 @@ void P_MovePlayer(player_t *player)
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
{
- if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (th->removing)
continue;
mo2 = (mobj_t *)th;
@@ -8699,13 +8718,10 @@ void P_MovePlayer(player_t *player)
&& !(player->mo->eflags & (MFE_UNDERWATER|MFE_TOUCHWATER)))
P_ElementalFire(player, false);
- if ((cmd->buttons & (BT_SPIN|BT_SHIELD)) == (BT_SPIN|BT_SHIELD) && !(player->pflags & (PF_SPINDOWN|PF_SHIELDDOWN)))
- spinshieldhack = true; // Spin and Shield is bound to the same button (pressed on the same tic), so enable two-button play (Jump and Spin+Shield)
-
P_DoSpinAbility(player, cmd);
// jumping
- P_DoJumpStuff(player, cmd, spinshieldhack);
+ P_DoJumpStuff(player, cmd);
// If you're not spinning, you'd better not be spindashing!
if (!(player->pflags & PF_SPINNING) && player->powers[pw_carry] != CR_NIGHTSMODE)
@@ -8793,25 +8809,10 @@ void P_MovePlayer(player_t *player)
P_PlayerFlagBurst(player, true);
}
- // Check for fire and shield buttons
+ // check for fire
if (!player->exiting)
- {
P_DoFiring(player, cmd);
- // Shield button behavior
- // Check P_PlayerShieldThink for actual shields!
- if ((cmd->buttons & BT_SHIELD) && !(player->pflags & PF_SHIELDDOWN) && !spinshieldhack)
- {
- // Transform into super if we can!
- if (P_SuperReady(player, true))
- P_DoSuperTransformation(player, false);
-
- // Detransform from super if we can!
- else if (P_SuperReady(player, false))
- P_DoSuperDetransformation(player);
- }
- }
-
{
boolean atspinheight = false;
fixed_t oldheight = player->mo->height;
@@ -9161,7 +9162,7 @@ void P_NukeEnemies(mobj_t *inflictor, mobj_t *source, fixed_t radius)
for (think = thlist[THINK_MOBJ].next; think != &thlist[THINK_MOBJ]; think = think->next)
{
- if (think->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (think->removing)
continue;
mo = (mobj_t *)think;
@@ -9259,7 +9260,7 @@ mobj_t *P_LookForFocusTarget(player_t *player, mobj_t *exclude, SINT8 direction,
for (think = thlist[THINK_MOBJ].next; think != &thlist[THINK_MOBJ]; think = think->next)
{
- if (think->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (think->removing)
continue;
mo = (mobj_t *)think;
@@ -9378,7 +9379,7 @@ mobj_t *P_LookForEnemies(player_t *player, boolean nonenemies, boolean bullet)
for (think = thlist[THINK_MOBJ].next; think != &thlist[THINK_MOBJ]; think = think->next)
{
- if (think->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (think->removing)
continue;
mo = (mobj_t *)think;
@@ -9524,7 +9525,7 @@ void P_FindEmerald(void)
// to find all emeralds
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
{
- if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (th->removing)
continue;
mo2 = (mobj_t *)th;
@@ -10925,7 +10926,7 @@ static mobj_t *P_GetAxis(INT32 num)
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
{
- if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (th->removing)
continue;
mobj = (mobj_t *)th;
@@ -11514,6 +11515,18 @@ void P_DoTailsOverlay(player_t *player, mobj_t *tails)
}
// Metal Sonic's jet fume
+//
+// The follow object's state is set to its spawn state when deactivated.
+// When the player is on a moving animation, the follow object goes to its see state.
+// When dash mode is entered, the follow object switches to its melee state.
+//
+// If MF2_FRET is set, the jet fume will flash during dash mode.
+// MF2_AMBUSH can be used to enable Metal Sonic's skidding animation.
+// MF2_JUSTATTACKED will enable the color cycling.
+// If the follow item is MT_METALJETFUME, the above two effects are automatically applied.
+//
+// MF2_STRONGBOX is internally used to track if the jet fume is in its deactivated state or not.
+// MF2_BOSSNOTRAP is internally used to instantly reset the jet fume's scale to its intended scale.
void P_DoMetalJetFume(player_t *player, mobj_t *fume)
{
static const UINT8 FUME_SKINCOLORS[] =
@@ -11540,15 +11553,28 @@ void P_DoMetalJetFume(player_t *player, mobj_t *fume)
fixed_t heightoffset = ((mo->eflags & MFE_VERTICALFLIP) ? mo->height - (P_GetPlayerHeight(player) >> 1) : (P_GetPlayerHeight(player) >> 1));
panim_t panim = player->panim;
tic_t dashmode = min(player->dashmode, DASHMODE_MAX);
+ boolean ismetaljetfume = fume->type == MT_METALJETFUME;
+ boolean notmoving = panim != PA_WALK && panim != PA_RUN && panim != PA_DASH;
boolean underwater = mo->eflags & MFE_UNDERWATER;
statenum_t stat = fume->state-states;
boolean resetinterp = false;
- if (panim != PA_WALK && panim != PA_RUN && panim != PA_DASH) // turn invisible when not in a coherent movement state
+ if (notmoving) // deactivate when not in a coherent movement state
{
- if (stat != fume->info->spawnstate)
+ if ((fume->flags2 & MF2_STRONGBOX) == 0)
+ {
P_SetMobjState(fume, fume->info->spawnstate);
- return;
+ fume->flags2 |= MF2_STRONGBOX;
+ }
+ if (P_MobjWasRemoved(fume) || ismetaljetfume)
+ return;
+ }
+
+ // Rotate on skid animation if follow item is MT_METALJETFUME, or if MF2_AMBUSH is set
+ if (player->mo->sprite2 == SPR2_SKID)
+ {
+ if ((ismetaljetfume && (player->charflags & SF_JETFUME)) || (fume->flags2 & MF2_AMBUSH))
+ angle += ANGLE_90;
}
if (underwater) // No fume underwater; spawn bubbles instead!
@@ -11586,54 +11612,82 @@ void P_DoMetalJetFume(player_t *player, mobj_t *fume)
if (panim == PA_WALK)
{
- if (stat != fume->info->spawnstate)
+ if ((fume->flags2 & MF2_STRONGBOX) == 0)
{
- fume->threshold = 0;
P_SetMobjState(fume, fume->info->spawnstate);
+ fume->threshold = 0;
+ fume->flags2 &= ~MF2_STRONGBOX;
}
- return;
+ if (P_MobjWasRemoved(fume) || ismetaljetfume)
+ return;
}
}
- if (stat == fume->info->spawnstate) // If currently inivisble, activate!
+ // If currently deactivated, activate!
+ if (!notmoving && !underwater && (fume->flags2 & MF2_STRONGBOX))
{
P_SetMobjState(fume, (stat = fume->info->seestate));
+ if (P_MobjWasRemoved(fume))
+ return;
P_SetScale(fume, mo->scale, false);
+ fume->flags2 &= ~MF2_STRONGBOX;
resetinterp = true;
}
- if (dashmode > DASHMODE_THRESHOLD && stat != fume->info->seestate) // If in dashmode, grow really big and flash
+ // If in dash mode, grow really big
+ if (dashmode > DASHMODE_THRESHOLD && stat != fume->info->meleestate)
{
fume->destscale = mo->scale;
- fume->flags2 ^= MF2_DONTDRAW;
fume->flags2 |= mo->flags2 & MF2_DONTDRAW;
+
+ // Flash if follow item is MT_METALJETFUME, or if MF2_FRET is set
+ if (ismetaljetfume || (fume->flags2 & MF2_FRET))
+ fume->flags2 ^= MF2_DONTDRAW;
}
else // Otherwise, pick a size and color depending on speed and proximity to dashmode
{
- if (dashmode == DASHMODE_THRESHOLD && dashmode > (tic_t)fume->movecount) // If just about to enter dashmode, play the startup animation again
+ // If just about to enter dash mode, play the startup animation again
+ if (dashmode == DASHMODE_THRESHOLD && dashmode > (tic_t)fume->movecount)
{
- P_SetMobjState(fume, (stat = fume->info->seestate));
+ P_SetMobjState(fume, fume->info->meleestate);
+ if (P_MobjWasRemoved(fume))
+ return;
P_SetScale(fume, 2*mo->scale, true);
}
+
fume->flags2 = (fume->flags2 & ~MF2_DONTDRAW) | (mo->flags2 & MF2_DONTDRAW);
fume->destscale = (mo->scale + FixedDiv(player->speed, player->normalspeed)) / (underwater ? 6 : 3);
- fume->color = FUME_SKINCOLORS[(dashmode * sizeof(FUME_SKINCOLORS)) / (DASHMODE_MAX + 1)];
+
+ // Do color cycling if follow item is MT_METALJETFUME, or if MF2_JUSTATTACKED is set
+ if (ismetaljetfume || (fume->flags2 & MF2_JUSTATTACKED))
+ fume->color = FUME_SKINCOLORS[(dashmode * sizeof(FUME_SKINCOLORS)) / (DASHMODE_MAX + 1)];
if (underwater)
{
- fume->frame = (fume->frame & FF_FRAMEMASK) | FF_ANIMATE | (P_RandomRange(0, 9) * FF_TRANS10);
+ fume->frame = (fume->frame & ~FF_TRANSMASK) | (P_RandomRange(0, 9) << FF_TRANSSHIFT);
fume->threshold = 1;
}
else if (fume->threshold)
{
- fume->frame = (fume->frame & FF_FRAMEMASK) | fume->state->frame;
+ fume->frame = (fume->frame & FF_FRAMEMASK) | (fume->state->frame & ~FF_FRAMEMASK);
fume->threshold = 0;
}
}
- fume->movecount = dashmode; // keeps track of previous dashmode value so we know whether Metal is entering or leaving it
- fume->flags2 = (fume->flags2 & ~MF2_OBJECTFLIP) | (mo->flags2 & MF2_OBJECTFLIP); // Make sure to flip in reverse gravity!
- fume->eflags = (fume->eflags & ~MFE_VERTICALFLIP) | (mo->eflags & MFE_VERTICALFLIP); // Make sure to flip in reverse gravity!
+ // keeps track of previous dash mode value so we know whether Metal is entering or leaving it
+ fume->movecount = dashmode;
+
+ // Make sure to flip in reverse gravity!
+ fume->flags2 = (fume->flags2 & ~MF2_OBJECTFLIP) | (mo->flags2 & MF2_OBJECTFLIP);
+ fume->eflags = (fume->eflags & ~MFE_VERTICALFLIP) | (mo->eflags & MFE_VERTICALFLIP);
+
+ // Set the appropriate scale at spawn
+ // This is... strange, but I had to choose a flag that a follow object would not ordinarily use.
+ if ((fume->flags2 & MF2_BOSSNOTRAP) == 0)
+ {
+ P_SetScale(fume, fume->destscale, true);
+ fume->flags2 |= MF2_BOSSNOTRAP;
+ }
// Finally, set its position
dist = -mo->radius - FixedMul(fume->info->radius, fume->destscale - mo->scale/3);
@@ -11643,9 +11697,10 @@ void P_DoMetalJetFume(player_t *player, mobj_t *fume)
fume->y = mo->y + P_ReturnThrustY(fume, angle, dist);
fume->z = mo->z + heightoffset - (fume->height >> 1);
P_SetThingPosition(fume);
- if (resetinterp) R_ResetMobjInterpolationState(fume);
+ if (resetinterp)
+ R_ResetMobjInterpolationState(fume);
- // If dashmode is high enough, spawn a trail
+ // If dash mode is high enough, spawn a trail
if (player->normalspeed >= skins[player->skin]->normalspeed*2)
{
mobj_t *ghost = P_SpawnGhostMobj(fume);
@@ -11659,6 +11714,8 @@ void P_DoFollowMobj(player_t *player, mobj_t *followmobj)
{
if (LUA_HookFollowMobj(player, followmobj) || P_MobjWasRemoved(followmobj))
{;}
+ else if (player->charflags & SF_JETFUME)
+ P_DoMetalJetFume(player, followmobj);
else
{
switch (followmobj->type)
@@ -12007,7 +12064,7 @@ void P_PlayerThink(player_t *player)
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
{
- if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (th->removing)
continue;
mo2 = (mobj_t *)th;
@@ -12067,7 +12124,7 @@ void P_PlayerThink(player_t *player)
ticmiss++;
P_DoRopeHang(player);
- P_DoJumpStuff(player, &player->cmd, false); // P_DoRopeHang would set PF_SPINDOWN, so no spinshieldhack here
+ P_DoJumpStuff(player, &player->cmd);
}
else //if (player->powers[pw_carry] == CR_ZOOMTUBE)
{
@@ -12341,12 +12398,6 @@ void P_PlayerThink(player_t *player)
player->pflags &= ~PF_SPINDOWN;
}
- // Check for Shield button
- if (cmd->buttons & BT_SHIELD)
- player->pflags |= PF_SHIELDDOWN;
- else
- player->pflags &= ~PF_SHIELDDOWN;
-
// IF PLAYER NOT HERE THEN FLASH END IF
if (player->quittime && player->powers[pw_flashing] < flashingtics - 1
&& !(G_TagGametype() && !(player->pflags & PF_TAGIT)) && !player->gotflag)
@@ -13166,7 +13217,8 @@ void P_PlayerAfterThink(player_t *player)
player->followmobj->colorized = true;
break;
default:
- player->followmobj->flags2 |= MF2_LINKDRAW;
+ if ((player->charflags & SF_JETFUME) == 0)
+ player->followmobj->flags2 |= MF2_LINKDRAW;
break;
}
}
diff --git a/src/r_bbox.c b/src/r_bbox.c
index 8ccad2bb58186098810f299405fc0f4d23fa9b5a..93fa2dca28c4a1f923c69ff4f44958c7e583310c 100644
--- a/src/r_bbox.c
+++ b/src/r_bbox.c
@@ -275,7 +275,7 @@ boolean R_ThingBoundingBoxVisible(mobj_t *thing)
switch (thing->type)
{
default:
- // First person / awayviewmobj -- rendering a bbox
+ // First person / awayviewmobj -- rendering a bbox
// too close to the viewpoint causes anomalies
// and these are exactly on the viewpoint!
if (thing != r_viewmobj)
diff --git a/src/r_bsp.c b/src/r_bsp.c
index 373a170c90ea0b24e60bd6469a098ae4f8b75142..ad27b9bf8162a39bef6a5ddfa75c3e681c5632ca 100644
--- a/src/r_bsp.c
+++ b/src/r_bsp.c
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
diff --git a/src/r_data.c b/src/r_data.c
index 75ec0556d46f1edff4d2c473b595a40e835426ac..32faa07a8fb40370008218f2c4fa9ec3a4d3737b 100644
--- a/src/r_data.c
+++ b/src/r_data.c
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -426,9 +426,6 @@ void R_ClearColormaps(void)
{
// Purged by PU_LEVEL, just overwrite the pointer
extra_colormaps = R_CreateDefaultColormap(true);
-#ifdef HWRENDER
- HWR_ClearLightTables();
-#endif
}
//
@@ -849,6 +846,15 @@ void R_GenerateLightTable(extracolormap_t *extra_colormap, boolean uselookup)
}
}
+void R_UpdateLightTable(extracolormap_t *extra_colormap, boolean uselookup)
+{
+ R_GenerateLightTable(extra_colormap, uselookup);
+
+#ifdef HWRENDER
+ extra_colormap->gl_lighttable.needs_update = true;
+#endif
+}
+
extracolormap_t *R_CreateColormapFromLinedef(char *p1, char *p2, char *p3)
{
// default values
diff --git a/src/r_data.h b/src/r_data.h
index 9340ed284b6524e54774cfa43ed6c24e3e92afe3..64abf6d83637ed8f54c7449f621ac52eb6aa9113 100644
--- a/src/r_data.h
+++ b/src/r_data.h
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -90,6 +90,7 @@ typedef enum
} textmapcolormapflags_t;
void R_GenerateLightTable(extracolormap_t *extra_colormap, boolean uselookup);
+void R_UpdateLightTable(extracolormap_t *extra_colormap, boolean uselookup);
lighttable_t *R_CreateLightTable(extracolormap_t *extra_colormap);
extracolormap_t * R_CreateColormapFromLinedef(char *p1, char *p2, char *p3);
extracolormap_t* R_CreateColormap(INT32 rgba, INT32 fadergba, UINT8 fadestart, UINT8 fadeend, UINT8 flags);
diff --git a/src/r_defs.h b/src/r_defs.h
index 51cc0864652f0363eaf614fee7b23394a6b0dfc1..eac3e2d1f38752f9b3b2002f1a7ab3e3fe15975e 100644
--- a/src/r_defs.h
+++ b/src/r_defs.h
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -76,8 +76,11 @@ typedef struct extracolormap_s
lighttable_t *colormap;
#ifdef HWRENDER
- // The id of the hardware lighttable. Zero means it does not exist yet.
- UINT32 gl_lighttable_id;
+ struct {
+ UINT32 id; // The id of the hardware lighttable. Zero means it does not exist yet.
+ RGBA_t *data; // The texture data of the hardware lighttable.
+ boolean needs_update; // If the colormap changed recently or not.
+ } gl_lighttable;
#endif
#ifdef EXTRACOLORMAPLUMPS
@@ -242,9 +245,8 @@ typedef struct sectorportal_s
struct sector_s *sector;
struct mobj_s *mobj;
};
- struct {
- fixed_t x, y;
- } origin;
+ struct sector_s *target;
+ boolean ceiling;
} sectorportal_t;
typedef struct ffloor_s
diff --git a/src/r_draw.c b/src/r_draw.c
index eca3f36b780d2763920fa57d4c6d7ecd4f79a57b..906398ec4972e53565cdcfa04deb51557956d39c 100644
--- a/src/r_draw.c
+++ b/src/r_draw.c
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
diff --git a/src/r_draw.h b/src/r_draw.h
index 6a6ab2db1b1d8c07e825c2bab9f96553b8b12895..d5c5b4e25d36ba375d365a2d13f0ba5fab19e3f3 100644
--- a/src/r_draw.h
+++ b/src/r_draw.h
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -173,6 +173,7 @@ void R_DrawTiltedTranslucentSpan_8(void);
void R_DrawSplat_8(void);
void R_DrawTranslucentSplat_8(void);
void R_DrawTiltedSplat_8(void);
+void R_DrawTiltedTranslucentSplat_8(void);
void R_DrawFloorSprite_8(void);
void R_DrawTranslucentFloorSprite_8(void);
@@ -194,6 +195,7 @@ void R_DrawTiltedTranslucentSpan_NPO2_8(void);
void R_DrawSplat_NPO2_8(void);
void R_DrawTranslucentSplat_NPO2_8(void);
void R_DrawTiltedSplat_NPO2_8(void);
+void R_DrawTiltedTranslucentSplat_NPO2_8(void);
void R_DrawFloorSprite_NPO2_8(void);
void R_DrawTranslucentFloorSprite_NPO2_8(void);
diff --git a/src/r_draw8.c b/src/r_draw8.c
index 2011e46407cd46469d9ca6f0dd8de7fd4e7f84ef..c720f454e078d1f7857227eae01caa866d56d136 100644
--- a/src/r_draw8.c
+++ b/src/r_draw8.c
@@ -1,7 +1,7 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -1301,6 +1301,136 @@ void R_DrawTiltedSplat_8(void)
#endif
}
+void R_DrawTiltedTranslucentSplat_8(void)
+{
+ // x1, x2 = ds_x1, ds_x2
+ int width = ds_x2 - ds_x1;
+ double iz, uz, vz;
+ UINT32 u, v;
+ int i;
+
+ UINT8 *source;
+ UINT8 *colormap;
+ UINT8 *dest;
+
+ UINT8 val;
+
+ double startz, startu, startv;
+ double izstep, uzstep, vzstep;
+ double endz, endu, endv;
+ UINT32 stepu, stepv;
+
+ iz = ds_sz.z + ds_sz.y*(centery-ds_y) + ds_sz.x*(ds_x1-centerx);
+ uz = ds_su.z + ds_su.y*(centery-ds_y) + ds_su.x*(ds_x1-centerx);
+ vz = ds_sv.z + ds_sv.y*(centery-ds_y) + ds_sv.x*(ds_x1-centerx);
+
+ R_CalcSlopeLight();
+
+ dest = &topleft[ds_y*vid.width + ds_x1];
+ source = ds_source;
+ //colormap = ds_colormap;
+
+#if 0 // The "perfect" reference version of this routine. Pretty slow.
+ // Use it only to see how things are supposed to look.
+ i = 0;
+ do
+ {
+ double z = 1.f/iz;
+ u = (INT64)(uz*z);
+ v = (INT64)(vz*z);
+
+ colormap = planezlight[tiltlighting[ds_x1++]] + (ds_colormap - colormaps);
+
+ val = source[((v >> nflatyshift) & nflatmask) | (u >> nflatxshift)];
+ if (val != TRANSPARENTPIXEL)
+ *dest = *(ds_transmap + (colormap[val] << 8) + *dest);
+
+ dest++;
+ iz += ds_sz.x;
+ uz += ds_su.x;
+ vz += ds_sv.x;
+ } while (--width >= 0);
+#else
+ startz = 1.f/iz;
+ startu = uz*startz;
+ startv = vz*startz;
+
+ izstep = ds_sz.x * SPANSIZE;
+ uzstep = ds_su.x * SPANSIZE;
+ vzstep = ds_sv.x * SPANSIZE;
+ //x1 = 0;
+ width++;
+
+ while (width >= SPANSIZE)
+ {
+ iz += izstep;
+ uz += uzstep;
+ vz += vzstep;
+
+ endz = 1.f/iz;
+ endu = uz*endz;
+ endv = vz*endz;
+ stepu = (INT64)((endu - startu) * INVSPAN);
+ stepv = (INT64)((endv - startv) * INVSPAN);
+ u = (INT64)(startu);
+ v = (INT64)(startv);
+
+ for (i = SPANSIZE-1; i >= 0; i--)
+ {
+ colormap = planezlight[tiltlighting[ds_x1++]] + (ds_colormap - colormaps);
+ val = source[((v >> nflatyshift) & nflatmask) | (u >> nflatxshift)];
+ if (val != TRANSPARENTPIXEL)
+ *dest = *(ds_transmap + (colormap[val] << 8) + *dest);
+ dest++;
+ u += stepu;
+ v += stepv;
+ }
+ startu = endu;
+ startv = endv;
+ width -= SPANSIZE;
+ }
+ if (width > 0)
+ {
+ if (width == 1)
+ {
+ u = (INT64)(startu);
+ v = (INT64)(startv);
+ colormap = planezlight[tiltlighting[ds_x1++]] + (ds_colormap - colormaps);
+ val = source[((v >> nflatyshift) & nflatmask) | (u >> nflatxshift)];
+ if (val != TRANSPARENTPIXEL)
+ *dest = *(ds_transmap + (colormap[val] << 8) + *dest);
+ }
+ else
+ {
+ double left = width;
+ iz += ds_sz.x * left;
+ uz += ds_su.x * left;
+ vz += ds_sv.x * left;
+
+ endz = 1.f/iz;
+ endu = uz*endz;
+ endv = vz*endz;
+ left = 1.f/left;
+ stepu = (INT64)((endu - startu) * left);
+ stepv = (INT64)((endv - startv) * left);
+ u = (INT64)(startu);
+ v = (INT64)(startv);
+
+ for (; width != 0; width--)
+ {
+ colormap = planezlight[tiltlighting[ds_x1++]] + (ds_colormap - colormaps);
+ val = source[((v >> nflatyshift) & nflatmask) | (u >> nflatxshift)];
+ if (val != TRANSPARENTPIXEL)
+ *dest = *(ds_transmap + (colormap[val] << 8) + *dest);
+ dest++;
+ u += stepu;
+ v += stepv;
+ }
+ }
+ }
+#endif
+}
+
/** \brief The R_DrawSplat_8 function
Just like R_DrawSpan_8, but skips transparent pixels.
*/
diff --git a/src/r_draw8_npo2.c b/src/r_draw8_npo2.c
index 1ed3a8fa406ac8cb7cef2c95729a3a4de611faf0..7fbb40d84956d342f1d675876f7dbcc9b2cd539b 100644
--- a/src/r_draw8_npo2.c
+++ b/src/r_draw8_npo2.c
@@ -1,7 +1,7 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -666,6 +666,204 @@ void R_DrawTiltedSplat_NPO2_8(void)
#endif
}
+void R_DrawTiltedTranslucentSplat_NPO2_8(void)
+{
+ // x1, x2 = ds_x1, ds_x2
+ int width = ds_x2 - ds_x1;
+ double iz, uz, vz;
+ UINT32 u, v;
+ int i;
+
+ UINT8 *source;
+ UINT8 *colormap;
+ UINT8 *dest;
+
+ UINT8 val;
+
+ double startz, startu, startv;
+ double izstep, uzstep, vzstep;
+ double endz, endu, endv;
+ UINT32 stepu, stepv;
+
+ struct libdivide_u32_t x_divider = libdivide_u32_gen(ds_flatwidth);
+ struct libdivide_u32_t y_divider = libdivide_u32_gen(ds_flatheight);
+
+ iz = ds_sz.z + ds_sz.y*(centery-ds_y) + ds_sz.x*(ds_x1-centerx);
+ uz = ds_su.z + ds_su.y*(centery-ds_y) + ds_su.x*(ds_x1-centerx);
+ vz = ds_sv.z + ds_sv.y*(centery-ds_y) + ds_sv.x*(ds_x1-centerx);
+
+ R_CalcSlopeLight();
+
+ dest = &topleft[ds_y*vid.width + ds_x1];
+ source = ds_source;
+ //colormap = ds_colormap;
+
+#if 0 // The "perfect" reference version of this routine. Pretty slow.
+ // Use it only to see how things are supposed to look.
+ i = 0;
+ do
+ {
+ double z = 1.f/iz;
+ u = (INT64)(uz*z);
+ v = (INT64)(vz*z);
+
+ colormap = planezlight[tiltlighting[ds_x1++]] + (ds_colormap - colormaps);
+
+ // Lactozilla: Non-powers-of-two
+ {
+ fixed_t x = (((fixed_t)u) >> FRACBITS);
+ fixed_t y = (((fixed_t)v) >> FRACBITS);
+
+ // Carefully align all of my Friends.
+ if (x < 0)
+ x += (libdivide_u32_do((UINT32)(-x-1), &x_divider) + 1) * ds_flatwidth;
+ else
+ x -= libdivide_u32_do((UINT32)x, &x_divider) * ds_flatwidth;
+ if (y < 0)
+ y += (libdivide_u32_do((UINT32)(-y-1), &y_divider) + 1) * ds_flatheight;
+ else
+ y -= libdivide_u32_do((UINT32)y, &y_divider) * ds_flatheight;
+
+ val = source[((y * ds_flatwidth) + x)];
+ }
+
+ if (val != TRANSPARENTPIXEL)
+ *dest = *(ds_transmap + (colormap[val] << 8) + *dest);
+
+ dest++;
+ iz += ds_sz.x;
+ uz += ds_su.x;
+ vz += ds_sv.x;
+ } while (--width >= 0);
+#else
+ startz = 1.f/iz;
+ startu = uz*startz;
+ startv = vz*startz;
+
+ izstep = ds_sz.x * SPANSIZE;
+ uzstep = ds_su.x * SPANSIZE;
+ vzstep = ds_sv.x * SPANSIZE;
+ //x1 = 0;
+ width++;
+
+ while (width >= SPANSIZE)
+ {
+ iz += izstep;
+ uz += uzstep;
+ vz += vzstep;
+
+ endz = 1.f/iz;
+ endu = uz*endz;
+ endv = vz*endz;
+ stepu = (INT64)((endu - startu) * INVSPAN);
+ stepv = (INT64)((endv - startv) * INVSPAN);
+ u = (INT64)(startu);
+ v = (INT64)(startv);
+
+ for (i = SPANSIZE-1; i >= 0; i--)
+ {
+ colormap = planezlight[tiltlighting[ds_x1++]] + (ds_colormap - colormaps);
+ // Lactozilla: Non-powers-of-two
+ {
+ fixed_t x = (((fixed_t)u) >> FRACBITS);
+ fixed_t y = (((fixed_t)v) >> FRACBITS);
+
+ // Carefully align all of my Friends.
+ if (x < 0)
+ x += (libdivide_u32_do((UINT32)(-x-1), &x_divider) + 1) * ds_flatwidth;
+ else
+ x -= libdivide_u32_do((UINT32)x, &x_divider) * ds_flatwidth;
+ if (y < 0)
+ y += (libdivide_u32_do((UINT32)(-y-1), &y_divider) + 1) * ds_flatheight;
+ else
+ y -= libdivide_u32_do((UINT32)y, &y_divider) * ds_flatheight;
+
+ val = source[((y * ds_flatwidth) + x)];
+ }
+ if (val != TRANSPARENTPIXEL)
+ *dest = *(ds_transmap + (colormap[val] << 8) + *dest);
+ dest++;
+ u += stepu;
+ v += stepv;
+ }
+ startu = endu;
+ startv = endv;
+ width -= SPANSIZE;
+ }
+ if (width > 0)
+ {
+ if (width == 1)
+ {
+ u = (INT64)(startu);
+ v = (INT64)(startv);
+ colormap = planezlight[tiltlighting[ds_x1++]] + (ds_colormap - colormaps);
+ // Lactozilla: Non-powers-of-two
+ {
+ fixed_t x = (((fixed_t)u) >> FRACBITS);
+ fixed_t y = (((fixed_t)v) >> FRACBITS);
+
+ // Carefully align all of my Friends.
+ if (x < 0)
+ x += (libdivide_u32_do((UINT32)(-x-1), &x_divider) + 1) * ds_flatwidth;
+ else
+ x -= libdivide_u32_do((UINT32)x, &x_divider) * ds_flatwidth;
+ if (y < 0)
+ y += (libdivide_u32_do((UINT32)(-y-1), &y_divider) + 1) * ds_flatheight;
+ else
+ y -= libdivide_u32_do((UINT32)y, &y_divider) * ds_flatheight;
+
+ val = source[((y * ds_flatwidth) + x)];
+ }
+ if (val != TRANSPARENTPIXEL)
+ *dest = *(ds_transmap + (colormap[val] << 8) + *dest);
+ }
+ else
+ {
+ double left = width;
+ iz += ds_sz.x * left;
+ uz += ds_su.x * left;
+ vz += ds_sv.x * left;
+
+ endz = 1.f/iz;
+ endu = uz*endz;
+ endv = vz*endz;
+ left = 1.f/left;
+ stepu = (INT64)((endu - startu) * left);
+ stepv = (INT64)((endv - startv) * left);
+ u = (INT64)(startu);
+ v = (INT64)(startv);
+
+ for (; width != 0; width--)
+ {
+ colormap = planezlight[tiltlighting[ds_x1++]] + (ds_colormap - colormaps);
+ // Lactozilla: Non-powers-of-two
+ {
+ fixed_t x = (((fixed_t)u) >> FRACBITS);
+ fixed_t y = (((fixed_t)v) >> FRACBITS);
+
+ // Carefully align all of my Friends.
+ if (x < 0)
+ x += (libdivide_u32_do((UINT32)(-x-1), &x_divider) + 1) * ds_flatwidth;
+ else
+ x -= libdivide_u32_do((UINT32)x, &x_divider) * ds_flatwidth;
+ if (y < 0)
+ y += (libdivide_u32_do((UINT32)(-y-1), &y_divider) + 1) * ds_flatheight;
+ else
+ y -= libdivide_u32_do((UINT32)y, &y_divider) * ds_flatheight;
+
+ val = source[((y * ds_flatwidth) + x)];
+ }
+ if (val != TRANSPARENTPIXEL)
+ *dest = *(ds_transmap + (colormap[val] << 8) + *dest);
+ dest++;
+ u += stepu;
+ v += stepv;
+ }
+ }
+ }
+#endif
+}
+
/** \brief The R_DrawSplat_NPO2_8 function
Just like R_DrawSpan_NPO2_8, but skips transparent pixels.
*/
diff --git a/src/r_fps.c b/src/r_fps.c
index 7f1f2bb303e23c10104febcdd9646d510a3aba1c..71f6e59a7c465690f4acbc8c48522bb31fe8e225 100644
--- a/src/r_fps.c
+++ b/src/r_fps.c
@@ -3,7 +3,7 @@
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
// Copyright (C) 1999-2000 by Jess Haas, Nicolas Kalkhof, Colin Phipps, Florian Schulze, Andrey Budko (prboom)
-// Copyright (C) 1999-2019 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
diff --git a/src/r_fps.h b/src/r_fps.h
index 33224a83a1e728ae1ac3379c9060d6bb3eb35c3d..ce64d19be442b2cc9bd2627b0787cb76538a6aa5 100644
--- a/src/r_fps.h
+++ b/src/r_fps.h
@@ -3,7 +3,7 @@
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
// Copyright (C) 1999-2000 by Jess Haas, Nicolas Kalkhof, Colin Phipps, Florian Schulze, Andrey Budko (prboom)
-// Copyright (C) 1999-2019 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
diff --git a/src/r_main.c b/src/r_main.c
index 067b8abdbcf20d9918d582285b6efbe9374f453d..46bac9dc76a1886cb3ddc60167772312721b6a53 100644
--- a/src/r_main.c
+++ b/src/r_main.c
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -1095,7 +1095,7 @@ void R_SetupFrame(player_t *player)
camera_t *thiscam;
boolean chasecam = R_ViewpointHasChasecam(player);
boolean ispaused = paused || P_AutoPause();
-
+
if (splitscreen && player == &players[secondarydisplayplayer] && player != &players[consoleplayer])
thiscam = &camera2;
else
@@ -1152,8 +1152,14 @@ void R_SetupFrame(player_t *player)
if (quake.epicenter) {
// Calculate 3D distance from epicenter, using the camera.
- fixed_t xydist = R_PointToDist2(thiscam->x, thiscam->y, quake.epicenter->x, quake.epicenter->y);
- fixed_t dist = R_PointToDist2(0, thiscam->z, xydist, quake.epicenter->z);
+ fixed_t xydist, dist;
+ if (P_MobjWasRemoved(r_viewmobj)) {
+ xydist = R_PointToDist2(thiscam->x, thiscam->y, quake.epicenter->x, quake.epicenter->y);
+ dist = R_PointToDist2(0, thiscam->z, xydist, quake.epicenter->z);
+ } else {
+ xydist = R_PointToDist2(r_viewmobj->x, r_viewmobj->y, quake.epicenter->x, quake.epicenter->y);
+ dist = R_PointToDist2(0, r_viewmobj->z, xydist, quake.epicenter->z);
+ }
// More effect closer to epicenter, outside of radius = no effect
if (!quake.radius || dist > quake.radius)
@@ -1369,7 +1375,7 @@ boolean R_ViewpointHasChasecam(player_t *player)
chasecam = true; // force chasecam on
else if (player->spectator) // no spectator chasecam
chasecam = false; // force chasecam off
-
+
if (chasecam && !thiscam->chase)
{
P_ResetCamera(player, thiscam);
@@ -1380,7 +1386,7 @@ boolean R_ViewpointHasChasecam(player_t *player)
P_ResetCamera(player, thiscam);
thiscam->chase = false;
}
-
+
if (isplayer2)
{
R_SetViewContext(VIEWCONTEXT_PLAYER2);
@@ -1428,6 +1434,9 @@ static void R_PortalFrame(portal_t *portal)
viewsin = FINESINE(viewangle>>ANGLETOFINESHIFT);
viewcos = FINECOSINE(viewangle>>ANGLETOFINESHIFT);
+ if (!P_MobjWasRemoved(portal->viewmobj))
+ r_viewmobj = portal->viewmobj;
+
portalclipstart = portal->start;
portalclipend = portal->end;
diff --git a/src/r_main.h b/src/r_main.h
index 64a69fffe64d0096241d2eca6c25b528069e8aaf..af7086e834a9e902da7f32e4413e64433c89bd0a 100644
--- a/src/r_main.h
+++ b/src/r_main.h
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
diff --git a/src/r_patch.c b/src/r_patch.c
index a6a9dc2ebcc0651c26f6faaede8bf7535f607c74..19e66404f1da18e82f5ec4076e5b61b83184feea 100644
--- a/src/r_patch.c
+++ b/src/r_patch.c
@@ -1,6 +1,6 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
-// Copyright (C) 2020-2023 by Jaime "Lactozilla" Passos.
+// Copyright (C) 2020-2023 by Lactozilla.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
diff --git a/src/r_patch.h b/src/r_patch.h
index f1a018c035a322a2a57f926e161fe97b66be5c2f..ff76254e84a5e204b75e3b2a1d83c69532ee4a31 100644
--- a/src/r_patch.h
+++ b/src/r_patch.h
@@ -1,6 +1,6 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
-// Copyright (C) 2020-2023 by Jaime "Lactozilla" Passos.
+// Copyright (C) 2020-2024 by Lactozilla.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
diff --git a/src/r_patchrotation.c b/src/r_patchrotation.c
index b9106984970f728e83e567627daa4c1b9c478011..989665d74179854fcfac552814132671c3d00ed2 100644
--- a/src/r_patchrotation.c
+++ b/src/r_patchrotation.c
@@ -1,6 +1,6 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
-// Copyright (C) 2020-2023 by Jaime "Lactozilla" Passos.
+// Copyright (C) 2020-2023 by Lactozilla.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
diff --git a/src/r_patchrotation.h b/src/r_patchrotation.h
index a239ac5fa4dfb4220e3aeda3faebe2781e58b7ff..184d7ac13b5f7987cd63976d127165836e59b5b4 100644
--- a/src/r_patchrotation.h
+++ b/src/r_patchrotation.h
@@ -1,6 +1,6 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
-// Copyright (C) 2020-2023 by Jaime "Lactozilla" Passos.
+// Copyright (C) 2020-2023 by Lactozilla.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
diff --git a/src/r_picformats.c b/src/r_picformats.c
index d71657021b6e2cc91efe504b49286f459461095d..a45c143b01698de2abbb48f534f543a3a68d845e 100644
--- a/src/r_picformats.c
+++ b/src/r_picformats.c
@@ -2,8 +2,8 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 2005-2009 by Andrey "entryway" Budko.
-// Copyright (C) 2018-2023 by Jaime "Lactozilla" Passos.
-// Copyright (C) 2019-2023 by Sonic Team Junior.
+// Copyright (C) 2018-2024 by Lactozilla.
+// Copyright (C) 2019-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
diff --git a/src/r_picformats.h b/src/r_picformats.h
index 098f927a5619d74ca9813d37658d5bfb75bc8f04..123dda976c204787505fb1a90bad859fe39b836b 100644
--- a/src/r_picformats.h
+++ b/src/r_picformats.h
@@ -1,8 +1,8 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
-// Copyright (C) 2018-2023 by Jaime "Lactozilla" Passos.
-// Copyright (C) 2019-2023 by Sonic Team Junior.
+// Copyright (C) 2018-2024 by Lactozilla.
+// Copyright (C) 2019-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
diff --git a/src/r_plane.c b/src/r_plane.c
index 04272f8d317a790de6f658ddb2592072e50f7393..053cfe921fb16fc94c4bc14755dcf4305f3911dd 100644
--- a/src/r_plane.c
+++ b/src/r_plane.c
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2025 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -83,7 +83,7 @@ static fixed_t planeheight;
fixed_t yslopetab[MAXVIDHEIGHT*16];
fixed_t *yslope;
-static fixed_t xoffs, yoffs;
+static INT64 xoffs, yoffs;
static dvector3_t slope_origin, slope_u, slope_v;
static dvector3_t slope_lightu, slope_lightv;
@@ -182,8 +182,8 @@ static void R_MapPlane(INT32 y, INT32 x1, INT32 x2)
R_CalculatePlaneRipple(currentplane->viewangle + currentplane->plangle);
- ds_xfrac += planeripple.xfrac;
- ds_yfrac += planeripple.yfrac;
+ ds_xfrac += FixedMul(planeripple.xfrac, currentplane->xscale);
+ ds_yfrac += FixedMul(planeripple.yfrac, currentplane->yscale);
ds_bgofs >>= FRACBITS;
if ((y + ds_bgofs) >= viewheight)
@@ -376,19 +376,25 @@ visplane_t *R_FindPlane(sector_t *sector, fixed_t height, INT32 picnum, INT32 li
visplane_t *check;
unsigned hash;
+ float offset_xd = FixedToFloat(xoff) / FixedToFloat(xscale ? xscale : 1);
+ float offset_yd = FixedToFloat(yoff) / FixedToFloat(yscale ? yscale : 1);
+
+ INT64 offset_x = offset_xd * FRACUNIT;
+ INT64 offset_y = offset_yd * FRACUNIT;
+
if (!slope) // Don't mess with this right now if a slope is involved
{
- xoff += FixedMul(viewx, xscale);
- yoff -= FixedMul(viewy, yscale);
+ offset_x += viewx;
+ offset_y -= viewy;
if (plangle != 0)
{
// Add the view offset, rotated by the plane angle.
float ang = ANG2RAD(plangle);
- float x = FixedToFloat(xoff);
- float y = FixedToFloat(yoff);
- xoff = FloatToFixed(x * cos(ang) + y * sin(ang));
- yoff = FloatToFixed(-x * sin(ang) + y * cos(ang));
+ float x = offset_x / (float)FRACUNIT;
+ float y = offset_y / (float)FRACUNIT;
+ offset_x = (x * cos(ang) + y * sin(ang)) * FRACUNIT;
+ offset_y = (-x * sin(ang) + y * cos(ang)) * FRACUNIT;
}
}
@@ -399,16 +405,19 @@ visplane_t *R_FindPlane(sector_t *sector, fixed_t height, INT32 picnum, INT32 li
float ang = ANG2RAD(polyobj->angle);
float x = FixedToFloat(polyobj->centerPt.x);
float y = FixedToFloat(polyobj->centerPt.y);
- xoff -= FloatToFixed(x * cos(ang) + y * sin(ang));
- yoff -= FloatToFixed(x * sin(ang) - y * cos(ang));
+ offset_x -= (x * cos(ang) + y * sin(ang)) * FRACUNIT;
+ offset_y -= (x * sin(ang) - y * cos(ang)) * FRACUNIT;
}
else
{
- xoff -= polyobj->centerPt.x;
- yoff += polyobj->centerPt.y;
+ offset_x -= polyobj->centerPt.x;
+ offset_y += polyobj->centerPt.y;
}
}
+ offset_x = ((INT64)offset_x * xscale) / FRACUNIT;
+ offset_y = ((INT64)offset_y * yscale) / FRACUNIT;
+
// This appears to fix the Nimbus Ruins sky bug.
if (picnum == skyflatnum && pfloor)
{
@@ -423,7 +432,7 @@ visplane_t *R_FindPlane(sector_t *sector, fixed_t height, INT32 picnum, INT32 li
{
if (height == check->height && picnum == check->picnum
&& lightlevel == check->lightlevel
- && xoff == check->xoffs && yoff == check->yoffs
+ && offset_x == check->xoffs && offset_y == check->yoffs
&& xscale == check->xscale && yscale == check->yscale
&& planecolormap == check->extra_colormap
&& check->viewx == viewx && check->viewy == viewy && check->viewz == viewz
@@ -449,8 +458,8 @@ visplane_t *R_FindPlane(sector_t *sector, fixed_t height, INT32 picnum, INT32 li
check->lightlevel = lightlevel;
check->minx = vid.width;
check->maxx = -1;
- check->xoffs = xoff;
- check->yoffs = yoff;
+ check->xoffs = offset_x;
+ check->yoffs = offset_y;
check->xscale = xscale;
check->yscale = yscale;
check->extra_colormap = planecolormap;
@@ -658,13 +667,13 @@ static void R_DrawSkyPlane(visplane_t *pl)
}
// Returns the height of the sloped plane at (x, y) as a double
-static double R_GetSlopeZAt(const pslope_t *slope, fixed_t x, fixed_t y)
+static double R_GetSlopeZAt(const pslope_t *slope, INT64 x, INT64 y)
{
// If you want to reimplement this using just the equation constants, use this instead:
// (d + a*x + b*y) * -(1.0 / c)
- double px = FixedToDouble(x) - slope->dorigin.x;
- double py = FixedToDouble(y) - slope->dorigin.y;
+ double px = (x / (double)FRACUNIT) - slope->dorigin.x;
+ double py = (y / (double)FRACUNIT) - slope->dorigin.y;
double dist = (px * slope->dnormdir.x) + (py * slope->dnormdir.y);
@@ -672,10 +681,10 @@ static double R_GetSlopeZAt(const pslope_t *slope, fixed_t x, fixed_t y)
}
// Sets the texture origin vector of the sloped plane.
-static void R_SetSlopePlaneOrigin(pslope_t *slope, fixed_t xpos, fixed_t ypos, fixed_t zpos, fixed_t xoff, fixed_t yoff, fixed_t angle)
+static void R_SetSlopePlaneOrigin(pslope_t *slope, fixed_t xpos, fixed_t ypos, fixed_t zpos, INT64 xoff, INT64 yoff, fixed_t angle)
{
- INT64 vx = (INT64)xpos + (INT64)xoff;
- INT64 vy = (INT64)ypos - (INT64)yoff;
+ INT64 vx = (INT64)xpos + xoff;
+ INT64 vy = (INT64)ypos - yoff;
float vxf = vx / (float)FRACUNIT;
float vyf = vy / (float)FRACUNIT;
@@ -702,7 +711,7 @@ void R_SetSlopePlane(pslope_t *slope, fixed_t xpos, fixed_t ypos, fixed_t zpos,
slope->moved = false;
}
- R_SetSlopePlaneOrigin(slope, xpos, ypos, zpos, xoff, yoff, angle);
+ R_SetSlopePlaneOrigin(slope, xpos, ypos, zpos, (INT64)xoff, (INT64)yoff, angle);
height = R_GetSlopeZAt(slope, xpos, ypos);
zeroheight = height - FixedToDouble(zpos);
@@ -735,7 +744,7 @@ void R_SetSlopePlane(pslope_t *slope, fixed_t xpos, fixed_t ypos, fixed_t zpos,
}
// This function calculates all of the vectors necessary for drawing a sloped and scaled plane.
-void R_SetScaledSlopePlane(pslope_t *slope, fixed_t xpos, fixed_t ypos, fixed_t zpos, fixed_t xs, fixed_t ys, fixed_t xoff, fixed_t yoff, angle_t angle, angle_t plangle)
+void R_SetScaledSlopePlane(pslope_t *slope, fixed_t xpos, fixed_t ypos, fixed_t zpos, fixed_t xs, fixed_t ys, INT64 xoff, INT64 yoff, angle_t angle, angle_t plangle)
{
double height, z_at_xy;
float ang;
@@ -836,9 +845,11 @@ static void CalcSlopePlaneVectors(visplane_t *pl, fixed_t xoff, fixed_t yoff)
{
if (!ds_fog && (pl->xscale != FRACUNIT || pl->yscale != FRACUNIT))
{
+ float offset_x = FixedToFloat(xoff) / FixedToFloat(pl->xscale ? pl->xscale : 1);
+ float offset_y = FixedToFloat(yoff) / FixedToFloat(pl->yscale ? pl->yscale : 1);
R_SetScaledSlopePlane(pl->slope, pl->viewx, pl->viewy, pl->viewz,
FixedDiv(FRACUNIT, pl->xscale), FixedDiv(FRACUNIT, pl->yscale),
- FixedDiv(xoff, pl->xscale), FixedDiv(yoff, pl->yscale), pl->viewangle, pl->plangle);
+ (INT64)(offset_x * FRACUNIT), (INT64)(offset_y * FRACUNIT), pl->viewangle, pl->plangle);
}
else
R_SetSlopePlane(pl->slope, pl->viewx, pl->viewy, pl->viewz, xoff, yoff, pl->viewangle, pl->plangle);
@@ -1079,6 +1090,9 @@ void R_DrawSinglePlane(visplane_t *pl)
case SPANDRAWFUNC_SPLAT:
spanfunctype = SPANDRAWFUNC_TILTEDSPLAT;
break;
+ case SPANDRAWFUNC_TRANSSPLAT:
+ spanfunctype = SPANDRAWFUNC_TILTEDTRANSSPLAT;
+ break;
case SPANDRAWFUNC_SOLID:
spanfunctype = SPANDRAWFUNC_TILTEDSOLID;
break;
diff --git a/src/r_plane.h b/src/r_plane.h
index 69620f25e07cadefee8242f23ad3a26a57ffbc9d..cd947750119b8446e0683bd4d62ae7b88fa9c1a7 100644
--- a/src/r_plane.h
+++ b/src/r_plane.h
@@ -48,7 +48,7 @@ typedef struct visplane_s
UINT16 padbottomstart, bottom[MAXVIDWIDTH], padbottomend;
INT32 high, low; // R_PlaneBounds should set these.
- fixed_t xoffs, yoffs; // Scrolling flats.
+ INT64 xoffs, yoffs; // Scrolling flats.
fixed_t xscale, yscale;
sector_t *sector;
@@ -85,7 +85,7 @@ void R_DrawSinglePlane(visplane_t *pl);
// Calculates the slope vectors needed for tilted span drawing.
void R_SetSlopePlane(pslope_t *slope, fixed_t xpos, fixed_t ypos, fixed_t zpos, fixed_t xoff, fixed_t yoff, angle_t angle, angle_t plangle);
-void R_SetScaledSlopePlane(pslope_t *slope, fixed_t xpos, fixed_t ypos, fixed_t zpos, fixed_t xs, fixed_t ys, fixed_t xoff, fixed_t yoff, angle_t angle, angle_t plangle);
+void R_SetScaledSlopePlane(pslope_t *slope, fixed_t xpos, fixed_t ypos, fixed_t zpos, fixed_t xs, fixed_t ys, INT64 xoff, INT64 yoff, angle_t angle, angle_t plangle);
typedef struct planemgr_s
{
diff --git a/src/r_portal.c b/src/r_portal.c
index 4d042cae38574bd54165d5b5850e8e18c5f31f33..957d574b2e9ebc3505a459adfee51c08270066ac 100644
--- a/src/r_portal.c
+++ b/src/r_portal.c
@@ -101,7 +101,7 @@ void Portal_ClipApply (const portal_t* portal)
static portal_t* Portal_Add (const INT16 x1, const INT16 x2)
{
- portal_t *portal = Z_Malloc(sizeof(portal_t), PU_LEVEL, NULL);
+ portal_t *portal = Z_Calloc(sizeof(portal_t), PU_LEVEL, NULL);
INT16 *ceilingclipsave = Z_Malloc(sizeof(INT16)*(x2-x1 + 1), PU_LEVEL, NULL);
INT16 *floorclipsave = Z_Malloc(sizeof(INT16)*(x2-x1 + 1), PU_LEVEL, NULL);
fixed_t *frontscalesave = Z_Malloc(sizeof(fixed_t)*(x2-x1 + 1), PU_LEVEL, NULL);
@@ -117,7 +117,7 @@ static portal_t* Portal_Add (const INT16 x1, const INT16 x2)
portal_cap->next = portal;
portal_cap = portal;
}
- portal->next = NULL;
+ portal->clipline = -1;
// Store clipping values so they can be restored once the portal is rendered.
portal->ceilingclip = ceilingclipsave;
@@ -142,11 +142,9 @@ void Portal_Remove (portal_t* portal)
Z_Free(portal);
}
-static void Portal_GetViewpointForLine(portal_t *portal, line_t *start, line_t *dest)
+static void Portal_GetViewpointForLine(portal_t *portal, line_t *start, line_t *dest, angle_t dangle)
{
// Offset the portal view by the linedef centers
- angle_t dangle = R_PointToAngle2(0,0,dest->dx,dest->dy) - R_PointToAngle2(start->dx,start->dy,0,0);
-
fixed_t disttopoint;
angle_t angtopoint;
@@ -168,7 +166,6 @@ static void Portal_GetViewpointForLine(portal_t *portal, line_t *start, line_t *
portal->viewx = dest_c.x + FixedMul(FINECOSINE(angtopoint>>ANGLETOFINESHIFT), disttopoint);
portal->viewy = dest_c.y + FixedMul(FINESINE(angtopoint>>ANGLETOFINESHIFT), disttopoint);
- portal->viewz = viewz + dest->frontsector->floorheight - start->frontsector->floorheight;
portal->viewangle = viewangle + dangle;
}
@@ -189,12 +186,13 @@ void Portal_Add2Lines (const INT32 line1, const INT32 line2, const INT32 x1, con
line_t* start = &lines[line1];
line_t* dest = &lines[line2];
- Portal_GetViewpointForLine(portal, start, dest);
+ angle_t dangle = R_PointToAngle2(0,0,dest->dx,dest->dy) - R_PointToAngle2(start->dx,start->dy,0,0);
+
+ Portal_GetViewpointForLine(portal, start, dest, dangle);
+
+ portal->viewz = viewz + dest->frontsector->floorheight - start->frontsector->floorheight;
portal->clipline = line2;
- portal->is_skybox = false;
- portal->is_horizon = false;
- portal->horizon_sector = NULL;
Portal_ClipRange(portal);
@@ -317,10 +315,7 @@ static boolean Portal_AddSkybox (const visplane_t* plane)
Portal_ClipVisplane(plane, portal);
- portal->clipline = -1;
portal->is_skybox = true;
- portal->is_horizon = false;
- portal->horizon_sector = NULL;
Portal_GetViewpointForSkybox(portal);
@@ -332,14 +327,28 @@ static void Portal_GetViewpointForSecPortal(portal_t *portal, sectorportal_t *se
fixed_t x, y, z;
angle_t angle;
+ sector_t *target = secportal->target;
+
+ fixed_t target_x = target->soundorg.x;
+ fixed_t target_y = target->soundorg.y;
+ fixed_t target_z;
+
+ if (secportal->ceiling)
+ target_z = P_GetSectorCeilingZAt(target, target_x, target_y);
+ else
+ target_z = P_GetSectorFloorZAt(target, target_x, target_y);
+
switch (secportal->type)
{
case SECPORTAL_LINE:
- Portal_GetViewpointForLine(portal, secportal->line.start, secportal->line.dest);
+ angle = secportal->line.dest->angle - secportal->line.start->angle;
+ Portal_GetViewpointForLine(portal, secportal->line.start, secportal->line.dest, angle);
+ portal->viewz = viewz; // Apparently it just works like that. Not going to question it.
return;
case SECPORTAL_OBJECT:
- if (!secportal->mobj || P_MobjWasRemoved(secportal->mobj))
+ if (P_MobjWasRemoved(secportal->mobj))
return;
+ portal->viewmobj = secportal->mobj;
x = secportal->mobj->x;
y = secportal->mobj->y;
z = secportal->mobj->z;
@@ -373,8 +382,9 @@ static void Portal_GetViewpointForSecPortal(portal_t *portal, sectorportal_t *se
return;
}
- fixed_t refx = secportal->origin.x - viewx;
- fixed_t refy = secportal->origin.y - viewy;
+ fixed_t refx = target_x - viewx;
+ fixed_t refy = target_y - viewy;
+ fixed_t refz = target_z - viewz;
// Rotate the X/Y to match the target angle
if (angle != 0)
@@ -387,7 +397,7 @@ static void Portal_GetViewpointForSecPortal(portal_t *portal, sectorportal_t *se
portal->viewx = x - refx;
portal->viewy = y - refy;
- portal->viewz = z + viewz;
+ portal->viewz = z - refz;
portal->viewangle = angle + viewangle;
}
@@ -413,11 +423,6 @@ static boolean Portal_AddSectorPortal (const visplane_t* plane)
Portal_ClipVisplane(plane, portal);
- portal->clipline = -1;
- portal->is_horizon = false;
- portal->is_skybox = false;
- portal->horizon_sector = NULL;
-
Portal_GetViewpointForSecPortal(portal, secportal);
return true;
@@ -425,7 +430,7 @@ static boolean Portal_AddSectorPortal (const visplane_t* plane)
/** Creates a transferred sector portal.
*/
-void Portal_AddTransferred (UINT32 secportalnum, const INT32 x1, const INT32 x2)
+void Portal_AddTransferred (const UINT32 secportalnum, const INT32 x1, const INT32 x2)
{
if (secportalnum >= secportalcount)
return;
@@ -435,9 +440,6 @@ void Portal_AddTransferred (UINT32 secportalnum, const INT32 x1, const INT32 x2)
return;
portal_t* portal = Portal_Add(x1, x2);
- portal->is_skybox = false;
- portal->is_horizon = false;
- portal->horizon_sector = NULL;
if (secportal->type == SECPORTAL_SKYBOX)
Portal_GetViewpointForSkybox(portal);
diff --git a/src/r_portal.h b/src/r_portal.h
index 2485e45a71afb5bc189525f140527c5bb03e2a21..5190885b7189c38b1b7b1b7b13f0519f1d455b0c 100644
--- a/src/r_portal.h
+++ b/src/r_portal.h
@@ -36,6 +36,8 @@ typedef struct portal_s
boolean is_skybox;
+ mobj_t *viewmobj;
+
UINT8 pass; /**< Keeps track of the portal's recursion depth. */
INT32 clipline; /**< Optional clipline for line-based portals. */
@@ -58,7 +60,7 @@ extern INT32 portalclipstart, portalclipend;
void Portal_InitList (void);
void Portal_Remove (portal_t* portal);
void Portal_Add2Lines (const INT32 line1, const INT32 line2, const INT32 x1, const INT32 x2);
-void Portal_AddTransferred (UINT32 secportalnum, const INT32 x1, const INT32 x2);
+void Portal_AddTransferred (const UINT32 secportalnum, const INT32 x1, const INT32 x2);
void Portal_ClipRange (portal_t* portal);
void Portal_ClipApply (const portal_t* portal);
diff --git a/src/r_segs.c b/src/r_segs.c
index a8a065c9b4c643f29b107baf34a25e1eb4e36ba5..4939d1fc8924af906c2aeff2f260e16fc06d8937 100644
--- a/src/r_segs.c
+++ b/src/r_segs.c
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
diff --git a/src/r_skins.c b/src/r_skins.c
index a341ee80f56cb5162e63f02f50619095a8dd575d..7b5e547148a6ba975775dfc933602614be33921d 100644
--- a/src/r_skins.c
+++ b/src/r_skins.c
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2025 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -80,10 +80,19 @@ UINT16 P_ApplySuperFlagToSprite2(UINT16 spr2, mobj_t *mobj)
{
if (mobj->player)
{
- if (mobj->player->charflags & SF_NOSUPERSPRITES || (mobj->player->powers[pw_carry] == CR_NIGHTSMODE && (mobj->player->charflags & SF_NONIGHTSSUPER)))
+ boolean is_nights = mobj->player->powers[pw_carry] == CR_NIGHTSMODE;
+
+ if (mobj->player->charflags & SF_NOSUPERSPRITES || (is_nights && (mobj->player->charflags & SF_NONIGHTSSUPER)))
spr2 &= ~SPR2F_SUPER;
- else if (mobj->player->powers[pw_super] || (mobj->player->powers[pw_carry] == CR_NIGHTSMODE && (mobj->player->charflags & SF_SUPER)))
+ else if (mobj->player->powers[pw_super] || (is_nights && (mobj->player->charflags & SF_SUPER)))
spr2 |= SPR2F_SUPER;
+
+ // Special case for transforming when you are NiGHTS.
+ // Do NOT apply the super sprites in this situation, even if they exist.
+ if (is_nights && mobj->state >= &states[S_PLAY_NIGHTS_TRANS1] && mobj->state <= &states[S_PLAY_NIGHTS_TRANS6])
+ {
+ spr2 &= ~SPR2F_SUPER;
+ }
}
if (spr2 & SPR2F_SUPER)
@@ -730,6 +739,8 @@ static boolean R_ProcessPatchableFields(skin_t *skin, char *stoken, char *value)
GETFLAG(MACHINE)
GETFLAG(DASHMODE)
GETFLAG(FASTEDGE)
+ GETFLAG(FASTWAIT)
+ GETFLAG(JETFUME)
GETFLAG(MULTIABILITY)
GETFLAG(NONIGHTSROTATION)
GETFLAG(NONIGHTSSUPER)
diff --git a/src/r_skins.h b/src/r_skins.h
index 5122b53a6b4163d4de408704ca65631933f996b7..645fea540c53dd26e61cc7f3a2e71ecc3c365d1a 100644
--- a/src/r_skins.h
+++ b/src/r_skins.h
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
diff --git a/src/r_sky.c b/src/r_sky.c
index 1b2c43d12b770bffba413bbbae8a84139aeb041f..ad7262c6e168d9a469e5189c41cb1c2b45438576 100644
--- a/src/r_sky.c
+++ b/src/r_sky.c
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
diff --git a/src/r_splats.c b/src/r_splats.c
index 027ccd720aed2902b7c096040548b95e3d3b369d..ce35a35b4c3ff24d1045a170a67d421310f837af 100644
--- a/src/r_splats.c
+++ b/src/r_splats.c
@@ -1,7 +1,7 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -381,7 +381,7 @@ static void R_RasterizeFloorSplat(floorsplat_t *pSplat, vector2_t *verts, visspr
if (pSplat->slope)
{
- R_SetScaledSlopePlane(pSplat->slope, vis->viewpoint.x, vis->viewpoint.y, vis->viewpoint.z, pSplat->xscale, pSplat->yscale, -pSplat->verts[0].x, pSplat->verts[0].y, vis->viewpoint.angle, pSplat->angle);
+ R_SetScaledSlopePlane(pSplat->slope, vis->viewpoint.x, vis->viewpoint.y, vis->viewpoint.z, (INT64)pSplat->xscale, (INT64)pSplat->yscale, -pSplat->verts[0].x, pSplat->verts[0].y, vis->viewpoint.angle, pSplat->angle);
}
else if (!ds_solidcolor)
{
diff --git a/src/r_textures.c b/src/r_textures.c
index b61ddb86f849f26c3e53980163c5a7f1ac2e94cd..4dc6bbae40ea7f722ed040eab779ed1ce62ae467 100644
--- a/src/r_textures.c
+++ b/src/r_textures.c
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -925,7 +925,7 @@ Rloadtextures (INT32 i, INT32 w)
// printf("\"%s\" (wad: %u, lump: %u) is a single patch, dimensions %d x %d\n",W_CheckNameForNumPwad(wadnum,lumpnum),wadnum,lumpnum,width,height);
- R_AddSinglePatchTexture(i, wadnum, lumpnum, width, height, TEXTURETYPE_SINGLEPATCH);
+ R_AddSinglePatchTexture(i, wadnum, lumpnum, width, height, TEXTURETYPE_TEXTURE);
i++;
}
@@ -1110,7 +1110,7 @@ static lumpnum_t W_GetTexPatchLumpNum(const char *name)
lumpnum_t lump = LUMPERROR;
INT32 lump_type_it;
-
+
for (lump_type_it = 0; lump_type_it < USE__MAX; lump_type_it++)
{
@@ -1494,7 +1494,7 @@ static texture_t *R_ParseTexture(boolean actuallyLoadTexture)
resultTexture->hash = quickncasehash(newTextureName, 8);
resultTexture->width = newTextureWidth;
resultTexture->height = newTextureHeight;
- resultTexture->type = TEXTURETYPE_COMPOSITE;
+ resultTexture->type = TEXTURETYPE_TEXTURE;
}
Z_Free(texturesToken);
texturesToken = M_GetToken(NULL);
@@ -1680,7 +1680,7 @@ static void AddTextureToCache(const char *name, UINT32 hash, INT32 id, UINT8 typ
//
// Check whether texture is available. Filter out NoTexture indicator.
//
-INT32 R_CheckTextureNumForName(const char *name)
+INT32 R_CheckTextureNumForName(const char *name, UINT8 type)
{
INT32 i;
UINT32 hash;
@@ -1692,14 +1692,14 @@ INT32 R_CheckTextureNumForName(const char *name)
hash = quickncasehash(name, 8);
for (i = 0; i < tidcachelen; i++)
- if (tidcache[i].hash == hash && !strncasecmp(tidcache[i].name, name, 8))
+ if (tidcache[i].type == type && tidcache[i].hash == hash && !strncasecmp(tidcache[i].name, name, 8))
return tidcache[i].id;
// Need to parse the list backwards, so textures loaded more recently are used in lieu of ones loaded earlier
for (i = numtextures - 1; i >= 0; i--)
- if (textures[i]->hash == hash && !strncasecmp(textures[i]->name, name, 8))
+ if (textures[i]->type == type && textures[i]->hash == hash && !strncasecmp(textures[i]->name, name, 8))
{
- AddTextureToCache(name, hash, i, textures[i]->type);
+ AddTextureToCache(name, hash, i, type);
return i;
}
@@ -1716,7 +1716,7 @@ const char *R_CheckTextureNameForNum(INT32 num)
{
if (num > 0 && num < numtextures)
return textures[num]->name;
-
+
return "-";
}
@@ -1738,47 +1738,29 @@ const char *R_TextureNameForNum(INT32 num)
//
// R_TextureNumForName
//
-// Calls R_CheckTextureNumForName, aborts with error message.
+// Calls R_CheckTextureNumForName. Returns REDWALL if not found.
//
INT32 R_TextureNumForName(const char *name)
{
- const INT32 i = R_CheckTextureNumForName(name);
+ INT32 i = R_CheckTextureNumForName(name, TEXTURETYPE_TEXTURE);
+ // Didn't find it, so look for a flat
+ if (i == -1)
+ {
+ i = R_CheckTextureNumForName(name, TEXTURETYPE_FLAT);
+ }
+
+ // Still didn't find it, so return REDWALL
if (i == -1)
{
static INT32 redwall = -2;
CONS_Debug(DBG_SETUP, "WARNING: R_TextureNumForName: %.8s not found\n", name);
if (redwall == -2)
- redwall = R_CheckTextureNumForName("REDWALL");
+ redwall = R_CheckTextureNumForName("REDWALL", TEXTURETYPE_TEXTURE);
if (redwall != -1)
return redwall;
return 1;
}
- return i;
-}
-
-// Like R_CheckTextureNumForName, but only looks in the flat namespace specifically.
-INT32 R_CheckFlatNumForName(const char *name)
-{
- INT32 i;
- UINT32 hash;
-
- // "NoTexture" marker.
- if (name[0] == '-')
- return 0;
-
- hash = quickncasehash(name, 8);
-
- for (i = 0; i < tidcachelen; i++)
- if (tidcache[i].type == TEXTURETYPE_FLAT && tidcache[i].hash == hash && !strncasecmp(tidcache[i].name, name, 8))
- return tidcache[i].id;
- for (i = numtextures - 1; i >= 0; i--)
- if (textures[i]->hash == hash && !strncasecmp(textures[i]->name, name, 8) && textures[i]->type == TEXTURETYPE_FLAT)
- {
- AddTextureToCache(name, hash, i, TEXTURETYPE_FLAT);
- return i;
- }
-
- return -1;
+ return i;
}
diff --git a/src/r_textures.h b/src/r_textures.h
index 7e1588851d93093882ae8fb17bca1e70ba0aa61a..e6985556b65176058416c9c6ebb1aa5551d6e086 100644
--- a/src/r_textures.h
+++ b/src/r_textures.h
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -40,8 +40,7 @@ typedef struct
enum
{
TEXTURETYPE_UNKNOWN,
- TEXTURETYPE_SINGLEPATCH,
- TEXTURETYPE_COMPOSITE,
+ TEXTURETYPE_TEXTURE,
TEXTURETYPE_FLAT
};
@@ -100,8 +99,7 @@ void R_SetFlatVars(size_t length);
// Returns the texture number for the texture name.
INT32 R_TextureNumForName(const char *name);
-INT32 R_CheckTextureNumForName(const char *name);
-INT32 R_CheckFlatNumForName(const char *name);
+INT32 R_CheckTextureNumForName(const char *name, UINT8 type);
// Returns the texture name for the texture number (in case you ever needed it)
const char *R_CheckTextureNameForNum(INT32 num);
diff --git a/src/r_things.c b/src/r_things.c
index b32181670aa0ad9e3c5c59bcdc9f9fb2a810108d..2c0529e47a572b8fcd5b7966fcb7652e13a6b03b 100644
--- a/src/r_things.c
+++ b/src/r_things.c
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -279,6 +279,14 @@ static boolean GetFramesAndRotationsFromShortLumpName(
*ret_rotation2 = R_Char2Rotation(name[7]);
if (*ret_frame2 >= 64 || *ret_rotation2 == 255)
return false;
+
+ // TRNSLATE is a valid but extremely unlikely sprite name:
+ // * The sprite name is "TRNS"
+ // * The frame is L, rotation A; mirrored to frame T, rotation E
+ // In the very unfortunate event that TRNSLATE is found between sprite lumps,
+ // this name check prevents it from being added as a sprite, when it actually isn't.
+ if (memcmp(name, "TRNSLATE", 8) == 0)
+ return false;
}
else
{
@@ -367,7 +375,7 @@ static void MirrorMissingRotations(void)
{
spriteframe_t *frame = &sprtemp[framenum];
- if (frame->rotate == SRF_NONE || !(frame->rotate & SRF_3DMASK))
+ if (frame->rotate == SRF_NONE || !(frame->rotate & (SRF_3DMASK | SRF_2D)))
continue;
UINT8 numrotations = frame->rotate == SRF_3D ? 8 : 16;
@@ -379,7 +387,7 @@ static void MirrorMissingRotations(void)
UINT8 baserotation = GetOppositeRotation(rotation, frame->rotate);
UINT32 lumpnum = frame->lumppat[baserotation - 1];
- R_InstallSpriteLump(WADFILENUM(lumpnum), LUMPNUM(lumpnum), frame->lumpid[baserotation], framenum, rotation, 1);
+ R_InstallSpriteLump(WADFILENUM(lumpnum), LUMPNUM(lumpnum), frame->lumpid[baserotation - 1], framenum, rotation, 1);
}
}
}
@@ -960,7 +968,9 @@ UINT8 *R_GetTranslationForThing(mobj_t *mobj, skincolornum_t color, UINT16 trans
if (color != SKINCOLOR_NONE)
{
// New colormap stuff for skins Tails 06-07-2002
- if (mobj->colorized)
+ if ((mobj->state-states == S_METALSONIC_DASH || mobj->state-states == S_METALSONIC_BOUNCE) && (((leveltime/2) & 1))) // Metal boss doing attack
+ skinnum = TC_DASHMODE;
+ else if (mobj->colorized)
skinnum = TC_RAINBOW;
else if (mobj->player && mobj->player->dashmode >= DASHMODE_THRESHOLD
&& (mobj->player->charflags & SF_DASHMODE)
@@ -2198,7 +2208,7 @@ static void R_ProjectSprite(mobj_t *thing)
}
else
trans = 0;
-
+
if ((oldthing->flags2 & MF2_LINKDRAW) && oldthing->tracer)
trans = R_GetThingTransTable(oldthing->tracer->alpha, trans);
else
diff --git a/src/r_things.h b/src/r_things.h
index 55ab71ec3847d5b85295904a18de516afa6f1b74..ae21d2404bc1793c569194f22ed0a8e815c89e46 100644
--- a/src/r_things.h
+++ b/src/r_things.h
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
diff --git a/src/r_translation.c b/src/r_translation.c
index a53b30e9f6fc6196b72df18b3f6063534bda3219..53bb0e6a0fd12fa1291d697db462b647d8909503 100644
--- a/src/r_translation.c
+++ b/src/r_translation.c
@@ -1,7 +1,7 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
// Copyright (C) 1998-2006 by Randy Heit.
-// Copyright (C) 2023 by Sonic Team Junior.
+// Copyright (C) 2023-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
diff --git a/src/r_translation.h b/src/r_translation.h
index 1eb40233d12070708d9bda26bfa8b53792235352..9cae1a6470d71ae76647a4c6f70b821d0f615d6a 100644
--- a/src/r_translation.h
+++ b/src/r_translation.h
@@ -1,7 +1,7 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
// Copyright (C) 1998-2006 by Randy Heit.
-// Copyright (C) 2023 by Sonic Team Junior.
+// Copyright (C) 2023-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
diff --git a/src/s_sound.c b/src/s_sound.c
index 32353a59c2d590dd8ea1f74b47399de0886684d0..0329c289ee104e56cf1c156683690d65455aeed5 100644
--- a/src/s_sound.c
+++ b/src/s_sound.c
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
diff --git a/src/s_sound.h b/src/s_sound.h
index d64778fc37db6fffdf8027ad7aa3cb4f338a6a33..589060c8c2a45ce25deeee80db521a4673f39dc2 100644
--- a/src/s_sound.h
+++ b/src/s_sound.h
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
diff --git a/src/screen.c b/src/screen.c
index 014a20117999065fc2ee47e6d4a00af11f6e0e87..dc77a9a93a6395becb4ac9177625ae7f00c74cad 100644
--- a/src/screen.c
+++ b/src/screen.c
@@ -1,7 +1,7 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -124,6 +124,7 @@ void SCR_SetDrawFuncs(void)
spanfuncs[SPANDRAWFUNC_SPLAT] = R_DrawSplat_8;
spanfuncs[SPANDRAWFUNC_TRANSSPLAT] = R_DrawTranslucentSplat_8;
spanfuncs[SPANDRAWFUNC_TILTEDSPLAT] = R_DrawTiltedSplat_8;
+ spanfuncs[SPANDRAWFUNC_TILTEDTRANSSPLAT] = R_DrawTiltedTranslucentSplat_8;
spanfuncs[SPANDRAWFUNC_SPRITE] = R_DrawFloorSprite_8;
spanfuncs[SPANDRAWFUNC_TRANSSPRITE] = R_DrawTranslucentFloorSprite_8;
spanfuncs[SPANDRAWFUNC_TILTEDSPRITE] = R_DrawTiltedFloorSprite_8;
@@ -146,6 +147,7 @@ void SCR_SetDrawFuncs(void)
spanfuncs_npo2[SPANDRAWFUNC_SPLAT] = R_DrawSplat_NPO2_8;
spanfuncs_npo2[SPANDRAWFUNC_TRANSSPLAT] = R_DrawTranslucentSplat_NPO2_8;
spanfuncs_npo2[SPANDRAWFUNC_TILTEDSPLAT] = R_DrawTiltedSplat_NPO2_8;
+ spanfuncs_npo2[SPANDRAWFUNC_TILTEDTRANSSPLAT] = R_DrawTiltedTranslucentSplat_NPO2_8;
spanfuncs_npo2[SPANDRAWFUNC_SPRITE] = R_DrawFloorSprite_NPO2_8;
spanfuncs_npo2[SPANDRAWFUNC_TRANSSPRITE] = R_DrawTranslucentFloorSprite_NPO2_8;
spanfuncs_npo2[SPANDRAWFUNC_TILTEDSPRITE] = R_DrawTiltedFloorSprite_NPO2_8;
@@ -493,11 +495,9 @@ void SCR_ClosedCaptions(void)
basey -= 42;
else if (splitscreen)
basey -= 8;
- else if ((modeattacking == ATTACKING_NIGHTS)
- || (!(maptol & TOL_NIGHTS)
- && LUA_HudEnabled(hud_powerups)
+ else if (LUA_HudEnabled(hud_powerups)
&& ((cv_powerupdisplay.value == 2) // "Always"
- || (cv_powerupdisplay.value == 1 && !camera.chase)))) // "First-person only"
+ || (cv_powerupdisplay.value == 1 && !camera.chase))) // "First-person only"
basey -= 16;
}
diff --git a/src/screen.h b/src/screen.h
index 375b3e04e9f3846a60992b9f230b4054321cf743..3ce593a52e8595e7412eb9c20c29c91ba9c057bb 100644
--- a/src/screen.h
+++ b/src/screen.h
@@ -1,7 +1,7 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -115,6 +115,7 @@ enum
SPANDRAWFUNC_SPLAT,
SPANDRAWFUNC_TRANSSPLAT,
SPANDRAWFUNC_TILTEDSPLAT,
+ SPANDRAWFUNC_TILTEDTRANSSPLAT,
SPANDRAWFUNC_SPRITE,
SPANDRAWFUNC_TRANSSPRITE,
diff --git a/src/sdl/CMakeLists.txt b/src/sdl/CMakeLists.txt
index 99425108e69b3761fd03de7790d02232e44bb898..8950846ee4f43cf794bd6d2505bbf039e6c71d2f 100644
--- a/src/sdl/CMakeLists.txt
+++ b/src/sdl/CMakeLists.txt
@@ -14,8 +14,13 @@ target_sources(SRB2SDL2 PRIVATE
# Compatibility flag with later versions of GCC
# We should really fix our code to not need this
-if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
- target_compile_options(SRB2SDL2 PRIVATE -mno-ms-bitfields)
+if (NOT SRB2_CONFIG_FORCE_NO_MS_BITFIELDS)
+ if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+ check_cxx_compiler_flag("-mno-ms-bitfields" HAS_NO_MS_BITFIELDS)
+ if(HAS_NO_MS_BITFIELDS)
+ target_compile_options(SRB2SDL2 PRIVATE -mno-ms-bitfields)
+ endif()
+ endif()
endif()
# Yes we know we use insecure CRT functions...
diff --git a/src/sdl/Srb2SDL-vc10.vcxproj b/src/sdl/Srb2SDL-vc10.vcxproj
index 86ffa7082ac3210321a06c3b477ba3b6239947b9..8026cd3acbdd4adb6652269dbf308c8ec6fa4e12 100644
--- a/src/sdl/Srb2SDL-vc10.vcxproj
+++ b/src/sdl/Srb2SDL-vc10.vcxproj
@@ -447,6 +447,7 @@
<ClCompile Include="..\blua\lauxlib.c" />
<ClCompile Include="..\blua\lbaselib.c" />
<ClCompile Include="..\blua\lcode.c" />
+ <ClCompile Include="..\blua\ldblib.c" />
<ClCompile Include="..\blua\ldebug.c" />
<ClCompile Include="..\blua\ldo.c" />
<ClCompile Include="..\blua\ldump.c" />
@@ -641,4 +642,4 @@
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>
-</Project>
\ No newline at end of file
+</Project>
diff --git a/src/sdl/Srb2SDL-vc10.vcxproj.filters b/src/sdl/Srb2SDL-vc10.vcxproj.filters
index d2f9d018f2b3ef44e59def85634aa46ef24acd95..bbfca04d4c1132bc5241e02e612aa6fc2e48c7e5 100644
--- a/src/sdl/Srb2SDL-vc10.vcxproj.filters
+++ b/src/sdl/Srb2SDL-vc10.vcxproj.filters
@@ -604,6 +604,9 @@
<ClCompile Include="..\blua\ldebug.c">
<Filter>BLUA</Filter>
</ClCompile>
+ <ClCompile Include="..\blua\ldblib.c">
+ <Filter>BLUA</Filter>
+ </ClCompile>
<ClCompile Include="..\blua\ldo.c">
<Filter>BLUA</Filter>
</ClCompile>
@@ -1125,4 +1128,4 @@
<Filter>SDLApp</Filter>
</Image>
</ItemGroup>
-</Project>
\ No newline at end of file
+</Project>
diff --git a/src/sdl/hwsym_sdl.c b/src/sdl/hwsym_sdl.c
index ca87fcc7951758e9a5de7ca1a405f88b1f202204..f561266017dd9fcf20b467b3c5e9323be7f5dbe2 100644
--- a/src/sdl/hwsym_sdl.c
+++ b/src/sdl/hwsym_sdl.c
@@ -112,6 +112,7 @@ void *hwSym(const char *funcName,void *handle)
GETFUNC(SetPaletteLookup);
GETFUNC(CreateLightTable);
+ GETFUNC(UpdateLightTable);
GETFUNC(ClearLightTables);
GETFUNC(SetScreenPalette);
diff --git a/src/sdl/i_system.c b/src/sdl/i_system.c
index 9fe50a6a2347583f0fe705ff5c6f6a0466ea51a9..b2396e269b8d7cc456ee9f525aeda7991835cd4e 100644
--- a/src/sdl/i_system.c
+++ b/src/sdl/i_system.c
@@ -5,7 +5,7 @@
//
// Copyright (C) 1993-1996 by id Software, Inc.
// Portions Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 2014-2023 by Sonic Team Junior.
+// Copyright (C) 2014-2025 by Sonic Team Junior.
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
@@ -78,10 +78,11 @@ typedef LPVOID (WINAPI *p_MapViewOfFile) (HANDLE, DWORD, DWORD, DWORD, SIZE_T);
#include "SDL_cpuinfo.h"
#define HAVE_SDLCPUINFO
-#if defined (__unix__) || defined(__APPLE__) || (defined (UNIXCOMMON) && !defined (__HAIKU__))
-#if defined (__linux__)
-#include <sys/vfs.h>
+#if defined (__unix__) || defined(__APPLE__) || defined (UNIXCOMMON)
+#if defined (__linux__) || defined (__HAIKU__)
+#include <sys/statvfs.h>
#else
+#include <sys/statvfs.h>
#include <sys/param.h>
#include <sys/mount.h>
/*For meminfo*/
@@ -94,7 +95,7 @@ typedef LPVOID (WINAPI *p_MapViewOfFile) (HANDLE, DWORD, DWORD, DWORD, SIZE_T);
#endif
#endif
-#if defined (__linux__) || (defined (UNIXCOMMON) && !defined (__HAIKU__))
+#if defined (__linux__) || defined (UNIXCOMMON)
#ifndef NOTERMIOS
#include <termios.h>
#include <sys/ioctl.h> // ioctl
@@ -109,8 +110,10 @@ typedef LPVOID (WINAPI *p_MapViewOfFile) (HANDLE, DWORD, DWORD, DWORD, SIZE_T);
#if defined (__unix__) || (defined (UNIXCOMMON) && !defined (__APPLE__))
#include <errno.h>
#include <sys/wait.h>
+#ifndef __HAIKU__ // haiku's crash dialog is just objectively better
#define NEWSIGNALHANDLER
#endif
+#endif
#ifndef NOMUMBLE
#ifdef __linux__ // need -lrt
@@ -477,10 +480,9 @@ typedef struct
feild_t tty_con;
-// when printing general stuff to stdout stderr (Sys_Printf)
-// we need to disable the tty console stuff
-// this increments so we can recursively disable
-static INT32 ttycon_hide = 0;
+// lock to prevent clearing partial lines, since not everything
+// printed ends on a newline.
+static boolean ttycon_ateol = true;
// some key codes that the terminal may be using
// TTimo NOTE: I'm not sure how relevant this is
static INT32 tty_erase;
@@ -508,63 +510,31 @@ static inline void tty_FlushIn(void)
// TTimo NOTE: it seems on some terminals just sending '\b' is not enough
// so for now, in any case we send "\b \b" .. yeah well ..
// (there may be a way to find out if '\b' alone would work though)
+// Hanicef NOTE: using \b this way is unreliable because of terminal state,
+// it's better to use \r to reset the cursor to the beginning of the
+// line and clear from there.
static void tty_Back(void)
{
- char key;
- ssize_t d;
- key = '\b';
- d = write(STDOUT_FILENO, &key, 1);
- key = ' ';
- d = write(STDOUT_FILENO, &key, 1);
- key = '\b';
- d = write(STDOUT_FILENO, &key, 1);
- (void)d;
-}
-
-static void tty_Clear(void)
-{
- size_t i;
+ write(STDOUT_FILENO, "\r", 1);
if (tty_con.cursor>0)
{
- for (i=0; i<tty_con.cursor; i++)
- {
- tty_Back();
- }
- }
-
-}
-
-// clear the display of the line currently edited
-// bring cursor back to beginning of line
-static inline void tty_Hide(void)
-{
- //I_Assert(consolevent);
- if (ttycon_hide)
- {
- ttycon_hide++;
- return;
+ write(STDOUT_FILENO, tty_con.buffer, tty_con.cursor);
}
- tty_Clear();
- ttycon_hide++;
+ write(STDOUT_FILENO, " \b", 2);
}
-// show the current line
-// FIXME TTimo need to position the cursor if needed??
-static inline void tty_Show(void)
+static void tty_Clear(void)
{
size_t i;
- ssize_t d;
- //I_Assert(consolevent);
- I_Assert(ttycon_hide>0);
- ttycon_hide--;
- if (ttycon_hide == 0 && tty_con.cursor)
+ write(STDOUT_FILENO, "\r", 1);
+ if (tty_con.cursor>0)
{
for (i=0; i<tty_con.cursor; i++)
{
- d = write(STDOUT_FILENO, tty_con.buffer+i, 1);
+ write(STDOUT_FILENO, " ", 1);
}
+ write(STDOUT_FILENO, "\r", 1);
}
- (void)d;
}
// never exit without calling this, or your terminal will be left in a pretty bad state
@@ -672,6 +642,11 @@ void I_GetConsoleEvents(void)
tty_con.cursor = 0;
ev.key = KEY_ENTER;
}
+ else if (key == 0x4) // ^D, aka EOF
+ {
+ // shut down, most unix programs behave this way
+ I_Quit();
+ }
else continue;
}
else if (tty_con.cursor < sizeof (tty_con.buffer))
@@ -879,9 +854,16 @@ static void I_RegisterChildSignals(void)
void I_OutputMsg(const char *fmt, ...)
{
size_t len;
- char txt[8192];
+ char *txt;
va_list argptr;
+ va_start(argptr,fmt);
+ len = vsnprintf(NULL, 0, fmt, argptr);
+ va_end(argptr);
+ if (len == 0)
+ return;
+
+ txt = malloc(len+1);
va_start(argptr,fmt);
vsprintf(txt, fmt, argptr);
va_end(argptr);
@@ -915,7 +897,10 @@ void I_OutputMsg(const char *fmt, ...)
DWORD bytesWritten;
if (co == INVALID_HANDLE_VALUE)
+ {
+ free(txt);
return;
+ }
if (GetFileType(co) == FILE_TYPE_CHAR && GetConsoleMode(co, &bytesWritten))
{
@@ -931,11 +916,16 @@ void I_OutputMsg(const char *fmt, ...)
if (oldLength > 0)
{
LPVOID blank = malloc(oldLength);
- if (!blank) return;
+ if (!blank)
+ {
+ free(txt);
+ return;
+ }
memset(blank, ' ', oldLength); // Blank out.
oldLines = malloc(oldLength*sizeof(TCHAR));
if (!oldLines)
{
+ free(txt);
free(blank);
return;
}
@@ -970,18 +960,20 @@ void I_OutputMsg(const char *fmt, ...)
}
#else
#ifdef HAVE_TERMIOS
- if (consolevent)
+ if (consolevent && ttycon_ateol)
{
- tty_Hide();
+ tty_Clear();
+ ttycon_ateol = false;
}
#endif
if (!framebuffer)
fprintf(stderr, "%s", txt);
#ifdef HAVE_TERMIOS
- if (consolevent)
+ if (consolevent && txt[len-1] == '\n')
{
- tty_Show();
+ write(STDOUT_FILENO, tty_con.buffer, tty_con.cursor);
+ ttycon_ateol = true;
}
#endif
@@ -990,6 +982,7 @@ void I_OutputMsg(const char *fmt, ...)
fflush(stderr);
#endif
+ free(txt);
}
//
@@ -2307,15 +2300,24 @@ void I_Sleep(UINT32 ms)
void I_SleepDuration(precise_t duration)
{
-#if defined(__linux__) || defined(__FreeBSD__)
+#if defined(__linux__) || defined(__FreeBSD__) || defined(__HAIKU__)
UINT64 precision = I_GetPrecisePrecision();
- struct timespec ts = {
- .tv_sec = duration / precision,
- .tv_nsec = duration * 1000000000 / precision % 1000000000,
- };
- int status;
- do status = clock_nanosleep(CLOCK_MONOTONIC, 0, &ts, &ts);
- while (status == EINTR);
+ precise_t dest = I_GetPreciseTime() + duration;
+ precise_t slack = (precision / 5000); // 0.2 ms slack
+ if (duration > slack)
+ {
+ duration -= slack;
+ struct timespec ts = {
+ .tv_sec = duration / precision,
+ .tv_nsec = duration * 1000000000 / precision % 1000000000,
+ };
+ int status;
+ do status = clock_nanosleep(CLOCK_MONOTONIC, 0, &ts, &ts);
+ while (status == EINTR);
+ }
+
+ // busy-wait the rest
+ while (((INT64)dest - (INT64)I_GetPreciseTime()) > 0);
#elif defined (MIN_SLEEP_DURATION_MS)
UINT64 precision = I_GetPrecisePrecision();
INT32 sleepvalue = cv_sleep.value;
@@ -2754,18 +2756,13 @@ void I_ShutdownSystem(void)
void I_GetDiskFreeSpace(INT64 *freespace)
{
#if defined (__unix__) || defined(__APPLE__) || defined (UNIXCOMMON)
-#if defined (SOLARIS) || defined (__HAIKU__)
- *freespace = INT32_MAX;
- return;
-#else // Both Linux and BSD have this, apparently.
- struct statfs stfs;
- if (statfs(srb2home, &stfs) == -1)
+ struct statvfs stfs;
+ if (statvfs(srb2home, &stfs) == -1)
{
*freespace = INT32_MAX;
return;
}
*freespace = stfs.f_bavail * stfs.f_bsize;
-#endif
#elif defined (_WIN32)
static p_GetDiskFreeSpaceExA pfnGetDiskFreeSpaceEx = NULL;
static boolean testwin95 = false;
@@ -3087,8 +3084,10 @@ const char *I_LocateWad(void)
{
// change to the directory where we found srb2.pk3
#if defined (_WIN32)
+ waddir = _fullpath(NULL, waddir, MAX_PATH);
SetCurrentDirectoryA(waddir);
#else
+ waddir = realpath(waddir, NULL);
if (chdir(waddir) == -1)
I_OutputMsg("Couldn't change working directory\n");
#endif
diff --git a/src/sdl/i_video.c b/src/sdl/i_video.c
index 10c866a1e32ff6dd3c8ac248fb50df2a4e3a30f6..82583ccb4651ff8cbfc42be4a0f40ee54bd31d7d 100644
--- a/src/sdl/i_video.c
+++ b/src/sdl/i_video.c
@@ -87,7 +87,7 @@
#endif
// maximum number of windowed modes (see windowedModes[][])
-#define MAXWINMODES (18)
+#define MAXWINMODES (21)
/** \brief
*/
@@ -157,7 +157,9 @@ static INT32 windowedModes[MAXWINMODES][2] =
{1920,1080}, // 1.66
{1680,1050}, // 1.60,5.25
{1600,1200}, // 1.33
+ {1600,1000}, // 1.60,5.00
{1600, 900}, // 1.66
+ {1536, 864}, // 1.66,4.80
{1366, 768}, // 1.66
{1440, 900}, // 1.60,4.50
{1280,1024}, // 1.33?
@@ -166,6 +168,7 @@ static INT32 windowedModes[MAXWINMODES][2] =
{1280, 720}, // 1.66
{1152, 864}, // 1.33,3.60
{1024, 768}, // 1.33,3.20
+ { 960, 600}, // 1.60,3.00
{ 800, 600}, // 1.33,2.50
{ 640, 480}, // 1.33,2.00
{ 640, 400}, // 1.60,2.00
@@ -1901,6 +1904,7 @@ void VID_StartupOpenGL(void)
HWD.pfnSetPaletteLookup = hwSym("SetPaletteLookup",NULL);
HWD.pfnCreateLightTable = hwSym("CreateLightTable",NULL);
+ HWD.pfnUpdateLightTable = hwSym("UpdateLightTable",NULL);
HWD.pfnClearLightTables = hwSym("ClearLightTables",NULL);
HWD.pfnSetScreenPalette = hwSym("SetScreenPalette",NULL);
@@ -1945,8 +1949,6 @@ void I_ShutdownGraphics(void)
I_OutputMsg("shut down\n");
#ifdef HWRENDER
- if (GLUhandle)
- hwClose(GLUhandle);
if (sdlglcontext)
{
SDL_GL_DeleteContext(sdlglcontext);
diff --git a/src/sdl/ogl_sdl.c b/src/sdl/ogl_sdl.c
index e7347547e224b43f2fcdf66e527c8adc2681e243..c78b43ec4097cafad8420ceb7497e2883220a67e 100644
--- a/src/sdl/ogl_sdl.c
+++ b/src/sdl/ogl_sdl.c
@@ -70,18 +70,10 @@ PFNglGetString pglGetString;
/** \brief SDL video display surface
*/
INT32 oglflags = 0;
-void *GLUhandle = NULL;
SDL_GLContext sdlglcontext = 0;
void *GetGLFunc(const char *proc)
{
- if (strncmp(proc, "glu", 3) == 0)
- {
- if (GLUhandle)
- return hwSym(proc, GLUhandle);
- else
- return NULL;
- }
return SDL_GL_GetProcAddress(proc);
}
@@ -89,7 +81,6 @@ boolean LoadGL(void)
{
#ifndef STATIC_OPENGL
const char *OGLLibname = NULL;
- const char *GLULibname = NULL;
if (M_CheckParm("-OGLlib") && M_IsNextParm())
OGLLibname = M_GetNextParm();
@@ -102,43 +93,6 @@ boolean LoadGL(void)
CONS_Printf("If you know what is the OpenGL library's name, use -OGLlib\n");
return 0;
}
-
-#if 0
- GLULibname = "/proc/self/exe";
-#elif defined (_WIN32)
- GLULibname = "GLU32.DLL";
-#elif defined (__MACH__)
- GLULibname = "/System/Library/Frameworks/OpenGL.framework/Libraries/libGLU.dylib";
-#elif defined (macintos)
- GLULibname = "OpenGLLibrary";
-#elif defined (__unix__)
- GLULibname = "libGLU.so.1";
-#elif defined (__HAIKU__)
- GLULibname = "libGLU.so";
-#else
- GLULibname = NULL;
-#endif
-
- if (M_CheckParm("-GLUlib") && M_IsNextParm())
- GLULibname = M_GetNextParm();
-
- if (GLULibname)
- {
- GLUhandle = hwOpen(GLULibname);
- if (GLUhandle)
- return SetupGLfunc();
- else
- {
- CONS_Alert(CONS_ERROR, "Could not load GLU Library: %s\n", GLULibname);
- if (!M_CheckParm ("-GLUlib"))
- CONS_Alert(CONS_ERROR, "If you know what is the GLU library's name, use -GLUlib\n");
- }
- }
- else
- {
- CONS_Alert(CONS_ERROR, "Could not load GLU Library\n");
- CONS_Alert(CONS_ERROR, "If you know what is the GLU library's name, use -GLUlib\n");
- }
#endif
return SetupGLfunc();
}
@@ -155,6 +109,7 @@ boolean OglSdlSurface(INT32 w, INT32 h)
{
INT32 cbpp = cv_scr_depth.value < 16 ? 16 : cv_scr_depth.value;
static boolean first_init = false;
+ static int majorGL = 0, minorGL = 0;
oglflags = 0;
@@ -189,6 +144,12 @@ boolean OglSdlSurface(INT32 w, INT32 h)
else
maximumAnisotropy = 1;
+ if (sscanf((const char*)gl_version, "%d.%d", &majorGL, &minorGL)
+ && (!(majorGL == 1 && minorGL <= 3)))
+ supportMipMap = true;
+ else
+ supportMipMap = false;
+
SetupGLFunc4();
glanisotropicmode_cons_t[1].value = maximumAnisotropy;
diff --git a/src/sdl/ogl_sdl.h b/src/sdl/ogl_sdl.h
index bd1d699ff44db27a4599bfb81d4f65e34ac7f858..87df5e5e6115334dd8705658d70f9f6e5b6706f8 100644
--- a/src/sdl/ogl_sdl.h
+++ b/src/sdl/ogl_sdl.h
@@ -19,8 +19,6 @@
#include "../v_video.h"
-extern void *GLUhandle;
-
boolean OglSdlSurface(INT32 w, INT32 h);
void OglSdlFinishUpdate(boolean vidwait);
diff --git a/src/st_stuff.c b/src/st_stuff.c
index e088a448c129ed6e2392e8bcadf3cb62e9932525..4fdacd51ada1871c4a711f91749e0d9b39872796 100644
--- a/src/st_stuff.c
+++ b/src/st_stuff.c
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -1042,6 +1042,9 @@ static void ST_drawInput(void)
INT32 x = hudinfo[HUD_INPUT].x, y = hudinfo[HUD_INPUT].y;
+ if (hu_showscores)
+ return;
+
if (stplyr->powers[pw_carry] == CR_NIGHTSMODE)
y += 8;
else if (modeattacking || !LUA_HudEnabled(hud_lives))
@@ -1173,10 +1176,8 @@ static void ST_drawInput(void)
V_DrawFill(x+16+(xoffs), y+(yoffs)-offs, 10, 10, col);\
V_DrawCharacter(x+16+1+(xoffs), y+1+(yoffs)-offs, hudinfo[HUD_INPUT].f|symb, false)
- drawbutt( 4,-3, BT_JUMP, 'J' );
- drawbutt(15,-3, BT_SPIN, 'S' );
- drawbutt(26,-3, BT_SHIELD, '\0'); // Instead of a wide 'J' or 'S', we'll draw a thin "SH" for Shield
- V_DrawThinString(x+16+26, y+2+(-3)-offs, hudinfo[HUD_LIVES].f, "SH");
+ drawbutt( 4,-3, BT_JUMP, 'J');
+ drawbutt(15,-3, BT_SPIN, 'S');
V_DrawFill(x+16+4, y+8, 21, 10, hudinfo[HUD_INPUT].f|20); // sundial backing
if (stplyr->mo)
@@ -1255,6 +1256,8 @@ static void ST_drawInput(void)
V_DrawThinString(x, y, hudinfo[HUD_INPUT].f|((leveltime & 4) ? V_YELLOWMAP : V_REDMAP), "BAD DEMO!!");
}
+static boolean lt_active = false;
+
static patch_t *lt_patches[3];
static INT32 lt_scroll = 0;
static INT32 lt_mom = 0;
@@ -1303,6 +1306,7 @@ void ST_startTitleCard(void)
ST_cacheLevelTitle();
// initialize HUD variables
+ lt_active = true;
lt_ticker = lt_exitticker = lt_lasttic = 0;
lt_endtime = 2*TICRATE + (10*NEWTICRATERATIO);
lt_scroll = BASEVIDWIDTH * FRACUNIT;
@@ -1311,21 +1315,11 @@ void ST_startTitleCard(void)
}
//
-// What happens before drawing the title card.
-// Which is just setting the HUD translucency.
+// Stops the title card.
//
-void ST_preDrawTitleCard(void)
+void ST_stopTitleCard(void)
{
- if (!G_IsTitleCardAvailable())
- return;
-
- if (lt_ticker >= (lt_endtime + TICRATE))
- return;
-
- if (!lt_exitticker)
- st_translucency = 0;
- else
- st_translucency = max(0, min((INT32)lt_exitticker-4, cv_translucenthud.value));
+ lt_active = false;
}
//
@@ -1334,47 +1328,43 @@ void ST_preDrawTitleCard(void)
//
void ST_runTitleCard(void)
{
- boolean run = !(paused || P_AutoPause());
-
- if (!G_IsTitleCardAvailable())
- return;
-
- if (lt_ticker >= (lt_endtime + TICRATE))
+ if (!lt_active || ((paused || P_AutoPause()) && lt_ticker >= PRELEVELTIME))
return;
- if (run || (lt_ticker < PRELEVELTIME))
+ if (!lt_exitticker)
{
- // tick
- lt_ticker++;
- if (lt_ticker >= lt_endtime)
- lt_exitticker++;
+ if (abs(lt_scroll) > FRACUNIT)
+ lt_scroll -= (lt_scroll>>2);
+ else
+ lt_scroll = 0;
- // scroll to screen (level title)
- if (!lt_exitticker)
- {
- if (abs(lt_scroll) > FRACUNIT)
- lt_scroll -= (lt_scroll>>2);
- else
- lt_scroll = 0;
- }
- // scroll away from screen (level title)
+ if (abs(lt_zigzag) > FRACUNIT)
+ lt_zigzag -= (lt_zigzag>>2);
else
+ lt_zigzag = 0;
+ }
+ else
+ {
+ lt_mom -= FRACUNIT*6;
+
+ if (lt_scroll > -BASEVIDWIDTH * FRACUNIT * 2)
{
- lt_mom -= FRACUNIT*6;
lt_scroll += lt_mom;
}
- // scroll to screen (zigzag)
- if (!lt_exitticker)
+ if (lt_zigzag > -(lt_patches[1]->width)*FRACUNIT)
{
- if (abs(lt_zigzag) > FRACUNIT)
- lt_zigzag -= (lt_zigzag>>2);
- else
- lt_zigzag = 0;
- }
- // scroll away from screen (zigzag)
- else
lt_zigzag += lt_mom;
+ }
+ }
+
+ lt_ticker++;
+ lt_exitticker = max((signed)lt_ticker - (signed)lt_endtime, 0);
+
+ if (lt_ticker >= (lt_endtime + TICRATE))
+ {
+ lt_active = false;
+ return;
}
}
@@ -1401,9 +1391,6 @@ void ST_drawTitleCard(void)
colormap = R_GetTranslationColormap(TC_DEFAULT, colornum, GTC_CACHE);
- if (!G_IsTitleCardAvailable())
- return;
-
if (!LUA_HudEnabled(hud_stagetitle))
goto luahook;
@@ -1484,13 +1471,14 @@ void ST_preLevelTitleCardDrawer(void)
//
void ST_drawWipeTitleCard(void)
{
+ if (!lt_active)
+ return;
+
stplyr = &players[consoleplayer];
- ST_preDrawTitleCard();
ST_drawTitleCard();
if (splitscreen)
{
stplyr = &players[secondarydisplayplayer];
- ST_preDrawTitleCard();
ST_drawTitleCard();
}
}
@@ -2078,24 +2066,25 @@ static void ST_drawNiGHTSHUD(void)
if (!stplyr->exiting && !oldspecialstage && LUA_HudEnabled(hud_nightsscore))
ST_DrawNightsOverlayNum(304<<FRACBITS, 14<<FRACBITS, FRACUNIT, V_PERPLAYER|V_SNAPTOTOP|V_SNAPTORIGHT, stplyr->marescore, nightsnum, SKINCOLOR_AZURE);
- // TODO give this its own section for Lua
+ // TODO: give this its own section for Lua
+ // TODO: on multi-mare maps, show time & grade for each completed mare
if (!stplyr->exiting && LUA_HudEnabled(hud_nightsscore))
{
if (modeattacking == ATTACKING_NIGHTS)
{
INT32 maretime = max(stplyr->realtime - stplyr->marebegunat, 0);
-#define VFLAGS V_SNAPTOBOTTOM|V_SNAPTORIGHT|V_PERPLAYER|V_HUDTRANS
- V_DrawScaledPatch(BASEVIDWIDTH-22, BASEVIDHEIGHT-20, VFLAGS, W_CachePatchName("NGRTIMER", PU_HUDGFX));
- V_DrawPaddedTallNum(BASEVIDWIDTH-22, BASEVIDHEIGHT-20, VFLAGS, G_TicsToCentiseconds(maretime), 2);
- V_DrawScaledPatch(BASEVIDWIDTH-46, BASEVIDHEIGHT-20, VFLAGS, sboperiod);
+#define VFLAGS V_SNAPTOTOP|V_SNAPTORIGHT|V_PERPLAYER|V_HUDTRANS
+ V_DrawScaledPatch(BASEVIDWIDTH-16, 40, VFLAGS, W_CachePatchName("NGRTIMER", PU_HUDGFX));
+ V_DrawPaddedTallNum(BASEVIDWIDTH-16, 40, VFLAGS, G_TicsToCentiseconds(maretime), 2);
+ V_DrawScaledPatch(BASEVIDWIDTH-40, 40, VFLAGS, sboperiod);
if (maretime < 60*TICRATE)
- V_DrawTallNum(BASEVIDWIDTH-46, BASEVIDHEIGHT-20, VFLAGS, G_TicsToSeconds(maretime));
+ V_DrawTallNum(BASEVIDWIDTH-40, 40, VFLAGS, G_TicsToSeconds(maretime));
else
{
- V_DrawPaddedTallNum(BASEVIDWIDTH-46, BASEVIDHEIGHT-20, VFLAGS, G_TicsToSeconds(maretime), 2);
- V_DrawScaledPatch(BASEVIDWIDTH-70, BASEVIDHEIGHT-20, VFLAGS, sbocolon);
- V_DrawTallNum(BASEVIDWIDTH-70, BASEVIDHEIGHT-20, VFLAGS, G_TicsToMinutes(maretime, true));
+ V_DrawPaddedTallNum(BASEVIDWIDTH-40, 40, VFLAGS, G_TicsToSeconds(maretime), 2);
+ V_DrawScaledPatch(BASEVIDWIDTH-64, 40, VFLAGS, sbocolon);
+ V_DrawTallNum(BASEVIDWIDTH-64, 40, VFLAGS, G_TicsToMinutes(maretime, true));
}
#undef VFLAGS
}
@@ -2665,7 +2654,7 @@ static boolean ST_doItemFinderIconsAndSound(void)
// Scan thinkers to find emblem mobj with these ids
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
{
- if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
+ if (th->removing)
continue;
mo2 = (mobj_t *)th;
@@ -2701,24 +2690,14 @@ static boolean ST_doItemFinderIconsAndSound(void)
return true;
}
+static boolean drawstagetitle = false;
+
//
// Draw the status bar overlay, customisable: the user chooses which
// kind of information to overlay
//
static void ST_overlayDrawer(void)
{
- // Decide whether to draw the stage title or not
- boolean stagetitle = false;
-
- // Check for a valid level title
- // If the HUD is enabled
- // And, if Lua is running, if the HUD library has the stage title enabled
- if (G_IsTitleCardAvailable() && *mapheaderinfo[gamemap-1]->lvlttl != '\0' && !(hu_showscores && (netgame || multiplayer)))
- {
- stagetitle = true;
- ST_preDrawTitleCard();
- }
-
// hu_showscores = auto hide score/time/rings when tab rankings are shown
if (!(hu_showscores && (netgame || multiplayer)))
{
@@ -2841,7 +2820,7 @@ static void ST_overlayDrawer(void)
}
else if (cv_powerupdisplay.value == 2 && LUA_HudEnabled(hud_powerups))
ST_drawPowerupHUD(); // same as it ever was...
-
+
}
else if (!(netgame || multiplayer) && cv_powerupdisplay.value == 2 && LUA_HudEnabled(hud_powerups))
ST_drawPowerupHUD(); // same as it ever was...
@@ -2858,7 +2837,7 @@ static void ST_overlayDrawer(void)
}
// draw level title Tails
- if (stagetitle && (!WipeInAction) && (!WipeStageTitle))
+ if (drawstagetitle && !WipeInAction && !WipeStageTitle)
ST_drawTitleCard();
if (!hu_showscores && (netgame || multiplayer) && LUA_HudEnabled(hud_textspectator))
@@ -2929,7 +2908,22 @@ void ST_Drawer(void)
}
}
- st_translucency = cv_translucenthud.value;
+ // Decide whether to draw the stage title or not
+ if (lt_active)
+ {
+ drawstagetitle = !(hu_showscores && (netgame || multiplayer));
+
+ if (!lt_exitticker)
+ st_translucency = 0;
+ else
+ st_translucency = max(0, min((INT32)lt_exitticker-4, cv_translucenthud.value));
+ }
+ else
+ {
+ st_translucency = cv_translucenthud.value;
+
+ drawstagetitle = false;
+ }
if (st_overlay)
{
diff --git a/src/st_stuff.h b/src/st_stuff.h
index 6f6bac1fa47fd5b4b71a850383138ad9821456ee..a2fb8a0ed7328f27de43f750e32a3c9c7f390eae 100644
--- a/src/st_stuff.h
+++ b/src/st_stuff.h
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -49,9 +49,9 @@ void ST_doPaletteStuff(void);
// title card
void ST_startTitleCard(void);
+void ST_stopTitleCard(void);
void ST_runTitleCard(void);
void ST_drawTitleCard(void);
-void ST_preDrawTitleCard(void);
void ST_preLevelTitleCardDrawer(void);
void ST_drawWipeTitleCard(void);
diff --git a/src/string.c b/src/string.c
index b24e12e6e36fec3078aaae76bee7a765f9c30c8f..79573283e10bee24ef70a394899c6f5585f67521 100644
--- a/src/string.c
+++ b/src/string.c
@@ -1,7 +1,7 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
// Copyright (C) 2006 by Graue.
-// Copyright (C) 2006-2023 by Sonic Team Junior.
+// Copyright (C) 2006-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -83,7 +83,7 @@ char *xstrtok(char *line, const char *delims)
return NULL;
p = saveline; // save start of this token
-
+
saveline += strcspn(saveline, delims); // get the number of non-delims characters, go past delimiter
if(*saveline != '\0') // trash the delim if necessary
@@ -91,4 +91,3 @@ char *xstrtok(char *line, const char *delims)
return p;
}
-
diff --git a/src/tables.c b/src/tables.c
index d0fb428ba8909653cc7f1d340caa9590f1373391..8e9075be259be149d1bb68686201973ccad70ae1 100644
--- a/src/tables.c
+++ b/src/tables.c
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
// Copyright (C) 2009 by Stephen McGranahan.
//
// This program is free software distributed under the
diff --git a/src/tables.h b/src/tables.h
index 65d7f72433177f77d711c5e4b5809ed2f9d6e2b8..3c0dd2a81ff97a6ccc382716bf136a897b1c4e75 100644
--- a/src/tables.h
+++ b/src/tables.h
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
diff --git a/src/v_video.c b/src/v_video.c
index 3beb435b58428491e5b62f3ce48ec35535c25f60..39a1001d199952077fc783875b4d104c819a8fcd 100644
--- a/src/v_video.c
+++ b/src/v_video.c
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -1137,7 +1137,7 @@ void V_DrawFill(INT32 x, INT32 y, INT32 w, INT32 h, INT32 c)
}
#endif
-
+
if (splitscreen && (c & V_PERPLAYER))
{
@@ -1953,7 +1953,7 @@ char *V_FontWordWrap(INT32 x, INT32 w, INT32 option, fixed_t scale, const char *
INT32 spacewidth = font.spacewidth, charwidth = 0;
slen = strlen(string);
-
+
if (w == 0)
w = BASEVIDWIDTH;
w -= x;
@@ -2131,7 +2131,7 @@ void V_DrawAlignedFontStringAtFixed(fixed_t x, fixed_t y, INT32 option, fixed_t
lx = x - (V_FontStringWidth(line, option, font)*pscale);
break;
}
-
+
V_DrawFontStringAtFixed(lx, ly, option, pscale, vscale, line, font);
ly += FixedMul(((option & V_RETURN8) ? 8 : font.linespacing)<<FRACBITS, vscale);
@@ -2422,7 +2422,7 @@ INT32 V_FontStringWidth(const char *string, INT32 option, fontdef_t font)
if (wline < w) wline = w;
w = 0;
continue;
- }
+ }
if (string[i] & 0x80)
continue;
@@ -2455,7 +2455,7 @@ INT32 V_FontStringHeight(const char *string, INT32 option, fontdef_t font)
{
result += (option & V_RETURN8) ? 8 : font.linespacing;
h = 0;
- }
+ }
continue;
}
diff --git a/src/v_video.h b/src/v_video.h
index d37762466147ae843c8f0fba5218f4e8af3f6462..bdab23e8ad6cbd0c5868525da6f91500742e7e0f 100644
--- a/src/v_video.h
+++ b/src/v_video.h
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
diff --git a/src/version.h b/src/version.h
index 8d8f8978e7ea3cf593247a73a9460ed139193c10..8e69194cd20b98debe50bc67afb264a0bb2aec9b 100644
--- a/src/version.h
+++ b/src/version.h
@@ -1,4 +1,4 @@
-#define SRB2VERSION "2.2.14"/* this must be the first line, for cmake !! */
+#define SRB2VERSION "2.2.15"/* this must be the first line, for cmake !! */
// The Modification ID; must be obtained from a Master Server Admin ( https://mb.srb2.org/members/?key=ms_admin ).
// DO NOT try to set this otherwise, or your modification will be unplayable through the Master Server.
@@ -9,7 +9,7 @@
// it's only for detection of the version the player is using so the MS can alert them of an update.
// Only set it higher, not lower, obviously.
// Note that we use this to help keep internal testing in check; this is why v2.2.0 is not version "1".
-#define MODVERSION 55
+#define MODVERSION 56
// Define this as a prerelease version suffix (pre#, RC#)
-#define BETAVERSION "nightly"
+//#define BETAVERSION "pre4"
diff --git a/src/w_wad.c b/src/w_wad.c
index cc7cdc20167d616083d86db652b05aa8eb182e5e..50ba622a9b32f538b18d50dcdf29fbfd457f7355 100644
--- a/src/w_wad.c
+++ b/src/w_wad.c
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -65,6 +65,7 @@
#include "i_video.h" // rendermode
#include "md5.h"
#include "lua_script.h"
+#include "lua_hook.h"
#ifdef SCANTHINGS
#include "p_setup.h" // P_ScanThings
#endif
@@ -307,12 +308,10 @@ static void W_LoadDehackedLumps(UINT16 wadnum, boolean mainfile)
* \param resblock resulting MD5 checksum
* \return 0 if MD5 checksum was made, and is at resblock, 1 if error was found
*/
+
+#ifndef NOMD5
static INT32 W_MakeFileMD5(const char *filename, void *resblock)
{
-#ifdef NOMD5
- (void)filename;
- memset(resblock, 0x00, 16);
-#else
FILE *fhandle;
if ((fhandle = fopen(filename, "rb")) != NULL)
@@ -329,9 +328,9 @@ static INT32 W_MakeFileMD5(const char *filename, void *resblock)
fclose(fhandle);
return 0;
}
-#endif
return 1;
}
+#endif
// Invalidates the cache of lump numbers. Call this whenever a wad is added.
static void W_InvalidateLumpnumCache(void)
@@ -1011,6 +1010,10 @@ UINT16 W_InitFile(const char *filename, boolean mainfile, boolean startup)
break;
}
+ lua_lumploading++;
+ LUA_HookVoid(HOOK(AddonLoaded));
+ lua_lumploading--;
+
W_InvalidateLumpnumCache();
return wadfile->numlumps;
}
@@ -1171,6 +1174,11 @@ UINT16 W_InitFolder(const char *path, boolean mainfile, boolean startup)
W_ReadFileShaders(wadfile);
W_LoadTrnslateLumps(numwadfiles - 1);
W_LoadDehackedLumpsPK3(numwadfiles - 1, mainfile);
+
+ lua_lumploading++;
+ LUA_HookVoid(HOOK(AddonLoaded));
+ lua_lumploading--;
+
W_InvalidateLumpnumCache();
return wadfile->numlumps;
@@ -1329,10 +1337,10 @@ UINT16 W_CheckNumForFolderStartPK3(const char *name, UINT16 wad, UINT16 startlum
/* SLADE is special and puts a single directory entry. Skip that. */
if (strlen(lump_p->fullname) == name_length)
i++;
- break;
+ return i;
}
}
- return i;
+ return INT16_MAX;
}
// In a PK3 type of resource file, it looks for the next lumpinfo entry that doesn't share the specified pathfile.
@@ -1692,7 +1700,7 @@ lumpnum_t W_GetNumForLongName(const char *name)
//
static UINT16 W_CheckNumForPatchNamePwad(const char *name, UINT16 wad, boolean longname)
{
- UINT16 i, start, end;
+ UINT16 i, start = INT16_MAX, end = INT16_MAX;
static char uname[8 + 1] = { 0 };
UINT32 hash = 0;
lumpinfo_t *lump_p;
@@ -1716,6 +1724,13 @@ static UINT16 W_CheckNumForPatchNamePwad(const char *name, UINT16 wad, boolean l
{
start = W_CheckNumForFolderStartPK3("Flats/", wad, 0);
end = W_CheckNumForFolderEndPK3("Flats/", wad, start);
+
+ // if the start and end is the same, the folder is empty
+ if (end <= start)
+ {
+ start = INT16_MAX;
+ end = INT16_MAX;
+ }
}
else
{
@@ -2643,7 +2658,8 @@ static lumpchecklist_t folderblacklist[] =
{
{"Lua/", 4},
{"SOC/", 4},
- {"Sprites/", 8},
+ {"Sprites/", 8},
+ {"LongSprites/", 12},
{"Textures/", 9},
{"Patches/", 8},
{"Flats/", 6},
diff --git a/src/w_wad.h b/src/w_wad.h
index 3dcb9b6e8bbc6ee11669f473e9395a0006f84db0..84aafa3a40e2e48f662c723d5a5854138806b5b0 100644
--- a/src/w_wad.h
+++ b/src/w_wad.h
@@ -2,7 +2,7 @@
//-----------------------------------------------------------------------------
// Copyright (C) 1993-1996 by id Software, Inc.
// Copyright (C) 1998-2000 by DooM Legacy Team.
-// Copyright (C) 1999-2023 by Sonic Team Junior.
+// Copyright (C) 1999-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
diff --git a/src/win32/Srb2win.rc b/src/win32/Srb2win.rc
index 46114f8717cc0a7396a7355084c25a2e704ac075..6fba9f9a8877e65fb99c91c2e24022926857beba 100644
--- a/src/win32/Srb2win.rc
+++ b/src/win32/Srb2win.rc
@@ -98,7 +98,7 @@ BEGIN
VALUE "FileDescription", "Sonic Robo Blast 2\0"
VALUE "FileVersion", VERSIONSTRING_RC
VALUE "InternalName", "srb2\0"
- VALUE "LegalCopyright", "Copyright 1998-2023 by Sonic Team Junior\0"
+ VALUE "LegalCopyright", "Copyright 1998-2025 by Sonic Team Junior\0"
VALUE "LegalTrademarks", "Sonic the Hedgehog and related characters are trademarks of Sega.\0"
VALUE "OriginalFilename", "srb2win.exe\0"
VALUE "PrivateBuild", "\0"
diff --git a/src/y_inter.c b/src/y_inter.c
index 2add8645b0888ea460419b0165abeca702d6e29b..d7e644567eb14030e1bbb569434e1db460d8b56c 100644
--- a/src/y_inter.c
+++ b/src/y_inter.c
@@ -1,6 +1,6 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
-// Copyright (C) 2004-2023 by Sonic Team Junior.
+// Copyright (C) 2004-2024 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -109,6 +109,7 @@ typedef union
UINT16 *color[MAXPLAYERS]; // Winner's color #
boolean spectator[MAXPLAYERS]; // Spectator list
UINT8 *character[MAXPLAYERS]; // Winner's character #
+ INT32 ctfteam[MAXPLAYERS]; // Winner's ctfteam #
INT32 num[MAXPLAYERS]; // Winner's player #
char *name[MAXPLAYERS]; // Winner's name
patch_t *result; // RESULT
@@ -579,9 +580,9 @@ void Y_IntermissionDrawer(void)
{
if (LUA_HudEnabled(hud_intermissiontitletext))
{
- const char *ringtext = "\x82" "get 50 rings, then";
- const char *tut1text = "\x82" "press " "\x80" "shield";
- const char *tut2text = "\x82" "to transform";
+ const char *ringtext = "\x82" "50 rings, no shield";
+ const char *tut1text = "\x82" "press " "\x80" "spin";
+ const char *tut2text = "\x82" "mid-" "\x80" "jump";
ttheight = 8;
V_DrawLevelTitle(data.spec.passedx1 + xoffset1, ttheight, 0, data.spec.passed1);
ttheight += V_LevelNameHeight(data.spec.passed3) + 2;
@@ -849,7 +850,7 @@ void Y_IntermissionDrawer(void)
{
UINT8 *colormap = R_GetTranslationColormap(*data.match.character[i], *data.match.color[i], GTC_CACHE);
- if (*data.match.color[i] == SKINCOLOR_RED) //red
+ if (data.match.ctfteam[i] == 1) //red
{
if (redplayers++ > 9)
continue;
@@ -857,7 +858,7 @@ void Y_IntermissionDrawer(void)
y = (redplayers * 16) + 32;
V_DrawCenteredString(x+6, y, 0, va("%d", redplayers));
}
- else if (*data.match.color[i] == SKINCOLOR_BLUE) //blue
+ else if (data.match.ctfteam[i] == 2) //blue
{
if (blueplayers++ > 9)
continue;
@@ -1129,7 +1130,7 @@ void Y_Ticker(void)
else if (mapheaderinfo[gamemap-1]->musintername[0] && S_MusicExists(mapheaderinfo[gamemap-1]->musintername, !midi_disabled, !digital_disabled))
S_ChangeMusicInternal(mapheaderinfo[gamemap-1]->musintername, false); // don't loop it
else
- S_ChangeMusicInternal("_clear", false); // don't loop it
+ S_ChangeMusicInternal(stagefailed ? "CHFAIL" : "CHPASS", false); // don't loop it
tallydonetic = -1;
}
@@ -1622,6 +1623,7 @@ static void Y_CalculateMatchWinners(void)
boolean completed[MAXPLAYERS];
// Initialize variables
+ memset(data.match.ctfteam, 0, sizeof (data.match.ctfteam));
memset(data.match.scores, 0, sizeof (data.match.scores));
memset(data.match.color, 0, sizeof (data.match.color));
memset(data.match.character, 0, sizeof (data.match.character));
@@ -1642,8 +1644,15 @@ static void Y_CalculateMatchWinners(void)
if (players[i].score >= data.match.scores[data.match.numplayers] && completed[i] == false)
{
+ data.match.ctfteam[data.match.numplayers] = players[i].ctfteam;
data.match.scores[data.match.numplayers] = players[i].score;
data.match.color[data.match.numplayers] = &players[i].skincolor;
+ if (data.match.ctfteam[data.match.numplayers] == 1) // red team
+ data.match.color[data.match.numplayers] = &skincolor_redteam;
+
+ if (data.match.ctfteam[data.match.numplayers] == 2) // blue team
+ data.match.color[data.match.numplayers] = &skincolor_blueteam;
+
data.match.character[data.match.numplayers] = &players[i].skin;
data.match.name[data.match.numplayers] = player_names[i];
data.match.spectator[data.match.numplayers] = players[i].spectator;
@@ -2065,7 +2074,7 @@ static void Y_AwardCoopBonuses(void)
(bonuses_list[bonusnum][j])(&players[i], &localbonuses[j]);
else
Y_SetNullBonus(&players[i], &localbonuses[j]);
-
+
players[i].score += localbonuses[j].points;
if (players[i].score > MAXSCORE)
players[i].score = MAXSCORE;
diff --git a/src/z_zone.c b/src/z_zone.c
index 5750f8ae016becd9c9548b690b0e7fd5b32ec7cb..0852fabaeac03f3751d33063cb14f63105678537 100644
--- a/src/z_zone.c
+++ b/src/z_zone.c
@@ -671,6 +671,7 @@ static void Command_Memfree_f(void)
CONS_Printf(M_GetText("Cached textures : %7s KB\n"), sizeu1(Z_TagUsage(PU_HWRCACHE)>>10));
CONS_Printf(M_GetText("Texture colormaps : %7s KB\n"), sizeu1(Z_TagUsage(PU_HWRPATCHCOLMIPMAP)>>10));
CONS_Printf(M_GetText("Model textures : %7s KB\n"), sizeu1(Z_TagUsage(PU_HWRMODELTEXTURE)>>10));
+ CONS_Printf(M_GetText("Light table textures : %7s KB\n"), sizeu1(Z_TagUsage(PU_HWRLIGHTTABLEDATA)>>10));
CONS_Printf(M_GetText("Plane polygons : %7s KB\n"), sizeu1(Z_TagUsage(PU_HWRPLANE)>>10));
CONS_Printf(M_GetText("All GPU textures : %7d KB\n"), HWR_GetTextureUsed()>>10);
}
diff --git a/src/z_zone.h b/src/z_zone.h
index ce7af4a159555e3a6c2be83e8d0eadcf8a7a69eb..56c540c3bb31a4a84e5f2403519455f3830583ee 100644
--- a/src/z_zone.h
+++ b/src/z_zone.h
@@ -55,6 +55,7 @@ enum
PU_HWRPATCHINFO = 21, // Hardware GLPatch_t struct for OpenGL texture cache
PU_HWRPATCHCOLMIPMAP = 22, // Hardware GLMipmap_t struct colormap variation of patch
PU_HWRMODELTEXTURE = 23, // Hardware model texture
+ PU_HWRLIGHTTABLEDATA = 24, // Hardware light table data
PU_HWRCACHE = 48, // static until unlocked
PU_CACHE = 49, // static until unlocked
diff --git a/thirdparty/curl.cmake b/thirdparty/curl.cmake
index 5c3aa26e35882d64ca8a6cf99517d28e9fc56dcc..7b6c3a299f951139fe18e0c25d18074d0deae300 100644
--- a/thirdparty/curl.cmake
+++ b/thirdparty/curl.cmake
@@ -55,4 +55,3 @@ else()
endif()
FetchContent_MakeAvailable(curl)
-
diff --git a/thirdparty/sdl2-mixer-ext.cmake b/thirdparty/sdl2-mixer-ext.cmake
index a52b11584ae747630ed4c44af6282fb8cc9dea75..1998a7bd9217c2bdfd9da5f1b5de544e48cd6c5d 100644
--- a/thirdparty/sdl2-mixer-ext.cmake
+++ b/thirdparty/sdl2-mixer-ext.cmake
@@ -36,4 +36,3 @@ FetchContent_Declare(
)
FetchContent_MakeAvailable(SDL2_mixer_ext)
-
diff --git a/thirdparty/zlib.cmake b/thirdparty/zlib.cmake
index 257609f775ae9f7c325665198f0e8804a5cb6030..50c567dda9e664632c709fc374276c401ee59203 100644
--- a/thirdparty/zlib.cmake
+++ b/thirdparty/zlib.cmake
@@ -33,4 +33,3 @@ FetchContent_MakeAvailable(ZLIB)
add_library(ZLIB::ZLIB ALIAS zlibstatic)
set(ZLIB_INCLUDE_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/zlib" "${zlib_BINARY_DIR}" CACHE PATH "" FORCE)
-