diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index b21ce1b00313089705addb772b455a8308d21795..29f5ef5fff9f1bc4afb83006c65f54088762e6dc 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -1,848 +1,19 @@
-variables:
- GIT_STRATEGY: clone
- GIT_CLONE_PATH: $CI_BUILDS_DIR/$CI_CONCURRENT_ID/$CI_PROJECT_PATH
-
-default:
- image: git.do.srb2.org:5050/stjr/srb2ci/srb2ci:stable
-
- cache:
- - key: ccache-$CI_PROJECT_PATH_SLUG-$CI_JOB_NAME_SLUG
- fallback_keys:
- - cache-$CI_PROJECT_PATH_SLUG-$CI_DEFAULT_BRANCH
- - cache-$CI_PROJECT_PATH_SLUG-default
- paths:
- - ccache
- - ccache_statslog
-
- - key: apt-$CI_JOB_IMAGE
- paths:
- - apt-cache
- unprotect: true
-
- - key: apk-$CI_JOB_IMAGE
- paths:
- - apk-cache
- unprotect: true
-
- before_script:
- - - |
- # debconf
- echo -e "\e[0Ksection_start:`date +%s`:debconf[collapsed=true]\r\e[0KSetup debconf's environment"
- - export DEBIAN_FRONTEND="noninteractive"
- - export DEBIAN_PRIORITY="low"
- - export DEBCONF_NONINTERACTIVE_SEEN="true"
- - |
- # debconf
- echo -e "\e[0Ksection_end:`date +%s`:debconf\r\e[0K"
- - - |
- # dpkg_aa
- echo -e "\e[0Ksection_start:`date +%s`:dpkg_aa[collapsed=true]\r\e[0KAdding architectures to dpkg"
- - dpkg --add-architecture i386
- - dpkg --add-architecture amd64
- - dpkg --add-architecture arm64
- - |
- # dpkg_aa
- echo -e "\e[0Ksection_end:`date +%s`:dpkg_aa\r\e[0K"
- - - |
- # apt_conf
- echo -e "\e[0Ksection_start:`date +%s`:apt_conf[collapsed=true]\r\e[0KSetting up APT conf"
- - export APT_CACHE_DIR=`pwd`/apt-cache
- - mkdir --parents --verbose $APT_CACHE_DIR/partial/
- - touch /etc/apt/apt.conf.d/99build
- - |
- # apt.conf
- echo Adding options to apt.conf':'
- - |
- # APT::Install-Recommends
- echo APT::Install-Recommends "false"\; | tee --append /etc/apt/apt.conf.d/99build
- - |
- # quit
- echo quiet "1"\; | tee --append /etc/apt/apt.conf.d/99build
- - |
- # APT::Get::Assume-Yes
- echo APT::Get::Assume-Yes "true"\; | tee --append /etc/apt/apt.conf.d/99build
- - |
- # Dir::Cache::Archives
- echo Dir::Cache::Archives "$APT_CACHE_DIR"\; | tee --append /etc/apt/apt.conf.d/99build
- - |
- # apt_conf
- echo -e "\e[0Ksection_end:`date +%s`:apt_conf\r\e[0K"
- - - |
- # apt_update
- echo -e "\e[0Ksection_start:`date +%s`:apt_update[collapsed=true]\r\e[0KUpdating APT listing"
- - apt-get update
- - |
- # apt_update
- echo -e "\e[0Ksection_end:`date +%s`:apt_update\r\e[0K"
-
- - - |
- # apt_pre
- echo -e "\e[0Ksection_start:`date +%s`:apt_pre[collapsed=true]\r\e[0KInstalling pre packages"
- - apt-get install apt-utils
- - |
- # apt_pre
- echo -e "\e[0Ksection_end:`date +%s`:apt_pre\r\e[0K"
-
- - - |
- # apt_upgrade
- echo -e "\e[0Ksection_start:`date +%s`:apt_upgrade[collapsed=true]\r\e[0KUpdating existing packages"
- - apt-get upgrade
- - |
- # apt_update
- echo -e "\e[0Ksection_end:`date +%s`:apt_upgrade\r\e[0K"
+include:
+ - '.gitlab/ci/templates/*.yml'
+ - '.gitlab/ci/jobs/*.yml'
- - - |
- # apt_common
- echo -e "\e[0Ksection_start:`date +%s`:apt_common[collapsed=true]\r\e[0KInstalling common packages"
- - apt-get install make git ccache nasm cmake ca-certificates
- - |
- # apt_common
- echo -e "\e[0Ksection_end:`date +%s`:apt_common\r\e[0K"
+workflow:
+ auto_cancel:
+ on_new_commit: interruptible
- - - |
- # 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 --append ~/.ccache/ccache.conf
- - |
- # cache_dir
- echo cache_dir = $PWD/ccache | tee --append ~/.ccache/ccache.conf
- - |
- # compiler_check
- echo compiler_check = content | tee --append ~/.ccache/ccache.conf
- - |
- # stats_log
- echo stats_log = $PWD/ccache_statslog | tee --append ~/.ccache/ccache.conf
- - |
- # max_size
- echo max_size = 50M | tee --append ~/.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"
-
- artifacts:
- paths:
- - "bin/"
- - "src/comptime.h"
- name: "$CI_PROJECT_PATH_SLUG-$CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA-$CI_JOB_NAME_SLUG"
-
- 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"
-
- - - |
- # 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"
+variables:
+ GIT_CLONE_PATH: $CI_BUILDS_DIR/$CI_CONCURRENT_ID/$CI_PROJECT_PATH
+ GIT_DEPTH: 20
stages:
- build
-Debian testing GCC:
- stage: build
-
- when: manual
-
- image: debian:testing-slim
-
- allow_failure: true
-
- artifacts:
- paths:
- - "bin/"
- - "src/comptime.h"
- expose_as: "testing-gcc"
- name: "$CI_PROJECT_PATH_SLUG-$CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA-testing-gcc"
-
- variables:
- CC: gcc
- 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_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"
-
-Windows x86:
- stage: build
-
- when: on_success
-
- artifacts:
- paths:
- - "bin/"
- - "src/comptime.h"
- expose_as: "Win32"
- name: "$CI_PROJECT_PATH_SLUG-$CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA-Win32"
-
- variables:
- PREFIX: i686-w64-mingw32
-
- script:
- - - |
- # 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_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"
-
-Debian stable:amd64:
- stage: build
-
- when: on_success
-
- artifacts:
- paths:
- - "bin/"
- - "src/comptime.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
- 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
-
- script:
- - - |
- # 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_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"
-
-Debian oldstable:amd64:
- extends: Debian stable:amd64
-
- 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"
- name: "$CI_PROJECT_PATH_SLUG-$CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA-old-x86-64"
-
- script:
- - - |
- # 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_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"
-
-Debian stable:i386:
- stage: build
-
- when: manual
-
- artifacts:
- paths:
- - "bin/"
- - "src/comptime.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
- OBJCOPY: i686-linux-gnu-objcopy
- OBJDUMP: i686-linux-gnu-objdump
- 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_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"
-
-Debian stable:arm64:
- stage: build
-
- when: manual
-
- artifacts:
- paths:
- - "bin/"
- - "src/comptime.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
- LDFLAGS: -Wl,-fuse-ld=gold
- OBJCOPY: aarch64-linux-gnu-objcopy
- OBJDUMP: aarch64-linux-gnu-objdump
- 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_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"
-
-Debian oldstable:arm64:
- extends: Debian stable:arm64
-
- 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"
- name: "$CI_PROJECT_PATH_SLUG-$CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA-old-aarch64"
-
- 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_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"
-
-batocera:arm64:
- extends: Debian stable:arm64
-
- when: manual
-
- allow_failure: true
-
- artifacts:
- paths:
- - "bin/"
- - "src/comptime.h"
- expose_as: "Debian old arm64"
- name: "$CI_PROJECT_PATH_SLUG-$CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA-batocera-aarch64"
-
- 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_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"
-
-Windows x64:
- stage: build
-
- when: manual
-
- artifacts:
- paths:
- - "bin/"
- - "src/comptime.h"
- expose_as: "Win64"
- name: "$CI_PROJECT_PATH_SLUG-$CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA-Win64"
-
- 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 gcc-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"
-
-Debian stable Clang:
- stage: build
-
- when: on_success
-
- allow_failure: false
-
- artifacts:
- paths:
- - "build.clang/bin/"
- - "build.clang/src/config.h"
- expose_as: "clang"
- name: "$CI_PROJECT_PATH_SLUG-$CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA-clang"
-
- variables:
- CC: clang
- CXX: clang
- WFLAGS: -Wno-cast-align -Wno-implicit-const-int-float-conversion -Werror
- CFLAGS: -Wno-cast-align -Wno-implicit-const-int-float-conversion -Werror
- 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 clang
- - |
- # 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"
-
- - - |
- # 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
- 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=build.clang --keep-going || make --directory=build.clang --keep-going
- - |
- # make
- echo -e "\e[0Ksection_end:`date +%s`:make\r\e[0K"
-
-Debian testing Clang:
- extends: Debian stable Clang
-
- when: manual
-
- allow_failure: true
-
- image: debian:testing-slim
-
- artifacts:
- paths:
- - "build.clang/bin/"
- - "build.clang/src/config.h"
- expose_as: "testing-clang"
- name: "$CI_PROJECT_PATH_SLUG-$CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA-testing-clang"
-
- variables:
- CC: clang
- CXX: clang
- WFLAGS: -Wno-cast-align -Wno-implicit-const-int-float-conversion -Werror -Wno-deprecated-non-prototype -Wno-single-bit-bitfield-constant-conversion
- CFLAGS: -Wno-cast-align -Wno-implicit-const-int-float-conversion -Werror -Wno-deprecated-non-prototype -Wno-single-bit-bitfield-constant-conversion
- LDFLAGS: -Wl,-fuse-ld=gold
-
-Alpine 3 GCC:
- stage: build
-
- when: on_success
-
- image: alpine:3
-
- allow_failure: true
-
- artifacts:
- paths:
- - "bin/"
- - "src/comptime.h"
- expose_as: "Apline-3"
- name: "$CI_PROJECT_PATH_SLUG-$CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA-Apline-3"
-
- 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 gcc
- - |
- # 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 musl-dev sdl2_mixer-dev libpng-dev curl-dev libgme-dev libopenmpt-dev miniupnpc-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"
-
-Alpine 3 GCC Dedicated:
- extends: Alpine 3 GCC
-
- 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"
-
- script:
- - - |
- # apk_toolchain
- echo -e "\e[0Ksection_start:`date +%s`:apk_toolchain[collapsed=true]\r\e[0KInstalling toolchain packages"
- - apk add gcc
- - |
- # 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 musl-dev libpng-dev curl-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 DEDICATED=1 || make --directory=src --keep-going CCACHE=1 ERRORMODE=1 NONX86=1 NOEXECINFO=1 DEDICATED=1
- - |
- # make
- echo -e "\e[0Ksection_end:`date +%s`:make\r\e[0K"
-
-osxcross x86_64:
- stage: build
-
- artifacts:
- paths:
- - "build.osxcross/bin/"
- - "build.osxcross/src/config.h"
- expose_as: "Mac x86_64"
- name: "$CI_PROJECT_PATH_SLUG-$CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA-clang"
-
- variables:
- OSXCROSS_HOST: x86_64-apple-darwin21.4
- LD: x86_64-apple-darwin21.4-ld
-
- script:
- - - |
- # 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
- - |
- # apt_development
- echo -e "\e[0Ksection_end:`date +%s`:macports_development\r\e[0K"
-
- - - |
- # make
- echo -e "\e[0Ksection_start:`date +%s`:make[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"
- - |
- # make
- echo -e "\e[0Ksection_end:`date +%s`:make\r\e[0K"
-
- - - |
- # 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
- - |
- # make
- echo -e "\e[0Ksection_end:`date +%s`:make\r\e[0K"
-
-osxcross arm64:
- stage: build
-
- when: manual
-
- allow_failure: true
-
+default:
+ interruptible: true
artifacts:
- paths:
- - "build.osxcross/bin/"
- - "build.osxcross/src/config.h"
- expose_as: "Mac arm64"
- name: "$CI_PROJECT_PATH_SLUG-$CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA-clang"
-
- variables:
- OSXCROSS_HOST: arm64-apple-darwin21.4
- LD: arm64-apple-darwin21.4-ld
-
- script:
- - - |
- # 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
- - |
- # apt_development
- echo -e "\e[0Ksection_end:`date +%s`:macports_development\r\e[0K"
-
- - - |
- # make
- echo -e "\e[0Ksection_start:`date +%s`:make[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"
- - |
- # make
- echo -e "\e[0Ksection_end:`date +%s`:make\r\e[0K"
-
- - - |
- # 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
- - |
- # make
- echo -e "\e[0Ksection_end:`date +%s`:make\r\e[0K"
+ expire_in: 1 day
diff --git a/.gitlab/ci/jobs/alpine-3-gcc-dedicated.yml b/.gitlab/ci/jobs/alpine-3-gcc-dedicated.yml
new file mode 100644
index 0000000000000000000000000000000000000000..242ddd0eaa3f0e45504fa0fe258e08c63e0845df
--- /dev/null
+++ b/.gitlab/ci/jobs/alpine-3-gcc-dedicated.yml
@@ -0,0 +1,34 @@
+Alpine 3 GCC Dedicated:
+ extends: Alpine 3 GCC
+
+ 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"
+
+ script:
+ - - |
+ # apk_toolchain
+ echo -e "\e[0Ksection_start:`date +%s`:apk_toolchain[collapsed=true]\r\e[0KInstalling toolchain packages"
+ - apk add gcc
+ - |
+ # 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 musl-dev libpng-dev curl-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 DEDICATED=1 || make --directory=src --keep-going CCACHE=1 ERRORMODE=1 NONX86=1 NOEXECINFO=1 DEDICATED=1
+ - |
+ # make
+ echo -e "\e[0Ksection_end:`date +%s`:make\r\e[0K"
diff --git a/.gitlab/ci/jobs/alpine-3-gcc.yml b/.gitlab/ci/jobs/alpine-3-gcc.yml
new file mode 100644
index 0000000000000000000000000000000000000000..b3b12e40167a568e3ced2abc7a09ed0045e0cc99
--- /dev/null
+++ b/.gitlab/ci/jobs/alpine-3-gcc.yml
@@ -0,0 +1,135 @@
+Alpine 3 GCC:
+ stage: build
+
+ when: manual
+
+ image: alpine:3
+
+ allow_failure: true
+
+ cache:
+ - key: apk-$CI_JOB_IMAGE
+ paths:
+ - apk-cache
+ unprotect: true
+
+ artifacts:
+ paths:
+ - "bin/"
+ - "src/comptime.h"
+ expose_as: "Apline-3"
+ name: "$CI_PROJECT_PATH_SLUG-$CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA-Apline-3"
+
+ 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 gcc
+ - |
+ # 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 musl-dev sdl2_mixer-dev libpng-dev curl-dev libgme-dev libopenmpt-dev miniupnpc-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/batocera-arm64.yml b/.gitlab/ci/jobs/batocera-arm64.yml
new file mode 100644
index 0000000000000000000000000000000000000000..3e43aa8753a0a1500abdc52e9f594863bd4b3691
--- /dev/null
+++ b/.gitlab/ci/jobs/batocera-arm64.yml
@@ -0,0 +1,38 @@
+batocera:arm64:
+ extends: Debian stable:arm64
+
+ when: manual
+
+ allow_failure: true
+
+ artifacts:
+ paths:
+ - "bin/"
+ - "src/comptime.h"
+ expose_as: "Debian old arm64"
+ name: "$CI_PROJECT_PATH_SLUG-$CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA-batocera-aarch64"
+
+ 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_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-amd64.yml b/.gitlab/ci/jobs/debian-oldstable-amd64.yml
new file mode 100644
index 0000000000000000000000000000000000000000..3929ecdcd10f8f448072d2c859de6a7dd31d94c7
--- /dev/null
+++ b/.gitlab/ci/jobs/debian-oldstable-amd64.yml
@@ -0,0 +1,40 @@
+Debian oldstable:amd64:
+ extends: Debian stable:amd64
+
+ 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"
+ name: "$CI_PROJECT_PATH_SLUG-$CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA-old-x86-64"
+
+ script:
+ - - |
+ # 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_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-arm64.yml b/.gitlab/ci/jobs/debian-oldstable-arm64.yml
new file mode 100644
index 0000000000000000000000000000000000000000..b18d538cd0824041650f3f8a5361b7b07c85f206
--- /dev/null
+++ b/.gitlab/ci/jobs/debian-oldstable-arm64.yml
@@ -0,0 +1,40 @@
+Debian oldstable:arm64:
+ extends: Debian stable:arm64
+
+ 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"
+ name: "$CI_PROJECT_PATH_SLUG-$CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA-old-aarch64"
+
+ 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_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-stable-amd64.yml b/.gitlab/ci/jobs/debian-stable-amd64.yml
new file mode 100644
index 0000000000000000000000000000000000000000..4a757afe0d519f268bb4541cda49ba03a3181600
--- /dev/null
+++ b/.gitlab/ci/jobs/debian-stable-amd64.yml
@@ -0,0 +1,45 @@
+Debian stable:amd64:
+ extends: .srb2ci
+
+ stage: build
+
+ artifacts:
+ paths:
+ - "bin/"
+ - "src/comptime.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
+ 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 gcc-x86-64-linux-gnu || apt-get install gcc
+ - |
+ # 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-arm64.yml b/.gitlab/ci/jobs/debian-stable-arm64.yml
new file mode 100644
index 0000000000000000000000000000000000000000..879391affebe7586e019e7bb7f8d77a0599983e2
--- /dev/null
+++ b/.gitlab/ci/jobs/debian-stable-arm64.yml
@@ -0,0 +1,45 @@
+Debian stable:arm64:
+ extends: .srb2ci
+
+ stage: build
+
+ when: manual
+
+ artifacts:
+ paths:
+ - "bin/"
+ - "src/comptime.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
+ LDFLAGS: -Wl,-fuse-ld=gold
+ OBJCOPY: aarch64-linux-gnu-objcopy
+ OBJDUMP: aarch64-linux-gnu-objdump
+ 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_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-clang-amd64.yml b/.gitlab/ci/jobs/debian-stable-clang-amd64.yml
new file mode 100644
index 0000000000000000000000000000000000000000..4686c1849196d3be6cbee936c1ad910c0f93627c
--- /dev/null
+++ b/.gitlab/ci/jobs/debian-stable-clang-amd64.yml
@@ -0,0 +1,55 @@
+Debian stable Clang:
+ extends: .srb2ci
+
+ stage: build
+
+ when: on_success
+
+ allow_failure: false
+
+ artifacts:
+ paths:
+ - "build.clang/bin/"
+ - "build.clang/src/config.h"
+ expose_as: "clang"
+ name: "$CI_PROJECT_PATH_SLUG-$CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA-clang"
+
+ variables:
+ CC: clang
+ CXX: clang
+ WFLAGS: -Wno-cast-align -Wno-implicit-const-int-float-conversion -Werror
+ CFLAGS: -Wno-cast-align -Wno-implicit-const-int-float-conversion -Werror
+ 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 clang
+ - |
+ # 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"
+
+ - - |
+ # 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
+ 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=build.clang --keep-going || make --directory=build.clang --keep-going
+ - |
+ # 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
new file mode 100644
index 0000000000000000000000000000000000000000..cd6206e55e9a497d7065d3ea652c1ed3c6bd8d23
--- /dev/null
+++ b/.gitlab/ci/jobs/debian-stable-i386.yml
@@ -0,0 +1,44 @@
+Debian stable:i386:
+ extends: .srb2ci
+
+ stage: build
+
+ when: manual
+
+ artifacts:
+ paths:
+ - "bin/"
+ - "src/comptime.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
+ OBJCOPY: i686-linux-gnu-objcopy
+ OBJDUMP: i686-linux-gnu-objdump
+ 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_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-testing-clang-amd64.yml b/.gitlab/ci/jobs/debian-testing-clang-amd64.yml
new file mode 100644
index 0000000000000000000000000000000000000000..dc790b397f2187b47a75c05bcf3e5973d5a175e1
--- /dev/null
+++ b/.gitlab/ci/jobs/debian-testing-clang-amd64.yml
@@ -0,0 +1,22 @@
+Debian testing Clang:
+ extends: Debian stable Clang
+
+ when: manual
+
+ allow_failure: true
+
+ image: debian:testing-slim
+
+ artifacts:
+ paths:
+ - "build.clang/bin/"
+ - "build.clang/src/config.h"
+ expose_as: "testing-clang"
+ name: "$CI_PROJECT_PATH_SLUG-$CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA-testing-clang"
+
+ variables:
+ CC: clang
+ CXX: clang
+ WFLAGS: -Wno-cast-align -Wno-implicit-const-int-float-conversion -Werror -Wno-deprecated-non-prototype -Wno-single-bit-bitfield-constant-conversion
+ CFLAGS: -Wno-cast-align -Wno-implicit-const-int-float-conversion -Werror -Wno-deprecated-non-prototype -Wno-single-bit-bitfield-constant-conversion
+ LDFLAGS: -Wl,-fuse-ld=gold
diff --git a/.gitlab/ci/jobs/debian-testing-gcc-amd64.yml b/.gitlab/ci/jobs/debian-testing-gcc-amd64.yml
new file mode 100644
index 0000000000000000000000000000000000000000..10799b3053e45a3d98fcfa1f63281e36ebadae9d
--- /dev/null
+++ b/.gitlab/ci/jobs/debian-testing-gcc-amd64.yml
@@ -0,0 +1,46 @@
+Debian testing GCC:
+ extends: .srb2ci
+
+ stage: build
+
+ when: manual
+
+ image: debian:testing-slim
+
+ allow_failure: true
+
+ artifacts:
+ paths:
+ - "bin/"
+ - "src/comptime.h"
+ expose_as: "testing-gcc"
+ name: "$CI_PROJECT_PATH_SLUG-$CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA-testing-gcc"
+
+ variables:
+ CC: gcc
+ 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_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/macos-arm64.yml b/.gitlab/ci/jobs/macos-arm64.yml
new file mode 100644
index 0000000000000000000000000000000000000000..3928413610a048460dfe05d0dfc8f92e9da76848
--- /dev/null
+++ b/.gitlab/ci/jobs/macos-arm64.yml
@@ -0,0 +1,44 @@
+osxcross arm64:
+ extends: .srb2ci
+
+ stage: build
+
+ when: manual
+
+ allow_failure: true
+
+ artifacts:
+ paths:
+ - "build.osxcross/bin/"
+ - "build.osxcross/src/config.h"
+ expose_as: "Mac arm64"
+ name: "$CI_PROJECT_PATH_SLUG-$CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA-clang"
+
+ variables:
+ OSXCROSS_HOST: arm64-apple-darwin21.4
+ LD: arm64-apple-darwin21.4-ld
+
+ script:
+ - - |
+ # 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
+ - |
+ # apt_development
+ echo -e "\e[0Ksection_end:`date +%s`:macports_development\r\e[0K"
+
+ - - |
+ # 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"
+ - |
+ # make
+ echo -e "\e[0Ksection_end:`date +%s`:make\r\e[0K"
+
+ - - |
+ # 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
+ - |
+ # make
+ echo -e "\e[0Ksection_end:`date +%s`:make\r\e[0K"
diff --git a/.gitlab/ci/jobs/macos-x86_64.yml b/.gitlab/ci/jobs/macos-x86_64.yml
new file mode 100644
index 0000000000000000000000000000000000000000..818028e49a43624f3e29a357d7d7614ef4dd5118
--- /dev/null
+++ b/.gitlab/ci/jobs/macos-x86_64.yml
@@ -0,0 +1,40 @@
+osxcross x86_64:
+ extends: .srb2ci
+
+ stage: build
+
+ artifacts:
+ paths:
+ - "build.osxcross/bin/"
+ - "build.osxcross/src/config.h"
+ expose_as: "Mac x86_64"
+ name: "$CI_PROJECT_PATH_SLUG-$CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA-clang"
+
+ variables:
+ OSXCROSS_HOST: x86_64-apple-darwin21.4
+ LD: x86_64-apple-darwin21.4-ld
+
+ script:
+ - - |
+ # 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
+ - |
+ # apt_development
+ echo -e "\e[0Ksection_end:`date +%s`:macports_development\r\e[0K"
+
+ - - |
+ # 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"
+ - |
+ # make
+ echo -e "\e[0Ksection_end:`date +%s`:make\r\e[0K"
+
+ - - |
+ # 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
+ - |
+ # 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
new file mode 100644
index 0000000000000000000000000000000000000000..da8d960bd1330229a2265ed9b015a487f1040e75
--- /dev/null
+++ b/.gitlab/ci/jobs/windows-x64.yml
@@ -0,0 +1,35 @@
+Windows x64:
+ extends: .srb2ci
+
+ stage: build
+
+ when: manual
+
+ allow_failure: true
+
+ artifacts:
+ paths:
+ - "bin/"
+ - "src/comptime.h"
+ expose_as: "Win64"
+ name: "$CI_PROJECT_PATH_SLUG-$CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA-Win64"
+
+ 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 gcc-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-x86.yml b/.gitlab/ci/jobs/windows-x86.yml
new file mode 100644
index 0000000000000000000000000000000000000000..311c767bbd9cd31d1063a248f68c0a6793dd47d5
--- /dev/null
+++ b/.gitlab/ci/jobs/windows-x86.yml
@@ -0,0 +1,35 @@
+Windows x86:
+ extends: .srb2ci
+
+ stage: build
+
+ when: on_success
+
+ artifacts:
+ paths:
+ - "bin/"
+ - "src/comptime.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
+
+ script:
+ - - |
+ # 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_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/templates/srb2ci.yml b/.gitlab/ci/templates/srb2ci.yml
new file mode 100644
index 0000000000000000000000000000000000000000..3716d9df921407cb29081af301a5b6a3d92db459
--- /dev/null
+++ b/.gitlab/ci/templates/srb2ci.yml
@@ -0,0 +1,145 @@
+.srb2ci:
+ image: git.do.srb2.org:5050/stjr/srb2ci/srb2ci:stable
+
+ 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
+
+ before_script:
+ - - |
+ # debconf
+ echo -e "\e[0Ksection_start:`date +%s`:debconf[collapsed=true]\r\e[0KSetup debconf's environment"
+ - export DEBIAN_FRONTEND="noninteractive"
+ - export DEBIAN_PRIORITY="low"
+ - export DEBCONF_NONINTERACTIVE_SEEN="true"
+ - |
+ # debconf
+ echo -e "\e[0Ksection_end:`date +%s`:debconf\r\e[0K"
+ - - |
+ # dpkg_aa
+ echo -e "\e[0Ksection_start:`date +%s`:dpkg_aa[collapsed=true]\r\e[0KAdding architectures to dpkg"
+ - dpkg --add-architecture i386
+ - dpkg --add-architecture amd64
+ - dpkg --add-architecture arm64
+ - |
+ # dpkg_aa
+ echo -e "\e[0Ksection_end:`date +%s`:dpkg_aa\r\e[0K"
+ - - |
+ # apt_conf
+ echo -e "\e[0Ksection_start:`date +%s`:apt_conf[collapsed=true]\r\e[0KSetting up APT conf"
+ - export APT_CACHE_DIR=$CI_PROJECT_DIR/build/apt-cache
+ - mkdir --parents --verbose $APT_CACHE_DIR/partial/
+ - touch /etc/apt/apt.conf.d/99build
+ - |
+ # apt.conf
+ echo Adding options to apt.conf':'
+ - |
+ # APT::Install-Recommends
+ echo APT::Install-Recommends "false"\; | tee --append /etc/apt/apt.conf.d/99build
+ - |
+ # quit
+ echo quiet "1"\; | tee --append /etc/apt/apt.conf.d/99build
+ - |
+ # APT::Get::Assume-Yes
+ echo APT::Get::Assume-Yes "true"\; | tee --append /etc/apt/apt.conf.d/99build
+ - |
+ # Dir::Cache::Archives
+ echo Dir::Cache::Archives "$APT_CACHE_DIR"\; | tee --append /etc/apt/apt.conf.d/99build
+ - |
+ # apt_conf
+ echo -e "\e[0Ksection_end:`date +%s`:apt_conf\r\e[0K"
+ - - |
+ # apt_update
+ echo -e "\e[0Ksection_start:`date +%s`:apt_update[collapsed=true]\r\e[0KUpdating APT listing"
+ - apt-get update
+ - |
+ # apt_update
+ echo -e "\e[0Ksection_end:`date +%s`:apt_update\r\e[0K"
+
+ - - |
+ # apt_pre
+ echo -e "\e[0Ksection_start:`date +%s`:apt_pre[collapsed=true]\r\e[0KInstalling pre packages"
+ - apt-get install apt-utils
+ - |
+ # apt_pre
+ echo -e "\e[0Ksection_end:`date +%s`:apt_pre\r\e[0K"
+
+ - - |
+ # apt_upgrade
+ echo -e "\e[0Ksection_start:`date +%s`:apt_upgrade[collapsed=true]\r\e[0KUpdating existing packages"
+ - apt-get upgrade
+ - |
+ # apt_update
+ echo -e "\e[0Ksection_end:`date +%s`:apt_upgrade\r\e[0K"
+
+ - - |
+ # apt_common
+ echo -e "\e[0Ksection_start:`date +%s`:apt_common[collapsed=true]\r\e[0KInstalling common packages"
+ - apt-get install make git ccache nasm cmake ca-certificates
+ - |
+ # apt_common
+ echo -e "\e[0Ksection_end:`date +%s`:apt_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 = $CI_PROJECT_DIR | tee --append ~/.ccache/ccache.conf
+ - |
+ # cache_dir
+ echo cache_dir = $CI_PROJECT_DIR/build/ccache | tee --append ~/.ccache/ccache.conf
+ - |
+ # compiler_check
+ echo compiler_check = content | tee --append ~/.ccache/ccache.conf
+ - |
+ # stats_log
+ echo stats_log = $CI_PROJECT_DIR/build/ccache_statslog | tee --append ~/.ccache/ccache.conf
+ - |
+ # max_size
+ echo max_size = 300M | tee --append ~/.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"
+
+ 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"
+
+ - - |
+ # 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/doc/specs/udmf_srb2.txt b/doc/specs/udmf_srb2.txt
index b25ed1af38ee55b6c2ecf568c824520d800c58e7..eaa3a8a9704439b72569aee0a0c4db956e8d8482 100644
--- a/doc/specs/udmf_srb2.txt
+++ b/doc/specs/udmf_srb2.txt
@@ -1,5 +1,5 @@
===============================================================================
-Universal Doom Map Format Sonic Robo Blast 2 extensions v1.0 19.02.2024
+Universal Doom Map Format Sonic Robo Blast 2 extensions v1.0 19.06.2024
Copyright (c) 2024 Sonic Team Junior
uses Universal Doom Map Format Specification v1.1 as a template,
@@ -126,7 +126,7 @@ Sonic Robo Blast 2 defines the following standardized fields:
texturebottom = <string>; // Lower texture. Default = "-".
texturemiddle = <string>; // Middle texture. Default = "-".
- repeatcnt = <string>; // Number of middle texture repetitions. Default = 0
+ repeatcnt = <integer>; // Number of middle texture repetitions. Default = 0.
sector = <integer>; // Sector index. No valid default.
@@ -143,6 +143,9 @@ Sonic Robo Blast 2 defines the following standardized fields:
offsetx_bottom = <float>; // X offset for lower texture. Default = 0.0.
offsety_bottom = <float>; // Y offset for lower texture. Default = 0.0.
+ light = <integer>; // Light level, relative to 'sector' light level. Default = 0.
+ lightabsolute = <bool>; // true = 'light' is an absolute value, ignoring 'sector' light level.
+
comment = <string>; // A comment. Implementors should attach no special
// semantic meaning to this field.
}
diff --git a/extras/conf/udb/Includes/SRB222_common.cfg b/extras/conf/udb/Includes/SRB222_common.cfg
index aee7a70e4e0a4b806d8c0a055d77f06fce476ea6..e5cafead431c0d79eaaef734eee008eeab89dd15 100644
--- a/extras/conf/udb/Includes/SRB222_common.cfg
+++ b/extras/conf/udb/Includes/SRB222_common.cfg
@@ -39,6 +39,7 @@ common
defaulttexturescale = 1.0f;
defaultflatscale = 1.0f;
scaledtextureoffsets = true;
+ scaledflatoffsets = true;
// Colormap/fade related options
maxcolormapalpha = 25;
@@ -114,7 +115,7 @@ mapformat_udmf
// Enables setting distinct brightness for floor, ceiling, and walls
distinctfloorandceilingbrightness = true;
- distinctwallbrightness = false;
+ distinctwallbrightness = true;
// Enables setting distinct brightness for upper, middle, and lower sidedef parts
distinctsidedefpartbrightness = false;
diff --git a/extras/conf/udb/Includes/SRB222_linedefs.cfg b/extras/conf/udb/Includes/SRB222_linedefs.cfg
index e297f473fd46d2848f3835765988bb913147e84f..fc505fb6025b02782d1a309b247f569a63dd96fd 100644
--- a/extras/conf/udb/Includes/SRB222_linedefs.cfg
+++ b/extras/conf/udb/Includes/SRB222_linedefs.cfg
@@ -7,13 +7,11 @@ udmf
0
{
title = "None";
- prefix = "(0)";
}
6
{
title = "Sector Set Portal";
- prefix = "(6)";
arg0
{
title = "Target sector tag";
@@ -52,7 +50,6 @@ udmf
7
{
title = "Sector Flat Alignment";
- prefix = "(7)";
arg0
{
title = "Target sector tag";
@@ -70,7 +67,6 @@ udmf
10
{
title = "Culling Plane";
- prefix = "(10)";
arg0
{
title = "Target sector tag";
@@ -91,20 +87,17 @@ udmf
40
{
title = "Visual Portal Between Tagged Linedefs";
- prefix = "(40)";
}
41
{
title = "Horizon Effect";
id = "srb2_horizonline";
- prefix = "(41)";
}
63
{
title = "Fake Floor/Ceiling Planes";
- prefix = "(63)";
arg0
{
title = "Target sector tag";
@@ -120,7 +113,6 @@ udmf
2
{
title = "Custom Exit";
- prefix = "(2)";
arg0
{
title = "Next map";
@@ -144,7 +136,6 @@ udmf
3
{
title = "Zoom Tube Parameters";
- prefix = "(3)";
arg0
{
title = "Speed";
@@ -166,7 +157,6 @@ udmf
4
{
title = "Speed Pad Parameters";
- prefix = "(4)";
arg0
{
title = "Speed";
@@ -193,7 +183,6 @@ udmf
8
{
title = "Set Camera Collision Planes";
- prefix = "(8)";
arg0
{
title = "Target sector tag";
@@ -204,7 +193,6 @@ udmf
11
{
title = "Rope Hang Parameters";
- prefix = "(11)";
arg0
{
title = "Speed";
@@ -226,7 +214,6 @@ udmf
14
{
title = "Bustable Block Parameters";
- prefix = "(14)";
arg0
{
title = "Debris spacing";
@@ -252,13 +239,11 @@ udmf
15
{
title = "Fan Particle Generator Heights";
- prefix = "(15)";
}
16
{
title = "Minecart Parameters";
- prefix = "(16)";
arg0
{
title = "Order";
@@ -268,7 +253,6 @@ udmf
64
{
title = "Continuously Appearing/Disappearing FOF";
- prefix = "(64)";
arg0
{
title = "Control linedef tag";
@@ -307,7 +291,6 @@ udmf
20
{
title = "PolyObject First Line";
- prefix = "(20)";
arg0
{
title = "PolyObject tag";
@@ -348,7 +331,6 @@ udmf
30
{
title = "Waving PolyObject Flag";
- prefix = "(30)";
arg0
{
title = "PolyObject tag";
@@ -369,7 +351,6 @@ udmf
31
{
title = "Move PolyObject by Front Sector Displacement";
- prefix = "(31)";
arg0
{
title = "PolyObject tag";
@@ -385,7 +366,6 @@ udmf
32
{
title = "Rotate PolyObject by Front Sector Displacement";
- prefix = "(32)";
arg0
{
title = "PolyObject tag";
@@ -421,7 +401,6 @@ udmf
52
{
title = "Continuously Falling Sector";
- prefix = "(52)";
arg0
{
title = "Speed";
@@ -442,7 +421,6 @@ udmf
53
{
title = "Continuous Plane Mover (Slowdown)";
- prefix = "(53)";
arg0
{
title = "Target sector tag";
@@ -477,7 +455,6 @@ udmf
56
{
title = "Continuous Plane Mover (Constant)";
- prefix = "(56)";
arg0
{
title = "Target sector tag";
@@ -512,7 +489,6 @@ udmf
60
{
title = "Activate Moving Platform";
- prefix = "(60)";
arg0
{
title = "Target sector tag";
@@ -542,7 +518,6 @@ udmf
61
{
title = "Ceiling Crusher";
- prefix = "(61)";
arg0
{
title = "Target sector tag";
@@ -573,7 +548,6 @@ udmf
66
{
title = "Move Planes by Front Sector Displacement";
- prefix = "(66)";
arg0
{
title = "Target sector tag";
@@ -600,7 +574,6 @@ udmf
70
{
title = "Add Raise Thinker";
- prefix = "(70)";
arg0
{
title = "Control linedef tag";
@@ -626,7 +599,6 @@ udmf
71
{
title = "Add Air Bobbing Thinker";
- prefix = "(71)";
arg0
{
title = "Control linedef tag";
@@ -652,7 +624,6 @@ udmf
72
{
title = "Add Thwomp Thinker";
- prefix = "(72)";
arg0
{
title = "Control linedef tag";
@@ -679,7 +650,6 @@ udmf
73
{
title = "Add Laser Thinker";
- prefix = "(73)";
arg0
{
title = "Control linedef tag";
@@ -696,7 +666,6 @@ udmf
74
{
title = "Make FOF Bustable";
- prefix = "(74)";
arg0
{
title = "Control linedef tag";
@@ -735,7 +704,6 @@ udmf
75
{
title = "Make FOF Quicksand";
- prefix = "(75)";
arg0
{
title = "Control linedef tag";
@@ -755,7 +723,6 @@ udmf
76
{
title = "Make FOF Bouncy";
- prefix = "(76)";
arg0
{
title = "Control linedef tag";
@@ -775,7 +742,6 @@ udmf
100
{
title = "Solid";
- prefix = "(100)";
id = "srb2_fofsolid";
arg0
{
@@ -819,7 +785,6 @@ udmf
120
{
title = "Water";
- prefix = "(120)";
id = "srb2_fofwater";
arg0
{
@@ -857,7 +822,6 @@ udmf
150
{
title = "Air Bobbing";
- prefix = "(150)";
id = "srb2_fofsolidopaque";
arg0
{
@@ -884,7 +848,6 @@ udmf
160
{
title = "Water Bobbing";
- prefix = "(160)";
id = "srb2_fofsolidopaque";
arg0
{
@@ -896,7 +859,6 @@ udmf
170
{
title = "Crumbling";
- prefix = "(170)";
id = "srb2_fofcrumbling";
arg0
{
@@ -939,7 +901,6 @@ udmf
190
{
title = "Rising";
- prefix = "(190)";
id = "srb2_fofsolid";
arg0
{
@@ -998,7 +959,6 @@ udmf
200
{
title = "Light Block";
- prefix = "(200)";
id = "srb2_foflight";
arg0
{
@@ -1016,7 +976,6 @@ udmf
202
{
title = "Fog Block";
- prefix = "(202)";
id = "srb2_foffog";
arg0
{
@@ -1028,7 +987,6 @@ udmf
220
{
title = "Intangible";
- prefix = "(220)";
id = "srb2_fofintangible";
arg0
{
@@ -1066,7 +1024,6 @@ udmf
223
{
title = "Intangible, Invisible";
- prefix = "(223)";
id = "srb2_fofintangibleinvisible";
arg0
{
@@ -1078,7 +1035,6 @@ udmf
250
{
title = "Mario Block";
- prefix = "(250)";
id = "srb2_fofsolidopaque";
arg0
{
@@ -1100,7 +1056,6 @@ udmf
251
{
title = "Thwomp Block";
- prefix = "(251)";
id = "srb2_fofsolidopaque";
arg0
{
@@ -1128,7 +1083,6 @@ udmf
254
{
title = "Bustable Block";
- prefix = "(254)";
id = "srb2_fofbustable";
arg0
{
@@ -1181,7 +1135,6 @@ udmf
257
{
title = "Quicksand";
- prefix = "(257)";
id = "srb2_fofsolidopaque";
arg0
{
@@ -1208,7 +1161,6 @@ udmf
258
{
title = "Laser";
- prefix = "(258)";
id = "srb2_foflaser";
arg0
{
@@ -1242,7 +1194,6 @@ udmf
259
{
title = "Custom";
- prefix = "(259)";
id = "srb2_fofcustom";
arg0
{
@@ -1307,7 +1258,6 @@ udmf
300
{
title = "Basic";
- prefix = "(300)";
arg0
{
title = "Trigger type";
@@ -1319,7 +1269,6 @@ udmf
303
{
title = "Ring Count";
- prefix = "(303)";
arg0
{
title = "Trigger type";
@@ -1347,7 +1296,6 @@ udmf
305
{
title = "Character Ability";
- prefix = "(305)";
arg0
{
title = "Trigger type";
@@ -1383,7 +1331,6 @@ udmf
308
{
title = "Gametype";
- prefix = "(308)";
arg0
{
title = "Trigger type";
@@ -1441,7 +1388,6 @@ udmf
309
{
title = "CTF Team";
- prefix = "(309)";
arg0
{
title = "Trigger type";
@@ -1459,7 +1405,6 @@ udmf
313
{
title = "No More Enemies";
- prefix = "(313)";
arg0
{
title = "Target sector tag";
@@ -1470,7 +1415,6 @@ udmf
314
{
title = "Number of Pushables";
- prefix = "(314)";
arg0
{
title = "Trigger type";
@@ -1492,7 +1436,6 @@ udmf
317
{
title = "Condition Set Trigger";
- prefix = "(317)";
arg0
{
title = "Trigger type";
@@ -1508,7 +1451,6 @@ udmf
319
{
title = "Unlockable";
- prefix = "(319)";
arg0
{
title = "Trigger type";
@@ -1524,7 +1466,6 @@ udmf
321
{
title = "Trigger After X Calls";
- prefix = "(321)";
arg0
{
title = "Trigger type";
@@ -1550,7 +1491,6 @@ udmf
323
{
title = "NiGHTSerize";
- prefix = "(323)";
arg0
{
title = "Trigger type";
@@ -1617,7 +1557,6 @@ udmf
325
{
title = "De-NiGHTSerize";
- prefix = "(325)";
arg0
{
title = "Trigger type";
@@ -1680,7 +1619,6 @@ udmf
327
{
title = "NiGHTS Lap";
- prefix = "(327)";
arg0
{
title = "Trigger type";
@@ -1732,7 +1670,6 @@ udmf
329
{
title = "Ideya Capture Touch";
- prefix = "(329)";
arg0
{
title = "Trigger type";
@@ -1800,7 +1737,6 @@ udmf
331
{
title = "Player Skin";
- prefix = "(331)";
arg0
{
title = "Trigger type";
@@ -1823,7 +1759,6 @@ udmf
334
{
title = "Object Dye";
- prefix = "(334)";
arg0
{
title = "Trigger type";
@@ -1846,7 +1781,6 @@ udmf
337
{
title = "Emerald Check";
- prefix = "(337)";
arg0
{
title = "Trigger type";
@@ -1879,7 +1813,6 @@ udmf
340
{
title = "NiGHTS Mare";
- prefix = "(340)";
arg0
{
title = "Trigger type";
@@ -1901,7 +1834,6 @@ udmf
343
{
title = "Gravity Check";
- prefix = "(343)";
arg0
{
title = "Trigger type";
@@ -1924,7 +1856,6 @@ udmf
399
{
title = "Level Load";
- prefix = "(399)";
}
}
@@ -1935,7 +1866,6 @@ udmf
400
{
title = "Set Tagged Sector's Heights/Textures";
- prefix = "(400)";
arg0
{
title = "Target sector tag";
@@ -1958,7 +1888,6 @@ udmf
402
{
title = "Copy Light Level to Tagged Sectors";
- prefix = "(402)";
arg0
{
title = "Target sector tag";
@@ -1980,7 +1909,6 @@ udmf
408
{
title = "Set Tagged Sector's Flats";
- prefix = "(408)";
arg0
{
title = "Target sector tag";
@@ -1997,7 +1925,6 @@ udmf
409
{
title = "Change Tagged Sector's Tag";
- prefix = "(409)";
arg0
{
title = "Target sector tag";
@@ -2025,7 +1952,6 @@ udmf
410
{
title = "Change Front Sector's Tag";
- prefix = "(410)";
arg0
{
title = "Tag";
@@ -2048,7 +1974,6 @@ udmf
416
{
title = "Start Adjustable Flickering Light";
- prefix = "(416)";
arg0
{
title = "Target sector tag";
@@ -2077,7 +2002,6 @@ udmf
417
{
title = "Start Adjustable Pulsating Light";
- prefix = "(417)";
arg0
{
title = "Target sector tag";
@@ -2106,7 +2030,6 @@ udmf
418
{
title = "Start Adjustable Blinking Light";
- prefix = "(418)";
arg0
{
title = "Target sector tag";
@@ -2143,7 +2066,6 @@ udmf
420
{
title = "Fade Light Level";
- prefix = "(420)";
arg0
{
title = "Target sector tag";
@@ -2173,7 +2095,6 @@ udmf
421
{
title = "Stop Lighting Effect";
- prefix = "(421)";
arg0
{
title = "Target sector tag";
@@ -2184,7 +2105,6 @@ udmf
435
{
title = "Change Plane Scroller Direction";
- prefix = "(435)";
arg0
{
title = "Target sector tag";
@@ -2200,7 +2120,6 @@ udmf
467
{
title = "Set Tagged Sector's Light Level";
- prefix = "(467)";
arg0
{
title = "Target sector tag";
@@ -2232,7 +2151,6 @@ udmf
469
{
title = "Change Tagged Sector's Gravity";
- prefix = "(469)";
arg0
{
title = "Target sector tag";
@@ -2284,7 +2202,6 @@ udmf
403
{
title = "Move Tagged Sector's Planes";
- prefix = "(403)";
arg0
{
title = "Target sector tag";
@@ -2317,7 +2234,6 @@ udmf
405
{
title = "Move Planes by Set Distance";
- prefix = "(405)";
arg0
{
title = "Target sector tag";
@@ -2349,7 +2265,6 @@ udmf
411
{
title = "Stop Plane Movement";
- prefix = "(411)";
arg0
{
title = "Target sector tag";
@@ -2360,7 +2275,6 @@ udmf
428
{
title = "Start Platform Movement";
- prefix = "(428)";
arg0
{
title = "Target sector tag";
@@ -2394,7 +2308,6 @@ udmf
429
{
title = "Crush Planes Once";
- prefix = "(429)";
arg0
{
title = "Target sector tag";
@@ -2426,7 +2339,6 @@ udmf
412
{
title = "Teleporter";
- prefix = "(412)";
arg0
{
title = "Destination thing tag";
@@ -2461,7 +2373,6 @@ udmf
425
{
title = "Change Object State";
- prefix = "(425)";
stringarg0
{
title = "State";
@@ -2472,7 +2383,6 @@ udmf
426
{
title = "Stop Object";
- prefix = "(426)";
arg0
{
title = "Move to center?";
@@ -2484,7 +2394,6 @@ udmf
427
{
title = "Award Score";
- prefix = "(427)";
arg0
{
title = "Score";
@@ -2494,7 +2403,6 @@ udmf
432
{
title = "Enable/Disable 2D Mode";
- prefix = "(432)";
arg0
{
title = "Mode";
@@ -2510,7 +2418,6 @@ udmf
433
{
title = "Enable/Disable Gravity Flip";
- prefix = "(433)";
arg0
{
title = "Set gravity";
@@ -2546,7 +2453,6 @@ udmf
434
{
title = "Award Power-Up";
- prefix = "(434)";
stringarg0
{
title = "Power";
@@ -2562,7 +2468,6 @@ udmf
437
{
title = "Disable Player Control";
- prefix = "(437)";
arg0
{
title = "Time";
@@ -2578,7 +2483,6 @@ udmf
438
{
title = "Change Object Size";
- prefix = "(438)";
arg0
{
title = "Size (%)";
@@ -2589,7 +2493,6 @@ udmf
442
{
title = "Change Object Type State";
- prefix = "(442)";
arg0
{
title = "Target sector tag";
@@ -2620,7 +2523,6 @@ udmf
457
{
title = "Track Object's Angle";
- prefix = "(457)";
arg0
{
title = "Anchor tag";
@@ -2651,13 +2553,11 @@ udmf
458
{
title = "Stop Tracking Object's Angle";
- prefix = "(458)";
}
460
{
title = "Award Rings";
- prefix = "(460)";
arg0
{
title = "Rings";
@@ -2671,7 +2571,6 @@ udmf
461
{
title = "Spawn Object";
- prefix = "(461)";
arg0
{
title = "X position";
@@ -2717,13 +2616,11 @@ udmf
462
{
title = "Stop Timer/Exit Stage in Record Attack";
- prefix = "(462)";
}
463
{
title = "Dye Object";
- prefix = "(463)";
stringarg0
{
title = "Skin color";
@@ -2734,7 +2631,6 @@ udmf
464
{
title = "Trigger Egg Capsule";
- prefix = "(464)";
arg0
{
title = "Egg Capsule tag";
@@ -2751,7 +2647,6 @@ udmf
466
{
title = "Set Level Failure State";
- prefix = "(466)";
arg0
{
title = "State";
@@ -2772,7 +2667,6 @@ udmf
413
{
title = "Change Music";
- prefix = "(413)";
arg0
{
title = "Flags";
@@ -2823,7 +2717,6 @@ udmf
414
{
title = "Play Sound Effect";
- prefix = "(414)";
arg0
{
title = "Source";
@@ -2863,7 +2756,6 @@ udmf
415
{
title = "Run Script";
- prefix = "(415)";
stringarg0
{
title = "Lump name";
@@ -2874,7 +2766,6 @@ udmf
422
{
title = "Switch to Cut-Away View";
- prefix = "(422)";
arg0
{
title = "Viewpoint tag";
@@ -2889,7 +2780,6 @@ udmf
423
{
title = "Change Sky";
- prefix = "(423)";
arg0
{
title = "Sky number";
@@ -2905,7 +2795,6 @@ udmf
424
{
title = "Change Weather";
- prefix = "(424)";
arg0
{
title = "Weather";
@@ -2932,7 +2821,6 @@ udmf
436
{
title = "Shatter FOF";
- prefix = "(436)";
arg0
{
title = "Target sector tag";
@@ -2948,7 +2836,6 @@ udmf
439
{
title = "Change Tagged Linedef's Textures";
- prefix = "(439)";
arg0
{
title = "Target linedef tag";
@@ -2977,13 +2864,11 @@ udmf
440
{
title = "Start Metal Sonic Race";
- prefix = "(440)";
}
441
{
title = "Condition Set Trigger";
- prefix = "(441)";
arg0
{
title = "Trigger number";
@@ -2993,7 +2878,6 @@ udmf
443
{
title = "Call Lua Function";
- prefix = "(443)";
stringarg0
{
title = "Function name";
@@ -3004,7 +2888,6 @@ udmf
444
{
title = "Earthquake";
- prefix = "(444)";
arg0
{
title = "Duration";
@@ -3018,7 +2901,6 @@ udmf
445
{
title = "Make FOF Disappear/Reappear";
- prefix = "(445)";
arg0
{
title = "Target sector tag";
@@ -3044,7 +2926,6 @@ udmf
446
{
title = "Make FOF Crumble";
- prefix = "(446)";
arg0
{
title = "Target sector tag";
@@ -3072,7 +2953,6 @@ udmf
447
{
title = "Change Tagged Sector's Colormap";
- prefix = "(447)";
arg0
{
title = "Target sector tag";
@@ -3108,7 +2988,6 @@ udmf
448
{
title = "Change Skybox";
- prefix = "(448)";
arg0
{
title = "Viewpoint thing tag";
@@ -3139,7 +3018,6 @@ udmf
449
{
title = "Enable Bosses with Parameter";
- prefix = "(449)";
arg0
{
title = "Boss ID";
@@ -3159,7 +3037,6 @@ udmf
450
{
title = "Execute Linedef Executor (specific tag)";
- prefix = "(450)";
arg0
{
title = "Trigger linedef tag";
@@ -3170,7 +3047,6 @@ udmf
451
{
title = "Execute Linedef Executor (random tag in range)";
- prefix = "(451)";
arg0
{
title = "Start of tag range";
@@ -3186,7 +3062,6 @@ udmf
452
{
title = "Set FOF Translucency";
- prefix = "(452)";
arg0
{
title = "Target sector tag";
@@ -3217,7 +3092,6 @@ udmf
453
{
title = "Fade FOF";
- prefix = "(453)";
arg0
{
title = "Target sector tag";
@@ -3260,7 +3134,6 @@ udmf
454
{
title = "Stop Fading FOF";
- prefix = "(454)";
arg0
{
title = "Target sector tag";
@@ -3282,7 +3155,6 @@ udmf
455
{
title = "Fade Tagged Sector's Colormap";
- prefix = "(455)";
arg0
{
title = "Target sector tag";
@@ -3324,7 +3196,6 @@ udmf
456
{
title = "Stop Fading Tagged Sector's Colormap";
- prefix = "(456)";
arg0
{
title = "Target sector tag";
@@ -3335,7 +3206,6 @@ udmf
459
{
title = "Control Text Prompt";
- prefix = "(459)";
arg0
{
title = "Prompt number";
@@ -3371,7 +3241,6 @@ udmf
465
{
title = "Set Linedef Executor Delay";
- prefix = "(465)";
arg0
{
title = "Linedef tag";
@@ -3392,7 +3261,6 @@ udmf
468
{
title = "Change Linedef Argument";
- prefix = "(468)";
arg0
{
title = "Linedef tag";
@@ -3422,7 +3290,6 @@ udmf
480
{
title = "PolyObject Door Slide";
- prefix = "(480)";
arg0
{
title = "PolyObject tag";
@@ -3446,7 +3313,6 @@ udmf
481
{
title = "PolyObject Door Swing";
- prefix = "(481)";
arg0
{
title = "PolyObject tag";
@@ -3471,7 +3337,6 @@ udmf
482
{
title = "Move PolyObject";
- prefix = "(482)";
arg0
{
title = "PolyObject tag";
@@ -3497,7 +3362,6 @@ udmf
484
{
title = "Rotate PolyObject";
- prefix = "(484)";
arg0
{
title = "PolyObject tag";
@@ -3531,7 +3395,6 @@ udmf
488
{
title = "Move PolyObject by Waypoints";
- prefix = "(488)";
arg0
{
title = "PolyObject tag";
@@ -3573,7 +3436,6 @@ udmf
489
{
title = "Set PolyObject Visibility/Tangibility";
- prefix = "(489)";
arg0
{
title = "PolyObject tag";
@@ -3606,7 +3468,6 @@ udmf
491
{
title = "Set PolyObject Translucency";
- prefix = "(491)";
arg0
{
title = "PolyObject tag";
@@ -3628,7 +3489,6 @@ udmf
492
{
title = "Fade PolyObject Translucency";
- prefix = "(492)";
arg0
{
title = "PolyObject tag";
@@ -3666,7 +3526,6 @@ udmf
500
{
title = "Scroll Wall";
- prefix = "(500)";
arg0
{
title = "Side";
@@ -3686,7 +3545,6 @@ udmf
502
{
title = "Scroll Tagged Walls";
- prefix = "(502)";
arg0
{
title = "Linedef tag";
@@ -3717,7 +3575,6 @@ udmf
510
{
title = "Scroll Planes";
- prefix = "(510)";
arg0
{
title = "Sector tag";
@@ -3755,7 +3612,6 @@ udmf
541
{
title = "Wind/Current";
- prefix = "(541)";
arg0
{
title = "Sector tag";
@@ -3800,7 +3656,6 @@ udmf
600
{
title = "Copy Light Level to Tagged Sector's Planes";
- prefix = "(600)";
arg0
{
title = "Target sector tag";
@@ -3817,7 +3672,6 @@ udmf
602
{
title = "Adjustable Pulsating Light";
- prefix = "(602)";
arg0
{
title = "Target sector tag";
@@ -3846,7 +3700,6 @@ udmf
603
{
title = "Adjustable Flickering Light";
- prefix = "(603)";
arg0
{
title = "Target sector tag";
@@ -3875,7 +3728,6 @@ udmf
604
{
title = "Adjustable Blinking Light";
- prefix = "(604)";
arg0
{
title = "Target sector tag";
@@ -3912,7 +3764,6 @@ udmf
606
{
title = "Copy Colormap";
- prefix = "(606)";
arg0
{
title = "Target sector tag";
@@ -3933,7 +3784,6 @@ udmf
700
{
title = "Create Sector-Based Slope";
- prefix = "(700)";
id = "plane_align";
arg0
{
@@ -3963,7 +3813,6 @@ udmf
704
{
title = "Create Vertex-Based Slope";
- prefix = "(704)";
id = "srb2_vertexslope";
arg0
{
@@ -4007,7 +3856,6 @@ udmf
720
{
title = "Copy Slope";
- prefix = "(720)";
id = "plane_copy";
arg0
{
@@ -4046,7 +3894,6 @@ udmf
799
{
title = "Set Tagged Dynamic Slope Vertex to Front Sector Height";
- prefix = "(799)";
arg0
{
title = "Apply height";
diff --git a/extras/conf/udb/Includes/SRB222_misc.cfg b/extras/conf/udb/Includes/SRB222_misc.cfg
index 0b94a5a87a37a5ce7cf6a2a4c9e5799f7c738eab..c37c29ce0def1f471565d7d4494ac7ab833eb054 100644
--- a/extras/conf/udb/Includes/SRB222_misc.cfg
+++ b/extras/conf/udb/Includes/SRB222_misc.cfg
@@ -280,18 +280,18 @@ universalfields
default = "";
}
- //light
- //{
- // type = 0;
- // default = 0;
- //}
- //
- //lightabsolute
- //{
- // type = 3;
- // default = false;
- //}
- //
+ light
+ {
+ type = 0;
+ default = 0;
+ }
+
+ lightabsolute
+ {
+ type = 3;
+ default = false;
+ }
+
//light_top
//{
// type = 0;
@@ -590,6 +590,12 @@ universalfields
type = 3;
default = false;
}
+
+ triggertag
+ {
+ type = 0;
+ default = 0;
+ }
}
}
diff --git a/extras/conf/udb/Includes/SRB222_things.cfg b/extras/conf/udb/Includes/SRB222_things.cfg
index 990f8dca9f505b57f1797c49ed0d8ae003d18d5d..c028f9439c493d156e1ded87f7a116cc4b14d9d7 100644
--- a/extras/conf/udb/Includes/SRB222_things.cfg
+++ b/extras/conf/udb/Includes/SRB222_things.cfg
@@ -3938,6 +3938,7 @@ udmf
width = 30;
height = 32;
color = 17;
+ hangs = 1;
arg0
{
title = "Initial delay";
diff --git a/src/apng.c b/src/apng.c
index 11d3ab9f58ea9c26530374b7b18d8454fd367ed8..cfb1473a40269703985bc727cafd5f27f2c14f02 100644
--- a/src/apng.c
+++ b/src/apng.c
@@ -71,7 +71,7 @@ apng_create_info_struct (png_structp pngp)
{
apng_infop ainfop;
(void)pngp;
- if (( ainfop = calloc(sizeof (apng_info),1) ))
+ if (( ainfop = calloc(1,sizeof (apng_info)) ))
{
apng_set_write_fn(pngp, ainfop, 0, 0, 0, 0, 0);
apng_set_set_acTL_fn(pngp, ainfop, 0);
diff --git a/src/b_bot.c b/src/b_bot.c
index af57d65ecf6e3c24e725ed38b9533b9ab6509763..6229cb1d61893b328e667ba357fbbefe333e51f4 100644
--- a/src/b_bot.c
+++ b/src/b_bot.c
@@ -387,7 +387,8 @@ void B_BuildTiccmd(player_t *player, ticcmd_t *cmd)
}
// Bot AI isn't programmed in analog.
- CV_SetValue(&cv_analog[1], false);
+ if (!dedicated)
+ CV_SetValue(&cv_analog[1], false);
// Let Lua scripts build ticcmds
if (LUA_HookTiccmd(player, cmd, HOOK(BotTiccmd)))
diff --git a/src/byteptr.h b/src/byteptr.h
index 8ab359c4c4d9d00a0f613a86588b96a46112cd68..4377fae571a59f67b70a9410a44ea851e534e400 100644
--- a/src/byteptr.h
+++ b/src/byteptr.h
@@ -11,9 +11,6 @@
/// \brief Macros to read/write from/to a UINT8 *,
/// used for packet creation and such
-#if defined (__alpha__) || defined (__arm__) || defined (__mips__) || defined (__ia64__) || defined (__clang__)
-#define DEALIGNED
-#endif
#include "endian.h"
@@ -21,7 +18,6 @@
//
// Little-endian machines
//
-#ifdef DEALIGNED
#define WRITEUINT8(p,b) do { UINT8 *p_tmp = (void *)p; const UINT8 tv = ( UINT8)(b); memcpy(p, &tv, sizeof( UINT8)); p_tmp++; p = (void *)p_tmp; } while (0)
#define WRITESINT8(p,b) do { SINT8 *p_tmp = (void *)p; const SINT8 tv = ( UINT8)(b); memcpy(p, &tv, sizeof( UINT8)); p_tmp++; p = (void *)p_tmp; } while (0)
#define WRITEINT16(p,b) do { INT16 *p_tmp = (void *)p; const INT16 tv = ( INT16)(b); memcpy(p, &tv, sizeof( INT16)); p_tmp++; p = (void *)p_tmp; } while (0)
@@ -31,20 +27,8 @@
#define WRITECHAR(p,b) do { char *p_tmp = (void *)p; const char tv = ( char)(b); memcpy(p, &tv, sizeof( char)); p_tmp++; p = (void *)p_tmp; } while (0)
#define WRITEFIXED(p,b) do { fixed_t *p_tmp = (void *)p; const fixed_t tv = (fixed_t)(b); memcpy(p, &tv, sizeof(fixed_t)); p_tmp++; p = (void *)p_tmp; } while (0)
#define WRITEANGLE(p,b) do { angle_t *p_tmp = (void *)p; const angle_t tv = (angle_t)(b); memcpy(p, &tv, sizeof(angle_t)); p_tmp++; p = (void *)p_tmp; } while (0)
-#else
-#define WRITEUINT8(p,b) do { UINT8 *p_tmp = ( UINT8 *)p; *p_tmp = ( UINT8)(b); p_tmp++; p = (void *)p_tmp; } while (0)
-#define WRITESINT8(p,b) do { SINT8 *p_tmp = ( SINT8 *)p; *p_tmp = ( SINT8)(b); p_tmp++; p = (void *)p_tmp; } while (0)
-#define WRITEINT16(p,b) do { INT16 *p_tmp = ( INT16 *)p; *p_tmp = ( INT16)(b); p_tmp++; p = (void *)p_tmp; } while (0)
-#define WRITEUINT16(p,b) do { UINT16 *p_tmp = ( UINT16 *)p; *p_tmp = ( UINT16)(b); p_tmp++; p = (void *)p_tmp; } while (0)
-#define WRITEINT32(p,b) do { INT32 *p_tmp = ( INT32 *)p; *p_tmp = ( INT32)(b); p_tmp++; p = (void *)p_tmp; } while (0)
-#define WRITEUINT32(p,b) do { UINT32 *p_tmp = ( UINT32 *)p; *p_tmp = ( UINT32)(b); p_tmp++; p = (void *)p_tmp; } while (0)
-#define WRITECHAR(p,b) do { char *p_tmp = ( char *)p; *p_tmp = ( char)(b); p_tmp++; p = (void *)p_tmp; } while (0)
-#define WRITEFIXED(p,b) do { fixed_t *p_tmp = (fixed_t *)p; *p_tmp = (fixed_t)(b); p_tmp++; p = (void *)p_tmp; } while (0)
-#define WRITEANGLE(p,b) do { angle_t *p_tmp = (angle_t *)p; *p_tmp = (angle_t)(b); p_tmp++; p = (void *)p_tmp; } while (0)
-#endif
#ifdef __GNUC__
-#ifdef DEALIGNED
#define READUINT8(p) ({ UINT8 *p_tmp = (void *)p; UINT8 b; memcpy(&b, p, sizeof( UINT8)); p_tmp++; p = (void *)p_tmp; b; })
#define READSINT8(p) ({ SINT8 *p_tmp = (void *)p; SINT8 b; memcpy(&b, p, sizeof( SINT8)); p_tmp++; p = (void *)p_tmp; b; })
#define READINT16(p) ({ INT16 *p_tmp = (void *)p; INT16 b; memcpy(&b, p, sizeof( INT16)); p_tmp++; p = (void *)p_tmp; b; })
@@ -55,17 +39,6 @@
#define READFIXED(p) ({ fixed_t *p_tmp = (void *)p; fixed_t b; memcpy(&b, p, sizeof(fixed_t)); p_tmp++; p = (void *)p_tmp; b; })
#define READANGLE(p) ({ angle_t *p_tmp = (void *)p; angle_t b; memcpy(&b, p, sizeof(angle_t)); p_tmp++; p = (void *)p_tmp; b; })
#else
-#define READUINT8(p) ({ UINT8 *p_tmp = ( UINT8 *)p; UINT8 b = *p_tmp; p_tmp++; p = (void *)p_tmp; b; })
-#define READSINT8(p) ({ SINT8 *p_tmp = ( SINT8 *)p; SINT8 b = *p_tmp; p_tmp++; p = (void *)p_tmp; b; })
-#define READINT16(p) ({ INT16 *p_tmp = ( INT16 *)p; INT16 b = *p_tmp; p_tmp++; p = (void *)p_tmp; b; })
-#define READUINT16(p) ({ UINT16 *p_tmp = ( UINT16 *)p; UINT16 b = *p_tmp; p_tmp++; p = (void *)p_tmp; b; })
-#define READINT32(p) ({ INT32 *p_tmp = ( INT32 *)p; INT32 b = *p_tmp; p_tmp++; p = (void *)p_tmp; b; })
-#define READUINT32(p) ({ UINT32 *p_tmp = ( UINT32 *)p; UINT32 b = *p_tmp; p_tmp++; p = (void *)p_tmp; b; })
-#define READCHAR(p) ({ char *p_tmp = ( char *)p; char b = *p_tmp; p_tmp++; p = (void *)p_tmp; b; })
-#define READFIXED(p) ({ fixed_t *p_tmp = (fixed_t *)p; fixed_t b = *p_tmp; p_tmp++; p = (void *)p_tmp; b; })
-#define READANGLE(p) ({ angle_t *p_tmp = (angle_t *)p; angle_t b = *p_tmp; p_tmp++; p = (void *)p_tmp; b; })
-#endif
-#else
#define READUINT8(p) *(( UINT8 *)p)++
#define READSINT8(p) *(( SINT8 *)p)++
#define READINT16(p) *(( INT16 *)p)++
@@ -148,8 +121,6 @@ FUNCINLINE static ATTRINLINE UINT32 readulong(void *ptr)
#define READANGLE(p) ({ angle_t *p_tmp = (angle_t *)p; angle_t b = readulong(p); p_tmp++; p = (void *)p_tmp; b; })
#endif //SRB2_BIG_ENDIAN
-#undef DEALIGNED
-
#define WRITESTRINGN(p, s, n) { \
size_t tmp_i; \
\
diff --git a/src/command.c b/src/command.c
index a46cc98bcde4ad01557a31e439994135341a5c06..e0156274ea12353809653fd64e50a9205ee32d29 100644
--- a/src/command.c
+++ b/src/command.c
@@ -1992,7 +1992,7 @@ static void CV_SetCVar(consvar_t *var, const char *value, boolean stealth)
if (var->flags & CV_NETVAR)
{
// send the value of the variable
- UINT8 buf[128];
+ UINT8 buf[512];
UINT8 *p = buf;
// Loading from a config in a netgame? Set revert value.
@@ -2065,11 +2065,10 @@ static void CV_SetValueMaybeStealth(consvar_t *var, INT32 value, boolean stealth
if (var == &cv_forceskin) // Special handling.
{
const char *tmpskin = NULL;
- if ((value < 0) || (value >= numskins))
- ;
- else
+ if (value >= 0 && value < numskins)
tmpskin = skins[value]->name;
- memcpy(val, tmpskin, SKINNAMESIZE);
+ if (tmpskin)
+ memcpy(val, tmpskin, SKINNAMESIZE);
}
else
sprintf(val, "%d", value);
diff --git a/src/console.c b/src/console.c
index 874fc2a4f288eb261a367efd68c488dcd770fb72..0c3eac4f793854dad336dc641a73874cea74d510 100644
--- a/src/console.c
+++ b/src/console.c
@@ -922,8 +922,6 @@ static void CON_InputDelChar(void)
//
boolean CON_Responder(event_t *ev)
{
- static UINT8 consdown = false; // console is treated differently due to rare usage
-
// sequential completions a la 4dos
static char completioncmd[80 + sizeof("find ")] = "find ";
static char *completion = &completioncmd[sizeof("find ")-1];
@@ -943,32 +941,28 @@ boolean CON_Responder(event_t *ev)
// let go keyup events, don't eat them
if (ev->type != ev_keydown && ev->type != ev_text && ev->type != ev_console)
{
- if (ev->key == gamecontrol[GC_CONSOLE][0] || ev->key == gamecontrol[GC_CONSOLE][1])
- consdown = false;
return false;
}
key = ev->key;
// check for console toggle key
- if (ev->type != ev_console)
+ if (ev->type == ev_keydown)
{
if (modeattacking || metalrecording || marathonmode)
return false;
- if (ev->type == ev_keydown && ((key == gamecontrol[GC_CONSOLE][0] || key == gamecontrol[GC_CONSOLE][1]) && !shiftdown))
+ if ((key == gamecontrol[GC_CONSOLE][0] || key == gamecontrol[GC_CONSOLE][1]) && !shiftdown)
{
- if (consdown) // ignore repeat
- return true;
+ I_SetTextInputMode(con_destlines == 0); // inverse, since this is changed next tic.
consoletoggle = true;
- consdown = true;
return true;
}
// check other keys only if console prompt is active
if (!consoleready && key < NUMINPUTS) // metzgermeister: boundary check!!
{
- if (ev->type == ev_keydown && !menuactive && bindtable[key])
+ if (!menuactive && bindtable[key])
{
COM_BufAddText(bindtable[key]);
COM_BufAddText("\n");
@@ -980,14 +974,14 @@ boolean CON_Responder(event_t *ev)
// escape key toggle off console
if (key == KEY_ESCAPE)
{
+ I_SetTextInputMode(false);
consoletoggle = true;
return true;
}
}
-
- if (ev->type == ev_text)
+ else if (ev->type == ev_text)
{
- if (!consoletoggle)
+ if (!consoletoggle && consoleready)
CON_InputAddChar(key);
return true;
}
@@ -1036,7 +1030,7 @@ boolean CON_Responder(event_t *ev)
}
else if (key == KEY_BACKSPACE)
{
- if (ctrldown)
+ if (ctrldown && input_cur != 0)
{
input_sel = M_JumpWordReverse(inputlines[inputline], input_cur);
CON_InputDelSelection();
@@ -1094,7 +1088,9 @@ boolean CON_Responder(event_t *ev)
if (key == 'x' || key == 'X')
{
- if (input_sel > input_cur)
+ if (input_sel == input_cur) // Don't replace the clipboard without a text selection
+ return true;
+ else if (input_sel > input_cur)
I_ClipboardCopy(&inputlines[inputline][input_cur], input_sel-input_cur);
else
I_ClipboardCopy(&inputlines[inputline][input_sel], input_cur-input_sel);
@@ -1104,7 +1100,9 @@ boolean CON_Responder(event_t *ev)
}
else if (key == 'c' || key == 'C')
{
- if (input_sel > input_cur)
+ if (input_sel == input_cur) // Don't replace the clipboard without a text selection
+ return true;
+ else if (input_sel > input_cur)
I_ClipboardCopy(&inputlines[inputline][input_cur], input_sel-input_cur);
else
I_ClipboardCopy(&inputlines[inputline][input_sel], input_cur-input_sel);
@@ -1730,12 +1728,12 @@ static void CON_DrawBackpic(void)
// Get the lumpnum for CONSBACK, STARTUP (Only during game startup) or fallback into MISSING.
if (con_startup)
- piclump = W_CheckNumForName("STARTUP");
+ piclump = W_CheckNumForPatchName("STARTUP");
else
- piclump = W_CheckNumForName("CONSBACK");
+ piclump = W_CheckNumForPatchName("CONSBACK");
if (piclump == LUMPERROR)
- piclump = W_GetNumForName("MISSING");
+ piclump = W_GetNumForPatchName("MISSING");
// Cache the patch.
con_backpic = W_CachePatchNum(piclump, PU_PATCH);
diff --git a/src/d_main.c b/src/d_main.c
index a37b2e31794cfae0bf65a7e0fef807cce2d6a95d..d7bb738b9851b9e8ad0e4fe1708130a1d8866fae 100644
--- a/src/d_main.c
+++ b/src/d_main.c
@@ -687,13 +687,13 @@ static void D_Display(void)
s[sizeof s - 1] = '\0';
snprintf(s, sizeof s - 1, "get %d b/s", getbps);
- V_DrawRightAlignedString(BASEVIDWIDTH, BASEVIDHEIGHT-ST_HEIGHT-40, V_YELLOWMAP, s);
+ V_DrawRightAlignedString(BASEVIDWIDTH, BASEVIDHEIGHT-40, V_YELLOWMAP, s);
snprintf(s, sizeof s - 1, "send %d b/s", sendbps);
- V_DrawRightAlignedString(BASEVIDWIDTH, BASEVIDHEIGHT-ST_HEIGHT-30, V_YELLOWMAP, s);
+ V_DrawRightAlignedString(BASEVIDWIDTH, BASEVIDHEIGHT-30, V_YELLOWMAP, s);
snprintf(s, sizeof s - 1, "GameMiss %.2f%%", gamelostpercent);
- V_DrawRightAlignedString(BASEVIDWIDTH, BASEVIDHEIGHT-ST_HEIGHT-20, V_YELLOWMAP, s);
+ V_DrawRightAlignedString(BASEVIDWIDTH, BASEVIDHEIGHT-20, V_YELLOWMAP, s);
snprintf(s, sizeof s - 1, "SysMiss %.2f%%", lostpercent);
- V_DrawRightAlignedString(BASEVIDWIDTH, BASEVIDHEIGHT-ST_HEIGHT-10, V_YELLOWMAP, s);
+ V_DrawRightAlignedString(BASEVIDWIDTH, BASEVIDHEIGHT-10, V_YELLOWMAP, s);
}
if (cv_perfstats.value)
@@ -766,9 +766,9 @@ void D_SRB2Loop(void)
/* Smells like a hack... Don't fade Sonic's ass into the title screen. */
if (gamestate != GS_TITLESCREEN)
{
- gstartuplumpnum = W_CheckNumForName("STARTUP");
+ gstartuplumpnum = W_CheckNumForPatchName("STARTUP");
if (gstartuplumpnum == LUMPERROR)
- gstartuplumpnum = W_GetNumForName("MISSING");
+ gstartuplumpnum = W_GetNumForPatchName("MISSING");
V_DrawScaledPatch(0, 0, 0, W_CachePatchNum(gstartuplumpnum, PU_PATCH));
}
@@ -991,7 +991,7 @@ void D_StartTitle(void)
emeralds = 0;
memset(&luabanks, 0, sizeof(luabanks));
lastmaploaded = 0;
- pickedchar = R_SkinAvailable(cv_defaultskin.string);
+ pickedchar = R_SkinAvailable(cv_skin.string);
// In case someone exits out at the same time they start a time attack run,
// reset modeattacking
@@ -1032,7 +1032,7 @@ void D_StartTitle(void)
#define REALLOC_FILE_LIST \
if (list->files == NULL) \
{ \
- list->files = calloc(sizeof(list->files), 2); \
+ list->files = calloc(2, sizeof(list->files)); \
list->numfiles = 1; \
} \
else \
@@ -1543,7 +1543,7 @@ void D_SRB2Main(void)
I_Error("Cannot find a map remotely named '%s'\n", word);
else
{
- if (!M_CheckParm("-server"))
+ if (!(M_CheckParm("-server") || dedicated))
G_SetUsedCheats(true);
autostart = true;
}
@@ -1850,17 +1850,21 @@ static boolean check_top_dir(const char **path, const char *top)
return true;
}
-static int cmp_strlen_desc(const void *a, const void *b)
+static int cmp_strlen_desc(const void *A, const void *B)
{
- return ((int)strlen(*(const char*const*)b) - (int)strlen(*(const char*const*)a));
+ const char *pA = A;
+ const char *pB = B;
+ size_t As = strlen(pA);
+ size_t Bs = strlen(pB);
+ return ((int)Bs - (int)As);
}
boolean D_IsPathAllowed(const char *path)
{
- const char *paths[] = {
+ char *paths[] = {
srb2home,
srb2path,
- cv_addons_folder.string
+ cv_addons_folder.zstring
};
const size_t n_paths = sizeof paths / sizeof *paths;
diff --git a/src/dedicated/i_system.c b/src/dedicated/i_system.c
index 858dfaf20234cb6898ffe008bce3c3f76e8b950b..1a1db8fb351e6017a8ee9d7745556550245e47c1 100644
--- a/src/dedicated/i_system.c
+++ b/src/dedicated/i_system.c
@@ -1390,8 +1390,8 @@ static const char *searchWad(const char *searchDir)
#define CHECKWADPATH(ret) \
do { \
- I_OutputMsg(",%s", returnWadPath); \
- if (isWadPathOk(returnWadPath)) \
+ I_OutputMsg(",%s", ret); \
+ if (isWadPathOk(ret)) \
return ret; \
} while (0)
@@ -1416,7 +1416,9 @@ static const char *locateWad(void)
#ifndef NOCWD
// examine current dir
strcpy(returnWadPath, ".");
- CHECKWADPATH(NULL);
+ I_OutputMsg(",%s", returnWadPath);
+ if (isWadPathOk(returnWadPath))
+ return NULL;
#endif
#ifdef __APPLE__
@@ -1433,9 +1435,15 @@ static const char *locateWad(void)
#ifndef NOHOME
// find in $HOME
- I_OutputMsg(",HOME");
if ((envstr = I_GetEnv("HOME")) != NULL)
- SEARCHWAD(envstr);
+ {
+ char *tmp = malloc(strlen(envstr) + 1 + sizeof(DEFAULTDIR));
+ strcpy(tmp, envstr);
+ strcat(tmp, "/");
+ strcat(tmp, DEFAULTDIR);
+ CHECKWADPATH(tmp);
+ free(tmp);
+ }
#endif
// search paths
@@ -1585,5 +1593,15 @@ void I_GetCursorPosition(INT32 *x, INT32 *y)
(void)y;
}
+void I_SetTextInputMode(boolean active)
+{
+ (void)active;
+}
+
+boolean I_GetTextInputMode(void)
+{
+ return false;
+}
+
#include "../sdl/dosstr.c"
diff --git a/src/deh_lua.c b/src/deh_lua.c
index c056db82a7ca65c7bb9c1ba363708ce5880d253f..64fb52fc7423a7486c9d6736762fedd0fcde64ba 100644
--- a/src/deh_lua.c
+++ b/src/deh_lua.c
@@ -59,24 +59,19 @@ static inline int lib_freeslot(lua_State *L)
}
else if (fastcmp(type, "SPR"))
{
- char wad;
spritenum_t j;
- lua_getfield(L, LUA_REGISTRYINDEX, "WAD");
- wad = (char)lua_tointeger(L, -1);
- lua_pop(L, 1);
+
+ if (strlen(word) > MAXSPRITENAME)
+ return luaL_error(L, "Sprite name is longer than %d characters\n", MAXSPRITENAME);
+
for (j = SPR_FIRSTFREESLOT; j <= SPR_LASTFREESLOT; j++)
{
- if (used_spr[(j-SPR_FIRSTFREESLOT)/8] & (1<<(j%8)))
- {
- if (!sprnames[j][4] && memcmp(sprnames[j],word,4)==0)
- sprnames[j][4] = wad;
+ if (in_bit_array(used_spr, j - SPR_FIRSTFREESLOT))
continue; // Already allocated, next.
- }
// Found a free slot!
CONS_Printf("Sprite SPR_%s allocated.\n",word);
- strncpy(sprnames[j],word,4);
- //sprnames[j][4] = 0;
- used_spr[(j-SPR_FIRSTFREESLOT)/8] |= 1<<(j%8); // Okay, this sprite slot has been named now.
+ strcpy(sprnames[j], word);
+ set_bit_array(used_spr, j - SPR_FIRSTFREESLOT); // Okay, this sprite slot has been named now.
// Lua needs to update the value in _G if it exists
LUA_UpdateSprName(word, j);
lua_pushinteger(L, j);
@@ -455,17 +450,19 @@ static int ScanConstants(lua_State *L, boolean mathlib, const char *word)
}
else if (fastncmp("SPR_",word,4)) {
p = word+4;
- for (i = 0; i < NUMSPRITES; i++)
- if (!sprnames[i][4] && fastncmp(p,sprnames[i],4)) {
- // updating overridden sprnames is not implemented for soc parser,
- // so don't use cache
- if (mathlib)
- lua_pushinteger(L, i);
- else
- CacheAndPushConstant(L, word, i);
- return 1;
- }
- if (mathlib) return luaL_error(L, "sprite '%s' could not be found.\n", word);
+ i = R_GetSpriteNumByName(p);
+ if (i != NUMSPRITES)
+ {
+ // updating overridden sprnames is not implemented for soc parser,
+ // so don't use cache
+ if (mathlib)
+ lua_pushinteger(L, i);
+ else
+ CacheAndPushConstant(L, word, i);
+ return 1;
+ }
+ else if (mathlib)
+ return luaL_error(L, "sprite '%s' could not be found.\n", word);
return 0;
}
else if (fastncmp("SPR2_",word,5)) {
@@ -738,18 +735,18 @@ static inline int lib_getenum(lua_State *L)
// If a sprname has been "cached" to _G, update it to a new value.
void LUA_UpdateSprName(const char *name, lua_Integer value)
{
- char fullname[9] = "SPR_XXXX";
+ char fullname[4 + MAXSPRITENAME + 1] = "SPR_";
if (!gL)
return;
- strncpy(&fullname[4], name, 4);
+ strcpy(&fullname[4], name);
lua_pushstring(gL, fullname);
lua_rawget(gL, LUA_GLOBALSINDEX);
if (!lua_isnil(gL, -1))
{
- lua_pushstring(gL, name);
+ lua_pushstring(gL, fullname);
lua_pushinteger(gL, value);
lua_rawset(gL, LUA_GLOBALSINDEX);
}
diff --git a/src/deh_soc.c b/src/deh_soc.c
index 77143357f6e33b3b1e43d7770f2129f8096574a7..4107624d0c250db409d319d825bc09579914fd45 100644
--- a/src/deh_soc.c
+++ b/src/deh_soc.c
@@ -406,7 +406,6 @@ void readfreeslots(MYFILE *f)
{
char *s = Z_Malloc(MAXLINELEN, PU_STATIC, NULL);
char *word,*type;
- char *tmp;
int i;
do
@@ -416,10 +415,13 @@ void readfreeslots(MYFILE *f)
if (s[0] == '\n')
break;
- tmp = strchr(s, '#');
- if (tmp)
- *tmp = '\0';
- if (s == tmp)
+ char *hashtag = strchr(s, '#');
+ char *space = strchr(s, ' ');
+ if (hashtag)
+ *hashtag = '\0';
+ if (space)
+ *space = '\0';
+ if (s == hashtag || s == space)
continue; // Skip comment lines, but don't break.
type = strtok(s, "_");
@@ -441,18 +443,16 @@ void readfreeslots(MYFILE *f)
S_AddSoundFx(word, false, 0, false);
else if (fastcmp(type, "SPR"))
{
+ if (strlen(word) > MAXSPRITENAME)
+ I_Error("Sprite name is longer than %d characters\n", MAXSPRITENAME);
+
for (i = SPR_FIRSTFREESLOT; i <= SPR_LASTFREESLOT; i++)
{
- if (used_spr[(i-SPR_FIRSTFREESLOT)/8] & (1<<(i%8)))
- {
- if (!sprnames[i][4] && memcmp(sprnames[i],word,4)==0)
- sprnames[i][4] = (char)f->wad;
+ if (in_bit_array(used_spr, i - SPR_FIRSTFREESLOT))
continue; // Already allocated, next.
- }
// Found a free slot!
- strncpy(sprnames[i],word,4);
- //sprnames[i][4] = 0;
- used_spr[(i-SPR_FIRSTFREESLOT)/8] |= 1<<(i%8); // Okay, this sprite slot has been named now.
+ strcpy(sprnames[i], word);
+ set_bit_array(used_spr, i - SPR_FIRSTFREESLOT); // Okay, this sprite slot has been named now.
// Lua needs to update the value in _G if it exists
LUA_UpdateSprName(word, i);
break;
@@ -2809,7 +2809,7 @@ void readframe(MYFILE *f, INT32 num)
size_t z;
boolean found = false;
size_t actionlen = strlen(word2) + 1;
- char *actiontocompare = calloc(actionlen, 1);
+ char *actiontocompare = calloc(1, actionlen);
strcpy(actiontocompare, word2);
strupr(actiontocompare);
@@ -4200,9 +4200,9 @@ spritenum_t get_sprite(const char *word)
return atoi(word);
if (fastncmp("SPR_",word,4))
word += 4; // take off the SPR_
- for (i = 0; i < NUMSPRITES; i++)
- if (!sprnames[i][4] && memcmp(word,sprnames[i],4)==0)
- return i;
+ i = R_GetSpriteNumByName(word);
+ if (i != NUMSPRITES)
+ return i;
deh_warning("Couldn't find sprite named 'SPR_%s'",word);
return SPR_NULL;
}
diff --git a/src/deh_tables.c b/src/deh_tables.c
index 97e82f2cb8e00ddd693e10c553bdebacdfe74893..94b0f1b8d90a73f0f925257564b84d2a6e165b6d 100644
--- a/src/deh_tables.c
+++ b/src/deh_tables.c
@@ -32,7 +32,7 @@
char *FREE_STATES[NUMSTATEFREESLOTS];
char *FREE_MOBJS[NUMMOBJFREESLOTS];
char *FREE_SKINCOLORS[NUMCOLORFREESLOTS];
-UINT8 used_spr[(NUMSPRITEFREESLOTS / 8) + 1]; // Bitwise flag for sprite freeslot in use! I would use ceil() here if I could, but it only saves 1 byte of memory anyway.
+bitarray_t used_spr[BIT_ARRAY_SIZE(NUMSPRITEFREESLOTS)]; // Sprite freeslots in use
const char NIGHTSGRADE_LIST[] = {
'F', // GRADE_F
@@ -4484,6 +4484,8 @@ const char *const PLAYERFLAG_LIST[] = {
"CANCARRY", // Can carry?
"FINISHED",
+ "SHIELDDOWN", // Shield has been pressed.
+
NULL // stop loop here.
};
@@ -5811,6 +5813,10 @@ struct int_const_s const INT_CONST[] = {
{"MB_SCROLLUP",MB_SCROLLUP},
{"MB_SCROLLDOWN",MB_SCROLLDOWN},
+ // screen.h constants
+ {"BASEVIDWIDTH",BASEVIDWIDTH},
+ {"BASEVIDHEIGHT",BASEVIDHEIGHT},
+
{NULL,0}
};
diff --git a/src/deh_tables.h b/src/deh_tables.h
index 42716f9b4bd271c98aca83737f419670d862d7e5..b6986adff0166c3132be5f70ca78c7835030998f 100644
--- a/src/deh_tables.h
+++ b/src/deh_tables.h
@@ -23,13 +23,13 @@
extern char *FREE_STATES[NUMSTATEFREESLOTS];
extern char *FREE_MOBJS[NUMMOBJFREESLOTS];
extern char *FREE_SKINCOLORS[NUMCOLORFREESLOTS];
-extern UINT8 used_spr[(NUMSPRITEFREESLOTS / 8) + 1]; // Bitwise flag for sprite freeslot in use! I would use ceil() here if I could, but it only saves 1 byte of memory anyway.
+extern bitarray_t used_spr[BIT_ARRAY_SIZE(NUMSPRITEFREESLOTS)]; // Sprite freeslots in use
#define initfreeslots() {\
- memset(FREE_STATES,0,sizeof(char *) * NUMSTATEFREESLOTS);\
- memset(FREE_MOBJS,0,sizeof(char *) * NUMMOBJFREESLOTS);\
- memset(FREE_SKINCOLORS,0,sizeof(char *) * NUMCOLORFREESLOTS);\
- memset(used_spr,0,sizeof(UINT8) * ((NUMSPRITEFREESLOTS / 8) + 1));\
+ memset(FREE_STATES, 0, sizeof(FREE_STATES));\
+ memset(FREE_MOBJS, 0, sizeof(FREE_MOBJS));\
+ memset(FREE_SKINCOLORS, 0, sizeof(FREE_SKINCOLORS));\
+ memset(used_spr, 0, sizeof(used_spr));\
memset(actionsoverridden, LUA_REFNIL, sizeof(actionsoverridden));\
}
diff --git a/src/dummy/i_system.c b/src/dummy/i_system.c
index ecabe3576d3f15b06513315a945562076587aff5..99bfa9f363ca04c9281b17b0cffeda5cc4314586 100644
--- a/src/dummy/i_system.c
+++ b/src/dummy/i_system.c
@@ -211,5 +211,15 @@ const char *I_GetSysName(void)
return NULL;
}
+void I_SetTextInputMode(boolean active)
+{
+ (void)active;
+}
+
+boolean I_GetTextInputMode(void)
+{
+ return false;
+}
+
#include "../sdl/dosstr.c"
diff --git a/src/f_finale.c b/src/f_finale.c
index 9ff50147e0bb36ae17d3c23672b82d6528f54871..810af4e82f3ea4f08d035b626a6afffef52a0467 100644
--- a/src/f_finale.c
+++ b/src/f_finale.c
@@ -2336,7 +2336,7 @@ void F_SkyScroll(const char *patchname)
}
#define LOADTTGFX(arr, name, maxf) \
-lumpnum = W_CheckNumForName(name); \
+lumpnum = W_CheckNumForPatchName(name); \
if (lumpnum != LUMPERROR) \
{ \
arr[0] = W_CachePatchName(name, PU_PATCH_LOWPRIORITY); \
@@ -2350,7 +2350,7 @@ else if (strlen(name) <= 6) \
{ \
sprintf(&lumpname[cnt], "%.2hu", (UINT16)(i+1)); \
lumpname[8] = 0; \
- lumpnum = W_CheckNumForName(lumpname); \
+ lumpnum = W_CheckNumForPatchName(lumpname); \
if (lumpnum != LUMPERROR) \
arr[i] = W_CachePatchName(lumpname, PU_PATCH_LOWPRIORITY); \
else \
@@ -4116,7 +4116,7 @@ static void F_GetPageTextGeometry(UINT8 *pagelines, boolean *rightside, INT32 *b
// reuse:
// cutnum -> promptnum
// scenenum -> pagenum
- lumpnum_t iconlump = W_CheckNumForName(textprompts[cutnum]->page[scenenum].iconname);
+ lumpnum_t iconlump = W_CheckNumForPatchName(textprompts[cutnum]->page[scenenum].iconname);
*pagelines = textprompts[cutnum]->page[scenenum].lines ? textprompts[cutnum]->page[scenenum].lines : 4;
*rightside = (iconlump != LUMPERROR && textprompts[cutnum]->page[scenenum].rightside);
@@ -4508,7 +4508,7 @@ void F_TextPromptDrawer(void)
if (!promptactive)
return;
- iconlump = W_CheckNumForName(textprompts[cutnum]->page[scenenum].iconname);
+ iconlump = W_CheckNumForPatchName(textprompts[cutnum]->page[scenenum].iconname);
F_GetPageTextGeometry(&pagelines, &rightside, &boxh, &texth, &texty, &namey, &chevrony, &textx, &textr);
// Draw gfx first
diff --git a/src/filesrch.c b/src/filesrch.c
index 944e8447f4d462c5ee7cac302a7481422e184613..67a2e8976f88548c0f6f77b2143fbef6888d820f 100644
--- a/src/filesrch.c
+++ b/src/filesrch.c
@@ -444,12 +444,11 @@ filestatus_t filesearch(char *filename, const char *startpath, const UINT8 *want
strcpy(&searchpath[searchpathindex[depthleft]],dent->d_name);
#if defined(__linux__) || defined(__FreeBSD__)
- if (dent->d_type == DT_UNKNOWN)
- if (lstat(searchpath,&fsstat) == 0 && S_ISDIR(fsstat.st_mode))
+ if (dent->d_type == DT_UNKNOWN || dent->d_type == DT_LNK)
+ if (stat(searchpath,&fsstat) == 0 && S_ISDIR(fsstat.st_mode))
dent->d_type = DT_DIR;
// Linux and FreeBSD has a special field for file type on dirent, so use that to speed up lookups.
- // FIXME: should we also follow symlinks?
if (dent->d_type == DT_DIR && depthleft)
#else
if (stat(searchpath,&fsstat) < 0) // do we want to follow symlinks? if not: change it to lstat
@@ -699,6 +698,15 @@ static void initdirpath(char *dirpath, size_t *dirpathindex, int depthleft)
dirpathindex[depthleft]--;
}
+//sortdir by name?
+static int lumpnamecompare(const void *A, const void *B)
+{
+ const lumpinfo_t *pA = A;
+ const lumpinfo_t *pB = B;
+ return strcmp((pA->fullname), (pB->fullname));
+
+}
+
lumpinfo_t *getdirectoryfiles(const char *path, UINT16 *nlmp, UINT16 *nfolders)
{
DIR **dirhandle;
@@ -889,6 +897,9 @@ lumpinfo_t *getdirectoryfiles(const char *path, UINT16 *nlmp, UINT16 *nfolders)
free(dirpathindex);
free(dirhandle);
+ //sort files and directories
+ qsort (lumpinfo, numlumps, sizeof(lumpinfo_t), lumpnamecompare);
+
(*nlmp) = numlumps;
return lumpinfo;
}
@@ -1179,7 +1190,7 @@ boolean preparefilemenu(boolean samedepth)
size_t i;
if (filenamebuf == NULL)
- filenamebuf = calloc(sizeof(char) * MAX_WADPATH, numwadfiles);
+ filenamebuf = calloc(numwadfiles, sizeof(char) * MAX_WADPATH);
for (i = 0; i < numwadfiles; i++)
{
diff --git a/src/g_demo.c b/src/g_demo.c
index 0efba5a59724f3b64f3a9ed9dbcf1d137a472e47..cfa34fc7e76c7978a52603fdd05f3e55d19f3e17 100644
--- a/src/g_demo.c
+++ b/src/g_demo.c
@@ -67,6 +67,8 @@ static UINT8 *metalbuffer = NULL;
static UINT8 *metal_p;
static UINT16 metalversion;
+consvar_t cv_resyncdemo = CVAR_INIT("resyncdemo", "On", 0, CV_OnOff, NULL);
+
// extra data stuff (events registered this frame while recording)
static struct {
UINT8 flags; // EZT flags
@@ -549,6 +551,9 @@ void G_ConsGhostTic(void)
testmo = players[0].mo;
+ if (P_MobjWasRemoved(testmo))
+ return; // No valid mobj exists, probably because of unexpected quit
+
// Grab ghost data.
ziptic = READUINT8(demo_p);
if (ziptic & GZT_XYZ)
@@ -664,11 +669,14 @@ void G_ConsGhostTic(void)
CONS_Alert(CONS_WARNING, M_GetText("Demo playback has desynced!\n"));
demosynced = false;
- P_UnsetThingPosition(testmo);
- testmo->x = oldghost.x;
- testmo->y = oldghost.y;
- P_SetThingPosition(testmo);
- testmo->z = oldghost.z;
+ if (cv_resyncdemo.value)
+ {
+ P_UnsetThingPosition(testmo);
+ testmo->x = oldghost.x;
+ testmo->y = oldghost.y;
+ P_SetThingPosition(testmo);
+ testmo->z = oldghost.z;
+ }
}
if (*demo_p == DEMOMARKER)
diff --git a/src/g_demo.h b/src/g_demo.h
index e8c0c8d956187161ea5bbaffe9c145c764a40ba4..67f61f54de1166034d4376faa6ca340b39779e9d 100644
--- a/src/g_demo.h
+++ b/src/g_demo.h
@@ -35,6 +35,7 @@ typedef enum
} demo_file_override_e;
extern demo_file_override_e demofileoverride;
+extern consvar_t cv_resyncdemo;
// Quit after playing a demo from cmdline.
extern boolean singledemo;
diff --git a/src/g_game.c b/src/g_game.c
index 8d19c9e7cb68df142e68e7d0277b2425153f9206..5d6954b9b7cef3c6e5b34a1c2a5115fde61fdfb8 100644
--- a/src/g_game.c
+++ b/src/g_game.c
@@ -1363,11 +1363,11 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
axis = PlayerJoyAxis(ssplayer, JA_FIRENORMAL);
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))
@@ -1386,6 +1386,13 @@ 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
+ {
+ cmd->angleturn = ticcmd_oldangleturn[forplayer];
+ cmd->aiming = G_ClipAimingPitch(myaiming);
+ return;
+ }
+
// Centerview can be a toggle in simple mode!
{
static boolean last_centerviewdown[2], centerviewhold[2]; // detect taps for toggle behavior
@@ -1420,7 +1427,7 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
ticcmd_centerviewdown[forplayer] = true;
}
- else if (ticcmd_centerviewdown[forplayer])
+ else if (ticcmd_centerviewdown[forplayer] || (leveltime < 5))
{
if (controlstyle == CS_SIMPLE)
{
@@ -1435,6 +1442,9 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
{
if (
P_MobjWasRemoved(ticcmd_ztargetfocus[forplayer]) ||
+ (leveltime < 5) ||
+ (player->playerstate != PST_LIVE) ||
+ player->exiting ||
!ticcmd_ztargetfocus[forplayer]->health ||
(ticcmd_ztargetfocus[forplayer]->type == MT_EGGMOBILE3 && !ticcmd_ztargetfocus[forplayer]->movecount) // Sea Egg is moving around underground and shouldn't be tracked
)
@@ -1466,7 +1476,7 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
P_SetTarget(&newtarget->target, ticcmd_ztargetfocus[forplayer]);
newtarget->drawonlyforplayer = player; // Hide it from the other player in splitscreen, and yourself when spectating
- if (player->mo && P_AproxDistance(
+ if (player->mo && R_PointToDist2(0, 0,
player->mo->x - ticcmd_ztargetfocus[forplayer]->x,
player->mo->y - ticcmd_ztargetfocus[forplayer]->y
) > 50*player->mo->scale)
@@ -1714,7 +1724,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 && gamestate == GS_LEVEL)
+ if (addedtogame)
{
INT16 extra = ticcmd_oldangleturn[forplayer] - player->oldrelangleturn;
INT16 origangle = cmd->angleturn;
@@ -3342,7 +3352,7 @@ void G_AddPlayer(INT32 playernum)
p->playerstate = PST_REBORN;
- p->height = mobjinfo[MT_PLAYER].height;
+ p->height = skins[p->skin]->height;
if (G_GametypeUsesLives() || ((netgame || multiplayer) && (gametyperules & GTR_FRIENDLY)))
p->lives = cv_startinglives.value;
@@ -4018,7 +4028,7 @@ INT16 G_GetNextMap(boolean ignoretokens, boolean silent)
INT32 i;
INT16 newmapnum;
boolean spec = G_IsSpecialStage(gamemap);
-
+
// go to next level
// newmapnum is 0-based, unlike gamemap
if (nextmapoverride != 0)
@@ -4122,7 +4132,7 @@ INT16 G_GetNextMap(boolean ignoretokens, boolean silent)
if (spec && (!gottoken || ignoretokens) && !nextmapoverride)
newmapnum = lastmap; // Exiting from a special stage? Go back to the game. Tails 08-11-2001
-
+
if (!(gametyperules & GTR_CAMPAIGN))
{
if (cv_advancemap.value == 0) // Stay on same map.
@@ -4130,7 +4140,7 @@ INT16 G_GetNextMap(boolean ignoretokens, boolean silent)
else if (cv_advancemap.value == 2) // Go to random map.
newmapnum = RandMap(G_TOLFlag(gametype_to_use), prevmap);
}
-
+
return newmapnum;
}
@@ -4140,7 +4150,7 @@ INT16 G_GetNextMap(boolean ignoretokens, boolean silent)
static void G_DoCompleted(void)
{
INT32 i;
-
+
tokenlist = 0; // Reset the list
if (modeattacking && pausedelay)
@@ -4168,7 +4178,7 @@ static void G_DoCompleted(void)
//Get and set prevmap/nextmap
prevmap = (INT16)(gamemap-1);
nextmap = G_GetNextMap(false, false);
-
+
automapactive = false;
// We are committed to this map now.
diff --git a/src/hardware/hw_cache.c b/src/hardware/hw_cache.c
index 56f5416cf13f8d4c3176d93b122094d4bfd0bacb..f282ca89184b9d47fe000f47e126880c0467b602 100644
--- a/src/hardware/hw_cache.c
+++ b/src/hardware/hw_cache.c
@@ -450,15 +450,10 @@ static void HWR_GenerateTexture(INT32 texnum, GLMapTexture_t *grtex, GLMipmap_t
texture = textures[texnum];
- mipmap->flags = TF_WRAPXY;
- mipmap->width = (UINT16)texture->width;
- mipmap->height = (UINT16)texture->height;
- mipmap->format = textureformat;
-
blockwidth = texture->width;
blockheight = texture->height;
- blocksize = (blockwidth * blockheight);
- block = MakeBlock(&grtex->mipmap);
+ blocksize = blockwidth * blockheight;
+ block = MakeBlock(mipmap);
// Composite the columns together.
for (i = 0, patch = texture->patches; i < texture->patchcount; i++, patch++)
@@ -488,7 +483,7 @@ static void HWR_GenerateTexture(INT32 texnum, GLMapTexture_t *grtex, GLMipmap_t
realpatch = W_CachePatchNumPwad(wadnum, lumpnum, PU_PATCH);
}
- HWR_DrawTexturePatchInCache(&grtex->mipmap, blockwidth, blockheight, texture, patch, realpatch);
+ HWR_DrawTexturePatchInCache(mipmap, blockwidth, blockheight, texture, patch, realpatch);
if (free_patch)
Patch_Free(realpatch);
@@ -680,25 +675,24 @@ void HWR_InitMapTextures(void)
gl_maptexturesloaded = false;
}
-static void DeleteTextureMipmap(GLMipmap_t *grMipmap)
+static void DeleteTextureMipmap(GLMipmap_t *grMipmap, boolean delete_mipmap)
{
HWD.pfnDeleteTexture(grMipmap);
- // Chroma-keyed textures do not own their texture data, so do not free it
- if (!(grMipmap->flags & TF_CHROMAKEYED))
+ if (delete_mipmap)
Z_Free(grMipmap->data);
}
-static void FreeMapTexture(GLMapTexture_t *tex)
+static void FreeMapTexture(GLMapTexture_t *tex, boolean delete_chromakeys)
{
if (tex->mipmap.nextcolormap)
{
- DeleteTextureMipmap(tex->mipmap.nextcolormap);
+ DeleteTextureMipmap(tex->mipmap.nextcolormap, delete_chromakeys);
free(tex->mipmap.nextcolormap);
tex->mipmap.nextcolormap = NULL;
}
- DeleteTextureMipmap(&tex->mipmap);
+ DeleteTextureMipmap(&tex->mipmap, true);
}
void HWR_FreeMapTextures(void)
@@ -707,8 +701,8 @@ void HWR_FreeMapTextures(void)
for (i = 0; i < gl_numtextures; i++)
{
- FreeMapTexture(&gl_textures[i]);
- FreeMapTexture(&gl_flats[i]);
+ FreeMapTexture(&gl_textures[i], true);
+ FreeMapTexture(&gl_flats[i], false);
}
// now the heap don't have any 'user' pointing to our
@@ -741,22 +735,7 @@ void HWR_LoadMapTextures(size_t pnumtextures)
// --------------------------------------------------------------------------
// Make sure texture is downloaded and set it as the source
// --------------------------------------------------------------------------
-static void GetMapTexture(INT32 tex, GLMapTexture_t *grtex, GLMipmap_t *mipmap)
-{
- // Generate texture if missing from the cache
- if (!mipmap->data && !mipmap->downloaded)
- HWR_GenerateTexture(tex, grtex, mipmap);
-
- // If hardware does not have the texture, then call pfnSetTexture to upload it
- if (!mipmap->downloaded)
- HWD.pfnSetTexture(mipmap);
- HWR_SetCurrentTexture(mipmap);
-
- // The system-memory data can be purged now.
- Z_ChangeTag(mipmap->data, PU_HWRCACHE_UNLOCKED);
-}
-
-GLMapTexture_t *HWR_GetTexture(INT32 tex)
+GLMapTexture_t *HWR_GetTexture(INT32 tex, boolean chromakeyed)
{
if (tex < 0 || tex >= (signed)gl_numtextures)
{
@@ -769,7 +748,46 @@ GLMapTexture_t *HWR_GetTexture(INT32 tex)
GLMapTexture_t *grtex = &gl_textures[tex];
- GetMapTexture(tex, grtex, &grtex->mipmap);
+ GLMipmap_t *grMipmap = &grtex->mipmap;
+ GLMipmap_t *originalMipmap = grMipmap;
+
+ if (!originalMipmap->downloaded)
+ {
+ originalMipmap->flags = TF_WRAPXY;
+ originalMipmap->width = (UINT16)textures[tex]->width;
+ originalMipmap->height = (UINT16)textures[tex]->height;
+ originalMipmap->format = textureformat;
+ }
+
+ // If chroma-keyed, create or use a different mipmap for the variant
+ if (chromakeyed && !textures[tex]->transparency)
+ {
+ // Allocate it if it wasn't already
+ if (!originalMipmap->nextcolormap)
+ {
+ GLMipmap_t *newMipmap = calloc(1, sizeof (*grMipmap));
+ if (newMipmap == NULL)
+ I_Error("%s: Out of memory", "HWR_GetTexture");
+
+ newMipmap->flags = originalMipmap->flags | TF_CHROMAKEYED;
+ newMipmap->width = originalMipmap->width;
+ newMipmap->height = originalMipmap->height;
+ newMipmap->format = originalMipmap->format;
+ originalMipmap->nextcolormap = newMipmap;
+ }
+
+ // Generate, upload and bind the variant texture instead of the original one
+ grMipmap = originalMipmap->nextcolormap;
+ }
+
+ if (!grMipmap->data)
+ HWR_GenerateTexture(tex, grtex, grMipmap);
+
+ if (!grMipmap->downloaded)
+ HWD.pfnSetTexture(grMipmap);
+ HWR_SetCurrentTexture(grMipmap);
+
+ Z_ChangeTag(grMipmap->data, PU_HWRCACHE_UNLOCKED);
return grtex;
}
diff --git a/src/hardware/hw_glob.h b/src/hardware/hw_glob.h
index 807c7098946b5589ce7d3394f864d6dccb484194..5678cd593dfc017d2a1d067d76a8bc71954abb4f 100644
--- a/src/hardware/hw_glob.h
+++ b/src/hardware/hw_glob.h
@@ -120,7 +120,7 @@ void HWR_GetPatch(patch_t *patch);
void HWR_GetMappedPatch(patch_t *patch, const UINT8 *colormap);
void HWR_GetFadeMask(lumpnum_t fademasklumpnum);
-GLMapTexture_t *HWR_GetTexture(INT32 tex);
+GLMapTexture_t *HWR_GetTexture(INT32 tex, boolean chromakeyed);
void HWR_GetLevelFlat(levelflat_t *levelflat, boolean chromakeyed);
void HWR_GetRawFlat(lumpnum_t flatlumpnum);
diff --git a/src/hardware/hw_main.c b/src/hardware/hw_main.c
index f533082f76e6db8af21e90c6dcf4f98949f7f532..f395a83905de4ecd65bef7017c41cfb8cef8f2f0 100644
--- a/src/hardware/hw_main.c
+++ b/src/hardware/hw_main.c
@@ -309,6 +309,43 @@ static FUINT HWR_CalcSlopeLight(FUINT lightnum, angle_t dir, fixed_t delta)
return (FUINT)finallight;
}
+static UINT8 HWR_SideLightLevel(side_t *side, INT16 base_lightlevel)
+{
+ return max(0, min(255, side->light +
+ ((side->lightabsolute) ? 0 : base_lightlevel)));
+}
+
+/* TODO: implement per-texture lighting
+static UINT8 HWR_TopLightLevel(side_t *side, INT16 base_lightlevel)
+{
+ return max(0, min(255, side->light_top +
+ ((side->lightabsolute_top) ? 0 : HWR_SideLightLevel(side, base_lightlevel))));
+}
+
+static UINT8 HWR_MidLightLevel(side_t *side, INT16 base_lightlevel)
+{
+ return max(0, min(255, side->light_mid +
+ ((side->lightabsolute_mid) ? 0 : HWR_SideLightLevel(side, base_lightlevel))));
+}
+
+static UINT8 HWR_BottomLightLevel(side_t *side, INT16 base_lightlevel)
+{
+ return max(0, min(255, side->light_bottom +
+ ((side->lightabsolute_bottom) ? 0 : HWR_SideLightLevel(side, base_lightlevel))));
+}
+*/
+
+static UINT8 HWR_FloorLightLevel(sector_t *sector, INT16 base_lightlevel)
+{
+ return max(0, min(255, sector->floorlightlevel +
+ ((sector->floorlightabsolute) ? 0 : base_lightlevel)));
+}
+
+static UINT8 HWR_CeilingLightLevel(sector_t *sector, INT16 base_lightlevel)
+{
+ return max(0, min(255, sector->ceilinglightlevel +
+ ((sector->ceilinglightabsolute) ? 0 : base_lightlevel)));
+}
// ==========================================================================
// FLOOR/CEILING GENERATION FROM SUBSECTORS
// ==========================================================================
@@ -705,8 +742,9 @@ static void HWR_SplitWall(sector_t *sector, FOutVector *wallVerts, INT32 texnum,
fixed_t v2x = FloatToFixed(wallVerts[1].x);
fixed_t v2y = FloatToFixed(wallVerts[1].z);
+ FUINT lightnum = HWR_SideLightLevel(gl_sidedef, sector->lightlevel);
const UINT8 alpha = Surf->PolyColor.s.alpha;
- FUINT lightnum = HWR_CalcWallLight(sector->lightlevel, v1x, v1y, v2x, v2y);
+ lightnum = HWR_CalcWallLight(lightnum, v1x, v1y, v2x, v2y);
extracolormap_t *colormap = NULL;
if (!r_renderwalls)
@@ -750,13 +788,13 @@ static void HWR_SplitWall(sector_t *sector, FOutVector *wallVerts, INT32 texnum,
{
if (pfloor && (pfloor->fofflags & FOF_FOG))
{
- lightnum = pfloor->master->frontsector->lightlevel;
+ lightnum = HWR_SideLightLevel(gl_sidedef, pfloor->master->frontsector->lightlevel);
colormap = pfloor->master->frontsector->extra_colormap;
lightnum = colormap ? lightnum : HWR_CalcWallLight(lightnum, v1x, v1y, v2x, v2y);
}
else
{
- lightnum = *list[i].lightlevel;
+ lightnum = HWR_SideLightLevel(gl_sidedef, *list[i].lightlevel);
colormap = *list[i].extra_colormap;
lightnum = colormap ? lightnum : HWR_CalcWallLight(lightnum, v1x, v1y, v2x, v2y);
}
@@ -951,7 +989,7 @@ static void HWR_RenderMidtexture(INT32 gl_midtexture, float cliplow, float cliph
else
repeats = 1;
- GLMapTexture_t *grTex = HWR_GetTexture(gl_midtexture);
+ GLMapTexture_t *grTex = HWR_GetTexture(gl_midtexture, true);
float xscale = FixedToFloat(gl_sidedef->scalex_mid);
float yscale = FixedToFloat(gl_sidedef->scaley_mid);
@@ -1167,7 +1205,7 @@ static void HWR_ProcessSeg(void)
float cliplow = (float)gl_curline->offset;
float cliphigh = cliplow + (gl_curline->flength * FRACUNIT);
- FUINT lightnum = gl_frontsector->lightlevel;
+ FUINT lightnum = HWR_SideLightLevel(gl_sidedef, gl_frontsector->lightlevel);
extracolormap_t *colormap = gl_frontsector->extra_colormap;
lightnum = colormap ? lightnum : HWR_CalcWallLight(lightnum, vs.x, vs.y, ve.x, ve.y);
@@ -1210,7 +1248,7 @@ static void HWR_ProcessSeg(void)
// check TOP TEXTURE
if ((worldhighslope < worldtopslope || worldhigh < worldtop) && gl_toptexture)
{
- grTex = HWR_GetTexture(gl_toptexture);
+ grTex = HWR_GetTexture(gl_toptexture, false);
xscale = FixedToFloat(abs(gl_sidedef->scalex_top));
yscale = FixedToFloat(abs(gl_sidedef->scaley_top));
@@ -1300,7 +1338,7 @@ static void HWR_ProcessSeg(void)
// check BOTTOM TEXTURE
if ((worldlowslope > worldbottomslope || worldlow > worldbottom) && gl_bottomtexture)
{
- grTex = HWR_GetTexture(gl_bottomtexture);
+ grTex = HWR_GetTexture(gl_bottomtexture, false);
xscale = FixedToFloat(abs(gl_sidedef->scalex_bottom));
yscale = FixedToFloat(abs(gl_sidedef->scaley_bottom));
@@ -1414,7 +1452,7 @@ static void HWR_ProcessSeg(void)
// Single sided line... Deal only with the middletexture (if one exists)
if (gl_midtexture && gl_linedef->special != SPECIAL_HORIZON_LINE) // (Ignore horizon line for OGL)
{
- grTex = HWR_GetTexture(gl_midtexture);
+ grTex = HWR_GetTexture(gl_midtexture, false);
xscale = FixedToFloat(gl_sidedef->scalex_mid);
yscale = FixedToFloat(gl_sidedef->scaley_mid);
@@ -1533,14 +1571,14 @@ static void HWR_ProcessSeg(void)
if ((high1 < lowcut && highslope1 < lowcutslope) || (low1 > highcut && lowslope1 > highcutslope))
continue;
- side_t *side = R_GetFFloorSide(gl_curline, rover);
+ side_t *side = R_GetFFloorSide(gl_curline->linedef, rover, gl_backsector);
boolean do_texture_skew;
boolean dont_peg_bottom;
if (rover->master->flags & ML_TFERLINE)
{
- line_t *newline = R_GetFFloorLine(gl_curline, rover);
+ line_t *newline = R_GetFFloorLine(gl_curline->linedef, rover, gl_backsector);
do_texture_skew = newline->flags & ML_SKEWTD;
dont_peg_bottom = newline->flags & ML_DONTPEGBOTTOM;
}
@@ -1588,7 +1626,7 @@ static void HWR_ProcessSeg(void)
// -- Monster Iestyn 26/06/18
fixed_t texturevpeg = side->rowoffset + side->offsety_mid;
- grTex = HWR_GetTexture(texnum);
+ grTex = HWR_GetTexture(texnum, true);
xscale = FixedToFloat(side->scalex_mid);
yscale = FixedToFloat(side->scaley_mid);
@@ -1628,11 +1666,11 @@ static void HWR_ProcessSeg(void)
{
blendmode = PF_Fog|PF_NoTexture;
- lightnum = rover->master->frontsector->lightlevel;
+ lightnum = HWR_SideLightLevel(gl_sidedef, rover->master->frontsector->lightlevel);
colormap = rover->master->frontsector->extra_colormap;
lightnum = colormap ? lightnum : HWR_CalcWallLight(lightnum, vs.x, vs.y, ve.x, ve.y);
- Surf.PolyColor.s.alpha = HWR_FogBlockAlpha(rover->master->frontsector->lightlevel, rover->master->frontsector->extra_colormap);
+ Surf.PolyColor.s.alpha = HWR_FogBlockAlpha(HWR_SideLightLevel(gl_sidedef, rover->master->frontsector->lightlevel), rover->master->frontsector->extra_colormap);
if (gl_frontsector->numlights)
HWR_SplitWall(gl_frontsector, wallVerts, 0, &Surf, rover->fofflags, rover, blendmode);
@@ -1689,14 +1727,14 @@ static void HWR_ProcessSeg(void)
if ((high1 < lowcut && highslope1 < lowcutslope) || (low1 > highcut && lowslope1 > highcutslope))
continue;
- side_t *side = R_GetFFloorSide(gl_curline, rover);
+ side_t *side = R_GetFFloorSide(gl_curline->linedef, rover, gl_backsector);
boolean do_texture_skew;
boolean dont_peg_bottom;
if (rover->master->flags & ML_TFERLINE)
{
- line_t *newline = R_GetFFloorLine(gl_curline, rover);
+ line_t *newline = R_GetFFloorLine(gl_curline->linedef, rover, gl_backsector);
do_texture_skew = newline->flags & ML_SKEWTD;
dont_peg_bottom = newline->flags & ML_DONTPEGBOTTOM;
}
@@ -1745,7 +1783,7 @@ static void HWR_ProcessSeg(void)
// -- Monster Iestyn 26/06/18
fixed_t texturevpeg = side->rowoffset + side->offsety_mid;
- grTex = HWR_GetTexture(texnum);
+ grTex = HWR_GetTexture(texnum, true);
xscale = FixedToFloat(side->scalex_mid);
yscale = FixedToFloat(side->scaley_mid);
@@ -1785,7 +1823,7 @@ static void HWR_ProcessSeg(void)
{
blendmode = PF_Fog|PF_NoTexture;
- lightnum = rover->master->frontsector->lightlevel;
+ lightnum = HWR_SideLightLevel(gl_sidedef, rover->master->frontsector->lightlevel);
colormap = rover->master->frontsector->extra_colormap;
lightnum = colormap ? lightnum : HWR_CalcWallLight(lightnum, vs.x, vs.y, ve.x, ve.y);
@@ -2442,7 +2480,7 @@ 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)
@@ -2471,13 +2509,13 @@ static void HWR_Subsector(size_t num)
UINT8 alpha;
light = R_GetPlaneLight(gl_frontsector, centerHeight, viewz < bottomCullHeight ? true : false);
- alpha = HWR_FogBlockAlpha(*gl_frontsector->lightlist[light].lightlevel, rover->master->frontsector->extra_colormap);
+ alpha = HWR_FogBlockAlpha(HWR_FloorLightLevel(rover->master->frontsector, *gl_frontsector->lightlist[light].lightlevel), rover->master->frontsector->extra_colormap);
HWR_AddTransparentFloor(0,
&extrasubsectors[num],
false,
*rover->bottomheight,
- *gl_frontsector->lightlist[light].lightlevel,
+ HWR_FloorLightLevel(rover->master->frontsector, *gl_frontsector->lightlist[light].lightlevel),
alpha, rover->master->frontsector, PF_Fog|PF_NoTexture,
true, false, rover->master->frontsector->extra_colormap);
}
@@ -2489,7 +2527,7 @@ static void HWR_Subsector(size_t num)
&extrasubsectors[num],
false,
*rover->bottomheight,
- *gl_frontsector->lightlist[light].lightlevel,
+ HWR_FloorLightLevel(rover->master->frontsector, *gl_frontsector->lightlist[light].lightlevel),
max(0, min(rover->alpha, 255)), rover->master->frontsector,
HWR_RippleBlend(gl_frontsector, rover, false) | (rover->blend ? HWR_GetBlendModeFlag(rover->blend) : PF_Translucent),
false, rover->fofflags & FOF_SPLAT, *gl_frontsector->lightlist[light].extra_colormap);
@@ -2498,8 +2536,9 @@ static void HWR_Subsector(size_t num)
{
HWR_GetLevelFlat(&levelflats[*rover->bottompic], rover->fofflags & FOF_SPLAT);
light = R_GetPlaneLight(gl_frontsector, centerHeight, viewz < bottomCullHeight ? true : false);
- HWR_RenderPlane(sub, &extrasubsectors[num], false, *rover->bottomheight, HWR_RippleBlend(gl_frontsector, rover, false)|PF_Occlude, *gl_frontsector->lightlist[light].lightlevel, &levelflats[*rover->bottompic],
- rover->master->frontsector, 255, *gl_frontsector->lightlist[light].extra_colormap);
+ HWR_RenderPlane(sub, &extrasubsectors[num], false, *rover->bottomheight, HWR_RippleBlend(gl_frontsector, rover, false)|PF_Occlude,
+ HWR_FloorLightLevel(rover->master->frontsector, *gl_frontsector->lightlist[light].lightlevel),
+ &levelflats[*rover->bottompic], rover->master->frontsector, 255, *gl_frontsector->lightlist[light].extra_colormap);
}
}
@@ -2516,13 +2555,13 @@ static void HWR_Subsector(size_t num)
UINT8 alpha;
light = R_GetPlaneLight(gl_frontsector, centerHeight, viewz < topCullHeight ? true : false);
- alpha = HWR_FogBlockAlpha(*gl_frontsector->lightlist[light].lightlevel, rover->master->frontsector->extra_colormap);
+ alpha = HWR_FogBlockAlpha(HWR_CeilingLightLevel(rover->master->frontsector, *gl_frontsector->lightlist[light].lightlevel), rover->master->frontsector->extra_colormap);
HWR_AddTransparentFloor(0,
&extrasubsectors[num],
true,
*rover->topheight,
- *gl_frontsector->lightlist[light].lightlevel,
+ HWR_CeilingLightLevel(rover->master->frontsector, *gl_frontsector->lightlist[light].lightlevel),
alpha, rover->master->frontsector, PF_Fog|PF_NoTexture,
true, false, rover->master->frontsector->extra_colormap);
}
@@ -2534,7 +2573,7 @@ static void HWR_Subsector(size_t num)
&extrasubsectors[num],
true,
*rover->topheight,
- *gl_frontsector->lightlist[light].lightlevel,
+ HWR_CeilingLightLevel(rover->master->frontsector, *gl_frontsector->lightlist[light].lightlevel),
max(0, min(rover->alpha, 255)), rover->master->frontsector,
HWR_RippleBlend(gl_frontsector, rover, false) | (rover->blend ? HWR_GetBlendModeFlag(rover->blend) : PF_Translucent),
false, rover->fofflags & FOF_SPLAT, *gl_frontsector->lightlist[light].extra_colormap);
@@ -2543,8 +2582,9 @@ static void HWR_Subsector(size_t num)
{
HWR_GetLevelFlat(&levelflats[*rover->toppic], rover->fofflags & FOF_SPLAT);
light = R_GetPlaneLight(gl_frontsector, centerHeight, viewz < topCullHeight ? true : false);
- HWR_RenderPlane(sub, &extrasubsectors[num], true, *rover->topheight, HWR_RippleBlend(gl_frontsector, rover, false)|PF_Occlude, *gl_frontsector->lightlist[light].lightlevel, &levelflats[*rover->toppic],
- rover->master->frontsector, 255, *gl_frontsector->lightlist[light].extra_colormap);
+ HWR_RenderPlane(sub, &extrasubsectors[num], true, *rover->topheight, HWR_RippleBlend(gl_frontsector, rover, false)|PF_Occlude,
+ HWR_CeilingLightLevel(rover->master->frontsector, *gl_frontsector->lightlist[light].lightlevel),
+ &levelflats[*rover->toppic], rover->master->frontsector, 255, *gl_frontsector->lightlist[light].extra_colormap);
}
}
}
@@ -2880,7 +2920,7 @@ static void HWR_DrawDropShadow(mobj_t *thing, fixed_t scale)
}
HWR_Lighting(&sSurf, 0, colormap);
- sSurf.PolyColor.s.alpha = alpha;
+ sSurf.PolyColor.s.alpha = FixedMul(thing->alpha, alpha);
if (HWR_UseShader())
{
@@ -3054,11 +3094,16 @@ 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)
// this will result in sprites drawn afterwards to be drawn on top like intended when using linkdraw.
if ((spr->mobj->flags2 & MF2_LINKDRAW) && spr->mobj->tracer)
+ {
+ newalpha = spr->mobj->tracer->alpha;
occlusion = 0;
+ }
else
occlusion = PF_Occlude;
@@ -3094,6 +3139,8 @@ 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())
{
@@ -3543,11 +3590,15 @@ static void HWR_DrawSprite(gl_vissprite_t *spr)
FBITFIELD blend = 0;
FBITFIELD occlusion;
boolean use_linkdraw_hack = false;
+ fixed_t newalpha = spr->mobj->alpha;
// if sprite has linkdraw, then dont write to z-buffer (by not using PF_Occlude)
// this will result in sprites drawn afterwards to be drawn on top like intended when using linkdraw.
if ((spr->mobj->flags2 & MF2_LINKDRAW) && spr->mobj->tracer)
+ {
occlusion = 0;
+ newalpha = spr->mobj->tracer->alpha;
+ }
else
occlusion = PF_Occlude;
@@ -3583,6 +3634,8 @@ 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)
{
@@ -3893,7 +3946,7 @@ void HWR_AddTransparentFloor(levelflat_t *levelflat, extrasubsector_t *xsub, boo
planeinfo[numplanes].isceiling = isceiling;
planeinfo[numplanes].fixedheight = fixedheight;
- planeinfo[numplanes].lightlevel = (planecolormap && (planecolormap->flags & CMF_FOG)) ? 255 : lightlevel;
+ planeinfo[numplanes].lightlevel = (planecolormap && (planecolormap->flags & CMF_FOG)) ? lightlevel : 255; // TODO: 2.3: Make transparent FOF planes always use light level
planeinfo[numplanes].levelflat = levelflat;
planeinfo[numplanes].xsub = xsub;
planeinfo[numplanes].alpha = alpha;
@@ -3925,7 +3978,7 @@ void HWR_AddTransparentPolyobjectFloor(levelflat_t *levelflat, polyobj_t *polyse
polyplaneinfo[numpolyplanes].isceiling = isceiling;
polyplaneinfo[numpolyplanes].fixedheight = fixedheight;
- polyplaneinfo[numpolyplanes].lightlevel = (planecolormap && (planecolormap->flags & CMF_FOG)) ? 255 : lightlevel;
+ polyplaneinfo[numpolyplanes].lightlevel = (planecolormap && (planecolormap->flags & CMF_FOG)) ? lightlevel : 255; // TODO: 2.3: Make transparent polyobject planes always use light level
polyplaneinfo[numpolyplanes].levelflat = levelflat;
polyplaneinfo[numpolyplanes].polysector = polysector;
polyplaneinfo[numpolyplanes].alpha = alpha;
@@ -4086,7 +4139,7 @@ static void HWR_CreateDrawNodes(void)
else if (sortnode[sortindex[i]].wall)
{
if (!(sortnode[sortindex[i]].wall->blend & PF_NoTexture))
- HWR_GetTexture(sortnode[sortindex[i]].wall->texnum);
+ HWR_GetTexture(sortnode[sortindex[i]].wall->texnum, true);
HWR_RenderWall(sortnode[sortindex[i]].wall->wallVerts, &sortnode[sortindex[i]].wall->Surf, sortnode[sortindex[i]].wall->blend, sortnode[sortindex[i]].wall->fogwall,
sortnode[sortindex[i]].wall->lightlevel, sortnode[sortindex[i]].wall->wallcolormap);
}
@@ -5066,6 +5119,8 @@ static void HWR_DrawSkyBackground(player_t *player)
HWD.pfnSetBlend(PF_Translucent|PF_NoDepthTest|PF_Modulated);
+ HWR_GetTexture(texturetranslation[skytexture], false);
+
if (cv_glskydome.value)
{
FTransform dometransform;
@@ -5081,8 +5136,6 @@ static void HWR_DrawSkyBackground(player_t *player)
HWR_SetTransformAiming(&dometransform, player, false);
dometransform.angley = (float)((viewangle-ANGLE_270)>>ANGLETOFINESHIFT)*(360.0f/(float)FINEANGLES);
- HWR_GetTexture(texturetranslation[skytexture]);
-
if (gl_sky.texture != texturetranslation[skytexture])
{
HWR_ClearSkyDome();
@@ -5102,7 +5155,6 @@ static void HWR_DrawSkyBackground(player_t *player)
float aspectratio;
float angleturn;
- HWR_GetTexture(texturetranslation[skytexture]);
aspectratio = (float)vid.width/(float)vid.height;
//Hurdler: the sky is the only texture who need 4.0f instead of 1.0
@@ -5221,7 +5273,9 @@ static void HWR_SetTransformAiming(FTransform *trans, player_t *player, boolean
if (cv_glshearing.value == 1 || (cv_glshearing.value == 2 && R_IsViewpointThirdPerson(player, skybox)))
{
fixed_t fixedaiming = AIMINGTODY(aimingangle);
- trans->viewaiming = FIXED_TO_FLOAT(fixedaiming);
+ trans->viewaiming = FIXED_TO_FLOAT(fixedaiming) * ((float)vid.width / vid.height) / ((float)BASEVIDWIDTH / BASEVIDHEIGHT);
+ if (splitscreen)
+ trans->viewaiming *= 2.125; // splitscreen adjusts fov with 0.8, so compensate (but only halfway, since splitscreen means only half the screen is used)
trans->shearing = true;
gl_aimingangle = 0;
}
diff --git a/src/hardware/hw_md2.c b/src/hardware/hw_md2.c
index 656fbc4a68b12302f524229aee1b8223f0baaa6e..2616d4085c4c9e8fa81e6ce82bfa2f30f072f68f 100644
--- a/src/hardware/hw_md2.c
+++ b/src/hardware/hw_md2.c
@@ -571,19 +571,15 @@ void HWR_LoadModels(void)
}
// Add sprite models.
- // Must be 4 characters long exactly. Otherwise, it's not a sprite name.
- if (len == 4)
+ for (i = 0; i < numsprites; i++)
{
- for (i = 0; i < numsprites; i++)
+ if (stricmp(name, sprnames[i]) == 0)
{
- if (stricmp(name, sprnames[i]) == 0)
- {
- md2_models[i].scale = scale;
- md2_models[i].offset = offset;
- md2_models[i].found = true;
- strcpy(md2_models[i].filename, filename);
- goto modelfound;
- }
+ md2_models[i].scale = scale;
+ md2_models[i].offset = offset;
+ md2_models[i].found = true;
+ strcpy(md2_models[i].filename, filename);
+ goto modelfound;
}
}
@@ -1097,19 +1093,19 @@ static modelspr2frames_t *HWR_GetModelSprite2Frames(md2_t *md2, UINT16 spr2)
return &md2->model->superspr2frames[spr2];
}
- if (md2->model->spr2frames)
+ if (md2->model->spr2frames[spr2].numframes)
return &md2->model->spr2frames[spr2];
return NULL;
}
-static modelspr2frames_t *HWR_GetModelSprite2(md2_t *md2, skin_t *skin, UINT16 spr2, player_t *player)
+static UINT16 HWR_GetModelSprite2Num(md2_t *md2, skin_t *skin, UINT16 spr2, player_t *player)
{
UINT16 super = 0;
UINT8 i = 0;
if (!md2 || !md2->model || !skin)
- return HWR_GetModelSprite2Frames(md2, 0);
+ return 0;
while (!HWR_GetModelSprite2Frames(md2, spr2)
&& spr2 != SPR2_STND
@@ -1149,7 +1145,7 @@ static modelspr2frames_t *HWR_GetModelSprite2(md2_t *md2, skin_t *skin, UINT16 s
if (i >= 32) // probably an infinite loop...
spr2 = 0;
- return HWR_GetModelSprite2Frames(md2, spr2);
+ return spr2;
}
// Adjust texture coords of model to fit into a patch's max_s and max_t
@@ -1158,6 +1154,9 @@ static void adjustTextureCoords(model_t *model, patch_t *patch)
int i;
GLPatch_t *gpatch = ((GLPatch_t *)patch->hardware);
+ if (!gpatch)
+ return;
+
for (i = 0; i < model->numMeshes; i++)
{
int j;
@@ -1273,6 +1272,7 @@ boolean HWR_DrawModel(gl_vissprite_t *spr)
const UINT8 flip = (UINT8)(!(spr->mobj->eflags & MFE_VERTICALFLIP) != !R_ThingVerticallyFlipped(spr->mobj));
const UINT8 hflip = (UINT8)(!(spr->mobj->mirrored) != !R_ThingHorizontallyFlipped(spr->mobj));
spritedef_t *sprdef;
+ UINT16 spr2 = 0;
spriteframe_t *sprframe;
INT32 mod;
interpmobjstate_t interp;
@@ -1289,6 +1289,11 @@ 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;
+
+ // Make linkdraw objects use their tracer's alpha value
+ fixed_t newalpha = spr->mobj->alpha;
+ if ((spr->mobj->flags2 & MF2_LINKDRAW) && spr->mobj->tracer)
+ newalpha = spr->mobj->tracer->alpha;
INT32 blendmode;
if (spr->mobj->frame & FF_BLENDMASK)
@@ -1303,6 +1308,8 @@ 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
// like before: model polygons are not sorted
@@ -1442,13 +1449,17 @@ boolean HWR_DrawModel(gl_vissprite_t *spr)
frame = (spr->mobj->frame & FF_FRAMEMASK);
if (spr->mobj->skin && spr->mobj->sprite == SPR_PLAY)
- spr2frames = HWR_GetModelSprite2(md2, spr->mobj->skin, spr->mobj->sprite2, spr->mobj->player);
+ {
+ spr2 = HWR_GetModelSprite2Num(md2, spr->mobj->skin, spr->mobj->sprite2, spr->mobj->player);
+ spr2frames = HWR_GetModelSprite2Frames(md2, spr2);
+ }
if (spr2frames)
{
+ spritedef_t *defaultdef = P_GetSkinSpritedef(spr->mobj->skin, spr2);
mod = spr2frames->numframes;
#ifndef DONTHIDEDIFFANIMLENGTH // by default, different anim length is masked by the mod
- if (mod > (INT32)sprdef->numframes)
- mod = sprdef->numframes;
+ if (mod > (INT32)defaultdef->numframes)
+ mod = defaultdef->numframes;
#endif
if (!mod)
mod = 1;
diff --git a/src/hardware/hw_shaders.c b/src/hardware/hw_shaders.c
index 36cbb5db949c7fae0e28c82b6c0fcb6bd1dd3a73..ee1e2acdf58cd73d810c1884cfc5ffe3e4797389 100644
--- a/src/hardware/hw_shaders.c
+++ b/src/hardware/hw_shaders.c
@@ -448,6 +448,101 @@ void HWR_LoadAllCustomShaders(void)
HWR_LoadCustomShadersFromFile(i, W_FileHasFolders(wadfiles[i]));
}
+static const char version_directives[][14] = {
+ "#version 330\n",
+ "#version 150\n",
+ "#version 140\n",
+ "#version 130\n",
+ "#version 120\n",
+ "#version 110\n",
+};
+
+static boolean HWR_VersionDirectiveExists(const char* source)
+{
+ return strncmp(source, "#version", 8) == 0;
+}
+
+static char* HWR_PrependVersionDirective(const char* source, UINT32 version_index)
+{
+ const UINT32 version_len = sizeof(version_directives[version_index]) - 1;
+ const UINT32 source_len = strlen(source);
+
+ char* result = Z_Malloc(source_len + version_len + 1, PU_STATIC, NULL);
+ strcpy(result, version_directives[version_index]);
+ strcpy(result + version_len, source);
+
+ return result;
+}
+
+static void HWR_ReplaceVersionInplace(char* shader, UINT32 version_index)
+{
+ shader[9] = version_directives[version_index][9];
+ shader[10] = version_directives[version_index][10];
+ shader[11] = version_directives[version_index][11];
+}
+
+static boolean HWR_CheckVersionDirectives(const char* vert, const char* frag)
+{
+ return HWR_VersionDirectiveExists(vert) && HWR_VersionDirectiveExists(frag);
+}
+
+static void HWR_TryToCompileShaderWithImplicitVersion(INT32 shader_index, INT32 shaderxlat_id)
+{
+ char* vert_shader = gl_shaders[shader_index].vertex;
+ char* frag_shader = gl_shaders[shader_index].fragment;
+
+ boolean vert_shader_version_exists = HWR_VersionDirectiveExists(vert_shader);
+ boolean frag_shader_version_exists = HWR_VersionDirectiveExists(frag_shader);
+
+ if(!vert_shader_version_exists) {
+ CONS_Alert(CONS_WARNING, "HWR_LoadCustomShadersFromFile: vertex shader '%s' is missing a #version directive\n", HWR_GetShaderName(shaderxlat_id));
+ }
+
+ if(!frag_shader_version_exists) {
+ CONS_Alert(CONS_WARNING, "HWR_LoadCustomShadersFromFile: fragment shader '%s' is missing a #version directive\n", HWR_GetShaderName(shaderxlat_id));
+ }
+
+ // try to compile as is
+ HWR_CompileShader(shader_index);
+ if (gl_shaders[shader_index].compiled)
+ return;
+
+ // try each version directive
+ for(UINT32 i = 0; i < sizeof(version_directives) / sizeof(version_directives[0]); ++i) {
+ CONS_Alert(CONS_NOTICE, "HWR_TryToCompileShaderWithImplicitVersion: Trying %s\n", version_directives[i]);
+
+ if(!vert_shader_version_exists) {
+ // first time reallocation would have to be made
+
+ if(i == 0) {
+ void* old = (void*)gl_shaders[shader_index].vertex;
+ vert_shader = gl_shaders[shader_index].vertex = HWR_PrependVersionDirective(vert_shader, i);
+ Z_Free(old);
+ } else {
+ HWR_ReplaceVersionInplace(vert_shader, i);
+ }
+ }
+
+ if(!frag_shader_version_exists) {
+ if(i == 0) {
+ void* old = (void*)gl_shaders[shader_index].fragment;
+ frag_shader = gl_shaders[shader_index].fragment = HWR_PrependVersionDirective(frag_shader, i);
+ Z_Free(old);
+ } else {
+ HWR_ReplaceVersionInplace(frag_shader, i);
+ }
+ }
+
+ HWR_CompileShader(shader_index);
+ if (gl_shaders[shader_index].compiled) {
+ CONS_Alert(CONS_NOTICE, "HWR_TryToCompileShaderWithImplicitVersion: Compiled with %s\n",
+ version_directives[i]);
+ CONS_Alert(CONS_WARNING, "Implicit GLSL version is used. Correct behavior is not guaranteed\n");
+ return;
+ }
+ }
+}
+
void HWR_LoadCustomShadersFromFile(UINT16 wadnum, boolean PK3)
{
UINT16 lump;
@@ -610,7 +705,13 @@ skip_field:
gl_shaders[shader_index].fragment = Z_StrDup(gl_shadersources[i].fragment);
if (!gl_shaders[shader_index].vertex)
gl_shaders[shader_index].vertex = Z_StrDup(gl_shadersources[i].vertex);
- HWR_CompileShader(shader_index);
+
+ if(!HWR_CheckVersionDirectives(gl_shaders[shader_index].vertex, gl_shaders[shader_index].fragment)) {
+ HWR_TryToCompileShaderWithImplicitVersion(shader_index, i);
+ } else {
+ HWR_CompileShader(shader_index);
+ }
+
if (!gl_shaders[shader_index].compiled)
CONS_Alert(CONS_ERROR, "HWR_LoadCustomShadersFromFile: A compilation error occured for the %s shader in file %s. See the console messages above for more information.\n", shaderxlat[i].type, wadfiles[wadnum]->filename);
}
diff --git a/src/hu_stuff.c b/src/hu_stuff.c
index 4e2f3d492974c0027c3b343a075018dc29682d33..caf13a445716167adaa20424af74f268565787ea 100644
--- a/src/hu_stuff.c
+++ b/src/hu_stuff.c
@@ -29,7 +29,7 @@
#include "i_video.h"
#include "i_system.h"
-#include "st_stuff.h" // ST_HEIGHT
+#include "st_stuff.h"
#include "r_local.h"
#include "keys.h"
@@ -204,7 +204,7 @@ void HU_LoadGraphics(void)
HU_SetFontProperties(&hu_font, 0, 4, 8, 12);
HU_SetFontProperties(&tny_font, 0, 2, 4, 12);
HU_SetFontProperties(&cred_font, 0, 16, 16, 16);
- HU_SetFontProperties(<_font, 0, 16, 20, 20);
+ HU_SetFontProperties(<_font, 0, 16, 20, 16);
HU_SetFontProperties(&ntb_font, 2, 4, 20, 21);
HU_SetFontProperties(&nto_font, 0, 4, 20, 21);
@@ -272,7 +272,7 @@ void HU_LoadFontCharacters(fontdef_t *font, const char *prefix)
for (i = 0; i < FONTSIZE; i++, j++)
{
sprintf(buffer, "%.5s%.3d", prefix, j);
- if (W_CheckNumForName(buffer) == LUMPERROR)
+ if (W_CheckNumForPatchName(buffer) == LUMPERROR)
font->chars[i] = NULL;
else
font->chars[i] = (patch_t *)W_CachePatchName(buffer, PU_HUDGFX);
@@ -999,6 +999,7 @@ static void HU_sendChatMessage(void)
void HU_clearChatChars(void)
{
memset(w_chat, '\0', sizeof(w_chat));
+ I_SetTextInputMode(false);
chat_on = false;
c_input = 0;
@@ -1048,6 +1049,7 @@ boolean HU_Responder(event_t *ev)
if ((ev->key == gamecontrol[GC_TALKKEY][0] || ev->key == gamecontrol[GC_TALKKEY][1])
&& netgame && !OLD_MUTE) // check for old chat mute, still let the players open the chat incase they want to scroll otherwise.
{
+ I_SetTextInputMode(true);
chat_on = true;
chat_on_first_event = false;
w_chat[0] = 0;
@@ -1059,6 +1061,7 @@ boolean HU_Responder(event_t *ev)
if ((ev->key == gamecontrol[GC_TEAMKEY][0] || ev->key == gamecontrol[GC_TEAMKEY][1])
&& netgame && !OLD_MUTE)
{
+ I_SetTextInputMode(true);
chat_on = true;
chat_on_first_event = false;
w_chat[0] = 0;
@@ -1133,6 +1136,7 @@ boolean HU_Responder(event_t *ev)
if (!CHAT_MUTE)
HU_sendChatMessage();
+ I_SetTextInputMode(false);
chat_on = false;
c_input = 0; // reset input cursor
chat_scrollmedown = true; // you hit enter, so you might wanna autoscroll to see what you just sent. :)
@@ -1143,6 +1147,7 @@ boolean HU_Responder(event_t *ev)
|| c == gamecontrol[GC_TEAMKEY][0] || c == gamecontrol[GC_TEAMKEY][1])
&& c >= KEY_MOUSE1)) // If it's not a keyboard key, then the chat button is used as a toggle.
{
+ I_SetTextInputMode(false);
chat_on = false;
c_input = 0; // reset input cursor
I_UpdateMouseGrab();
@@ -1213,27 +1218,36 @@ static void HU_drawMiniChat(void)
INT32 charwidth = 4, charheight = 6;
INT32 boxw = cv_chatwidth.value;
INT32 dx = 0, dy = 0;
+ boolean prev_linereturn = false;
if (!chat_nummsg_min)
return; // needless to say it's useless to do anything if we don't have anything to draw.
for (size_t i = chat_nummsg_min; i > 0; i--)
{
- char *msg = V_ChatWordWrap(chatx, boxw-charwidth, V_SNAPTOBOTTOM|V_SNAPTOLEFT|V_ALLOWLOWERCASE, chat_mini[i-1]);
+ char *msg = V_ChatWordWrap(0, boxw-charwidth-2, V_SNAPTOBOTTOM|V_SNAPTOLEFT|V_ALLOWLOWERCASE|V_MONOSPACE, chat_mini[i-1]);
for(size_t j = 0; msg[j]; j++) // iterate through msg
{
if (msg[j] == '\n') // get back down.
{
- chatheight += charheight;
- dx = 0;
+ if (!prev_linereturn)
+ {
+ chatheight += charheight;
+ dx = 0;
+ }
+ prev_linereturn = true;
}
else if (msg[j] >= FONTSTART)
{
+ prev_linereturn = false;
+
dx += charwidth;
- if (dx >= boxw)
+
+ if (dx >= boxw-charwidth-2)
{
dx = 0;
chatheight += charheight;
+ prev_linereturn = true;
}
}
}
@@ -1245,35 +1259,43 @@ static void HU_drawMiniChat(void)
}
y = chaty - (chatheight + charheight);
+ prev_linereturn = false;
for (size_t i = 0; i < chat_nummsg_min; i++) // iterate through our hot messages
{
INT32 timer = ((cv_chattime.value*TICRATE)-chat_timers[i]) - cv_chattime.value*TICRATE+9; // see below...
INT32 transflag = (timer >= 0 && timer <= 9) ? (timer*V_10TRANS) : 0; // you can make bad jokes out of this one.
- char *msg = V_ChatWordWrap(chatx, boxw-charwidth, V_SNAPTOBOTTOM|V_SNAPTOLEFT|V_ALLOWLOWERCASE, chat_mini[i]); // get the current message, and word wrap it.
+ char *msg = V_ChatWordWrap(0, boxw-charwidth-2, V_SNAPTOBOTTOM|V_SNAPTOLEFT|V_ALLOWLOWERCASE|V_MONOSPACE, chat_mini[i]); // get the current message, and word wrap it.
UINT8 *colormap = NULL;
for(size_t j = 0; msg[j]; j++) // iterate through msg
{
if (msg[j] == '\n') // get back down.
{
- dy += charheight;
- dx = 0;
+ if (!prev_linereturn)
+ {
+ dy += charheight;
+ dx = 0;
+ }
+ prev_linereturn = true;
}
else if (msg[j] & 0x80) // get colormap
colormap = V_GetStringColormap(((msg[j] & 0x7f) << V_CHARCOLORSHIFT) & V_CHARCOLORMASK);
else if (msg[j] >= FONTSTART)
{
+ prev_linereturn = false;
+
if (cv_chatbacktint.value) // on request of wolfy
V_DrawFillConsoleMap(x + dx + 2, y+dy, charwidth, charheight, 239|V_SNAPTOBOTTOM|V_SNAPTOLEFT);
- V_DrawChatCharacter(x + dx + 2, y+dy, msg[j] |V_SNAPTOBOTTOM|V_SNAPTOLEFT|transflag, true, colormap);
-
+ V_DrawChatCharacter(x + dx + 2, y+dy, msg[j] |V_SNAPTOBOTTOM|V_SNAPTOLEFT|V_MONOSPACE|transflag, true, colormap);
dx += charwidth;
- if (dx >= boxw)
+
+ if (dx >= boxw-charwidth-2)
{
dx = 0;
dy += charheight;
+ prev_linereturn = true;
}
}
}
@@ -1298,6 +1320,7 @@ static void HU_drawChatLog(INT32 offset)
UINT32 i = 0;
INT32 chat_topy, chat_bottomy;
boolean atbottom = false;
+ boolean prev_linereturn = false;
// make sure that our scroll position isn't "illegal";
if (chat_scroll > chat_maxscroll)
@@ -1330,27 +1353,38 @@ static void HU_drawChatLog(INT32 offset)
for (i=0; i<chat_nummsg_log; i++) // iterate through our chatlog
{
- char *msg = V_ChatWordWrap(chatx, boxw-charwidth, V_SNAPTOBOTTOM|V_SNAPTOLEFT|V_ALLOWLOWERCASE, chat_log[i]); // get the current message, and word wrap it.
+ char *msg = V_ChatWordWrap(0, boxw-charwidth-2, V_SNAPTOBOTTOM|V_SNAPTOLEFT|V_ALLOWLOWERCASE|V_MONOSPACE, chat_log[i]); // get the current message, and word wrap it.
UINT8 *colormap = NULL;
for(size_t j = 0; msg[j]; j++) // iterate through msg
{
if (msg[j] == '\n') // get back down.
{
- dy += charheight;
- dx = 0;
+ if (!prev_linereturn)
+ {
+ dy += charheight;
+ dx = 0;
+ }
+ prev_linereturn = true;
}
else if (msg[j] & 0x80) // get colormap
colormap = V_GetStringColormap(((msg[j] & 0x7f) << V_CHARCOLORSHIFT) & V_CHARCOLORMASK);
- else if (msg[j] >= FONTSTART)
+ else
{
- if ((y+dy+2 >= chat_topy) && (y+dy < (chat_bottomy)))
- V_DrawChatCharacter(x + dx + 2, y+dy+2, msg[j] |V_SNAPTOBOTTOM|V_SNAPTOLEFT, true, colormap);
+ prev_linereturn = false;
- dx += charwidth;
- if (dx >= boxw-charwidth-2 && i<chat_nummsg_log) // end of message shouldn't count, nor should invisible characters!!!!
+ if (msg[j] >= FONTSTART)
+ {
+ if ((y+dy+2 >= chat_topy) && (y+dy < (chat_bottomy)))
+ V_DrawChatCharacter(x + dx + 2, y+dy+2, msg[j] |V_SNAPTOBOTTOM|V_SNAPTOLEFT|V_MONOSPACE, true, colormap);
+
+ dx += charwidth;
+ }
+
+ if (dx >= boxw-charwidth-2 && i < chat_nummsg_log) // end of message shouldn't count, nor should invisible characters!!!!
{
dx = 0;
dy += charheight;
+ prev_linereturn = true;
}
}
}
@@ -2010,13 +2044,13 @@ static void HU_Draw32TeamTabRankings(playersort_t *tab, INT32 whiteplayer)
greycheck = greycheckdef;
supercheck = supercheckdef;
- if (tab[i].color == skincolor_redteam) //red
+ if (players[tab[i].num].ctfteam == 1) //red
{
redplayers++;
x = 14 + (BASEVIDWIDTH/2);
y = (redplayers * 9) + 20;
}
- else if (tab[i].color == skincolor_blueteam) //blue
+ else if (players[tab[i].num].ctfteam == 2) //blue
{
blueplayers++;
x = 14;
@@ -2098,7 +2132,7 @@ void HU_DrawTeamTabRankings(playersort_t *tab, INT32 whiteplayer)
if (players[tab[i].num].spectator)
continue; //ignore them.
- if (tab[i].color == skincolor_redteam) //red
+ if (players[tab[i].num].ctfteam == 1) //red
{
if (redplayers++ > 8)
{
@@ -2106,7 +2140,7 @@ void HU_DrawTeamTabRankings(playersort_t *tab, INT32 whiteplayer)
break; // don't make more loops than we need to.
}
}
- else if (tab[i].color == skincolor_blueteam) //blue
+ else if (players[tab[i].num].ctfteam == 2) //blue
{
if (blueplayers++ > 8)
{
@@ -2137,14 +2171,14 @@ void HU_DrawTeamTabRankings(playersort_t *tab, INT32 whiteplayer)
if (players[tab[i].num].spectator)
continue; //ignore them.
- if (tab[i].color == skincolor_redteam) //red
+ if (players[tab[i].num].ctfteam == 1) //red
{
if (redplayers++ > 8)
continue;
x = 32 + (BASEVIDWIDTH/2);
y = (redplayers * 16) + 16;
}
- else if (tab[i].color == skincolor_blueteam) //blue
+ else if (players[tab[i].num].ctfteam == 2) //blue
{
if (blueplayers++ > 8)
continue;
@@ -2458,53 +2492,20 @@ static inline void HU_DrawSpectatorTicker(void)
{
int i;
int length = 0, height = 174;
- int totallength = 0, templength = 0;
+ int totallength = 0;
for (i = 0; i < MAXPLAYERS; i++)
if (playeringame[i] && players[i].spectator)
totallength += (signed)strlen(player_names[i]) * 8 + 16;
- length -= (leveltime % (totallength + BASEVIDWIDTH));
- length += BASEVIDWIDTH;
+ length -= (leveltime % (totallength + (vid.width / vid.dup)));
+ length += (vid.width / vid.dup);
for (i = 0; i < MAXPLAYERS; i++)
if (playeringame[i] && players[i].spectator)
{
- char *pos;
- char initial[MAXPLAYERNAME+1];
- char current[MAXPLAYERNAME+1];
-
- strcpy(initial, player_names[i]);
- pos = initial;
-
- if (length >= -((signed)strlen(player_names[i]) * 8 + 16) && length <= BASEVIDWIDTH)
- {
- if (length < 0)
- {
- UINT8 eatenchars = (UINT8)(abs(length) / 8 + 1);
-
- if (eatenchars <= strlen(initial))
- {
- // Eat one letter off the left side,
- // then compensate the drawing position.
- pos += eatenchars;
- strcpy(current, pos);
- templength = length % 8 + 8;
- }
- else
- {
- strcpy(current, " ");
- templength = length;
- }
- }
- else
- {
- strcpy(current, initial);
- templength = length;
- }
-
- V_DrawString(templength, height + 8, V_TRANSLUCENT|V_ALLOWLOWERCASE, current);
- }
+ if (length >= -((signed)strlen(player_names[i]) * 8 + 16) && length <= (vid.width / vid.dup))
+ V_DrawString(length, height + 8, V_TRANSLUCENT|V_ALLOWLOWERCASE|V_SNAPTOLEFT, player_names[i]);
length += (signed)strlen(player_names[i]) * 8 + 16;
}
diff --git a/src/i_system.h b/src/i_system.h
index 3f0e05d127fa4ed5ce9aa8fbe89ff109773851f4..f4d169113c50b0ae5e2c1aca53b4d04f128658f4 100644
--- a/src/i_system.h
+++ b/src/i_system.h
@@ -339,4 +339,12 @@ void I_SetMouseGrab(boolean grab);
*/
const char *I_GetSysName(void);
+/** \brief Sets text input mode. When enabled, keyboard inputs will respect dead keys.
+ */
+void I_SetTextInputMode(boolean active);
+
+/** \brief Retrieves current text input mode.
+ */
+boolean I_GetTextInputMode(void);
+
#endif
diff --git a/src/info.c b/src/info.c
index ab46cdbc728de4d8d71c39e97adf245235301acc..d66c24af81aaafb851e6a83e699d2027add29cb5 100644
--- a/src/info.c
+++ b/src/info.c
@@ -26,9 +26,10 @@
#include "hardware/hw_light.h"
#endif
+
// Hey, moron! If you change this table, don't forget about the sprite enum in info.h and the sprite lights in hw_light.c!
// For the sake of constant merge conflicts, let's spread this out
-char sprnames[NUMSPRITES + 1][5] =
+char sprnames[NUMSPRITES + 1][MAXSPRITENAME + 1] =
{
"NULL", // invisible object
"UNKN",
@@ -525,7 +526,7 @@ char sprnames[NUMSPRITES + 1][5] =
"GWLR",
};
-char spr2names[NUMPLAYERSPRITES][5] =
+char spr2names[NUMPLAYERSPRITES][MAXSPRITENAME + 1] =
{
"STND",
"WAIT",
@@ -760,12 +761,12 @@ state_t states[NUMSTATES] =
{SPR_PLAY, SPR2_MLEL, 35, {NULL}, 0, 0, S_PLAY_WALK, 0}, // S_PLAY_MELEE_LANDING
// SF_SUPER
- {SPR_PLAY, SPR2_TRNS|FF_SPR2SUPER|FF_ANIMATE, 7, {NULL}, 0, 4, S_PLAY_SUPER_TRANS2, 0}, // S_PLAY_SUPER_TRANS1
- {SPR_PLAY, SPR2_TRNS|FF_SPR2SUPER, 3, {NULL}, 0, 0, S_PLAY_SUPER_TRANS3, 0}, // S_PLAY_SUPER_TRANS2
- {SPR_PLAY, SPR2_TRNS|FF_SPR2SUPER|FF_FULLBRIGHT, 2, {NULL}, 0, 0, S_PLAY_SUPER_TRANS4, 0}, // S_PLAY_SUPER_TRANS3
- {SPR_PLAY, SPR2_TRNS|FF_SPR2SUPER|FF_FULLBRIGHT, 2, {NULL}, 0, 0, S_PLAY_SUPER_TRANS5, 0}, // S_PLAY_SUPER_TRANS4
- {SPR_PLAY, SPR2_TRNS|FF_SPR2SUPER|FF_FULLBRIGHT, 2, {NULL}, 0, 0, S_PLAY_SUPER_TRANS6, 0}, // S_PLAY_SUPER_TRANS5
- {SPR_PLAY, SPR2_TRNS|FF_SPR2SUPER|FF_FULLBRIGHT, 19, {A_FadeOverlay}, 0, 0, S_PLAY_FALL, 0}, // S_PLAY_SUPER_TRANS6
+ {SPR_PLAY, SPR2_TRNS|SPR2F_SUPER|FF_ANIMATE, 7, {NULL}, 0, 4, S_PLAY_SUPER_TRANS2, 0}, // S_PLAY_SUPER_TRANS1
+ {SPR_PLAY, SPR2_TRNS|SPR2F_SUPER, 3, {NULL}, 0, 0, S_PLAY_SUPER_TRANS3, 0}, // S_PLAY_SUPER_TRANS2
+ {SPR_PLAY, SPR2_TRNS|SPR2F_SUPER|FF_FULLBRIGHT, 2, {NULL}, 0, 0, S_PLAY_SUPER_TRANS4, 0}, // S_PLAY_SUPER_TRANS3
+ {SPR_PLAY, SPR2_TRNS|SPR2F_SUPER|FF_FULLBRIGHT, 2, {NULL}, 0, 0, S_PLAY_SUPER_TRANS5, 0}, // S_PLAY_SUPER_TRANS4
+ {SPR_PLAY, SPR2_TRNS|SPR2F_SUPER|FF_FULLBRIGHT, 2, {NULL}, 0, 0, S_PLAY_SUPER_TRANS6, 0}, // S_PLAY_SUPER_TRANS5
+ {SPR_PLAY, SPR2_TRNS|SPR2F_SUPER|FF_FULLBRIGHT, 19, {A_FadeOverlay}, 0, 0, S_PLAY_FALL, 0}, // S_PLAY_SUPER_TRANS6
{SPR_NULL, 0, -1, {NULL}, 0, 0, S_OBJPLACE_DUMMY, 0}, //S_OBJPLACE_DUMMY
diff --git a/src/info.h b/src/info.h
index 9475b2302852c6ff2f1ad37cda5706eda9410b0e..f58aee07df70b3c6d72478b8b4c3448acfe615ab 100644
--- a/src/info.h
+++ b/src/info.h
@@ -298,276 +298,278 @@ enum actionnum
NUMACTIONS
};
+struct mobj_s;
+
// IMPORTANT NOTE: If you add/remove from this list of action
// functions, don't forget to update them in deh_tables.c!
-void A_Explode();
-void A_Pain();
-void A_Fall();
-void A_MonitorPop();
-void A_GoldMonitorPop();
-void A_GoldMonitorRestore();
-void A_GoldMonitorSparkle();
-void A_Look();
-void A_Chase();
-void A_FaceStabChase();
-void A_FaceStabRev();
-void A_FaceStabHurl();
-void A_FaceStabMiss();
-void A_StatueBurst();
-void A_FaceTarget();
-void A_FaceTracer();
-void A_Scream();
-void A_BossDeath();
-void A_SetShadowScale();
-void A_ShadowScream(); // MARIA!!!!!!
-void A_CustomPower(); // Use this for a custom power
-void A_GiveWeapon(); // Gives the player weapon(s)
-void A_RingBox(); // Obtained Ring Box Tails
-void A_Invincibility(); // Obtained Invincibility Box
-void A_SuperSneakers(); // Obtained Super Sneakers Box
-void A_BunnyHop(); // have bunny hop tails
-void A_BubbleSpawn(); // Randomly spawn bubbles
-void A_FanBubbleSpawn();
-void A_BubbleRise(); // Bubbles float to surface
-void A_BubbleCheck(); // Don't draw if not underwater
-void A_AwardScore();
-void A_ExtraLife(); // Extra Life
-void A_GiveShield(); // Obtained Shield
-void A_GravityBox();
-void A_ScoreRise(); // Rise the score logo
-void A_AttractChase(); // Ring Chase
-void A_DropMine(); // Drop Mine from Skim or Jetty-Syn Bomber
-void A_FishJump(); // Fish Jump
-void A_ThrownRing(); // Sparkle trail for red ring
-void A_SetSolidSteam();
-void A_UnsetSolidSteam();
-void A_SignSpin();
-void A_SignPlayer();
-void A_OverlayThink();
-void A_JetChase();
-void A_JetbThink(); // Jetty-Syn Bomber Thinker
-void A_JetgThink(); // Jetty-Syn Gunner Thinker
-void A_JetgShoot(); // Jetty-Syn Shoot Function
-void A_ShootBullet(); // JetgShoot without reactiontime setting
-void A_MinusDigging();
-void A_MinusPopup();
-void A_MinusCheck();
-void A_ChickenCheck();
-void A_MouseThink(); // Mouse Thinker
-void A_DetonChase(); // Deton Chaser
-void A_CapeChase(); // Fake little Super Sonic cape
-void A_RotateSpikeBall(); // Spike ball rotation
-void A_SlingAppear();
-void A_UnidusBall();
-void A_RockSpawn();
-void A_SetFuse();
-void A_CrawlaCommanderThink(); // Crawla Commander
-void A_SmokeTrailer();
-void A_RingExplode();
-void A_OldRingExplode();
-void A_MixUp();
-void A_RecyclePowers();
-void A_BossScream();
-void A_Boss2TakeDamage();
-void A_GoopSplat();
-void A_Boss2PogoSFX();
-void A_Boss2PogoTarget();
-void A_EggmanBox();
-void A_TurretFire();
-void A_SuperTurretFire();
-void A_TurretStop();
-void A_JetJawRoam();
-void A_JetJawChomp();
-void A_PointyThink();
-void A_CheckBuddy();
-void A_HoodFire();
-void A_HoodThink();
-void A_HoodFall();
-void A_ArrowBonks();
-void A_SnailerThink();
-void A_SharpChase();
-void A_SharpSpin();
-void A_SharpDecel();
-void A_CrushstaceanWalk();
-void A_CrushstaceanPunch();
-void A_CrushclawAim();
-void A_CrushclawLaunch();
-void A_VultureVtol();
-void A_VultureCheck();
-void A_VultureHover();
-void A_VultureBlast();
-void A_VultureFly();
-void A_SkimChase();
-void A_SkullAttack();
-void A_LobShot();
-void A_FireShot();
-void A_SuperFireShot();
-void A_BossFireShot();
-void A_Boss7FireMissiles();
-void A_Boss1Laser();
-void A_FocusTarget();
-void A_Boss4Reverse();
-void A_Boss4SpeedUp();
-void A_Boss4Raise();
-void A_SparkFollow();
-void A_BuzzFly();
-void A_GuardChase();
-void A_EggShield();
-void A_SetReactionTime();
-void A_Boss1Spikeballs();
-void A_Boss3TakeDamage();
-void A_Boss3Path();
-void A_Boss3ShockThink();
-void A_Shockwave();
-void A_LinedefExecute();
-void A_LinedefExecuteFromArg();
-void A_PlaySeeSound();
-void A_PlayAttackSound();
-void A_PlayActiveSound();
-void A_1upThinker();
-void A_BossZoom(); //Unused
-void A_Boss1Chase();
-void A_Boss2Chase();
-void A_Boss2Pogo();
-void A_Boss7Chase();
-void A_BossJetFume();
-void A_SpawnObjectAbsolute();
-void A_SpawnObjectRelative();
-void A_ChangeAngleRelative();
-void A_ChangeAngleAbsolute();
-void A_RollAngle();
-void A_ChangeRollAngleRelative();
-void A_ChangeRollAngleAbsolute();
-void A_PlaySound();
-void A_FindTarget();
-void A_FindTracer();
-void A_SetTics();
-void A_SetRandomTics();
-void A_ChangeColorRelative();
-void A_ChangeColorAbsolute();
-void A_Dye();
-void A_SetTranslation();
-void A_MoveRelative();
-void A_MoveAbsolute();
-void A_Thrust();
-void A_ZThrust();
-void A_SetTargetsTarget();
-void A_SetObjectFlags();
-void A_SetObjectFlags2();
-void A_RandomState();
-void A_RandomStateRange();
-void A_StateRangeByAngle();
-void A_StateRangeByParameter();
-void A_DualAction();
-void A_RemoteAction();
-void A_ToggleFlameJet();
-void A_OrbitNights();
-void A_GhostMe();
-void A_SetObjectState();
-void A_SetObjectTypeState();
-void A_KnockBack();
-void A_PushAway();
-void A_RingDrain();
-void A_SplitShot();
-void A_MissileSplit();
-void A_MultiShot();
-void A_InstaLoop();
-void A_Custom3DRotate();
-void A_SearchForPlayers();
-void A_CheckRandom();
-void A_CheckTargetRings();
-void A_CheckRings();
-void A_CheckTotalRings();
-void A_CheckHealth();
-void A_CheckRange();
-void A_CheckHeight();
-void A_CheckTrueRange();
-void A_CheckThingCount();
-void A_CheckAmbush();
-void A_CheckCustomValue();
-void A_CheckCusValMemo();
-void A_SetCustomValue();
-void A_UseCusValMemo();
-void A_RelayCustomValue();
-void A_CusValAction();
-void A_ForceStop();
-void A_ForceWin();
-void A_SpikeRetract();
-void A_InfoState();
-void A_Repeat();
-void A_SetScale();
-void A_RemoteDamage();
-void A_HomingChase();
-void A_TrapShot();
-void A_VileTarget();
-void A_VileAttack();
-void A_VileFire();
-void A_BrakChase();
-void A_BrakFireShot();
-void A_BrakLobShot();
-void A_NapalmScatter();
-void A_SpawnFreshCopy();
-void A_FlickySpawn();
-void A_FlickyCenter();
-void A_FlickyAim();
-void A_FlickyFly();
-void A_FlickySoar();
-void A_FlickyCoast();
-void A_FlickyHop();
-void A_FlickyFlounder();
-void A_FlickyCheck();
-void A_FlickyHeightCheck();
-void A_FlickyFlutter();
-void A_FlameParticle();
-void A_FadeOverlay();
-void A_Boss5Jump();
-void A_LightBeamReset();
-void A_MineExplode();
-void A_MineRange();
-void A_ConnectToGround();
-void A_SpawnParticleRelative();
-void A_MultiShotDist();
-void A_WhoCaresIfYourSonIsABee();
-void A_ParentTriesToSleep();
-void A_CryingToMomma();
-void A_CheckFlags2();
-void A_Boss5FindWaypoint();
-void A_DoNPCSkid();
-void A_DoNPCPain();
-void A_PrepareRepeat();
-void A_Boss5ExtraRepeat();
-void A_Boss5Calm();
-void A_Boss5CheckOnGround();
-void A_Boss5CheckFalling();
-void A_Boss5PinchShot();
-void A_Boss5MakeItRain();
-void A_Boss5MakeJunk();
-void A_LookForBetter();
-void A_Boss5BombExplode();
-void A_DustDevilThink();
-void A_TNTExplode();
-void A_DebrisRandom();
-void A_TrainCameo();
-void A_TrainCameo2();
-void A_CanarivoreGas();
-void A_KillSegments();
-void A_SnapperSpawn();
-void A_SnapperThinker();
-void A_SaloonDoorSpawn();
-void A_MinecartSparkThink();
-void A_ModuloToState();
-void A_LavafallRocks();
-void A_LavafallLava();
-void A_FallingLavaCheck();
-void A_FireShrink();
-void A_SpawnPterabytes();
-void A_PterabyteHover();
-void A_RolloutSpawn();
-void A_RolloutRock();
-void A_DragonbomberSpawn();
-void A_DragonWing();
-void A_DragonSegment();
-void A_ChangeHeight();
+void A_Explode(struct mobj_s *actor);
+void A_Pain(struct mobj_s *actor);
+void A_Fall(struct mobj_s *actor);
+void A_MonitorPop(struct mobj_s *actor);
+void A_GoldMonitorPop(struct mobj_s *actor);
+void A_GoldMonitorRestore(struct mobj_s *actor);
+void A_GoldMonitorSparkle(struct mobj_s *actor);
+void A_Look(struct mobj_s *actor);
+void A_Chase(struct mobj_s *actor);
+void A_FaceStabChase(struct mobj_s *actor);
+void A_FaceStabRev(struct mobj_s *actor);
+void A_FaceStabHurl(struct mobj_s *actor);
+void A_FaceStabMiss(struct mobj_s *actor);
+void A_StatueBurst(struct mobj_s *actor);
+void A_FaceTarget(struct mobj_s *actor);
+void A_FaceTracer(struct mobj_s *actor);
+void A_Scream(struct mobj_s *actor);
+void A_BossDeath(struct mobj_s *actor);
+void A_SetShadowScale(struct mobj_s *actor);
+void A_ShadowScream(struct mobj_s *actor); // MARIA!!!!!!
+void A_CustomPower(struct mobj_s *actor); // Use this for a custom power
+void A_GiveWeapon(struct mobj_s *actor); // Gives the player weapon(s)
+void A_RingBox(struct mobj_s *actor); // Obtained Ring Box Tails
+void A_Invincibility(struct mobj_s *actor); // Obtained Invincibility Box
+void A_SuperSneakers(struct mobj_s *actor); // Obtained Super Sneakers Box
+void A_BunnyHop(struct mobj_s *actor); // have bunny hop tails
+void A_BubbleSpawn(struct mobj_s *actor); // Randomly spawn bubbles
+void A_FanBubbleSpawn(struct mobj_s *actor);
+void A_BubbleRise(struct mobj_s *actor); // Bubbles float to surface
+void A_BubbleCheck(struct mobj_s *actor); // Don't draw if not underwater
+void A_AwardScore(struct mobj_s *actor);
+void A_ExtraLife(struct mobj_s *actor); // Extra Life
+void A_GiveShield(struct mobj_s *actor); // Obtained Shield
+void A_GravityBox(struct mobj_s *actor);
+void A_ScoreRise(struct mobj_s *actor); // Rise the score logo
+void A_AttractChase(struct mobj_s *actor); // Ring Chase
+void A_DropMine(struct mobj_s *actor); // Drop Mine from Skim or Jetty-Syn Bomber
+void A_FishJump(struct mobj_s *actor); // Fish Jump
+void A_ThrownRing(struct mobj_s *actor); // Sparkle trail for red ring
+void A_SetSolidSteam(struct mobj_s *actor);
+void A_UnsetSolidSteam(struct mobj_s *actor);
+void A_SignSpin(struct mobj_s *actor);
+void A_SignPlayer(struct mobj_s *actor);
+void A_OverlayThink(struct mobj_s *actor);
+void A_JetChase(struct mobj_s *actor);
+void A_JetbThink(struct mobj_s *actor); // Jetty-Syn Bomber Thinker
+void A_JetgThink(struct mobj_s *actor); // Jetty-Syn Gunner Thinker
+void A_JetgShoot(struct mobj_s *actor); // Jetty-Syn Shoot Function
+void A_ShootBullet(struct mobj_s *actor); // JetgShoot without reactiontime setting
+void A_MinusDigging(struct mobj_s *actor);
+void A_MinusPopup(struct mobj_s *actor);
+void A_MinusCheck(struct mobj_s *actor);
+void A_ChickenCheck(struct mobj_s *actor);
+void A_MouseThink(struct mobj_s *actor); // Mouse Thinker
+void A_DetonChase(struct mobj_s *actor); // Deton Chaser
+void A_CapeChase(struct mobj_s *actor); // Fake little Super Sonic cape
+void A_RotateSpikeBall(struct mobj_s *actor); // Spike ball rotation
+void A_SlingAppear(struct mobj_s *actor);
+void A_UnidusBall(struct mobj_s *actor);
+void A_RockSpawn(struct mobj_s *actor);
+void A_SetFuse(struct mobj_s *actor);
+void A_CrawlaCommanderThink(struct mobj_s *actor); // Crawla Commander
+void A_SmokeTrailer(struct mobj_s *actor);
+void A_RingExplode(struct mobj_s *actor);
+void A_OldRingExplode(struct mobj_s *actor);
+void A_MixUp(struct mobj_s *actor);
+void A_RecyclePowers(struct mobj_s *actor);
+void A_BossScream(struct mobj_s *actor);
+void A_Boss2TakeDamage(struct mobj_s *actor);
+void A_GoopSplat(struct mobj_s *actor);
+void A_Boss2PogoSFX(struct mobj_s *actor);
+void A_Boss2PogoTarget(struct mobj_s *actor);
+void A_EggmanBox(struct mobj_s *actor);
+void A_TurretFire(struct mobj_s *actor);
+void A_SuperTurretFire(struct mobj_s *actor);
+void A_TurretStop(struct mobj_s *actor);
+void A_JetJawRoam(struct mobj_s *actor);
+void A_JetJawChomp(struct mobj_s *actor);
+void A_PointyThink(struct mobj_s *actor);
+void A_CheckBuddy(struct mobj_s *actor);
+void A_HoodFire(struct mobj_s *actor);
+void A_HoodThink(struct mobj_s *actor);
+void A_HoodFall(struct mobj_s *actor);
+void A_ArrowBonks(struct mobj_s *actor);
+void A_SnailerThink(struct mobj_s *actor);
+void A_SharpChase(struct mobj_s *actor);
+void A_SharpSpin(struct mobj_s *actor);
+void A_SharpDecel(struct mobj_s *actor);
+void A_CrushstaceanWalk(struct mobj_s *actor);
+void A_CrushstaceanPunch(struct mobj_s *actor);
+void A_CrushclawAim(struct mobj_s *actor);
+void A_CrushclawLaunch(struct mobj_s *actor);
+void A_VultureVtol(struct mobj_s *actor);
+void A_VultureCheck(struct mobj_s *actor);
+void A_VultureHover(struct mobj_s *actor);
+void A_VultureBlast(struct mobj_s *actor);
+void A_VultureFly(struct mobj_s *actor);
+void A_SkimChase(struct mobj_s *actor);
+void A_SkullAttack(struct mobj_s *actor);
+void A_LobShot(struct mobj_s *actor);
+void A_FireShot(struct mobj_s *actor);
+void A_SuperFireShot(struct mobj_s *actor);
+void A_BossFireShot(struct mobj_s *actor);
+void A_Boss7FireMissiles(struct mobj_s *actor);
+void A_Boss1Laser(struct mobj_s *actor);
+void A_FocusTarget(struct mobj_s *actor);
+void A_Boss4Reverse(struct mobj_s *actor);
+void A_Boss4SpeedUp(struct mobj_s *actor);
+void A_Boss4Raise(struct mobj_s *actor);
+void A_SparkFollow(struct mobj_s *actor);
+void A_BuzzFly(struct mobj_s *actor);
+void A_GuardChase(struct mobj_s *actor);
+void A_EggShield(struct mobj_s *actor);
+void A_SetReactionTime(struct mobj_s *actor);
+void A_Boss1Spikeballs(struct mobj_s *actor);
+void A_Boss3TakeDamage(struct mobj_s *actor);
+void A_Boss3Path(struct mobj_s *actor);
+void A_Boss3ShockThink(struct mobj_s *actor);
+void A_Shockwave(struct mobj_s *actor);
+void A_LinedefExecute(struct mobj_s *actor);
+void A_LinedefExecuteFromArg(struct mobj_s *actor);
+void A_PlaySeeSound(struct mobj_s *actor);
+void A_PlayAttackSound(struct mobj_s *actor);
+void A_PlayActiveSound(struct mobj_s *actor);
+void A_1upThinker(struct mobj_s *actor);
+void A_BossZoom(struct mobj_s *actor); //Unused
+void A_Boss1Chase(struct mobj_s *actor);
+void A_Boss2Chase(struct mobj_s *actor);
+void A_Boss2Pogo(struct mobj_s *actor);
+void A_Boss7Chase(struct mobj_s *actor);
+void A_BossJetFume(struct mobj_s *actor);
+void A_SpawnObjectAbsolute(struct mobj_s *actor);
+void A_SpawnObjectRelative(struct mobj_s *actor);
+void A_ChangeAngleRelative(struct mobj_s *actor);
+void A_ChangeAngleAbsolute(struct mobj_s *actor);
+void A_RollAngle(struct mobj_s *actor);
+void A_ChangeRollAngleRelative(struct mobj_s *actor);
+void A_ChangeRollAngleAbsolute(struct mobj_s *actor);
+void A_PlaySound(struct mobj_s *actor);
+void A_FindTarget(struct mobj_s *actor);
+void A_FindTracer(struct mobj_s *actor);
+void A_SetTics(struct mobj_s *actor);
+void A_SetRandomTics(struct mobj_s *actor);
+void A_ChangeColorRelative(struct mobj_s *actor);
+void A_ChangeColorAbsolute(struct mobj_s *actor);
+void A_Dye(struct mobj_s *actor);
+void A_SetTranslation(struct mobj_s *actor);
+void A_MoveRelative(struct mobj_s *actor);
+void A_MoveAbsolute(struct mobj_s *actor);
+void A_Thrust(struct mobj_s *actor);
+void A_ZThrust(struct mobj_s *actor);
+void A_SetTargetsTarget(struct mobj_s *actor);
+void A_SetObjectFlags(struct mobj_s *actor);
+void A_SetObjectFlags2(struct mobj_s *actor);
+void A_RandomState(struct mobj_s *actor);
+void A_RandomStateRange(struct mobj_s *actor);
+void A_StateRangeByAngle(struct mobj_s *actor);
+void A_StateRangeByParameter(struct mobj_s *actor);
+void A_DualAction(struct mobj_s *actor);
+void A_RemoteAction(struct mobj_s *actor);
+void A_ToggleFlameJet(struct mobj_s *actor);
+void A_OrbitNights(struct mobj_s *actor);
+void A_GhostMe(struct mobj_s *actor);
+void A_SetObjectState(struct mobj_s *actor);
+void A_SetObjectTypeState(struct mobj_s *actor);
+void A_KnockBack(struct mobj_s *actor);
+void A_PushAway(struct mobj_s *actor);
+void A_RingDrain(struct mobj_s *actor);
+void A_SplitShot(struct mobj_s *actor);
+void A_MissileSplit(struct mobj_s *actor);
+void A_MultiShot(struct mobj_s *actor);
+void A_InstaLoop(struct mobj_s *actor);
+void A_Custom3DRotate(struct mobj_s *actor);
+void A_SearchForPlayers(struct mobj_s *actor);
+void A_CheckRandom(struct mobj_s *actor);
+void A_CheckTargetRings(struct mobj_s *actor);
+void A_CheckRings(struct mobj_s *actor);
+void A_CheckTotalRings(struct mobj_s *actor);
+void A_CheckHealth(struct mobj_s *actor);
+void A_CheckRange(struct mobj_s *actor);
+void A_CheckHeight(struct mobj_s *actor);
+void A_CheckTrueRange(struct mobj_s *actor);
+void A_CheckThingCount(struct mobj_s *actor);
+void A_CheckAmbush(struct mobj_s *actor);
+void A_CheckCustomValue(struct mobj_s *actor);
+void A_CheckCusValMemo(struct mobj_s *actor);
+void A_SetCustomValue(struct mobj_s *actor);
+void A_UseCusValMemo(struct mobj_s *actor);
+void A_RelayCustomValue(struct mobj_s *actor);
+void A_CusValAction(struct mobj_s *actor);
+void A_ForceStop(struct mobj_s *actor);
+void A_ForceWin(struct mobj_s *actor);
+void A_SpikeRetract(struct mobj_s *actor);
+void A_InfoState(struct mobj_s *actor);
+void A_Repeat(struct mobj_s *actor);
+void A_SetScale(struct mobj_s *actor);
+void A_RemoteDamage(struct mobj_s *actor);
+void A_HomingChase(struct mobj_s *actor);
+void A_TrapShot(struct mobj_s *actor);
+void A_VileTarget(struct mobj_s *actor);
+void A_VileAttack(struct mobj_s *actor);
+void A_VileFire(struct mobj_s *actor);
+void A_BrakChase(struct mobj_s *actor);
+void A_BrakFireShot(struct mobj_s *actor);
+void A_BrakLobShot(struct mobj_s *actor);
+void A_NapalmScatter(struct mobj_s *actor);
+void A_SpawnFreshCopy(struct mobj_s *actor);
+void A_FlickySpawn(struct mobj_s *actor);
+void A_FlickyCenter(struct mobj_s *actor);
+void A_FlickyAim(struct mobj_s *actor);
+void A_FlickyFly(struct mobj_s *actor);
+void A_FlickySoar(struct mobj_s *actor);
+void A_FlickyCoast(struct mobj_s *actor);
+void A_FlickyHop(struct mobj_s *actor);
+void A_FlickyFlounder(struct mobj_s *actor);
+void A_FlickyCheck(struct mobj_s *actor);
+void A_FlickyHeightCheck(struct mobj_s *actor);
+void A_FlickyFlutter(struct mobj_s *actor);
+void A_FlameParticle(struct mobj_s *actor);
+void A_FadeOverlay(struct mobj_s *actor);
+void A_Boss5Jump(struct mobj_s *actor);
+void A_LightBeamReset(struct mobj_s *actor);
+void A_MineExplode(struct mobj_s *actor);
+void A_MineRange(struct mobj_s *actor);
+void A_ConnectToGround(struct mobj_s *actor);
+void A_SpawnParticleRelative(struct mobj_s *actor);
+void A_MultiShotDist(struct mobj_s *actor);
+void A_WhoCaresIfYourSonIsABee(struct mobj_s *actor);
+void A_ParentTriesToSleep(struct mobj_s *actor);
+void A_CryingToMomma(struct mobj_s *actor);
+void A_CheckFlags2(struct mobj_s *actor);
+void A_Boss5FindWaypoint(struct mobj_s *actor);
+void A_DoNPCSkid(struct mobj_s *actor);
+void A_DoNPCPain(struct mobj_s *actor);
+void A_PrepareRepeat(struct mobj_s *actor);
+void A_Boss5ExtraRepeat(struct mobj_s *actor);
+void A_Boss5Calm(struct mobj_s *actor);
+void A_Boss5CheckOnGround(struct mobj_s *actor);
+void A_Boss5CheckFalling(struct mobj_s *actor);
+void A_Boss5PinchShot(struct mobj_s *actor);
+void A_Boss5MakeItRain(struct mobj_s *actor);
+void A_Boss5MakeJunk(struct mobj_s *actor);
+void A_LookForBetter(struct mobj_s *actor);
+void A_Boss5BombExplode(struct mobj_s *actor);
+void A_DustDevilThink(struct mobj_s *actor);
+void A_TNTExplode(struct mobj_s *actor);
+void A_DebrisRandom(struct mobj_s *actor);
+void A_TrainCameo(struct mobj_s *actor);
+void A_TrainCameo2(struct mobj_s *actor);
+void A_CanarivoreGas(struct mobj_s *actor);
+void A_KillSegments(struct mobj_s *actor);
+void A_SnapperSpawn(struct mobj_s *actor);
+void A_SnapperThinker(struct mobj_s *actor);
+void A_SaloonDoorSpawn(struct mobj_s *actor);
+void A_MinecartSparkThink(struct mobj_s *actor);
+void A_ModuloToState(struct mobj_s *actor);
+void A_LavafallRocks(struct mobj_s *actor);
+void A_LavafallLava(struct mobj_s *actor);
+void A_FallingLavaCheck(struct mobj_s *actor);
+void A_FireShrink(struct mobj_s *actor);
+void A_SpawnPterabytes(struct mobj_s *actor);
+void A_PterabyteHover(struct mobj_s *actor);
+void A_RolloutSpawn(struct mobj_s *actor);
+void A_RolloutRock(struct mobj_s *actor);
+void A_DragonbomberSpawn(struct mobj_s *actor);
+void A_DragonWing(struct mobj_s *actor);
+void A_DragonSegment(struct mobj_s *actor);
+void A_ChangeHeight(struct mobj_s *actor);
extern int actionsoverridden[NUMACTIONS][MAX_ACTION_RECURSION];
@@ -575,6 +577,7 @@ extern int actionsoverridden[NUMACTIONS][MAX_ACTION_RECURSION];
#define NUMMOBJFREESLOTS 1024
#define NUMSPRITEFREESLOTS NUMMOBJFREESLOTS
#define NUMSTATEFREESLOTS (NUMMOBJFREESLOTS*8)
+#define MAXSPRITENAME 64
// Hey, moron! If you change this table, don't forget about sprnames in info.c and the sprite lights in hw_light.c!
typedef enum sprite
@@ -4383,8 +4386,8 @@ typedef struct
} state_t;
extern state_t states[NUMSTATES];
-extern char sprnames[NUMSPRITES + 1][5];
-extern char spr2names[NUMPLAYERSPRITES][5];
+extern char sprnames[NUMSPRITES + 1][MAXSPRITENAME + 1];
+extern char spr2names[NUMPLAYERSPRITES][MAXSPRITENAME + 1];
extern playersprite_t spr2defaults[NUMPLAYERSPRITES];
extern state_t *astate;
extern playersprite_t free_spr2;
diff --git a/src/lua_baselib.c b/src/lua_baselib.c
index 9e4eebeb08fd5b84b59c580f8221a1fa05b4b3f8..304c866c9c9ee6c8fc78b0c860a8a0ed09d83cb3 100644
--- a/src/lua_baselib.c
+++ b/src/lua_baselib.c
@@ -184,8 +184,10 @@ static const struct {
{META_SKIN, "skin_t"},
{META_POWERS, "player_t.powers"},
{META_SOUNDSID, "skin_t.soundsid"},
- {META_SKINSPRITES, "skin_t.sprites"},
- {META_SKINSPRITESLIST, "skin_t.sprites[]"},
+
+ {META_SKINSPRITES, "skin_t.skinsprites"},
+ {META_SKINSPRITESLIST, "skin_t.skinsprites[]"},
+ {META_SKINSPRITESCOMPAT, "skin_t.sprites"}, // TODO: 2.3: Delete
{META_VERTEX, "vertex_t"},
{META_LINE, "line_t"},
@@ -345,6 +347,18 @@ static int lib_reserveLuabanks(lua_State *L)
return 1;
}
+static int lib_tofixed(lua_State *L)
+{
+ const char *arg = luaL_checkstring(L, 1);
+ char *end;
+ float f = strtof(arg, &end);
+ if (*end != '\0')
+ lua_pushnil(L);
+ else
+ lua_pushnumber(L, FLOAT_TO_FIXED(f));
+ return 1;
+}
+
// M_MENU
//////////////
@@ -641,7 +655,7 @@ static int lib_pSpawnMobj(lua_State *L)
NOHUD
INLEVEL
NOSPAWNNULL
- LUA_PushUserdata(L, P_SpawnMobj(x, y, z, type), META_MOBJ);
+ LUA_PushUserdata(L, P_SpawnMobj(x, y, z, type, NULL), META_MOBJ);
return 1;
}
@@ -3030,6 +3044,9 @@ static int lib_rFrame2Char(lua_State *L)
//HUDSAFE
c[0] = R_Frame2Char(ch);
+ if (c[0] == '\xFF')
+ return luaL_error(L, "frame %u cannot be represented by a character", ch);
+
c[1] = 0;
lua_pushstring(L, c);
@@ -3861,7 +3878,7 @@ static int lib_gAddPlayer(lua_State *L)
player_t *newplayer;
SINT8 skinnum = 0, bot;
- for (i = 0; i < MAXPLAYERS; i++)
+ for (i = 1; i < MAXPLAYERS; i++)
{
if (!playeringame[i])
break;
@@ -4330,6 +4347,7 @@ static luaL_Reg lib[] = {
{"userdataMetatable", lib_userdataMetatable},
{"IsPlayerAdmin", lib_isPlayerAdmin},
{"reserveLuabanks", lib_reserveLuabanks},
+ {"tofixed", lib_tofixed},
// m_menu
{"M_MoveColorAfter",lib_pMoveColorAfter},
diff --git a/src/lua_hudlib.c b/src/lua_hudlib.c
index ddd6c688802076a913a8d55d3597d1b9aafc9454..d6771f1082a635e2bcb9e26ffb4349398113397c 100644
--- a/src/lua_hudlib.c
+++ b/src/lua_hudlib.c
@@ -492,9 +492,7 @@ static int libd_getSpritePatch(lua_State *L)
else if (lua_isstring(L, 1)) // sprite prefix name given, e.g. "THOK"
{
const char *name = lua_tostring(L, 1);
- for (i = 0; i < NUMSPRITES; i++)
- if (fastcmp(name, sprnames[i]))
- break;
+ i = R_GetSpriteNumByName(name);
if (i >= NUMSPRITES)
return 0;
}
diff --git a/src/lua_hudlib_drawlist.c b/src/lua_hudlib_drawlist.c
index c518ba52540ff874480d7cda2c8314a31987e993..cb58e628ea005217c819ddea922f4952f70961f0 100644
--- a/src/lua_hudlib_drawlist.c
+++ b/src/lua_hudlib_drawlist.c
@@ -180,7 +180,8 @@ static const char *CopyString(huddrawlist_h list, const char* str)
const char *old_offset = list->strbuf;
size_t i;
if (list->strbuf_capacity == 0) list->strbuf_capacity = 256;
- else list->strbuf_capacity *= 2;
+ while (list->strbuf_capacity <= list->strbuf_len + lenstr + 1)
+ list->strbuf_capacity *= 2;
list->strbuf = (char*) Z_Realloc(list->strbuf, sizeof(char) * list->strbuf_capacity, PU_STATIC, NULL);
// align the string pointers to make sure old pointers don't point towards invalid addresses
diff --git a/src/lua_infolib.c b/src/lua_infolib.c
index 0bcbcc5b983da37130a1ef7a1133c3a9b7193ea3..511c20031f8ea82d74c70da608535146bfce8eb2 100644
--- a/src/lua_infolib.c
+++ b/src/lua_infolib.c
@@ -88,12 +88,12 @@ static int lib_getSprname(lua_State *L)
else if (lua_isstring(L, 1))
{
const char *name = lua_tostring(L, 1);
- for (i = 0; i < NUMSPRITES; i++)
- if (fastcmp(name, sprnames[i]))
- {
- lua_pushinteger(L, i);
- return 1;
- }
+ i = R_GetSpriteNumByName(name);
+ if (i != NUMSPRITES)
+ {
+ lua_pushinteger(L, i);
+ return 1;
+ }
}
return 0;
}
@@ -242,25 +242,13 @@ static int lib_getSpriteInfo(lua_State *L)
UINT32 i = NUMSPRITES;
lua_remove(L, 1);
- if (lua_isstring(L, 1))
+ if (lua_type(L, 1) == LUA_TSTRING)
{
const char *name = lua_tostring(L, 1);
- INT32 spr;
- for (spr = 0; spr < NUMSPRITES; spr++)
- {
- if (fastcmp(name, sprnames[spr]))
- {
- i = spr;
- break;
- }
- }
- if (i == NUMSPRITES)
- {
- char *check;
- i = strtol(name, &check, 10);
- if (check == name || *check != '\0')
- return luaL_error(L, "unknown sprite name %s", name);
- }
+ INT32 spr = R_GetSpriteNumByName(name);
+ if (spr == NUMSPRITES)
+ return luaL_error(L, "unknown sprite name %s", name);
+ i = spr;
}
else
i = luaL_checkinteger(L, 1);
@@ -359,8 +347,8 @@ static int PopPivotTable(spriteinfo_t *info, lua_State *L, int stk)
default:
TYPEERROR("pivot frame", LUA_TNUMBER, lua_type(L, stk+1));
}
- if ((idx < 0) || (idx >= 64))
- return luaL_error(L, "pivot frame %d out of range (0 - %d)", idx, 63);
+ if ((idx < 0) || (idx >= MAXFRAMENUM))
+ return luaL_error(L, "pivot frame %d out of range (0 - %d)", idx, MAXFRAMENUM - 1);
// the values in pivot[] are also tables
if (PopPivotSubTable(info->pivot, L, stk+2, idx))
info->available = true;
@@ -555,7 +543,7 @@ static int pivotlist_set(lua_State *L)
static int pivotlist_num(lua_State *L)
{
- lua_pushinteger(L, 64);
+ lua_pushinteger(L, MAXFRAMENUM);
return 1;
}
@@ -1747,7 +1735,7 @@ static int lib_setSkinColor(lua_State *L)
else if (i == 6 || (str && fastcmp(str,"accessible"))) {
boolean v = lua_toboolean(L, 3);
if (cnum < FIRSTSUPERCOLOR && v != skincolors[cnum].accessible)
- CONS_Alert(CONS_WARNING, "skincolors[] index %d is a standard color; accessibility changes are prohibited.", cnum);
+ CONS_Alert(CONS_WARNING, "skincolors[] index %d is a standard color; accessibility changes are prohibited.\n", cnum);
else
info->accessible = v;
}
@@ -1842,7 +1830,7 @@ static int skincolor_set(lua_State *L)
else if (fastcmp(field,"accessible")) {
boolean v = lua_toboolean(L, 3);
if (cnum < FIRSTSUPERCOLOR && v != skincolors[cnum].accessible)
- CONS_Alert(CONS_WARNING, "skincolors[] index %d is a standard color; accessibility changes are prohibited.", cnum);
+ CONS_Alert(CONS_WARNING, "skincolors[] index %d is a standard color; accessibility changes are prohibited.\n", cnum);
else
info->accessible = v;
} else
diff --git a/src/lua_libs.h b/src/lua_libs.h
index a90d8ac7fb800c426e7bef94538803366a835b8b..90c7bba7c6f247c100dd619d05f54e57edc6d468 100644
--- a/src/lua_libs.h
+++ b/src/lua_libs.h
@@ -42,8 +42,9 @@ extern boolean ignoregameinputs;
#define META_SKIN "SKIN_T*"
#define META_POWERS "PLAYER_T*POWERS"
#define META_SOUNDSID "SKIN_T*SOUNDSID"
-#define META_SKINSPRITES "SKIN_T*SPRITES"
-#define META_SKINSPRITESLIST "SKIN_T*SPRITES[]"
+#define META_SKINSPRITES "SKIN_T*SKINSPRITES"
+#define META_SKINSPRITESLIST "SKIN_T*SKINSPRITES[]"
+#define META_SKINSPRITESCOMPAT "SKIN_T*SPRITES" // TODO: 2.3: Delete
#define META_VERTEX "VERTEX_T*"
#define META_LINE "LINE_T*"
diff --git a/src/lua_maplib.c b/src/lua_maplib.c
index 6b489f22b1939941c0ebf83a5a3ae0b7e215de5a..9985e5631201752eddf1ba2abc71aa7304da8f62 100644
--- a/src/lua_maplib.c
+++ b/src/lua_maplib.c
@@ -213,6 +213,14 @@ enum side_e {
side_sector,
side_special,
side_repeatcnt,
+ side_light,
+ side_light_top,
+ side_light_mid,
+ side_light_bottom,
+ side_lightabsolute,
+ side_lightabsolute_top,
+ side_lightabsolute_mid,
+ side_lightabsolute_bottom,
side_text
};
@@ -241,6 +249,14 @@ static const char *const side_opt[] = {
"sector",
"special",
"repeatcnt",
+ "light",
+ "light_top",
+ "light_mid",
+ "light_bottom",
+ "lightabsolute",
+ "lightabsolute_top",
+ "lightabsolute_mid",
+ "lightabsolute_bottom",
"text",
NULL};
@@ -1311,6 +1327,30 @@ static int side_get(lua_State *L)
case side_repeatcnt:
lua_pushinteger(L, side->repeatcnt);
return 1;
+ case side_light:
+ lua_pushinteger(L, side->light);
+ return 1;
+ case side_light_top:
+ lua_pushinteger(L, side->light_top);
+ return 1;
+ case side_light_mid:
+ lua_pushinteger(L, side->light_mid);
+ return 1;
+ case side_light_bottom:
+ lua_pushinteger(L, side->light_bottom);
+ return 1;
+ case side_lightabsolute:
+ lua_pushboolean(L, side->lightabsolute);
+ return 1;
+ case side_lightabsolute_top:
+ lua_pushboolean(L, side->lightabsolute_top);
+ return 1;
+ case side_lightabsolute_mid:
+ lua_pushboolean(L, side->lightabsolute_mid);
+ return 1;
+ case side_lightabsolute_bottom:
+ lua_pushboolean(L, side->lightabsolute_bottom);
+ return 1;
// TODO: 2.3: Delete
case side_text:
{
@@ -1413,6 +1453,30 @@ static int side_set(lua_State *L)
case side_repeatcnt:
side->repeatcnt = luaL_checkinteger(L, 3);
break;
+ case side_light:
+ side->light = luaL_checkinteger(L, 3);
+ break;
+ case side_light_top:
+ side->light_top = luaL_checkinteger(L, 3);
+ break;
+ case side_light_mid:
+ side->light_mid = luaL_checkinteger(L, 3);
+ break;
+ case side_light_bottom:
+ side->light_bottom = luaL_checkinteger(L, 3);
+ break;
+ case side_lightabsolute:
+ side->lightabsolute = luaL_checkboolean(L, 3);
+ break;
+ case side_lightabsolute_top:
+ side->lightabsolute_top = luaL_checkboolean(L, 3);
+ break;
+ case side_lightabsolute_mid:
+ side->lightabsolute_mid = luaL_checkboolean(L, 3);
+ break;
+ case side_lightabsolute_bottom:
+ side->lightabsolute_bottom = luaL_checkboolean(L, 3);
+ break;
}
return 0;
}
diff --git a/src/lua_mobjlib.c b/src/lua_mobjlib.c
index de7065790abb137e82f505c961215ca6acb10429..eadcbe33b0b676447f43f6479693046e507c02b6 100644
--- a/src/lua_mobjlib.c
+++ b/src/lua_mobjlib.c
@@ -69,6 +69,7 @@ enum mobj_e {
mobj_color,
mobj_translation,
mobj_blendmode,
+ mobj_alpha,
mobj_bnext,
mobj_bprev,
mobj_hnext,
@@ -150,6 +151,7 @@ static const char *const mobj_opt[] = {
"color",
"translation",
"blendmode",
+ "alpha",
"bnext",
"bprev",
"hnext",
@@ -354,6 +356,9 @@ static int mobj_get(lua_State *L)
case mobj_blendmode:
lua_pushinteger(L, mo->blendmode);
break;
+ case mobj_alpha:
+ lua_pushfixed(L, mo->alpha);
+ break;
case mobj_bnext:
if (mo->blocknode && mo->blocknode->bnext) {
LUA_PushUserdata(L, mo->blocknode->bnext->mobj, META_MOBJ);
@@ -733,6 +738,16 @@ static int mobj_set(lua_State *L)
mo->blendmode = blendmode;
break;
}
+ case mobj_alpha:
+ {
+ fixed_t alpha = luaL_checkfixed(L, 3);
+ if (alpha < 0)
+ alpha = 0;
+ else if (alpha > FRACUNIT)
+ alpha = FRACUNIT;
+ mo->alpha = alpha;
+ break;
+ }
case mobj_bnext:
return NOSETPOS;
case mobj_bprev:
diff --git a/src/lua_script.c b/src/lua_script.c
index b62fa675e2e7193da3a688d89d2f1cf377298a51..057899555480383611652c552e41bf41398b0e2b 100644
--- a/src/lua_script.c
+++ b/src/lua_script.c
@@ -622,9 +622,6 @@ static inline boolean LUA_LoadFile(MYFILE *f, char *name)
if (!gL) // Lua needs to be initialized
LUA_ClearState();
- lua_pushinteger(gL, f->wad);
- lua_setfield(gL, LUA_REGISTRYINDEX, "WAD");
-
lua_pushcfunction(gL, LUA_GetErrorMessage);
errorhandlerindex = lua_gettop(gL);
diff --git a/src/lua_skinlib.c b/src/lua_skinlib.c
index 24d948a6735c3c723dcbf86c285a23c8367090dd..26f4011d34a6328b3b76bd3dde67ae275bfcd824 100644
--- a/src/lua_skinlib.c
+++ b/src/lua_skinlib.c
@@ -54,7 +54,8 @@ enum skin {
skin_contspeed,
skin_contangle,
skin_soundsid,
- skin_sprites,
+ skin_sprites, // TODO: 2.3: Delete
+ skin_skinsprites,
skin_supersprites,
skin_natkcolor
};
@@ -95,7 +96,8 @@ static const char *const skin_opt[] = {
"contspeed",
"contangle",
"soundsid",
- "sprites",
+ "sprites", // TODO: 2.3: Delete
+ "skinsprites",
"supersprites",
"natkcolor",
NULL};
@@ -219,7 +221,10 @@ static int skin_get(lua_State *L)
case skin_soundsid:
LUA_PushUserdata(L, skin->soundsid, META_SOUNDSID);
break;
- case skin_sprites:
+ case skin_sprites: // TODO: 2.3: Delete
+ LUA_PushUserdata(L, skin->sprites_compat, META_SKINSPRITESCOMPAT);
+ break;
+ case skin_skinsprites:
LUA_PushUserdata(L, skin->sprites, META_SKINSPRITES);
break;
case skin_supersprites:
@@ -338,15 +343,7 @@ static int soundsid_num(lua_State *L)
return 1;
}
-enum spritesopt {
- numframes = 0
-};
-
-static const char *const sprites_opt[] = {
- "numframes",
- NULL};
-
-// skin.sprites[i] -> sprites[i]
+// skin.skinsprites[i] -> sprites[i]
static int lib_getSkinSprite(lua_State *L)
{
spritedef_t *sksprites = *(spritedef_t **)luaL_checkudata(L, 1, META_SKINSPRITES);
@@ -359,13 +356,43 @@ static int lib_getSkinSprite(lua_State *L)
return 1;
}
-// #skin.sprites -> NUMPLAYERSPRITES
+// #skin.skinsprites -> NUMPLAYERSPRITES
static int lib_numSkinsSprites(lua_State *L)
{
lua_pushinteger(L, NUMPLAYERSPRITES);
return 1;
}
+// TODO: 2.3: Delete
+// skin.sprites[i] -> sprites[i]
+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);
+
+ if (i < 0 || i >= NUMPLAYERSPRITES*2)
+ return luaL_error(L, "skin sprites index %d out of range (0 - %d)", i, (NUMPLAYERSPRITES*2)-1);
+
+ LUA_PushUserdata(L, &sksprites[i], META_SKINSPRITESLIST);
+ return 1;
+}
+
+// TODO: 2.3: Delete
+// #skin.sprites -> NUMPLAYERSPRITES*2
+static int lib_numSkinsSpritesCompat(lua_State *L)
+{
+ lua_pushinteger(L, NUMPLAYERSPRITES*2);
+ return 1;
+}
+
+enum spritesopt {
+ numframes = 0
+};
+
+static const char *const sprites_opt[] = {
+ "numframes",
+ NULL};
+
static int sprite_get(lua_State *L)
{
spritedef_t *sprite = *(spritedef_t **)luaL_checkudata(L, 1, META_SKINSPRITESLIST);
@@ -387,6 +414,7 @@ int LUA_SkinLib(lua_State *L)
LUA_RegisterUserdataMetatable(L, META_SOUNDSID, soundsid_get, NULL, soundsid_num);
LUA_RegisterUserdataMetatable(L, META_SKINSPRITES, lib_getSkinSprite, NULL, lib_numSkinsSprites);
LUA_RegisterUserdataMetatable(L, META_SKINSPRITESLIST, sprite_get, NULL, NULL);
+ LUA_RegisterUserdataMetatable(L, META_SKINSPRITESCOMPAT, lib_getSkinSpriteCompat, NULL, lib_numSkinsSpritesCompat); // TODO: 2.3: Delete
skin_fields_ref = Lua_CreateFieldTable(L, skin_opt);
diff --git a/src/m_cond.c b/src/m_cond.c
index 5a5913297157e24ada893ca5fad77a4d38ffd3e3..fa6cda223c376b2f458605ec4f99e23e1c28c2d2 100644
--- a/src/m_cond.c
+++ b/src/m_cond.c
@@ -494,6 +494,12 @@ UINT8 M_MapLocked(INT32 mapnum, gamedata_t *data)
UINT8 M_CampaignWarpIsCheat(INT32 gt, INT32 mapnum, gamedata_t *data)
{
+ if (dedicated)
+ {
+ // See M_MapLocked; don't make dedicated servers annoying.
+ return false;
+ }
+
if (M_MapLocked(mapnum, data) == true)
{
// Warping to locked maps is definitely always a cheat
diff --git a/src/m_menu.c b/src/m_menu.c
index 50011347550c32622238ef02a6d538be62bbb31f..301c4007538f4823ddd45ad33d0403c89c21e52e 100644
--- a/src/m_menu.c
+++ b/src/m_menu.c
@@ -140,6 +140,7 @@ 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
{
@@ -263,7 +264,7 @@ static void M_ConfirmTeamScramble(INT32 choice);
static void M_ConfirmTeamChange(INT32 choice);
static void M_SecretsMenu(INT32 choice);
static void M_SetupChoosePlayer(INT32 choice);
-static UINT16 M_SetupChoosePlayerDirect(INT32 choice);
+static INT32 M_SetupChoosePlayerDirect(INT32 choice);
static void M_QuitSRB2(INT32 choice);
menu_t SP_MainDef, OP_MainDef;
menu_t MISC_ScrambleTeamDef, MISC_ChangeTeamDef;
@@ -2102,6 +2103,12 @@ menu_t OP_PlaystyleDef = {
0, 0, 0, NULL
};
+static void M_UpdateItemOn(void)
+{
+ I_SetTextInputMode((currentMenu->menuitems[itemOn].status & IT_CVARTYPE) == IT_CV_STRING ||
+ (currentMenu->menuitems[itemOn].status & IT_TYPE) == IT_KEYHANDLER);
+}
+
static void M_VideoOptions(INT32 choice)
{
(void)choice;
@@ -2329,6 +2336,7 @@ void Nextmap_OnChange(void)
{
currentMenu->lastOn = itemOn;
itemOn = nastart;
+ M_UpdateItemOn();
}
}
else if (currentMenu == &SP_TimeAttackDef)
@@ -2378,6 +2386,7 @@ void Nextmap_OnChange(void)
{
currentMenu->lastOn = itemOn;
itemOn = tastart;
+ M_UpdateItemOn();
}
if (mapheaderinfo[cv_nextmap.value-1] && mapheaderinfo[cv_nextmap.value-1]->forcecharacter[0] != '\0')
@@ -3128,6 +3137,7 @@ static void M_NextOpt(void)
else
itemOn++;
} while (oldItemOn != itemOn && ( (currentMenu->menuitems[itemOn].status & IT_TYPE) & IT_SPACE ));
+ M_UpdateItemOn();
}
static void M_PrevOpt(void)
@@ -3140,6 +3150,7 @@ static void M_PrevOpt(void)
else
itemOn--;
} while (oldItemOn != itemOn && ( (currentMenu->menuitems[itemOn].status & IT_TYPE) & IT_SPACE ));
+ M_UpdateItemOn();
}
// lock out further input in a tic when important buttons are pressed
@@ -3151,6 +3162,7 @@ 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;
}
@@ -3330,6 +3342,7 @@ 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;
@@ -3340,6 +3353,7 @@ 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;
@@ -3351,6 +3365,7 @@ 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;
@@ -3621,6 +3636,230 @@ 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
//
@@ -3651,18 +3890,29 @@ 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)
{
currentMenu = &MAPauseDef;
MAPauseMenu[mapause_hints].status = (M_SecretUnlocked(SECRET_EMBLEMHINTS, clientGamedata)) ? (IT_STRING | IT_CALL) : (IT_DISABLED);
itemOn = mapause_continue;
+ M_UpdateItemOn();
}
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);
-
+
if (gamestate != GS_LEVEL || ultimatemode) // intermission, so gray out stuff.
{
SPauseMenu[spause_pandora].status = (pandora) ? (IT_GRAYEDOUT) : (IT_DISABLED);
@@ -3703,6 +3953,7 @@ void M_StartControlPanel(void)
currentMenu = &SPauseDef;
itemOn = spause_continue;
+ M_UpdateItemOn();
}
else // multiplayer
{
@@ -3744,6 +3995,7 @@ void M_StartControlPanel(void)
currentMenu = &MPauseDef;
itemOn = mpause_continue;
+ M_UpdateItemOn();
}
CON_ToggleOff(); // move away console
@@ -3837,6 +4089,7 @@ void M_SetupNextMenu(menu_t *menudef)
}
}
}
+ M_UpdateItemOn();
hidetitlemap = false;
}
@@ -4015,11 +4268,11 @@ static void M_DrawThermo(INT32 x, INT32 y, consvar_t *cv)
lumpnum_t leftlump, rightlump, centerlump[2], cursorlump;
patch_t *p;
- leftlump = W_GetNumForName("M_THERML");
- rightlump = W_GetNumForName("M_THERMR");
- centerlump[0] = W_GetNumForName("M_THERMM");
- centerlump[1] = W_GetNumForName("M_THERMM");
- cursorlump = W_GetNumForName("M_THERMO");
+ leftlump = W_GetNumForPatchName("M_THERML");
+ rightlump = W_GetNumForPatchName("M_THERMR");
+ centerlump[0] = W_GetNumForPatchName("M_THERMM");
+ centerlump[1] = W_GetNumForPatchName("M_THERMM");
+ cursorlump = W_GetNumForPatchName("M_THERMO");
V_DrawScaledPatch(xx, y, 0, p = W_CachePatchNum(leftlump,PU_PATCH));
xx += p->width - p->leftoffset;
@@ -4141,7 +4394,7 @@ static void M_DrawStaticBox(fixed_t x, fixed_t y, INT32 flags, fixed_t w, fixed_
temp = (gametic % temp) * h*2*FRACUNIT; // Which frame to draw
V_DrawCroppedPatch(x*FRACUNIT, y*FRACUNIT, (w*FRACUNIT) / 160, (h*FRACUNIT) / 100, flags, patch, NULL, 0, temp, w*2*FRACUNIT, h*2*FRACUNIT);
-
+
W_UnlockCachedPatch(patch);
return;
}
@@ -6109,6 +6362,7 @@ void M_StartMessage(const char *string, void *routine, menumessagetype_t itemtyp
currentMenu = &MessageDef;
itemOn = 0;
+ M_UpdateItemOn();
}
static void M_DrawMessageMenu(void)
@@ -6183,6 +6437,7 @@ static void M_HandleImageDef(INT32 choice)
if (itemOn >= (INT16)(currentMenu->numitems-1))
itemOn = 0;
else itemOn++;
+ M_UpdateItemOn();
break;
case KEY_LEFTARROW:
@@ -6193,6 +6448,7 @@ static void M_HandleImageDef(INT32 choice)
if (!itemOn)
itemOn = currentMenu->numitems - 1;
else itemOn--;
+ M_UpdateItemOn();
break;
case KEY_ESCAPE:
@@ -6982,7 +7238,10 @@ static void M_LevelSelectWarp(INT32 choice)
if (currentMenu == &SP_LevelSelectDef || currentMenu == &SP_PauseLevelSelectDef)
{
if (cursaveslot > 0) // do we have a save slot to load?
+ {
+ CV_StealthSet(&cv_skin, DEFAULTSKIN); // already handled by loadgame so we don't want this
G_LoadGame((UINT32)cursaveslot, startmap); // reload from SP save data: this is needed to keep score/lives/continues from reverting to defaults
+ }
else // no save slot, start new game but keep the current skin
{
M_ClearMenus(true);
@@ -7389,6 +7648,7 @@ static void M_EmblemHints(INT32 choice)
SR_EmblemHintDef.prevMenu = currentMenu;
M_SetupNextMenu(&SR_EmblemHintDef);
itemOn = 2; // always start on back.
+ M_UpdateItemOn();
}
static void M_DrawEmblemHints(void)
@@ -8350,7 +8610,7 @@ static void M_DrawLoadGameData(void)
if (savegameinfo[savetodraw].lives == -42)
col = 26;
else if (savegameinfo[savetodraw].botskin == 3) // & knuckles
- col = 105;
+ col = 106;
else if (savegameinfo[savetodraw].botskin) // tailsbot or custom
col = 134;
else
@@ -8410,7 +8670,17 @@ static void M_DrawLoadGameData(void)
if (savegameinfo[savetodraw].lives == -42)
V_DrawRightAlignedThinString(x + 79, y, V_GRAYMAP, "NEW GAME");
else if (savegameinfo[savetodraw].lives == -666)
- V_DrawRightAlignedThinString(x + 79, y, V_REDMAP, "CAN'T LOAD!");
+ {
+ if (savegameinfo[savetodraw].continuescore == -62)
+ {
+ V_DrawRightAlignedThinString(x + 79, y, V_REDMAP, "ADDON NOT LOADED");
+ V_DrawRightAlignedThinString(x + 79, y-10, V_REDMAP, savegameinfo[savetodraw].skinname);
+ }
+ else
+ {
+ V_DrawRightAlignedThinString(x + 79, y, V_REDMAP, "CAN'T LOAD!");
+ }
+ }
else if (savegameinfo[savetodraw].gamemap & 8192)
V_DrawRightAlignedThinString(x + 79, y, V_GREENMAP, "CLEAR!");
else
@@ -8630,14 +8900,20 @@ static void M_LoadSelect(INT32 choice)
M_NewGame();
}
else if (savegameinfo[saveSlotSelected-1].gamemap & 8192) // Completed
+ {
M_LoadGameLevelSelect(0);
+ }
else
+ {
+ CV_StealthSet(&cv_skin, DEFAULTSKIN); // already handled by loadgame so we don't want this
G_LoadGame((UINT32)saveSlotSelected, 0);
+ }
cursaveslot = saveSlotSelected;
}
#define VERSIONSIZE 16
+#define MISSING { savegameinfo[slot].continuescore = -62; savegameinfo[slot].lives = -666; Z_Free(savebuffer); return; }
#define BADSAVE { savegameinfo[slot].lives = -666; Z_Free(savebuffer); return; }
#define CHECKPOS if (sav_p >= end_p) BADSAVE
// Reads the save file to list lives, level, player, etc.
@@ -8734,10 +9010,11 @@ static void M_ReadSavegameInfo(UINT32 slot)
CHECKPOS
READSTRINGN(sav_p, ourSkinName, SKINNAMESIZE);
savegameinfo[slot].skinnum = R_SkinAvailable(ourSkinName);
+ STRBUFCPY(savegameinfo[slot].skinname, ourSkinName);
if (savegameinfo[slot].skinnum >= numskins
|| !R_SkinUsable(-1, savegameinfo[slot].skinnum))
- BADSAVE
+ MISSING
CHECKPOS
READSTRINGN(sav_p, botSkinName, SKINNAMESIZE);
@@ -8745,7 +9022,7 @@ static void M_ReadSavegameInfo(UINT32 slot)
if (savegameinfo[slot].botskin-1 >= numskins
|| !R_SkinUsable(-1, savegameinfo[slot].botskin-1))
- BADSAVE
+ MISSING
}
CHECKPOS
@@ -8790,6 +9067,7 @@ static void M_ReadSavegameInfo(UINT32 slot)
}
#undef CHECKPOS
#undef BADSAVE
+#undef MISSING
//
// M_ReadSaveStrings
@@ -9053,7 +9331,7 @@ static void M_CacheCharacterSelectEntry(INT32 i, INT32 skinnum)
description[i].namepic = W_CachePatchName(description[i].nametag, PU_PATCH);
}
-static UINT16 M_SetupChoosePlayerDirect(INT32 choice)
+static INT32 M_SetupChoosePlayerDirect(INT32 choice)
{
INT32 skinnum, botskinnum;
UINT16 i;
@@ -9142,7 +9420,7 @@ static UINT16 M_SetupChoosePlayerDirect(INT32 choice)
static void M_SetupChoosePlayer(INT32 choice)
{
- UINT16 skinset = M_SetupChoosePlayerDirect(choice);
+ INT32 skinset = M_SetupChoosePlayerDirect(choice);
if (skinset != MAXCHARACTERSLOTS)
{
M_ChoosePlayer(skinset);
@@ -9491,6 +9769,8 @@ static void M_ChoosePlayer(INT32 choice)
//lastmapsaved = 0;
gamecomplete = 0;
+ CV_StealthSet(&cv_skin, skins[skinnum]->name);
+
G_DeferedInitNew(ultmode, G_BuildMapName(startmap), skinnum, false, fromlevelselect);
COM_BufAddText("dummyconsvar 1\n"); // G_DeferedInitNew doesn't do this
@@ -10050,6 +10330,7 @@ static void M_TimeAttack(INT32 choice)
Nextmap_OnChange();
itemOn = tastart; // "Start" is selected.
+ M_UpdateItemOn();
}
// Drawing function for Nights Attack
@@ -10166,7 +10447,7 @@ void M_DrawNightsAttackMenu(void)
skinnumber = 0; //Default to Sonic
else
skinnumber = (cv_chooseskin.value-1);
-
+
spritedef_t *sprdef = &skins[skinnumber]->sprites[SPR2_NFLY]; //Make our patch the selected character's NFLY sprite
spritetimer = FixedInt(ntsatkdrawtimer/2) % skins[skinnumber]->sprites[SPR2_NFLY].numframes; //Make the sprite timer cycle though all the frames at 2 tics per frame
spriteframe_t *sprframe = &sprdef->spriteframes[spritetimer]; //Our animation frame is equal to the number on the timer
@@ -10179,11 +10460,14 @@ void M_DrawNightsAttackMenu(void)
color = skins[skinnumber]->supercolor+4;
else //If you don't go super in NiGHTS or at all, use prefcolor
color = skins[skinnumber]->prefcolor;
-
+
angle_t fa = (FixedAngle(((FixedInt(ntsatkdrawtimer * 4)) % 360)<<FRACBITS)>>ANGLETOFINESHIFT) & FINEMASK;
+ fixed_t scale = skins[skinnumber]->highresscale;
+ if (skins[skinnumber]->shieldscale)
+ scale = FixedDiv(scale, skins[skinnumber]->shieldscale);
V_DrawFixedPatch(270<<FRACBITS, (186<<FRACBITS) - 8*FINESINE(fa),
- FixedDiv(skins[skinnumber]->highresscale, skins[skinnumber]->shieldscale),
+ scale,
(sprframe->flip & 1<<6) ? V_FLIP : 0,
natksprite,
R_GetTranslationColormap(TC_BLINK, color, GTC_CACHE));
@@ -10288,6 +10572,7 @@ static void M_NightsAttack(INT32 choice)
Nextmap_OnChange();
itemOn = nastart; // "Start" is selected.
+ M_UpdateItemOn();
}
// Player has selected the "START" from the nights attack screen
@@ -10607,6 +10892,7 @@ static void M_ModeAttackEndGame(INT32 choice)
break;
}
itemOn = currentMenu->lastOn;
+ M_UpdateItemOn();
G_SetGamestate(GS_TIMEATTACK);
modeattacking = ATTACKING_NONE;
M_ChangeMenuMusic("_title", true);
@@ -10688,6 +10974,7 @@ static void M_Marathon(INT32 choice)
titlemapinaction = TITLEMAP_OFF; // Nope don't give us HOMs please
M_SetupNextMenu(&SP_MarathonDef);
itemOn = marathonstart; // "Start" is selected.
+ M_UpdateItemOn();
recatkdrawtimer = (50-8) * FRACUNIT;
char_scroll = 0;
}
@@ -11401,6 +11688,7 @@ static void M_ConnectMenu(INT32 choice)
else
M_SetupNextMenu(&MP_ConnectDef);
itemOn = 0;
+ M_UpdateItemOn();
M_Refresh(0);
}
@@ -11660,6 +11948,7 @@ static void M_StartServerMenu(INT32 choice)
Newgametype_OnChange();
M_SetupNextMenu(&MP_ServerDef);
itemOn = 1;
+ M_UpdateItemOn();
}
// ==============
@@ -11842,15 +12131,21 @@ static void M_HandleConnectIP(INT32 choice)
case KEY_INS:
case 'c':
case 'C': // ctrl+c, ctrl+insert, copying
- I_ClipboardCopy(setupm_ip, l);
- S_StartSound(NULL,sfx_menu1); // Tails
+ if (l != 0) // Don't replace the clipboard without any text
+ {
+ I_ClipboardCopy(setupm_ip, l);
+ S_StartSound(NULL,sfx_menu1); // Tails
+ }
break;
case 'x':
case 'X': // ctrl+x, cutting
- I_ClipboardCopy(setupm_ip, l);
- S_StartSound(NULL,sfx_menu1); // Tails
- setupm_ip[0] = 0;
+ if (l != 0) // Don't replace the clipboard without any text
+ {
+ I_ClipboardCopy(setupm_ip, l);
+ S_StartSound(NULL,sfx_menu1); // Tails
+ setupm_ip[0] = 0;
+ }
break;
default: // otherwise do nothing
@@ -11874,9 +12169,12 @@ static void M_HandleConnectIP(INT32 choice)
break;
}
case KEY_DEL: // shift+delete, cutting
- I_ClipboardCopy(setupm_ip, l);
- S_StartSound(NULL,sfx_menu1); // Tails
- setupm_ip[0] = 0;
+ if (l != 0) // Don't replace the clipboard without any text
+ {
+ I_ClipboardCopy(setupm_ip, l);
+ S_StartSound(NULL,sfx_menu1); // Tails
+ setupm_ip[0] = 0;
+ }
break;
default: // otherwise do nothing.
break;
@@ -12256,7 +12554,9 @@ static void M_DrawSetupMultiPlayerMenu(void)
if (multi_frame >= sprdef->numframes)
multi_frame = 0;
- scale = FixedDiv(skins[setupm_fakeskin]->highresscale, skins[setupm_fakeskin]->shieldscale);
+ scale = skins[setupm_fakeskin]->highresscale;
+ if (skins[setupm_fakeskin]->shieldscale)
+ scale = FixedDiv(scale, skins[setupm_fakeskin]->shieldscale);
#define chary (y+64)
@@ -12289,7 +12589,7 @@ static void M_DrawSetupMultiPlayerMenu(void)
V_DrawFixedPatch(
x<<FRACBITS,
chary<<FRACBITS,
- FixedDiv(skins[setupm_fakeskin]->highresscale, skins[setupm_fakeskin]->shieldscale),
+ scale,
flags, patch, colormap);
goto colordraw;
@@ -13071,7 +13371,10 @@ static void M_SetupScreenshotMenu(void)
{
item->status = IT_GRAYEDOUT;
if ((currentMenu == &OP_ScreenshotOptionsDef) && (itemOn == op_screenshot_colorprofile)) // Can't select that
+ {
itemOn = op_screenshot_storagelocation;
+ M_UpdateItemOn();
+ }
}
else
#endif
diff --git a/src/m_menu.h b/src/m_menu.h
index 99a5b6de4266be02b1cba0e98a26addac5524548..e76010c17a3dc76d99f6ceacdb19eb147be04c0c 100644
--- a/src/m_menu.h
+++ b/src/m_menu.h
@@ -176,6 +176,7 @@ 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);
@@ -421,6 +422,7 @@ typedef struct
{
char levelname[32];
UINT8 skinnum;
+ char skinname [SKINNAMESIZE+1];
UINT8 botskin;
UINT8 numemeralds;
UINT8 numgameovers;
diff --git a/src/m_misc.c b/src/m_misc.c
index 55c5485a149a2b2c43e48fab973c5ad898091036..724717aa681597b33a8b7bc573dc0be91220337f 100644
--- a/src/m_misc.c
+++ b/src/m_misc.c
@@ -560,6 +560,11 @@ 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);
@@ -2208,6 +2213,8 @@ int M_JumpWordReverse(const char *line, int offset)
{
int (*is)(int);
int c;
+ if (offset == 0) // Don't let "--offset" later result in a negative value
+ return 0;
c = line[--offset];
if (isspace(c))
is = isspace;
diff --git a/src/m_vector.c b/src/m_vector.c
index 3132a869d458c83aac517ac609258b506b6395b8..1b04f8ae1461b6a11f34cc07e6765c3ea640b330 100644
--- a/src/m_vector.c
+++ b/src/m_vector.c
@@ -21,6 +21,32 @@ void DVector3_Load(dvector3_t *vec, double x, double y, double z)
vec->z = z;
}
+void DVector3_Copy(dvector3_t *a_o, const dvector3_t *a_i)
+{
+ memcpy(a_o, a_i, sizeof(dvector3_t));
+}
+
+void DVector3_Add(const dvector3_t *a_i, const dvector3_t *a_c, dvector3_t *a_o)
+{
+ a_o->x = a_i->x + a_c->x;
+ a_o->y = a_i->y + a_c->y;
+ a_o->z = a_i->z + a_c->z;
+}
+
+void DVector3_Subtract(const dvector3_t *a_i, const dvector3_t *a_c, dvector3_t *a_o)
+{
+ a_o->x = a_i->x - a_c->x;
+ a_o->y = a_i->y - a_c->y;
+ a_o->z = a_i->z - a_c->z;
+}
+
+void DVector3_Multiply(const dvector3_t *a_i, double a_c, dvector3_t *a_o)
+{
+ a_o->x = a_i->x * a_c;
+ a_o->y = a_i->y * a_c;
+ a_o->z = a_i->z * a_c;
+}
+
double DVector3_Magnitude(const dvector3_t *a_normal)
{
double xs = a_normal->x * a_normal->x;
diff --git a/src/m_vector.h b/src/m_vector.h
index 55669be037c9ce54ffd70bf3782225e913e1a1b4..1395744f2984050991923bfc714e5a3a028ccfe6 100644
--- a/src/m_vector.h
+++ b/src/m_vector.h
@@ -19,6 +19,10 @@ typedef struct
} dvector3_t;
void DVector3_Load(dvector3_t *vec, double x, double y, double z);
+void DVector3_Copy(dvector3_t *a_o, const dvector3_t *a_i);
+void DVector3_Add(const dvector3_t *a_i, const dvector3_t *a_c, dvector3_t *a_o);
+void DVector3_Subtract(const dvector3_t *a_i, const dvector3_t *a_c, dvector3_t *a_o);
+void DVector3_Multiply(const dvector3_t *a_i, double a_c, dvector3_t *a_o);
double DVector3_Magnitude(const dvector3_t *a_normal);
double DVector3_Normalize(dvector3_t *a_normal);
void DVector3_Negate(dvector3_t *a_o);
diff --git a/src/netcode/d_clisrv.c b/src/netcode/d_clisrv.c
index 2bf9d2dde7cb60266687282748142af5e676c917..5fee506af320578b7228cb6e5616ebac238120f7 100644
--- a/src/netcode/d_clisrv.c
+++ b/src/netcode/d_clisrv.c
@@ -114,6 +114,7 @@ static CV_PossibleValue_t playbackspeed_cons_t[] = {{1, "MIN"}, {10, "MAX"}, {0,
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_httpsource = CVAR_INIT ("http_source", "", CV_SAVE, NULL, NULL);
@@ -1360,19 +1361,33 @@ static void IdleUpdate(void)
if (!server || !netgame)
return;
- for (i = 1; i < MAXPLAYERS; i++)
+ for (i = 0; i < MAXPLAYERS; i++)
{
- if (cv_idletime.value && playeringame[i] && playernode[i] != UINT8_MAX && !players[i].quittime && !players[i].spectator && !players[i].bot && !IsPlayerAdmin(i) && i != serverplayer && gamestate == GS_LEVEL)
+ if (playeringame[i] && playernode[i] != UINT8_MAX && !players[i].quittime && !players[i].spectator && !players[i].bot && gamestate == GS_LEVEL)
{
if (players[i].cmd.forwardmove || players[i].cmd.sidemove || players[i].cmd.buttons)
players[i].lastinputtime = 0;
else
players[i].lastinputtime++;
- if (players[i].lastinputtime > (tic_t)cv_idletime.value * TICRATE * 60)
+ 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;
- SendKick(i, KICK_MSG_IDLE | KICK_MSG_KEEP_BODY);
+ if (cv_idlespectate.value && G_GametypeHasSpectators())
+ {
+ changeteam_union NetPacket;
+ UINT16 usvalue;
+ NetPacket.value.l = NetPacket.value.b = 0;
+ NetPacket.packet.newteam = 0;
+ NetPacket.packet.playernum = i;
+ NetPacket.packet.verification = true; // This signals that it's a server change
+ usvalue = SHORT(NetPacket.value.l|NetPacket.value.b);
+ SendNetXCmd(XD_TEAMCHANGE, &usvalue, sizeof(usvalue));
+ }
+ else
+ {
+ SendKick(i, KICK_MSG_IDLE | KICK_MSG_KEEP_BODY);
+ }
}
}
else
diff --git a/src/netcode/d_clisrv.h b/src/netcode/d_clisrv.h
index 5aac4693d2fdd166cee7a796166ba7c798e183c8..342173dff5bf575a762433a4cb2ad753a61685a0 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_dedicatedidletime;
+extern consvar_t cv_netticbuffer, cv_resynchattempts, cv_blamecfail, cv_playbackspeed, cv_idletime, cv_idlespectate, cv_dedicatedidletime;
extern consvar_t cv_httpsource;
// Used in d_net, the only dependence
diff --git a/src/netcode/d_netcmd.c b/src/netcode/d_netcmd.c
index e073a863c90bbe88025fd6f7ed9f4d0decac23d0..4134c633e5a32e23e6be085a32300bb308a694df 100644
--- a/src/netcode/d_netcmd.c
+++ b/src/netcode/d_netcmd.c
@@ -620,6 +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_httpsource);
COM_AddCommand("ping", Command_Ping_f, COM_LUA);
@@ -691,6 +692,7 @@ void D_RegisterClientCommands(void)
COM_AddCommand("timedemo", Command_Timedemo_f, 0);
COM_AddCommand("stopdemo", Command_Stopdemo_f, COM_LUA);
COM_AddCommand("playintro", Command_Playintro_f, COM_LUA);
+ CV_RegisterVar(&cv_resyncdemo);
COM_AddCommand("resetcamera", Command_ResetCamera_f, COM_LUA);
@@ -1308,7 +1310,7 @@ static void SendNameAndColor(void)
SetColorLocal(consoleplayer, cv_playercolor.value);
- if (splitscreen)
+ if (splitscreen || (!pickedchar && stricmp(cv_skin.string, skins[consoleplayer]->name) != 0))
SetSkinLocal(consoleplayer, R_SkinAvailable(cv_skin.string));
else
SetSkinLocal(consoleplayer, pickedchar);
@@ -2509,11 +2511,11 @@ static void MutePlayer(boolean mute)
if (COM_Argc() < 2)
{
- CONS_Printf(M_GetText("muteplayer <playernum>: mute a player\n"));
+ CONS_Printf(M_GetText("muteplayer <playername/playernum>: mute a player\n"));
return;
}
- data[0] = atoi(COM_Argv(1));
+ data[0] = nametonum(COM_Argv(1));
if (data[0] >= MAXPLAYERS || !playeringame[data[0]])
{
CONS_Alert(CONS_NOTICE, M_GetText("There is no player %u!\n"), (unsigned int)data[0]);
@@ -2602,11 +2604,11 @@ static void Command_ServerTeamChange_f(void)
if (COM_Argc() < 3)
{
if (G_TagGametype())
- CONS_Printf(M_GetText("serverchangeteam <playernum> <team>: switch player to a new team (%s)\n"), "it, notit, playing, or spectator");
+ CONS_Printf(M_GetText("serverchangeteam <playername/playernum> <team>: switch player to a new team (%s)\n"), "it, notit, playing, or spectator");
else if (G_GametypeHasTeams())
- CONS_Printf(M_GetText("serverchangeteam <playernum> <team>: switch player to a new team (%s)\n"), "red, blue or spectator");
+ CONS_Printf(M_GetText("serverchangeteam <playername/playernum> <team>: switch player to a new team (%s)\n"), "red, blue or spectator");
else if (G_GametypeHasSpectators())
- CONS_Printf(M_GetText("serverchangeteam <playernum> <team>: switch player to a new team (%s)\n"), "spectator or playing");
+ CONS_Printf(M_GetText("serverchangeteam <playername/playernum> <team>: switch player to a new team (%s)\n"), "spectator or playing");
else
CONS_Alert(CONS_NOTICE, M_GetText("This command cannot be used in this gametype.\n"));
return;
@@ -2654,19 +2656,19 @@ static void Command_ServerTeamChange_f(void)
if (error)
{
if (G_TagGametype())
- CONS_Printf(M_GetText("serverchangeteam <playernum> <team>: switch player to a new team (%s)\n"), "it, notit, playing, or spectator");
+ CONS_Printf(M_GetText("serverchangeteam <playername/playernum> <team>: switch player to a new team (%s)\n"), "it, notit, playing, or spectator");
else if (G_GametypeHasTeams())
- CONS_Printf(M_GetText("serverchangeteam <playernum> <team>: switch player to a new team (%s)\n"), "red, blue or spectator");
+ CONS_Printf(M_GetText("serverchangeteam <playername/playernum> <team>: switch player to a new team (%s)\n"), "red, blue or spectator");
else if (G_GametypeHasSpectators())
- CONS_Printf(M_GetText("serverchangeteam <playernum> <team>: switch player to a new team (%s)\n"), "spectator or playing");
+ CONS_Printf(M_GetText("serverchangeteam <playername/playernum> <team>: switch player to a new team (%s)\n"), "spectator or playing");
return;
}
- NetPacket.packet.playernum = atoi(COM_Argv(1));
+ NetPacket.packet.playernum = nametonum(COM_Argv(1));
- if (!playeringame[NetPacket.packet.playernum])
+ if (NetPacket.packet.playernum == -1 || !playeringame[NetPacket.packet.playernum])
{
- CONS_Alert(CONS_NOTICE, M_GetText("There is no player %d!\n"), NetPacket.packet.playernum);
+ CONS_Alert(CONS_NOTICE, M_GetText("There is no player %s!\n"), COM_Argv(1));
return;
}
@@ -3105,13 +3107,16 @@ static void Command_Verify_f(void)
if (COM_Argc() != 2)
{
- CONS_Printf(M_GetText("promote <playernum>: give admin privileges to a player\n"));
+ CONS_Printf(M_GetText("promote <playername/playernum>: give admin privileges to a player\n"));
return;
}
- strlcpy(buf, COM_Argv(1), sizeof (buf));
-
- playernum = atoi(buf);
+ playernum = nametonum(COM_Argv(1));
+ if (playernum == -1)
+ {
+ CONS_Alert(CONS_NOTICE, M_GetText("There is no player %s!\n"), COM_Argv(1));
+ return;
+ }
temp = buf;
@@ -3155,13 +3160,16 @@ static void Command_RemoveAdmin_f(void)
if (COM_Argc() != 2)
{
- CONS_Printf(M_GetText("demote <playernum>: remove admin privileges from a player\n"));
+ CONS_Printf(M_GetText("demote <playername/playernum>: remove admin privileges from a player\n"));
return;
}
- strlcpy(buf, COM_Argv(1), sizeof(buf));
-
- playernum = atoi(buf);
+ playernum = nametonum(COM_Argv(1));
+ if (playernum == -1)
+ {
+ CONS_Alert(CONS_NOTICE, M_GetText("There is no player %s!\n"), COM_Argv(1));
+ return;
+ }
temp = buf;
@@ -4608,7 +4616,7 @@ static void Command_ExitLevel_f(void)
SendNetXCmd(XD_EXITLEVEL, NULL, 0);
return;
}
-
+
// Allow exiting without cheating if at least one player beat the level
// Consistent with just setting playersforexit to one
if (splitscreen || multiplayer)
@@ -4622,7 +4630,7 @@ static void Command_ExitLevel_f(void)
continue;
if (players[i].lives <= 0)
continue;
-
+
if ((players[i].pflags & PF_FINISHED) || players[i].exiting)
{
SendNetXCmd(XD_EXITLEVEL, NULL, 0);
@@ -4630,7 +4638,7 @@ static void Command_ExitLevel_f(void)
}
}
}
-
+
// Only consider it a cheat if we're not allowed to go to the next map
if (M_CampaignWarpIsCheat(gametype, G_GetNextMap(true, true) + 1, serverGamedata))
CONS_Alert(CONS_NOTICE, M_GetText("Cheats must be enabled to force exit to a locked level!\n"));
@@ -4769,7 +4777,7 @@ static void Command_Cheats_f(void)
G_SetUsedCheats(false);
return;
}
-
+
if (usedCheats)
CONS_Printf(M_GetText("Cheats are enabled, the game cannot be saved.\n"));
else
@@ -4941,6 +4949,8 @@ static boolean Skin2_CanChange(const char *valstr)
*/
static void Skin_OnChange(void)
{
+ pickedchar = R_SkinAvailable(cv_skin.string);
+
if (!Playing())
return;
diff --git a/src/netcode/http-mserv.c b/src/netcode/http-mserv.c
index b8c662a51e215965470310d758331236359378b7..4a080498455234f234655f505e4bf0df956dd9a6 100644
--- a/src/netcode/http-mserv.c
+++ b/src/netcode/http-mserv.c
@@ -486,20 +486,23 @@ int
HMS_unlist (void)
{
struct HMS_buffer *hms;
- int ok;
+ int ok = 0;
- hms = HMS_connect(PROTO_V4, "servers/%s/unlist", hms_server_token);
+ if (hms_server_token)
+ {
+ hms = HMS_connect(PROTO_V4, "servers/%s/unlist", hms_server_token);
- if (! hms)
- return 0;
+ if (! hms)
+ return 0;
- curl_easy_setopt(hms->curl, CURLOPT_POST, 1);
- curl_easy_setopt(hms->curl, CURLOPT_POSTFIELDSIZE, 0);
+ curl_easy_setopt(hms->curl, CURLOPT_POST, 1);
+ curl_easy_setopt(hms->curl, CURLOPT_POSTFIELDSIZE, 0);
- ok = HMS_do(hms);
- HMS_end(hms);
+ ok = HMS_do(hms);
+ HMS_end(hms);
- free(hms_server_token);
+ free(hms_server_token);
+ }
#ifndef NO_IPV6
if (hms_server_token_ipv6 && hms_allow_ipv6)
@@ -526,18 +529,13 @@ int
HMS_update (void)
{
struct HMS_buffer *hms;
- int ok;
+ int ok = 0;
char post[256];
char *title;
- hms = HMS_connect(PROTO_V4, "servers/%s/update", hms_server_token);
-
- if (! hms)
- return 0;
-
- title = curl_easy_escape(hms->curl, cv_servername.string, 0);
+ title = curl_easy_escape(NULL, cv_servername.string, 0);
snprintf(post, sizeof post,
"title=%s",
@@ -546,10 +544,18 @@ HMS_update (void)
curl_free(title);
- curl_easy_setopt(hms->curl, CURLOPT_POSTFIELDS, post);
+ if (hms_server_token)
+ {
+ hms = HMS_connect(PROTO_V4, "servers/%s/update", hms_server_token);
- ok = HMS_do(hms);
- HMS_end(hms);
+ if (! hms)
+ return 0;
+
+ curl_easy_setopt(hms->curl, CURLOPT_POSTFIELDS, post);
+
+ ok = HMS_do(hms);
+ HMS_end(hms);
+ }
#ifndef NO_IPV6
if (hms_server_token_ipv6 && hms_allow_ipv6)
diff --git a/src/netcode/i_tcp.c b/src/netcode/i_tcp.c
index 6a50f440be80cfee5a591ed757ae1c79414c6455..24dfd7ec2797c190b0c0fdbf0343f19e33b001a0 100644
--- a/src/netcode/i_tcp.c
+++ b/src/netcode/i_tcp.c
@@ -317,7 +317,11 @@ init_upnpc_once(struct upnpdata *upnpuserdata)
I_OutputMsg(M_GetText("Found UPnP device:\n desc: %s\n st: %s\n"),
dev->descURL, dev->st);
+#if (MINIUPNPC_API_VERSION >= 18)
+ UPNP_GetValidIGD(devlist, &urls, &data, lanaddr, sizeof(lanaddr), NULL, 0);
+#else
UPNP_GetValidIGD(devlist, &urls, &data, lanaddr, sizeof(lanaddr));
+#endif
I_OutputMsg(M_GetText("Local LAN IP address: %s\n"), lanaddr);
descXML = miniwget(dev->descURL, &descXMLsize, scope_id, &status_code);
if (descXML)
diff --git a/src/netcode/mserv.c b/src/netcode/mserv.c
index 3acacd24c164471057ca3ffa7a6225f8ba95d2f3..74ee120f96e17ed6641adb48e0dc29f35d46c0c8 100644
--- a/src/netcode/mserv.c
+++ b/src/netcode/mserv.c
@@ -50,6 +50,8 @@ static void Command_Listserv_f(void);
#endif/*MASTERSERVER*/
+static boolean ServerName_CanChange (const char*);
+
static void Update_parameters (void);
static void MasterServer_OnChange(void);
@@ -61,7 +63,7 @@ static CV_PossibleValue_t masterserver_update_rate_cons_t[] = {
};
consvar_t cv_masterserver = CVAR_INIT ("masterserver", "https://ds.ms.srb2.org/MS/0", CV_SAVE|CV_CALL, NULL, MasterServer_OnChange);
-consvar_t cv_servername = CVAR_INIT ("servername", "SRB2 server", CV_SAVE|CV_NETVAR|CV_CALL|CV_NOINIT|CV_ALLOWLUA, NULL, Update_parameters);
+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);
@@ -497,6 +499,15 @@ Set_api (const char *api)
#endif/*MASTERSERVER*/
+static boolean ServerName_CanChange(const char* newvalue)
+{
+ if (strlen(newvalue) < MAXSERVERNAME)
+ return true;
+
+ CONS_Alert(CONS_NOTICE, "The server name must be shorter than %d characters\n", MAXSERVERNAME);
+ return false;
+}
+
static void
Update_parameters (void)
{
diff --git a/src/p_enemy.c b/src/p_enemy.c
index 4990db6fd50a2f96102056984b4d02e3c0205ddb..e1b21e295bf4226a632112a4b66fe3d4b849c485 100644
--- a/src/p_enemy.c
+++ b/src/p_enemy.c
@@ -54,276 +54,6 @@ static dirtype_t diags[] =
DI_NORTHWEST, DI_NORTHEAST, DI_SOUTHWEST, DI_SOUTHEAST
};
-//Real Prototypes to A_*
-void A_Fall(mobj_t *actor);
-void A_Look(mobj_t *actor);
-void A_Chase(mobj_t *actor);
-void A_FaceStabChase(mobj_t *actor);
-void A_FaceStabRev(mobj_t *actor);
-void A_FaceStabHurl(mobj_t *actor);
-void A_FaceStabMiss(mobj_t *actor);
-void A_StatueBurst(mobj_t *actor);
-void A_JetJawRoam(mobj_t *actor);
-void A_JetJawChomp(mobj_t *actor);
-void A_PointyThink(mobj_t *actor);
-void A_CheckBuddy(mobj_t *actor);
-void A_HoodFire(mobj_t *actor);
-void A_HoodThink(mobj_t *actor);
-void A_HoodFall(mobj_t *actor);
-void A_ArrowBonks(mobj_t *actor);
-void A_SnailerThink(mobj_t *actor);
-void A_SharpChase(mobj_t *actor);
-void A_SharpSpin(mobj_t *actor);
-void A_SharpDecel(mobj_t *actor);
-void A_CrushstaceanWalk(mobj_t *actor);
-void A_CrushstaceanPunch(mobj_t *actor);
-void A_CrushclawAim(mobj_t *actor);
-void A_CrushclawLaunch(mobj_t *actor);
-void A_VultureVtol(mobj_t *actor);
-void A_VultureCheck(mobj_t *actor);
-void A_VultureHover(mobj_t *actor);
-void A_VultureBlast(mobj_t *actor);
-void A_VultureFly(mobj_t *actor);
-void A_SkimChase(mobj_t *actor);
-void A_FaceTarget(mobj_t *actor);
-void A_FaceTracer(mobj_t *actor);
-void A_LobShot(mobj_t *actor);
-void A_FireShot(mobj_t *actor);
-void A_SuperFireShot(mobj_t *actor);
-void A_BossFireShot(mobj_t *actor);
-void A_Boss7FireMissiles(mobj_t *actor);
-void A_Boss1Laser(mobj_t *actor);
-void A_FocusTarget(mobj_t *actor);
-void A_Boss4Reverse(mobj_t *actor);
-void A_Boss4SpeedUp(mobj_t *actor);
-void A_Boss4Raise(mobj_t *actor);
-void A_SkullAttack(mobj_t *actor);
-void A_BossZoom(mobj_t *actor);
-void A_BossScream(mobj_t *actor);
-void A_Scream(mobj_t *actor);
-void A_Pain(mobj_t *actor);
-void A_1upThinker(mobj_t *actor);
-void A_MonitorPop(mobj_t *actor);
-void A_GoldMonitorPop(mobj_t *actor);
-void A_GoldMonitorRestore(mobj_t *actor);
-void A_GoldMonitorSparkle(mobj_t *actor);
-void A_Explode(mobj_t *actor);
-void A_BossDeath(mobj_t *actor);
-void A_SetShadowScale(mobj_t *actor);
-void A_ShadowScream(mobj_t *actor);
-void A_CustomPower(mobj_t *actor);
-void A_GiveWeapon(mobj_t *actor);
-void A_RingBox(mobj_t *actor);
-void A_Invincibility(mobj_t *actor);
-void A_SuperSneakers(mobj_t *actor);
-void A_AwardScore(mobj_t *actor);
-void A_ExtraLife(mobj_t *actor);
-void A_GiveShield(mobj_t *actor);
-void A_GravityBox(mobj_t *actor);
-void A_ScoreRise(mobj_t *actor);
-void A_BunnyHop(mobj_t *actor);
-void A_BubbleSpawn(mobj_t *actor);
-void A_FanBubbleSpawn(mobj_t *actor);
-void A_BubbleRise(mobj_t *actor);
-void A_BubbleCheck(mobj_t *actor);
-void A_AttractChase(mobj_t *actor);
-void A_DropMine(mobj_t *actor);
-void A_FishJump(mobj_t *actor);
-void A_ThrownRing(mobj_t *actor);
-void A_SetSolidSteam(mobj_t *actor);
-void A_UnsetSolidSteam(mobj_t *actor);
-void A_SignSpin(mobj_t *actor);
-void A_SignPlayer(mobj_t *actor);
-void A_OverlayThink(mobj_t *actor);
-void A_JetChase(mobj_t *actor);
-void A_JetbThink(mobj_t *actor);
-void A_JetgShoot(mobj_t *actor);
-void A_JetgThink(mobj_t *actor);
-void A_ShootBullet(mobj_t *actor);
-void A_MinusDigging(mobj_t *actor);
-void A_MinusPopup(mobj_t *actor);
-void A_MinusCheck(mobj_t *actor);
-void A_ChickenCheck(mobj_t *actor);
-void A_MouseThink(mobj_t *actor);
-void A_DetonChase(mobj_t *actor);
-void A_CapeChase(mobj_t *actor);
-void A_RotateSpikeBall(mobj_t *actor);
-void A_SlingAppear(mobj_t *actor);
-void A_UnidusBall(mobj_t *actor);
-void A_RockSpawn(mobj_t *actor);
-void A_SetFuse(mobj_t *actor);
-void A_CrawlaCommanderThink(mobj_t *actor);
-void A_RingExplode(mobj_t *actor);
-void A_OldRingExplode(mobj_t *actor);
-void A_MixUp(mobj_t *actor);
-void A_RecyclePowers(mobj_t *actor);
-void A_Boss2TakeDamage(mobj_t *actor);
-void A_Boss7Chase(mobj_t *actor);
-void A_GoopSplat(mobj_t *actor);
-void A_Boss2PogoSFX(mobj_t *actor);
-void A_Boss2PogoTarget(mobj_t *actor);
-void A_EggmanBox(mobj_t *actor);
-void A_TurretFire(mobj_t *actor);
-void A_SuperTurretFire(mobj_t *actor);
-void A_TurretStop(mobj_t *actor);
-void A_SparkFollow(mobj_t *actor);
-void A_BuzzFly(mobj_t *actor);
-void A_GuardChase(mobj_t *actor);
-void A_EggShield(mobj_t *actor);
-void A_SetReactionTime(mobj_t *actor);
-void A_Boss1Spikeballs(mobj_t *actor);
-void A_Boss3TakeDamage(mobj_t *actor);
-void A_Boss3Path(mobj_t *actor);
-void A_Boss3ShockThink(mobj_t *actor);
-void A_Shockwave(mobj_t *actor);
-void A_LinedefExecute(mobj_t *actor);
-void A_LinedefExecuteFromArg(mobj_t *actor);
-void A_PlaySeeSound(mobj_t *actor);
-void A_PlayAttackSound(mobj_t *actor);
-void A_PlayActiveSound(mobj_t *actor);
-void A_SmokeTrailer(mobj_t *actor);
-void A_SpawnObjectAbsolute(mobj_t *actor);
-void A_SpawnObjectRelative(mobj_t *actor);
-void A_ChangeAngleRelative(mobj_t *actor);
-void A_ChangeAngleAbsolute(mobj_t *actor);
-void A_RollAngle(mobj_t *actor);
-void A_ChangeRollAngleRelative(mobj_t *actor);
-void A_ChangeRollAngleAbsolute(mobj_t *actor);
-void A_PlaySound(mobj_t *actor);
-void A_FindTarget(mobj_t *actor);
-void A_FindTracer(mobj_t *actor);
-void A_SetTics(mobj_t *actor);
-void A_SetRandomTics(mobj_t *actor);
-void A_ChangeColorRelative(mobj_t *actor);
-void A_ChangeColorAbsolute(mobj_t *actor);
-void A_Dye(mobj_t *actor);
-void A_SetTranslation(mobj_t *actor);
-void A_MoveRelative(mobj_t *actor);
-void A_MoveAbsolute(mobj_t *actor);
-void A_Thrust(mobj_t *actor);
-void A_ZThrust(mobj_t *actor);
-void A_SetTargetsTarget(mobj_t *actor);
-void A_SetObjectFlags(mobj_t *actor);
-void A_SetObjectFlags2(mobj_t *actor);
-void A_RandomState(mobj_t *actor);
-void A_RandomStateRange(mobj_t *actor);
-void A_StateRangeByAngle(mobj_t *actor);
-void A_StateRangeByParameter(mobj_t *actor);
-void A_DualAction(mobj_t *actor);
-void A_RemoteAction(mobj_t *actor);
-void A_ToggleFlameJet(mobj_t *actor);
-void A_OrbitNights(mobj_t *actor);
-void A_GhostMe(mobj_t *actor);
-void A_SetObjectState(mobj_t *actor);
-void A_SetObjectTypeState(mobj_t *actor);
-void A_KnockBack(mobj_t *actor);
-void A_PushAway(mobj_t *actor);
-void A_RingDrain(mobj_t *actor);
-void A_SplitShot(mobj_t *actor);
-void A_MissileSplit(mobj_t *actor);
-void A_MultiShot(mobj_t *actor);
-void A_InstaLoop(mobj_t *actor);
-void A_Custom3DRotate(mobj_t *actor);
-void A_SearchForPlayers(mobj_t *actor);
-void A_CheckRandom(mobj_t *actor);
-void A_CheckTargetRings(mobj_t *actor);
-void A_CheckRings(mobj_t *actor);
-void A_CheckTotalRings(mobj_t *actor);
-void A_CheckHealth(mobj_t *actor);
-void A_CheckRange(mobj_t *actor);
-void A_CheckHeight(mobj_t *actor);
-void A_CheckTrueRange(mobj_t *actor);
-void A_CheckThingCount(mobj_t *actor);
-void A_CheckAmbush(mobj_t *actor);
-void A_CheckCustomValue(mobj_t *actor);
-void A_CheckCusValMemo(mobj_t *actor);
-void A_SetCustomValue(mobj_t *actor);
-void A_UseCusValMemo(mobj_t *actor);
-void A_RelayCustomValue(mobj_t *actor);
-void A_CusValAction(mobj_t *actor);
-void A_ForceStop(mobj_t *actor);
-void A_ForceWin(mobj_t *actor);
-void A_SpikeRetract(mobj_t *actor);
-void A_InfoState(mobj_t *actor);
-void A_Repeat(mobj_t *actor);
-void A_SetScale(mobj_t *actor);
-void A_RemoteDamage(mobj_t *actor);
-void A_HomingChase(mobj_t *actor);
-void A_TrapShot(mobj_t *actor);
-void A_Boss1Chase(mobj_t *actor);
-void A_Boss2Chase(mobj_t *actor);
-void A_Boss2Pogo(mobj_t *actor);
-void A_BossJetFume(mobj_t *actor);
-void A_VileTarget(mobj_t *actor);
-void A_VileAttack(mobj_t *actor);
-void A_VileFire(mobj_t *actor);
-void A_BrakChase(mobj_t *actor);
-void A_BrakFireShot(mobj_t *actor);
-void A_BrakLobShot(mobj_t *actor);
-void A_NapalmScatter(mobj_t *actor);
-void A_SpawnFreshCopy(mobj_t *actor);
-void A_FlickySpawn(mobj_t *actor);
-void A_FlickyCenter(mobj_t *actor);
-void A_FlickyAim(mobj_t *actor);
-void A_FlickyFly(mobj_t *actor);
-void A_FlickySoar(mobj_t *actor);
-void A_FlickyCoast(mobj_t *actor);
-void A_FlickyHop(mobj_t *actor);
-void A_FlickyFlounder(mobj_t *actor);
-void A_FlickyCheck(mobj_t *actor);
-void A_FlickyHeightCheck(mobj_t *actor);
-void A_FlickyFlutter(mobj_t *actor);
-void A_FlameParticle(mobj_t *actor);
-void A_FadeOverlay(mobj_t *actor);
-void A_Boss5Jump(mobj_t *actor);
-void A_LightBeamReset(mobj_t *actor);
-void A_MineExplode(mobj_t *actor);
-void A_MineRange(mobj_t *actor);
-void A_ConnectToGround(mobj_t *actor);
-void A_SpawnParticleRelative(mobj_t *actor);
-void A_MultiShotDist(mobj_t *actor);
-void A_WhoCaresIfYourSonIsABee(mobj_t *actor);
-void A_ParentTriesToSleep(mobj_t *actor);
-void A_CryingToMomma(mobj_t *actor);
-void A_CheckFlags2(mobj_t *actor);
-void A_Boss5FindWaypoint(mobj_t *actor);
-void A_DoNPCSkid(mobj_t *actor);
-void A_DoNPCPain(mobj_t *actor);
-void A_PrepareRepeat(mobj_t *actor);
-void A_Boss5ExtraRepeat(mobj_t *actor);
-void A_Boss5Calm(mobj_t *actor);
-void A_Boss5CheckOnGround(mobj_t *actor);
-void A_Boss5CheckFalling(mobj_t *actor);
-void A_Boss5PinchShot(mobj_t *actor);
-void A_Boss5MakeItRain(mobj_t *actor);
-void A_Boss5MakeJunk(mobj_t *actor);
-void A_LookForBetter(mobj_t *actor);
-void A_Boss5BombExplode(mobj_t *actor);
-void A_DustDevilThink(mobj_t *actor);
-void A_TNTExplode(mobj_t *actor);
-void A_DebrisRandom(mobj_t *actor);
-void A_TrainCameo(mobj_t *actor);
-void A_TrainCameo2(mobj_t *actor);
-void A_CanarivoreGas(mobj_t *actor);
-void A_KillSegments(mobj_t *actor);
-void A_SnapperSpawn(mobj_t *actor);
-void A_SnapperThinker(mobj_t *actor);
-void A_SaloonDoorSpawn(mobj_t *actor);
-void A_MinecartSparkThink(mobj_t *actor);
-void A_ModuloToState(mobj_t *actor);
-void A_LavafallRocks(mobj_t *actor);
-void A_LavafallLava(mobj_t *actor);
-void A_FallingLavaCheck(mobj_t *actor);
-void A_FireShrink(mobj_t *actor);
-void A_SpawnPterabytes(mobj_t *actor);
-void A_PterabyteHover(mobj_t *actor);
-void A_RolloutSpawn(mobj_t *actor);
-void A_RolloutRock(mobj_t *actor);
-void A_DragonbomberSpawn(mobj_t *actor);
-void A_DragonWing(mobj_t *actor);
-void A_DragonSegment(mobj_t *actor);
-void A_ChangeHeight(mobj_t *actor);
-
//for p_enemy.c
//
@@ -4865,7 +4595,7 @@ void A_AttractChase(mobj_t *actor)
else
actor->flags2 &= ~MF2_DONTDRAW;
- // Turn flingrings back into regular rings if attracted.
+ // Turn rings into flingrings if shield is lost or out of range
if (actor->tracer && actor->tracer->player
&& !(actor->tracer->player->powers[pw_shield] & SH_PROTECTELECTRIC) && actor->info->reactiontime && actor->type != (mobjtype_t)actor->info->reactiontime)
{
@@ -4897,8 +4627,9 @@ void A_AttractChase(mobj_t *actor)
// If a FlingRing gets attracted by a shield, change it into a normal ring.
if (actor->type == (mobjtype_t)actor->info->reactiontime)
{
- P_SpawnMobj(actor->x, actor->y, actor->z, actor->info->painchance);
- P_RemoveMobj(actor);
+ actor->type = mobjinfo[actor->type].painchance; // Become the regular version of the fling object.
+ actor->flags = mobjinfo[actor->type].flags; // Reset actor flags.
+ P_SetMobjState(actor, actor->info->spawnstate); // Go to regular object's spawn state.
return;
}
@@ -14857,12 +14588,18 @@ void A_RolloutRock(mobj_t *actor)
if (!actor->tracer || P_MobjWasRemoved(actor->tracer) || !actor->tracer->health)
actor->flags |= MF_PUSHABLE;
+ else if (actor->tracer->eflags & MFE_VERTICALFLIP)
+ {
+ actor->flags2 |= MF2_OBJECTFLIP;
+ actor->eflags |= MFE_VERTICALFLIP;
+ }
else
{
- actor->flags2 = (actor->flags2 & ~MF2_OBJECTFLIP) | (actor->tracer->flags2 & MF2_OBJECTFLIP);
- actor->eflags = (actor->eflags & ~MFE_VERTICALFLIP) | (actor->tracer->eflags & MFE_VERTICALFLIP);
+ actor->flags2 &= ~MF2_OBJECTFLIP;
+ actor->eflags &= ~MFE_VERTICALFLIP;
}
+
actor->friction = FRACUNIT; // turns out riding on solids sucks, so let's just make it easier on ourselves
if (actor->eflags & MFE_JUSTHITFLOOR)
diff --git a/src/p_inter.c b/src/p_inter.c
index e73cd1fce675ee17721e6236e7dc764ede8e9d69..cbd56183df855ed0d8afc9e308bea5e05a7d0fee 100644
--- a/src/p_inter.c
+++ b/src/p_inter.c
@@ -3786,6 +3786,8 @@ boolean P_DamageMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source, INT32 da
if (player->powers[pw_carry] == CR_NIGHTSMODE) // NiGHTS damage handling
{
+ if (player->powers[pw_flashing])
+ return false;
if (!force)
{
if (source == target)
@@ -3803,6 +3805,10 @@ boolean P_DamageMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source, INT32 da
if (G_IsSpecialStage(gamemap) && !(damagetype & DMG_DEATHMASK))
{
+ if (player->powers[pw_flashing])
+ return false;
+ if (LUA_HookMobjDamage(target, inflictor, source, damage, damagetype))
+ return true;
P_SpecialStageDamage(player, inflictor, source);
return true;
}
diff --git a/src/p_map.c b/src/p_map.c
index f97ddfa3cd8aa3fa9f7e9dbb3e6d76b041aca164..b79f9d45c77ea069f079e1d2a50d6b45bfa1e646 100644
--- a/src/p_map.c
+++ b/src/p_map.c
@@ -389,7 +389,6 @@ boolean P_DoSpring(mobj_t *spring, mobj_t *object)
{
INT32 pflags;
UINT8 secondjump;
- boolean washoming;
if (spring->flags & MF_ENEMY) // Spring shells
P_SetTarget(&spring->target, object);
@@ -421,7 +420,7 @@ boolean P_DoSpring(mobj_t *spring, mobj_t *object)
{
boolean wasSpindashing = object->player->dashspeed > 0 && (object->player->charability2 == CA2_SPINDASH);
- pflags = object->player->pflags & (PF_STARTJUMP | PF_JUMPED | PF_NOJUMPDAMAGE | PF_SPINNING | PF_THOKKED | PF_BOUNCING); // I still need these.
+ pflags = object->player->pflags & (PF_STARTJUMP | PF_JUMPED | PF_NOJUMPDAMAGE | PF_SPINNING | PF_BOUNCING); // I still need these.
if (wasSpindashing) // Ensure we're in the rolling state, and not spindash.
P_SetMobjState(object, S_PLAY_ROLL);
@@ -433,7 +432,6 @@ boolean P_DoSpring(mobj_t *spring, mobj_t *object)
}
}
secondjump = object->player->secondjump;
- washoming = object->player->homing;
P_ResetPlayer(object->player);
if (spring->info->painchance == 1) // For all those ancient, SOC'd abilities.
@@ -445,8 +443,6 @@ boolean P_DoSpring(mobj_t *spring, mobj_t *object)
{
object->player->pflags |= (pflags &~ PF_STARTJUMP);
object->player->secondjump = secondjump;
- if (washoming)
- object->player->pflags &= ~PF_THOKKED;
}
else if (!vertispeed)
{
@@ -1027,7 +1023,6 @@ static unsigned PIT_DoCheckThing(mobj_t *thing)
if ((thing->flags & MF_PUSHABLE) // not carrying a player
&& (tmthing->player->powers[pw_carry] == CR_NONE) // player is not already riding something
&& !(tmthing->player->powers[pw_ignorelatch] & (1<<15))
- && ((tmthing->eflags & MFE_VERTICALFLIP) == (thing->eflags & MFE_VERTICALFLIP))
&& (P_MobjFlip(tmthing)*tmthing->momz <= 0)
&& ((!(tmthing->eflags & MFE_VERTICALFLIP) && abs(thing->z + thing->height - tmthing->z) < (thing->height>>2))
|| (tmthing->eflags & MFE_VERTICALFLIP && abs(tmthing->z + tmthing->height - thing->z) < (thing->height>>2))))
@@ -1041,6 +1036,7 @@ static unsigned PIT_DoCheckThing(mobj_t *thing)
P_SetTarget(&tmthing->tracer, thing);
if (!P_IsObjectOnGround(thing))
thing->momz += tmthing->momz;
+
return CHECKTHING_COLLIDE;
}
}
@@ -1262,8 +1258,9 @@ static unsigned PIT_DoCheckThing(mobj_t *thing)
if (tmthing->type != MT_SHELL && tmthing->target && tmthing->target->type == thing->type)
{
- // Don't hit same species as originator.
- if (thing == tmthing->target)
+ // Don't hit yourself, and if a player, don't hit bots
+ if (thing == tmthing->target
+ || (thing->player && tmthing->target->player && (thing->player->bot == BOT_2PAI || thing->player->bot == BOT_2PHUMAN)))
return CHECKTHING_IGNORE;
if (thing->type != MT_PLAYER)
@@ -2505,6 +2502,9 @@ boolean P_TryCameraMove(fixed_t x, fixed_t y, camera_t *thiscam)
floatok = false;
+ if (dedicated) // this crashes so don't even try it
+ return false;
+
if (twodlevel
|| (thiscam == &camera && players[displayplayer].mo && (players[displayplayer].mo->flags2 & MF2_TWOD))
|| (thiscam == &camera2 && players[secondarydisplayplayer].mo && (players[secondarydisplayplayer].mo->flags2 & MF2_TWOD)))
@@ -3964,23 +3964,25 @@ papercollision:
mo->momy = tmymove;
}
+ const fixed_t tmradius = mo->radius > 8 ? mo->radius : 8;
+
do {
- if (tmxmove > mo->radius) {
- newx = mo->x + mo->radius;
- tmxmove -= mo->radius;
- } else if (tmxmove < -mo->radius) {
- newx = mo->x - mo->radius;
- tmxmove += mo->radius;
+ if (tmxmove > tmradius) {
+ newx = mo->x + tmradius;
+ tmxmove -= tmradius;
+ } else if (tmxmove < -tmradius) {
+ newx = mo->x - tmradius;
+ tmxmove += tmradius;
} else {
newx = mo->x + tmxmove;
tmxmove = 0;
}
- if (tmymove > mo->radius) {
- newy = mo->y + mo->radius;
- tmymove -= mo->radius;
- } else if (tmymove < -mo->radius) {
- newy = mo->y - mo->radius;
- tmymove += mo->radius;
+ if (tmymove > tmradius) {
+ newy = mo->y + tmradius;
+ tmymove -= tmradius;
+ } else if (tmymove < -tmradius) {
+ newy = mo->y - tmradius;
+ tmymove += tmradius;
} else {
newy = mo->y + tmymove;
tmymove = 0;
diff --git a/src/p_maputl.c b/src/p_maputl.c
index 242bc559e8d31ba398bb5dd563b5da909e31fc28..200b89cff93c815bac281c8b270ae4975de219c6 100644
--- a/src/p_maputl.c
+++ b/src/p_maputl.c
@@ -500,8 +500,24 @@ void P_LineOpening(line_t *linedef, mobj_t *mobj)
INT32 texnum = R_GetTextureNum(side->midtexture); // make sure the texture is actually valid
if (texnum) {
+ fixed_t scaley = abs(side->scaley_mid);
+ fixed_t offsetvalue = FixedDiv(side->rowoffset + side->offsety_mid, scaley);
+ fixed_t midopentop, midopenbottom;
+
+ if (linedef->flags & ML_NOSKEW)
+ {
+ // Use the sector's actual heights if the midtexture is not skewed
+ midopentop = min(front->ceilingheight, back->ceilingheight);
+ midopenbottom = max(front->floorheight, back->floorheight);
+ }
+ else
+ {
+ midopentop = opentop;
+ midopenbottom = openbottom;
+ }
+
// Get the midtexture's height
- texheight = textures[texnum]->height << FRACBITS;
+ texheight = FixedDiv(textureheight[texnum], scaley);
// Set texbottom and textop to the Z coordinates of the texture's boundaries
#if 0
@@ -509,26 +525,26 @@ void P_LineOpening(line_t *linedef, mobj_t *mobj)
// on non-solid polyobjects should NEVER happen in the future
if (linedef->polyobj && (linedef->polyobj->flags & POF_TESTHEIGHT)) {
if (linedef->flags & ML_WRAPMIDTEX && !side->repeatcnt) { // "infinite" repeat
- texbottom = back->floorheight + side->rowoffset + side->offsety_mid;
- textop = back->ceilingheight + side->rowoffset + side->offsety_mid;
+ texbottom = back->floorheight + offsetvalue;
+ textop = back->ceilingheight + offsetvalue;
} else if (linedef->flags & ML_MIDTEX) {
- texbottom = back->floorheight + side->rowoffset + side->offsety_mid;
+ texbottom = back->floorheight + offsetvalue;
textop = texbottom + texheight*(side->repeatcnt+1);
} else {
- textop = back->ceilingheight + side->rowoffset + side->offsety_mid;
+ textop = back->ceilingheight + offsetvalue;
texbottom = textop - texheight*(side->repeatcnt+1);
}
} else
#endif
{
if (linedef->flags & ML_WRAPMIDTEX && !side->repeatcnt) { // "infinite" repeat
- texbottom = openbottom + side->rowoffset + side->offsety_mid;
- textop = opentop + side->rowoffset + side->offsety_mid;
+ texbottom = midopenbottom + offsetvalue;
+ textop = midopentop + offsetvalue;
} else if (linedef->flags & ML_MIDPEG) {
- texbottom = openbottom + side->rowoffset + side->offsety_mid;
+ texbottom = midopenbottom + offsetvalue;
textop = texbottom + texheight*(side->repeatcnt+1);
} else {
- textop = opentop + side->rowoffset + side->offsety_mid;
+ textop = midopentop + offsetvalue;
texbottom = textop - texheight*(side->repeatcnt+1);
}
}
@@ -539,11 +555,21 @@ void P_LineOpening(line_t *linedef, mobj_t *mobj)
delta2 = abs(thingtop - texmid);
if (delta1 > delta2) { // Below
- if (opentop > texbottom)
+ if (opentop > texbottom) {
opentop = texbottom;
+ if (linedef->flags & ML_NOSKEW)
+ opentopslope = NULL; // Object is not actually on a slope
+ else
+ opentopslope = linedef->midtexslope;
+ }
} else { // Above
- if (openbottom < textop)
+ if (openbottom < textop) {
openbottom = textop;
+ if (linedef->flags & ML_NOSKEW)
+ openbottomslope = NULL; // Object is not actually on a slope
+ else
+ openbottomslope = linedef->midtexslope;
+ }
}
}
}
diff --git a/src/p_mobj.c b/src/p_mobj.c
index 9cdd2628db8cfec3ee8af83a6f96b3713879b164..1ec09ab8582adea2716db0d817b670bf4aba0d2c 100644
--- a/src/p_mobj.c
+++ b/src/p_mobj.c
@@ -1385,6 +1385,7 @@ fixed_t P_GetMobjGravity(mobj_t *mo)
case MT_WATERDROP:
case MT_CYBRAKDEMON:
gravityadd >>= 1;
+ break;
default:
break;
}
@@ -2245,7 +2246,7 @@ boolean P_ZMovement(mobj_t *mo)
else if (!onground)
P_SlopeLaunch(mo);
}
-
+
if (!mo->player && P_CheckDeathPitCollide(mo) && mo->health
&& !(mo->flags & MF_NOCLIPHEIGHT) && !(mo->flags2 & MF2_BOSSDEAD))
{
@@ -2938,7 +2939,7 @@ boolean P_SceneryZMovement(mobj_t *mo)
mo->eflags &= ~MFE_APPLYPMOMZ;
}
mo->z += mo->momz;
-
+
if (!mo->player && P_CheckDeathPitCollide(mo) && mo->health
&& !(mo->flags & MF_NOCLIPHEIGHT) && !(mo->flags2 & MF2_BOSSDEAD))
{
@@ -3781,7 +3782,7 @@ static void P_PlayerMobjThinker(mobj_t *mobj)
// always do the gravity bit now, that's simpler
// BUT CheckPosition only if wasn't done before.
- if (!(mobj->eflags & MFE_ONGROUND) || mobj->momz
+ if (mobj->momz
|| ((mobj->eflags & MFE_VERTICALFLIP) && mobj->z + mobj->height != mobj->ceilingz)
|| (!(mobj->eflags & MFE_VERTICALFLIP) && mobj->z != mobj->floorz)
|| P_IsObjectInGoop(mobj))
@@ -3794,17 +3795,6 @@ static void P_PlayerMobjThinker(mobj_t *mobj)
}
else
{
-#if 0 // i don't know why this is here, it's causing a few undesired state glitches, and disabling it doesn't appear to negatively affect the game, but i don't want it gone permanently just in case some obscure bug crops up
- if (!(mobj->player->powers[pw_carry] == CR_NIGHTSMODE)) // used for drilling
- mobj->player->pflags &= ~PF_STARTJUMP;
- mobj->player->pflags &= ~(PF_JUMPED|PF_NOJUMPDAMAGE);
- if (mobj->player->secondjump || mobj->player->powers[pw_tailsfly])
- {
- mobj->player->secondjump = 0;
- mobj->player->powers[pw_tailsfly] = 0;
- P_SetMobjState(mobj, S_PLAY_WALK);
- }
-#endif
mobj->eflags &= ~MFE_JUSTHITFLOOR;
}
@@ -6661,8 +6651,21 @@ static boolean P_ShieldLook(mobj_t *thing, shieldtype_t shield)
thing->flags |= MF_NOCLIPHEIGHT;
thing->eflags = (thing->eflags & ~MFE_VERTICALFLIP)|(thing->target->eflags & MFE_VERTICALFLIP);
- P_SetScale(thing, FixedMul(thing->target->scale, thing->target->player->shieldscale), true);
- thing->old_scale = FixedMul(thing->target->old_scale, thing->target->player->shieldscale);
+ //Set the shield's scale based on shieldscale, hide it if we're too small!
+ fixed_t scale = FixedMul(thing->target->scale, thing->target->player->shieldscale);
+ 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);
+ }
#define NewMH(mobj) mobj->height // Ugly mobj-height and player-height defines, for the sake of prettier code
#define NewPH(player) P_GetPlayerHeight(player)
@@ -10341,6 +10344,7 @@ void P_MobjThinker(mobj_t *mobj)
case MT_GRENADEPICKUP:
if (mobj->health == 0) // Fading tile
{
+ // TODO: Maybe use mobj->alpha instead of messing with frame flags
INT32 value = mobj->info->damage/10;
value = mobj->fuse/value;
value = 10-value;
@@ -10686,6 +10690,7 @@ mobj_t *P_SpawnMobj(fixed_t x, fixed_t y, fixed_t z, mobjtype_t type, ...)
// Sprite rendering
mobj->blendmode = AST_TRANSLUCENT;
+ mobj->alpha = FRACUNIT;
mobj->spritexscale = mobj->spriteyscale = mobj->scale;
mobj->spritexoffset = mobj->spriteyoffset = 0;
mobj->floorspriteslope = NULL;
@@ -10730,7 +10735,7 @@ mobj_t *P_SpawnMobj(fixed_t x, fixed_t y, fixed_t z, mobjtype_t type, ...)
// Set shadowscale here, before spawn hook so that Lua can change it
mobj->shadowscale = P_DefaultMobjShadowScale(mobj);
-
+
// A monitor can't respawn if we're not in multiplayer,
// or if we're in co-op and it's score or a 1up
if (mobj->flags & MF_MONITOR && (!(netgame || multiplayer)
@@ -10746,7 +10751,8 @@ mobj_t *P_SpawnMobj(fixed_t x, fixed_t y, fixed_t z, mobjtype_t type, ...)
// when spawning MT_PLAYER, set mobj->player before calling MobjSpawn hook to prevent P_RemoveMobj from succeeding on player mobj.
va_start(args, type);
mobj->player = va_arg(args, player_t *);
- mobj->player->mo = mobj;
+ if (mobj->player)
+ mobj->player->mo = mobj;
va_end(args);
}
@@ -14288,7 +14294,8 @@ mobj_t *P_SpawnMobjFromMobj(mobj_t *mobj, fixed_t xofs, fixed_t yofs, fixed_t zo
yofs = FixedMul(yofs, mobj->scale);
zofs = FixedMul(zofs, mobj->scale);
- newmobj = P_SpawnMobj(mobj->x + xofs, mobj->y + yofs, mobj->z + zofs, type);
+ newmobj = P_SpawnMobj(mobj->x + xofs, mobj->y + yofs, mobj->z + zofs, type, NULL);
+
if (!newmobj)
return NULL;
diff --git a/src/p_mobj.h b/src/p_mobj.h
index 2f013a2f30fac7f7d117cb190fcbc5bd1db17e54..f281410f6ddc7ece41acc963afe63a6b23420269 100644
--- a/src/p_mobj.h
+++ b/src/p_mobj.h
@@ -313,6 +313,7 @@ typedef struct mobj_s
UINT32 renderflags; // render flags
INT32 blendmode; // blend mode
+ fixed_t alpha; // alpha
fixed_t spritexscale, spriteyscale;
fixed_t spritexoffset, spriteyoffset;
fixed_t old_spritexscale, old_spriteyscale, old_spritexscale2, old_spriteyscale2;
@@ -456,6 +457,7 @@ typedef struct precipmobj_s
UINT32 renderflags; // render flags
INT32 blendmode; // blend mode
+ fixed_t alpha; // alpha
fixed_t spritexscale, spriteyscale;
fixed_t spritexoffset, spriteyoffset;
fixed_t old_spritexscale, old_spriteyscale, old_spritexscale2, old_spriteyscale2;
diff --git a/src/p_pspr.h b/src/p_pspr.h
index be0d9f39e37369543ea70d74e1558ebb5ca4aa36..6510190f118fb639c52a22576dd911023d3b134c 100644
--- a/src/p_pspr.h
+++ b/src/p_pspr.h
@@ -35,11 +35,11 @@
#pragma interface
#endif
-/// \brief Frame flags: only the frame number - 0 to 256 (Frames from 0 to 63, Sprite2 number uses 0 to 127 plus FF_SPR2SUPER)
+/// \brief Frame flags: only the frame number - 0 to 256 (Frames from 0 to 255, Sprite2 number uses 0 to 127 plus FF_SPR2SUPER)
#define FF_FRAMEMASK 0xff
/// \brief Frame flags - SPR2: Super sprite2
-#define FF_SPR2SUPER 0x80
+#define FF_SPR2SUPER SPR2F_SUPER //TODO: 2.3: remove this backwards compat hack
/// \brief Frame flags - SPR2: A change of state at the end of Sprite2 animation
#define FF_SPR2ENDSTATE 0x100
/// \brief Frame flags - SPR2: 50% of starting in middle of Sprite2 animation
diff --git a/src/p_saveg.c b/src/p_saveg.c
index 5e4d6d0760441e6bc94c6815824b8b7e1ab38c80..da73dd8a0e1470a1fafd4f5285923ea29c70b7fb 100644
--- a/src/p_saveg.c
+++ b/src/p_saveg.c
@@ -919,7 +919,11 @@ enum
LD_SDMIDLIGHT = 1<<19,
LD_SDBOTLIGHT = 1<<20,
LD_SDREPEATCNT = 1<<21,
- LD_SDFLAGS = 1<<22
+ LD_SDFLAGS = 1<<22,
+ LD_SDLIGHTABS = 1<<23,
+ LD_SDTOPLIGHTABS = 1<<24,
+ LD_SDMIDLIGHTABS = 1<<25,
+ LD_SDBOTLIGHTABS = 1<<26
};
static boolean P_AreArgsEqual(const line_t *li, const line_t *spawnli)
@@ -1393,6 +1397,22 @@ static UINT32 GetSideDiff(const side_t *si, const side_t *spawnsi)
diff |= LD_SDBOTSCALEY;
if (si->repeatcnt != spawnsi->repeatcnt)
diff |= LD_SDREPEATCNT;
+ if (si->light != spawnsi->light)
+ diff |= LD_SDLIGHT;
+ if (si->light_top != spawnsi->light_top)
+ diff |= LD_SDTOPLIGHT;
+ if (si->light_mid != spawnsi->light_mid)
+ diff |= LD_SDMIDLIGHT;
+ if (si->light_bottom != spawnsi->light_bottom)
+ diff |= LD_SDBOTLIGHT;
+ if (si->lightabsolute != spawnsi->lightabsolute)
+ diff |= LD_SDLIGHTABS;
+ if (si->lightabsolute_top != spawnsi->lightabsolute_top)
+ diff |= LD_SDTOPLIGHTABS;
+ if (si->lightabsolute_mid != spawnsi->lightabsolute_mid)
+ diff |= LD_SDMIDLIGHTABS;
+ if (si->lightabsolute_bottom != spawnsi->lightabsolute_bottom)
+ diff |= LD_SDBOTLIGHTABS;
return diff;
}
@@ -1436,6 +1456,22 @@ static void ArchiveSide(const side_t *si, UINT32 diff)
WRITEFIXED(save_p, si->scaley_bottom);
if (diff & LD_SDREPEATCNT)
WRITEINT16(save_p, si->repeatcnt);
+ if (diff & LD_SDLIGHT)
+ WRITEINT16(save_p, si->light);
+ if (diff & LD_SDTOPLIGHT)
+ WRITEINT16(save_p, si->light_top);
+ if (diff & LD_SDMIDLIGHT)
+ WRITEINT16(save_p, si->light_mid);
+ if (diff & LD_SDBOTLIGHT)
+ WRITEINT16(save_p, si->light_bottom);
+ if (diff & LD_SDLIGHTABS)
+ WRITEUINT8(save_p, si->lightabsolute);
+ if (diff & LD_SDTOPLIGHTABS)
+ WRITEUINT8(save_p, si->lightabsolute_top);
+ if (diff & LD_SDMIDLIGHTABS)
+ WRITEUINT8(save_p, si->lightabsolute_mid);
+ if (diff & LD_SDBOTLIGHTABS)
+ WRITEUINT8(save_p, si->lightabsolute_bottom);
}
static void ArchiveLines(void)
@@ -1576,6 +1612,22 @@ static void UnArchiveSide(side_t *si)
si->scaley_bottom = READFIXED(save_p);
if (diff & LD_SDREPEATCNT)
si->repeatcnt = READINT16(save_p);
+ if (diff & LD_SDLIGHT)
+ si->light = READINT16(save_p);
+ if (diff & LD_SDTOPLIGHT)
+ si->light_top = READINT16(save_p);
+ if (diff & LD_SDMIDLIGHT)
+ si->light_mid = READINT16(save_p);
+ if (diff & LD_SDBOTLIGHT)
+ si->light_bottom = READINT16(save_p);
+ if (diff & LD_SDLIGHTABS)
+ si->lightabsolute = READUINT8(save_p);
+ if (diff & LD_SDTOPLIGHTABS)
+ si->lightabsolute_top = READUINT8(save_p);
+ if (diff & LD_SDMIDLIGHTABS)
+ si->lightabsolute_mid = READUINT8(save_p);
+ if (diff & LD_SDBOTLIGHTABS)
+ si->lightabsolute_bottom = READUINT8(save_p);
}
static void UnArchiveLines(void)
@@ -1746,7 +1798,8 @@ typedef enum
MD2_DISPOFFSET = 1<<23,
MD2_DRAWONLYFORPLAYER = 1<<24,
MD2_DONTDRAWFORVIEWMOBJ = 1<<25,
- MD2_TRANSLATION = 1<<26
+ MD2_TRANSLATION = 1<<26,
+ MD2_ALPHA = 1<<27
} mobj_diff2_t;
typedef enum
@@ -1989,6 +2042,8 @@ static void SaveMobjThinker(const thinker_t *th, const UINT8 type)
diff2 |= MD2_DONTDRAWFORVIEWMOBJ;
if (mobj->dispoffset != mobj->info->dispoffset)
diff2 |= MD2_DISPOFFSET;
+ if (mobj->alpha != FRACUNIT)
+ diff2 |= MD2_ALPHA;
if (diff2 != 0)
diff |= MD_MORE;
@@ -2172,6 +2227,8 @@ static void SaveMobjThinker(const thinker_t *th, const UINT8 type)
WRITEINT32(save_p, mobj->dispoffset);
if (diff2 & MD2_TRANSLATION)
WRITEUINT16(save_p, mobj->translation);
+ if (diff2 & MD2_ALPHA)
+ WRITEFIXED(save_p, mobj->alpha);
WRITEUINT32(save_p, mobj->mobjnum);
}
@@ -3238,6 +3295,10 @@ static thinker_t* LoadMobjThinker(actionf_p1 thinker)
mobj->dispoffset = mobj->info->dispoffset;
if (diff2 & MD2_TRANSLATION)
mobj->translation = READUINT16(save_p);
+ if (diff2 & MD2_ALPHA)
+ mobj->alpha = READFIXED(save_p);
+ else
+ mobj->alpha = FRACUNIT;
if (diff & MD_REDFLAG)
{
diff --git a/src/p_setup.c b/src/p_setup.c
index a59b60dcd21545a641a1b6981f0a2f8eb3e1c396..b914a83b9f4b5410eb70d5c7024d351b82c3234d 100644
--- a/src/p_setup.c
+++ b/src/p_setup.c
@@ -834,13 +834,15 @@ void P_ScanThings(INT16 mapnum, INT16 wadnum, INT16 lumpnum)
static void P_SpawnEmeraldHunt(void)
{
- INT32 emer[3], num[MAXHUNTEMERALDS], i, randomkey;
+ INT32 emer[3], num[MAXHUNTEMERALDS], i, amount, randomkey;
fixed_t x, y, z;
for (i = 0; i < numhuntemeralds; i++)
num[i] = i;
- for (i = 0; i < 3; i++)
+ amount = min(numhuntemeralds, 3);
+
+ for (i = 0; i < amount; i++)
{
// generate random index, shuffle afterwards
randomkey = P_RandomKey(numhuntemeralds--);
@@ -1116,6 +1118,8 @@ static void P_InitializeLinedef(line_t *ld)
ld->callcount = 0;
ld->secportal = UINT32_MAX;
+ ld->midtexslope = NULL;
+
// cph 2006/09/30 - fix sidedef errors right away.
// cph 2002/07/20 - these errors are fatal if not fixed, so apply them
for (j = 0; j < 2; j++)
@@ -1366,6 +1370,9 @@ static void P_LoadSidedefs(UINT8 *data)
sd->scalex_top = sd->scalex_mid = sd->scalex_bottom = FRACUNIT;
sd->scaley_top = sd->scaley_mid = sd->scaley_bottom = FRACUNIT;
+ sd->light = sd->light_top = sd->light_mid = sd->light_bottom = 0;
+ sd->lightabsolute = sd->lightabsolute_top = sd->lightabsolute_mid = sd->lightabsolute_bottom = false;
+
P_SetSidedefSector(i, (UINT16)SHORT(msd->sector));
// Special info stored in texture fields!
@@ -1553,11 +1560,41 @@ static void P_LoadThings(UINT8 *data)
}
// Stores positions for relevant map data spread through a TEXTMAP.
-UINT32 mapthingsPos[UINT16_MAX];
-UINT32 linesPos[UINT16_MAX];
-UINT32 sidesPos[UINT16_MAX];
-UINT32 vertexesPos[UINT16_MAX];
-UINT32 sectorsPos[UINT16_MAX];
+typedef struct textmap_block_s
+{
+ UINT32 *pos;
+ size_t capacity;
+} textmap_block_t;
+
+static textmap_block_t mapthingBlocks;
+static textmap_block_t linedefBlocks;
+static textmap_block_t sidedefBlocks;
+static textmap_block_t vertexBlocks;
+static textmap_block_t sectorBlocks;
+
+static void TextmapStorePos(textmap_block_t *blocks, size_t *count)
+{
+ size_t locCount = (*count) + 1;
+
+ if (blocks->pos == NULL)
+ {
+ // Initial capacity (half of the former one.)
+ blocks->capacity = UINT16_MAX / 2;
+
+ Z_Calloc(sizeof(blocks->pos) * blocks->capacity, PU_LEVEL, &blocks->pos);
+ }
+ else if (locCount >= blocks->capacity)
+ {
+ // If we hit the list's capacity, make space for 1024 more blocks
+ blocks->capacity += 1024;
+
+ Z_Realloc(blocks->pos, sizeof(blocks->pos) * blocks->capacity, PU_LEVEL, &blocks->pos);
+ }
+
+ blocks->pos[locCount - 1] = M_TokenizerGetEndPos();
+
+ (*count) = locCount;
+}
// Determine total amount of map data in TEXTMAP.
static boolean TextmapCount(size_t size)
@@ -1601,15 +1638,15 @@ static boolean TextmapCount(size_t size)
brackets++;
// Check for valid fields.
else if (fastcmp(tkn, "thing"))
- mapthingsPos[nummapthings++] = M_TokenizerGetEndPos();
+ TextmapStorePos(&mapthingBlocks, &nummapthings);
else if (fastcmp(tkn, "linedef"))
- linesPos[numlines++] = M_TokenizerGetEndPos();
+ TextmapStorePos(&linedefBlocks, &numlines);
else if (fastcmp(tkn, "sidedef"))
- sidesPos[numsides++] = M_TokenizerGetEndPos();
+ TextmapStorePos(&sidedefBlocks, &numsides);
else if (fastcmp(tkn, "vertex"))
- vertexesPos[numvertexes++] = M_TokenizerGetEndPos();
+ TextmapStorePos(&vertexBlocks, &numvertexes);
else if (fastcmp(tkn, "sector"))
- sectorsPos[numsectors++] = M_TokenizerGetEndPos();
+ TextmapStorePos(§orBlocks, &numsectors);
else
CONS_Alert(CONS_NOTICE, "Unknown field '%s'.\n", tkn);
}
@@ -1946,6 +1983,22 @@ static void ParseTextmapSidedefParameter(UINT32 i, const char *param, const char
P_SetSidedefSector(i, atol(val));
else if (fastcmp(param, "repeatcnt"))
sides[i].repeatcnt = atol(val);
+ else if (fastcmp(param, "light"))
+ sides[i].light = atol(val);
+ else if (fastcmp(param, "light_top"))
+ sides[i].light_top = atol(val);
+ else if (fastcmp(param, "light_mid"))
+ sides[i].light_mid = atol(val);
+ else if (fastcmp(param, "light_bottom"))
+ sides[i].light_bottom = atol(val);
+ else if (fastcmp(param, "lightabsolute") && fastcmp("true", val))
+ sides[i].lightabsolute = true;
+ else if (fastcmp(param, "lightabsolute_top") && fastcmp("true", val))
+ sides[i].lightabsolute_top = true;
+ else if (fastcmp(param, "lightabsolute_mid") && fastcmp("true", val))
+ sides[i].lightabsolute_mid = true;
+ else if (fastcmp(param, "lightabsolute_bottom") && fastcmp("true", val))
+ sides[i].lightabsolute_bottom = true;
}
static void ParseTextmapLinedefParameter(UINT32 i, const char *param, const char *val)
@@ -2673,6 +2726,22 @@ static void P_WriteTextmap(void)
fprintf(f, "texturemiddle = \"%.*s\";\n", 8, textures[wsides[i].midtexture]->name);
if (wsides[i].repeatcnt != 0)
fprintf(f, "repeatcnt = %d;\n", wsides[i].repeatcnt);
+ if (wsides[i].light != 0)
+ fprintf(f, "light = %d;\n", wsides[i].light);
+ if (wsides[i].light_top != 0)
+ fprintf(f, "light_top = %d;\n", wsides[i].light_top);
+ if (wsides[i].light_mid != 0)
+ fprintf(f, "light_mid = %d;\n", wsides[i].light_mid);
+ if (wsides[i].light_bottom != 0)
+ fprintf(f, "light_bottom = %d;\n", wsides[i].light_bottom);
+ if (wsides[i].lightabsolute)
+ fprintf(f, "lightabsolute = true;\n");
+ if (wsides[i].lightabsolute_top)
+ fprintf(f, "lightabsolute_top = true;\n");
+ if (wsides[i].lightabsolute_mid)
+ fprintf(f, "lightabsolute_mid = true;\n");
+ if (wsides[i].lightabsolute_bottom)
+ fprintf(f, "lightabsolute_bottom = true;\n");
fprintf(f, "}\n");
fprintf(f, "\n");
}
@@ -2943,7 +3012,7 @@ static void P_LoadTextmap(void)
vt->floorzset = vt->ceilingzset = false;
vt->floorz = vt->ceilingz = 0;
- TextmapParse(vertexesPos[i], i, ParseTextmapVertexParameter);
+ TextmapParse(vertexBlocks.pos[i], i, ParseTextmapVertexParameter);
if (vt->x == INT32_MAX)
I_Error("P_LoadTextmap: vertex %s has no x value set!\n", sizeu1(i));
@@ -3000,7 +3069,7 @@ static void P_LoadTextmap(void)
textmap_planefloor.defined = 0;
textmap_planeceiling.defined = 0;
- TextmapParse(sectorsPos[i], i, ParseTextmapSectorParameter);
+ TextmapParse(sectorBlocks.pos[i], i, ParseTextmapSectorParameter);
P_InitializeSector(sc);
if (textmap_colormap.used)
@@ -3049,7 +3118,7 @@ static void P_LoadTextmap(void)
ld->sidenum[0] = NO_SIDEDEF;
ld->sidenum[1] = NO_SIDEDEF;
- TextmapParse(linesPos[i], i, ParseTextmapLinedefParameter);
+ TextmapParse(linedefBlocks.pos[i], i, ParseTextmapLinedefParameter);
if (!ld->v1)
I_Error("P_LoadTextmap: linedef %s has no v1 value set!\n", sizeu1(i));
@@ -3075,8 +3144,10 @@ static void P_LoadTextmap(void)
sd->bottomtexture = R_TextureNumForName("-");
sd->sector = NULL;
sd->repeatcnt = 0;
+ sd->light = sd->light_top = sd->light_mid = sd->light_bottom = 0;
+ sd->lightabsolute = sd->lightabsolute_top = sd->lightabsolute_mid = sd->lightabsolute_bottom = false;
- TextmapParse(sidesPos[i], i, ParseTextmapSidedefParameter);
+ TextmapParse(sidedefBlocks.pos[i], i, ParseTextmapSidedefParameter);
if (!sd->sector)
I_Error("P_LoadTextmap: sidedef %s has no sector value set!\n", sizeu1(i));
@@ -3100,7 +3171,7 @@ static void P_LoadTextmap(void)
memset(mt->stringargs, 0x00, NUMMAPTHINGSTRINGARGS*sizeof(*mt->stringargs));
mt->mobj = NULL;
- TextmapParse(mapthingsPos[i], i, ParseTextmapThingParameter);
+ TextmapParse(mapthingBlocks.pos[i], i, ParseTextmapThingParameter);
}
}
@@ -3418,13 +3489,13 @@ typedef enum {
} nodetype_t;
// Find out the BSP format.
-static nodetype_t P_GetNodetype(const virtres_t *virt, UINT8 **nodedata)
+static nodetype_t P_GetNodetype(const virtres_t *virt, UINT8 **nodedata, char signature[4 + 1])
{
boolean supported[NUMNODETYPES] = {0};
nodetype_t nodetype = NT_UNSUPPORTED;
- char signature[4 + 1];
*nodedata = NULL;
+ signature[0] = signature[4] = '\0';
if (udmf)
{
@@ -3433,7 +3504,7 @@ static nodetype_t P_GetNodetype(const virtres_t *virt, UINT8 **nodedata)
if (virtznodes && virtznodes->size)
{
*nodedata = virtznodes->data;
- supported[NT_XGLN] = supported[NT_XGL3] = true;
+ supported[NT_XGLN] = supported[NT_XGL2] = supported[NT_XGL3] = true;
}
}
else
@@ -3455,9 +3526,9 @@ static nodetype_t P_GetNodetype(const virtres_t *virt, UINT8 **nodedata)
virtssectors = vres_Find(virt, "SSECTORS");
if (virtssectors && virtssectors->size)
- { // Possibly GL nodes: NODES ignored, SSECTORS takes precedence as nodes lump, (It is confusing yeah) and has a signature.
+ { // Possibly GL nodes: NODES ignored, SSECTORS takes precedence as nodes lump (it is confusing, yeah), and has a signature.
*nodedata = virtssectors->data;
- supported[NT_XGLN] = supported[NT_ZGLN] = supported[NT_XGL3] = true;
+ supported[NT_XGLN] = supported[NT_ZGLN] = supported[NT_XGL2] = supported[NT_XGL3] = true;
}
else
{ // Possibly ZDoom extended nodes: SSECTORS is empty, NODES has a signature.
@@ -3477,19 +3548,42 @@ static nodetype_t P_GetNodetype(const virtres_t *virt, UINT8 **nodedata)
}
M_Memcpy(signature, *nodedata, 4);
- signature[4] = '\0';
(*nodedata) += 4;
- if (!strcmp(signature, "XNOD"))
- nodetype = NT_XNOD;
- else if (!strcmp(signature, "ZNOD"))
- nodetype = NT_ZNOD;
- else if (!strcmp(signature, "XGLN"))
- nodetype = NT_XGLN;
- else if (!strcmp(signature, "ZGLN"))
- nodetype = NT_ZGLN;
- else if (!strcmp(signature, "XGL3"))
- nodetype = NT_XGL3;
+ // Identify node format from its starting signature.
+ if (memcmp(&signature[1], "NOD", 3) == 0) // ZDoom extended nodes
+ {
+ if (signature[0] == 'X')
+ {
+ nodetype = NT_XNOD; // Uncompressed
+ }
+ else if (signature[0] == 'Z')
+ {
+ nodetype = NT_ZNOD; // Compressed
+ }
+ }
+ else if (memcmp(&signature[1], "GL", 2) == 0) // GL nodes
+ {
+ switch (signature[0])
+ {
+ case 'X': // Uncompressed
+ switch (signature[3])
+ {
+ case 'N': nodetype = NT_XGLN; break; // GL nodes
+ case '2': nodetype = NT_XGL2; break; // Version 2 GL nodes
+ case '3': nodetype = NT_XGL3; break; // Version 3 GL nodes
+ }
+ break;
+ case 'Z': // Compressed
+ switch (signature[3])
+ {
+ case 'N': nodetype = NT_ZGLN; break; // GL nodes (compressed)
+ case '2': nodetype = NT_ZGL2; break; // Version 2 GL nodes (compressed)
+ case '3': nodetype = NT_ZGL3; break; // Version 3 GL nodes (compressed)
+ }
+ break;
+ }
+ }
return supported[nodetype] ? nodetype : NT_UNSUPPORTED;
}
@@ -3501,7 +3595,6 @@ static boolean P_LoadExtraVertices(UINT8 **data)
UINT32 xtrvrtx = READUINT32((*data));
line_t* ld = lines;
vertex_t *oldpos = vertexes;
- ssize_t offset;
size_t i;
if (numvertexes != origvrtx) // If native vertex count doesn't match node original vertex count, bail out (broken data?).
@@ -3516,12 +3609,11 @@ static boolean P_LoadExtraVertices(UINT8 **data)
// If extra vertexes were generated, reallocate the vertex array and fix the pointers.
numvertexes += xtrvrtx;
vertexes = Z_Realloc(vertexes, numvertexes*sizeof(*vertexes), PU_LEVEL, NULL);
- offset = (size_t)(vertexes - oldpos);
for (i = 0, ld = lines; i < numlines; i++, ld++)
{
- ld->v1 += offset;
- ld->v2 += offset;
+ ld->v1 = &vertexes[ld->v1 - oldpos];
+ ld->v2 = &vertexes[ld->v2 - oldpos];
}
// Read extra vertex data.
@@ -3559,6 +3651,7 @@ static boolean P_LoadExtendedSubsectorsAndSegs(UINT8 **data, nodetype_t nodetype
switch (nodetype)
{
case NT_XGLN:
+ case NT_XGL2:
case NT_XGL3:
for (m = 0; m < (size_t)subsectors[i].numlines; m++, k++)
{
@@ -3570,7 +3663,7 @@ static boolean P_LoadExtendedSubsectorsAndSegs(UINT8 **data, nodetype_t nodetype
READUINT32((*data)); // partner, can be ignored by software renderer
- if (nodetype == NT_XGL3)
+ if (nodetype != NT_XGLN)
{
UINT32 linenum = READUINT32((*data));
if (linenum != 0xFFFFFFFF && linenum >= numlines)
@@ -3681,8 +3774,9 @@ static void P_LoadExtendedNodes(UINT8 **data, nodetype_t nodetype)
static void P_LoadMapBSP(const virtres_t *virt)
{
+ char signature[4 + 1];
UINT8 *nodedata = NULL;
- nodetype_t nodetype = P_GetNodetype(virt, &nodedata);
+ nodetype_t nodetype = P_GetNodetype(virt, &nodedata, signature);
switch (nodetype)
{
@@ -3714,6 +3808,7 @@ static void P_LoadMapBSP(const virtres_t *virt)
}
case NT_XNOD:
case NT_XGLN:
+ case NT_XGL2:
case NT_XGL3:
if (!P_LoadExtraVertices(&nodedata))
return;
@@ -3722,10 +3817,13 @@ static void P_LoadMapBSP(const virtres_t *virt)
P_LoadExtendedNodes(&nodedata, nodetype);
break;
default:
- CONS_Alert(CONS_WARNING, "Unsupported BSP format detected.\n");
- return;
+ if (isprint(signature[0]) && isprint(signature[1]) && isprint(signature[2]) && isprint(signature[3]))
+ {
+ I_Error("Unsupported BSP format '%s' detected!\n", signature);
+ return;
+ }
+ I_Error("Unknown BSP format detected!\n");
}
- return;
}
// Split from P_LoadBlockMap for convenience
diff --git a/src/p_slopes.c b/src/p_slopes.c
index e75d36edefe8d8484cb0c9bebb4d02d5f1b1e174..ce276a6729a6bea818328821430366ffa920b18c 100644
--- a/src/p_slopes.c
+++ b/src/p_slopes.c
@@ -28,6 +28,8 @@
pslope_t *slopelist = NULL;
UINT16 slopecount = 0;
+static void P_UpdateMidtextureSlopesForSector(sector_t *sector);
+
// Calculate line normal
void P_CalculateSlopeNormal(pslope_t *slope)
{
@@ -179,8 +181,8 @@ void T_DynamicSlopeLine (dynlineplanethink_t* th)
{
pslope_t* slope = th->slope;
line_t* srcline = th->sourceline;
-
- fixed_t zdelta;
+
+ fixed_t zdelta, oldoz = slope->o.z;
switch(th->type) {
case DP_FRONTFLOOR:
@@ -207,11 +209,14 @@ void T_DynamicSlopeLine (dynlineplanethink_t* th)
return;
}
- if (slope->zdelta != FixedDiv(zdelta, th->extent)) {
+ if (slope->zdelta != FixedDiv(zdelta, th->extent) || oldoz != slope->o.z) {
slope->zdelta = FixedDiv(zdelta, th->extent);
slope->zangle = R_PointToAngle2(0, 0, th->extent, -zdelta);
slope->moved = true;
P_CalculateSlopeNormal(slope);
+ P_UpdateMidtextureSlopesForSector(srcline->frontsector);
+ if (srcline->backsector)
+ P_UpdateMidtextureSlopesForSector(srcline->backsector);
}
}
@@ -232,6 +237,12 @@ void T_DynamicSlopeVert (dynvertexplanethink_t* th)
}
ReconfigureViaVertexes(th->slope, th->vex[0], th->vex[1], th->vex[2]);
+
+ for (i = 0; i < 3; i++)
+ {
+ if (th->secs[i])
+ P_UpdateMidtextureSlopesForSector(th->secs[i]);
+ }
}
static inline void P_AddDynLineSlopeThinker (pslope_t* slope, dynplanetype_t type, line_t* sourceline, fixed_t extent)
@@ -758,6 +769,111 @@ pslope_t *P_MakeSlopeViaEquationConstants(const double a, const double b, const
return ret;
}
+static pslope_t *P_GetReferenceSlopeForMidtexture(line_t *line)
+{
+ if (line->flags & ML_MIDPEG)
+ {
+ // Line has ML_MIDPEG, so use the floor slope
+ fixed_t frontheight = P_GetSectorFloorZAt(line->frontsector, line->v1->x, line->v1->y);
+ fixed_t backheight = P_GetSectorFloorZAt(line->backsector, line->v1->x, line->v1->y);
+
+ if (frontheight > backheight)
+ {
+ return line->frontsector->f_slope;
+ }
+ else
+ {
+ return line->backsector->f_slope;
+ }
+ }
+ else
+ {
+ // Line does not have ML_MIDPEG, so use the ceiling slope
+ fixed_t frontheight = P_GetSectorCeilingZAt(line->frontsector, line->v1->x, line->v1->y);
+ fixed_t backheight = P_GetSectorCeilingZAt(line->backsector, line->v1->x, line->v1->y);
+
+ if (frontheight < backheight)
+ {
+ return line->frontsector->c_slope;
+ }
+ else
+ {
+ return line->backsector->c_slope;
+ }
+ }
+
+ return NULL;
+}
+
+// Updates a slope for a solid midtexture based on the slope of the sector it's in.
+static void P_UpdateSolidMidtextureSlope(line_t *line, pslope_t *ref)
+{
+ pslope_t *slope = line->midtexslope;
+
+ if (ref == NULL)
+ return;
+
+ // Set origin
+ vector3_t origin;
+ origin.x = line->v1->x;
+ origin.y = line->v1->y;
+ origin.z = P_GetSlopeZAt(ref, origin.x, origin.y);
+ FV3_Copy(&slope->o, &origin);
+
+ // Get where the line ends
+ vector3_t point;
+ point.x = line->v2->x;
+ point.y = line->v2->y;
+ point.z = P_GetSlopeZAt(ref, point.x, point.y);
+
+ // Get length of the line
+ fixed_t extent = R_PointToDist2(0, 0, line->dx, line->dy);
+
+ // Precalculate variables
+ slope->zdelta = FixedDiv(origin.z - point.z, extent);
+ slope->zangle = R_PointToAngle2(0, origin.z, extent, point.z);
+ slope->xydirection = line->angle;
+
+ // Precalculate the direction
+ vector2_t dir;
+ dir.x = FixedMul(FINECOSINE(slope->zangle >> ANGLETOFINESHIFT), FINECOSINE((slope->xydirection+ANGLE_180) >> ANGLETOFINESHIFT));
+ dir.y = FixedMul(FINECOSINE(slope->zangle >> ANGLETOFINESHIFT), FINESINE((slope->xydirection+ANGLE_180) >> ANGLETOFINESHIFT));
+ FV2_Copy(&slope->d, &dir);
+
+ P_CalculateSlopeNormal(slope);
+
+ // Calling P_CalculateSlopeVectors is not necessary.
+ slope->moved = true;
+}
+
+// Goes through every line in the sector and updates the midtexture slope if it is present
+static void P_UpdateMidtextureSlopesForSector(sector_t *sector)
+{
+ for (size_t i = 0; i < sector->linecount; i++)
+ {
+ if (sector->lines[i]->midtexslope != NULL)
+ P_UpdateSolidMidtextureSlope(sector->lines[i], P_GetReferenceSlopeForMidtexture(sector->lines[i]));
+ }
+}
+
+// Creates a solid midtexture slope for the line if possible
+static void P_CreateSolidMidtextureSlope(line_t *line)
+{
+ if (line->backsector == NULL) // Ignore single-sided lines (of course)
+ return;
+
+ if ((line->flags & ML_MIDSOLID) == 0) // Ignore if the midtexture is not solid
+ return;
+
+ pslope_t *ref = P_GetReferenceSlopeForMidtexture(line);
+ if (ref)
+ {
+ line->midtexslope = Slope_Add(ref->flags & SL_NOPHYSICS);
+
+ P_UpdateSolidMidtextureSlope(line, ref);
+ }
+}
+
/// Initializes and reads the slopes from the map data.
void P_SpawnSlopes(const boolean fromsave) {
size_t i;
@@ -785,14 +901,21 @@ void P_SpawnSlopes(const boolean fromsave) {
/// Copies slopes from tagged sectors via line specials.
/// \note Doesn't actually copy, but instead they share the same pointers.
+ // Also, creates midtexture slopes.
for (i = 0; i < numlines; i++)
- switch (lines[i].special)
+ {
+ line_t *line = &lines[i];
+
+ switch (line->special)
{
case 720:
- P_CopySectorSlope(&lines[i]);
+ P_CopySectorSlope(line);
default:
break;
}
+
+ P_CreateSolidMidtextureSlope(line);
+ }
}
/// Initializes slopes.
@@ -810,10 +933,10 @@ void P_InitSlopes(void)
// Returns the height of the sloped plane at (x, y) as a fixed_t
fixed_t P_GetSlopeZAt(const pslope_t *slope, fixed_t x, fixed_t y)
{
- fixed_t dist = FixedMul(x - slope->o.x, slope->d.x) +
- FixedMul(y - slope->o.y, slope->d.y);
+ fixed_t dist = FixedMul(x - slope->o.x, slope->d.x) / 2 +
+ FixedMul(y - slope->o.y, slope->d.y) / 2;
- return slope->o.z + FixedMul(dist, slope->zdelta);
+ return slope->o.z + FixedMul(dist, slope->zdelta) * 2;
}
// Like P_GetSlopeZAt but falls back to z if slope is NULL
diff --git a/src/p_spec.c b/src/p_spec.c
index 805817fb033c465b33059c24fbefb52432173444..d4939669a1ec5bce2ee873617b00edfce966829e 100644
--- a/src/p_spec.c
+++ b/src/p_spec.c
@@ -2405,18 +2405,15 @@ static void P_ProcessLineSpecial(line_t *line, mobj_t *mo, sector_t *callsec)
y = line->args[3] << FRACBITS;
z = line->args[4] << FRACBITS;
- P_UnsetThingPosition(mo);
- mo->x += x;
- mo->y += y;
- mo->z += z;
- P_SetThingPosition(mo);
-
+ 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
P_SetOrigin(bot, bot->x + x, bot->y + y, bot->z + z);
if (splitscreen && mo->player == &players[secondarydisplayplayer] && camera2.chase)
{
+ camera2.reset = true;
camera2.x += x;
camera2.y += y;
camera2.z += z;
@@ -2424,6 +2421,7 @@ static void P_ProcessLineSpecial(line_t *line, mobj_t *mo, sector_t *callsec)
}
else if (camera.chase && mo->player == &players[displayplayer])
{
+ camera.reset = true;
camera.x += x;
camera.y += y;
camera.z += z;
@@ -3684,7 +3682,7 @@ static void P_ProcessLineSpecial(line_t *line, mobj_t *mo, sector_t *callsec)
case 466: // Set level failure state
{
- if (line->args[1])
+ if (line->args[0])
{
stagefailed = false;
CONS_Debug(DBG_GAMELOGIC, "Stage can be completed successfully!\n");
diff --git a/src/p_user.c b/src/p_user.c
index 7cd128cf080792f64df4a56ca4aeb4e9076e6b94..3ee13aca96989a4c7f5b94a64c8e525f275f9882 100644
--- a/src/p_user.c
+++ b/src/p_user.c
@@ -915,7 +915,7 @@ void P_NightserizePlayer(player_t *player, INT32 nighttime)
player->textvar = NTV_BONUSTIMEEND; // Score and grades
player->finishedspheres = (INT16)(player->spheres);
player->finishedrings = (INT16)(player->rings);
-
+
// Add score to temp leaderboards
player->lastmaretime = leveltime - player->marebegunat;
G_AddTempNightsRecords(player, player->marescore, player->lastmaretime, (UINT8)(oldmare + 1));
@@ -976,6 +976,9 @@ pflags_t P_GetJumpFlags(player_t *player)
//
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;
@@ -1089,6 +1092,13 @@ void P_ResetPlayer(player_t *player)
if (player->mo->tracer && !P_MobjWasRemoved(player->mo->tracer))
{
player->mo->tracer->flags |= MF_PUSHABLE;
+
+ // goose the mom a little bit to trigger gravity to process for a tic
+ if (player->mo->tracer->eflags & MFE_VERTICALFLIP)
+ player->mo->tracer->momz -= 1;
+ else
+ player->mo->tracer->momz += 1;
+
P_SetTarget(&player->mo->tracer->tracer, NULL);
}
P_SetTarget(&player->mo->tracer, NULL);
@@ -2071,6 +2081,7 @@ mobj_t *P_SpawnGhostMobj(mobj_t *mobj)
ghost->renderflags = mobj->renderflags;
ghost->blendmode = mobj->blendmode;
+ ghost->alpha = mobj->alpha;
ghost->spritexscale = mobj->spritexscale;
ghost->spriteyscale = mobj->spriteyscale;
@@ -2372,7 +2383,7 @@ boolean P_PlayerHitFloor(player_t *player, boolean dorollstuff)
if (dorollstuff)
{
if ((player->charability2 == CA2_SPINDASH) && !((player->pflags & (PF_SPINNING|PF_THOKKED)) == PF_THOKKED) && !(player->charability == CA_THOK && player->secondjump)
- && (player->cmd.buttons & BT_SPIN) && (FixedHypot(player->mo->momx, player->mo->momy) > (5*player->mo->scale)))
+ && (player->cmd.buttons & BT_SPIN) && (FixedHypot(player->mo->momx, player->mo->momy) >= (5*player->mo->scale)))
player->pflags = (player->pflags|PF_SPINNING) & ~PF_THOKKED;
else if (!(player->pflags & PF_STARTDASH))
player->pflags &= ~PF_SPINNING;
@@ -4546,6 +4557,13 @@ void P_DoJump(player_t *player, boolean soundandstate, boolean allowflip)
player->mo->momz += player->mo->tracer->momz;
if (!P_IsObjectOnGround(player->mo->tracer))
P_SetObjectMomZ(player->mo->tracer, -9*FRACUNIT, true);
+
+ // goose the mom a little bit to trigger gravity to process for a tic
+ if (player->mo->tracer->eflags & MFE_VERTICALFLIP)
+ player->mo->tracer->momz -= 1;
+ else
+ player->mo->tracer->momz += 1;
+
player->mo->tracer->flags |= MF_PUSHABLE;
P_SetTarget(&player->mo->tracer->tracer, NULL);
}
@@ -4721,7 +4739,7 @@ static void P_DoSpinAbility(player_t *player, ticcmd_t *cmd)
// Revving
else if ((cmd->buttons & BT_SPIN) && (player->pflags & PF_STARTDASH))
{
- if (player->speed > 5*player->mo->scale)
+ if (player->speed >= 5*player->mo->scale)
{
player->pflags &= ~PF_STARTDASH;
P_SetMobjState(player->mo, S_PLAY_ROLL);
@@ -4761,9 +4779,8 @@ static void P_DoSpinAbility(player_t *player, ticcmd_t *cmd)
if (!player->spectator)
S_StartSound(player->mo, sfx_spin);
}
- else
// Catapult the player from a spindash rev!
- if (onground && !(player->pflags & PF_SPINDOWN) && (player->pflags & PF_STARTDASH) && (player->pflags & PF_SPINNING))
+ else if (onground && !(player->pflags & PF_SPINDOWN) && (player->pflags & PF_STARTDASH) && (player->pflags & PF_SPINNING))
{
player->pflags &= ~PF_STARTDASH;
if (player->powers[pw_carry] == CR_BRAKGOOP)
@@ -8766,7 +8783,7 @@ void P_MovePlayer(player_t *player)
if (!(player->mo->momz || player->mo->momx || player->mo->momy) && !(player->mo->eflags & MFE_GOOWATER)
&& player->panim == PA_IDLE && !(player->powers[pw_carry]))
P_DoTeeter(player);
-
+
// Toss a flag
if (G_GametypeHasTeams() && (cmd->buttons & BT_TOSSFLAG) && !(player->powers[pw_super]) && !(player->tossdelay))
{
@@ -8812,6 +8829,8 @@ void P_MovePlayer(player_t *player)
player->mo->height = P_GetPlayerSpinHeight(player);
atspinheight = true;
}
+ else if (player->powers[pw_carry] == CR_PLAYER || player->powers[pw_carry] == CR_PTERABYTE) // You're slightly shorter while being carried
+ player->mo->height = FixedDiv(P_GetPlayerHeight(player), FixedDiv(14*FRACUNIT,10*FRACUNIT));
else
player->mo->height = P_GetPlayerHeight(player);
@@ -12129,6 +12148,10 @@ void P_PlayerThink(player_t *player)
case CR_DUSTDEVIL:
player->drawangle += ANG20;
break;
+ case CR_FAN:
+ if (player->pflags & PF_ANALOGMODE) // Don't impact drawangle in any special way when on a fan
+ player->drawangle = player->mo->angle;
+ break;
/* -- in case we wanted to have the camera freely movable during zoom tubes
case CR_ZOOMTUBE:*/
case CR_ROPEHANG:
@@ -12829,9 +12852,9 @@ void P_PlayerAfterThink(player_t *player)
else
{
if (tails->player)
- P_TryMove(player->mo, tails->x + P_ReturnThrustX(tails, tails->player->drawangle, 4*FRACUNIT), tails->y + P_ReturnThrustY(tails, tails->player->drawangle, 4*FRACUNIT), true);
+ P_TryMove(player->mo, tails->x + P_ReturnThrustX(tails, tails->player->drawangle, 4*tails->scale), tails->y + P_ReturnThrustY(tails, tails->player->drawangle, 4*tails->scale), true);
else
- P_TryMove(player->mo, tails->x + P_ReturnThrustX(tails, tails->angle, 4*FRACUNIT), tails->y + P_ReturnThrustY(tails, tails->angle, 4*FRACUNIT), true);
+ P_TryMove(player->mo, tails->x + P_ReturnThrustX(tails, tails->angle, 4*tails->scale), tails->y + P_ReturnThrustY(tails, tails->angle, 4*tails->scale), true);
player->mo->momx = tails->momx;
player->mo->momy = tails->momy;
player->mo->momz = tails->momz;
@@ -12845,7 +12868,7 @@ void P_PlayerAfterThink(player_t *player)
P_SetPlayerAngle(player, player->mo->angle);
}
- if (P_AproxDistance(player->mo->x - tails->x, player->mo->y - tails->y) > player->mo->radius)
+ if (P_AproxDistance(player->mo->x - tails->x, player->mo->y - tails->y) > tails->radius)
player->powers[pw_carry] = CR_NONE;
if (player->powers[pw_carry] == CR_PLAYER)
@@ -13066,7 +13089,7 @@ void P_PlayerAfterThink(player_t *player)
player->mo->momy = ptera->momy;
player->mo->momz = ptera->momz;
- if (P_AproxDistance(player->mo->x - ptera->x - ptera->watertop, player->mo->y - ptera->y - ptera->waterbottom) > player->mo->radius)
+ if (P_AproxDistance(player->mo->x - ptera->x - ptera->watertop, player->mo->y - ptera->y - ptera->waterbottom) > ptera->radius)
goto dropoff;
ptera->watertop >>= 1;
diff --git a/src/r_bsp.c b/src/r_bsp.c
index d606d7a274b322e932cdd9778ea9d780748c7394..373a170c90ea0b24e60bd6469a098ae4f8b75142 100644
--- a/src/r_bsp.c
+++ b/src/r_bsp.c
@@ -230,6 +230,18 @@ static INT32 R_DoorClosed(void)
&& (backsector->floorheight <= frontsector->floorheight || curline->sidedef->bottomtexture);
}
+static UINT8 R_FloorLightLevel(sector_t *sector, INT16 base_lightlevel)
+{
+ return max(0, min(255, sector->floorlightlevel +
+ ((sector->floorlightabsolute) ? 0 : base_lightlevel)));
+}
+
+static UINT8 R_CeilingLightLevel(sector_t *sector, INT16 base_lightlevel)
+{
+ return max(0, min(255, sector->ceilinglightlevel +
+ ((sector->ceilinglightabsolute) ? 0 : base_lightlevel)));
+}
+
//
// If player's view height is underneath fake floor, lower the
// drawn ceiling to be just under the floor height, and replace
@@ -312,11 +324,11 @@ sector_t *R_FakeFlat(sector_t *sec, sector_t *tempsec, INT32 *floorlightlevel,
tempsec->lightlevel = s->lightlevel;
if (floorlightlevel)
- *floorlightlevel = s->floorlightsec == -1 ? (s->floorlightabsolute ? s->floorlightlevel : max(0, min(255, s->lightlevel + s->floorlightlevel)))
+ *floorlightlevel = s->floorlightsec == -1 ? (s->floorlightabsolute ? s->floorlightlevel : max(0, min(255, s->lightlevel + s->floorlightlevel)))
: sectors[s->floorlightsec].lightlevel;
if (ceilinglightlevel)
- *ceilinglightlevel = s->ceilinglightsec == -1 ? (s->ceilinglightabsolute ? s->ceilinglightlevel : max(0, min(255, s->lightlevel + s->ceilinglightlevel)))
+ *ceilinglightlevel = s->ceilinglightsec == -1 ? (s->ceilinglightabsolute ? s->ceilinglightlevel : max(0, min(255, s->lightlevel + s->ceilinglightlevel)))
: sectors[s->ceilinglightsec].lightlevel;
}
else if (heightsec != -1 && viewz >= sectors[heightsec].ceilingheight
@@ -356,11 +368,11 @@ sector_t *R_FakeFlat(sector_t *sec, sector_t *tempsec, INT32 *floorlightlevel,
tempsec->lightlevel = s->lightlevel;
if (floorlightlevel)
- *floorlightlevel = s->floorlightsec == -1 ? (s->floorlightabsolute ? s->floorlightlevel : max(0, min(255, s->lightlevel + s->floorlightlevel)))
+ *floorlightlevel = s->floorlightsec == -1 ? (s->floorlightabsolute ? s->floorlightlevel : max(0, min(255, s->lightlevel + s->floorlightlevel)))
: sectors[s->floorlightsec].lightlevel;
if (ceilinglightlevel)
- *ceilinglightlevel = s->ceilinglightsec == -1 ? (s->ceilinglightabsolute ? s->ceilinglightlevel : max(0, min(255, s->lightlevel + s->ceilinglightlevel)))
+ *ceilinglightlevel = s->ceilinglightsec == -1 ? (s->ceilinglightabsolute ? s->ceilinglightlevel : max(0, min(255, s->lightlevel + s->ceilinglightlevel)))
: sectors[s->ceilinglightsec].lightlevel;
}
sec = tempsec;
@@ -968,11 +980,10 @@ static void R_Subsector(size_t num)
&& ((viewz < heightcheck && (rover->fofflags & FOF_BOTHPLANES || !(rover->fofflags & FOF_INVERTPLANES)))
|| (viewz > heightcheck && (rover->fofflags & FOF_BOTHPLANES || rover->fofflags & FOF_INVERTPLANES))))
{
- light = R_GetPlaneLight(frontsector, planecenterz,
- viewz < heightcheck);
+ light = R_GetPlaneLight(frontsector, planecenterz, viewz < heightcheck);
ffloor[numffloors].plane = R_FindPlane(rover->master->frontsector, *rover->bottomheight, *rover->bottompic,
- *frontsector->lightlist[light].lightlevel, *rover->bottomxoffs, *rover->bottomyoffs,
+ R_FloorLightLevel(rover->master->frontsector, *frontsector->lightlist[light].lightlevel), *rover->bottomxoffs, *rover->bottomyoffs,
*rover->bottomxscale, *rover->bottomyscale, *rover->bottomangle,
*frontsector->lightlist[light].extra_colormap, rover, NULL, *rover->b_slope, NULL);
@@ -1002,7 +1013,7 @@ static void R_Subsector(size_t num)
light = R_GetPlaneLight(frontsector, planecenterz, viewz < heightcheck);
ffloor[numffloors].plane = R_FindPlane(rover->master->frontsector, *rover->topheight, *rover->toppic,
- *frontsector->lightlist[light].lightlevel, *rover->topxoffs, *rover->topyoffs,
+ R_CeilingLightLevel(rover->master->frontsector, *frontsector->lightlist[light].lightlevel), *rover->topxoffs, *rover->topyoffs,
*rover->topxscale, *rover->topyscale, *rover->topangle,
*frontsector->lightlist[light].extra_colormap, rover, NULL, *rover->t_slope, NULL);
diff --git a/src/r_defs.h b/src/r_defs.h
index cb94dd6e5a5641970b216e88ce9183d66d186e63..51cc0864652f0363eaf614fee7b23394a6b0dfc1 100644
--- a/src/r_defs.h
+++ b/src/r_defs.h
@@ -60,6 +60,8 @@ typedef UINT8 lighttable_t;
#define CMF_FADEFULLBRIGHTSPRITES 1
#define CMF_FOG 4
+#define TEXTURE_255_IS_TRANSPARENT
+
// ExtraColormap type. Use for extra_colormaps from now on.
typedef struct extracolormap_s
{
@@ -358,7 +360,7 @@ typedef struct pslope_s
double dzdelta;
- boolean moved : 1;
+ boolean moved;
UINT8 flags; // Slope options
} pslope_t;
@@ -612,6 +614,8 @@ typedef struct line_s
INT16 callcount; // no. of calls left before triggering, for the "X calls" linedef specials, defaults to 0
UINT32 secportal; // transferred sector portal
+
+ struct pslope_s *midtexslope;
} line_t;
typedef struct
@@ -629,6 +633,11 @@ typedef struct
fixed_t scalex_top, scalex_mid, scalex_bottom;
fixed_t scaley_top, scaley_mid, scaley_bottom;
+ // per-wall lighting for UDMF
+ // TODO: implement per-texture lighting
+ INT16 light, light_top, light_mid, light_bottom;
+ boolean lightabsolute, lightabsolute_top, lightabsolute_mid, lightabsolute_bottom;
+
// Texture indices.
// We do not maintain names here.
INT32 toptexture, bottomtexture, midtexture;
@@ -976,6 +985,8 @@ typedef struct
#endif
} spriteframe_t;
+#define MAXFRAMENUM 256
+
//
// A sprite definition: a number of animation frames.
//
diff --git a/src/r_draw.c b/src/r_draw.c
index 86f7e488c8502516cc4f36bb04b7a516385fc5ed..eca3f36b780d2763920fa57d4c6d7ecd4f79a57b 100644
--- a/src/r_draw.c
+++ b/src/r_draw.c
@@ -19,7 +19,6 @@
#include "doomstat.h"
#include "r_local.h"
#include "r_translation.h"
-#include "st_stuff.h" // need ST_HEIGHT
#include "i_video.h"
#include "v_video.h"
#include "m_misc.h"
@@ -74,7 +73,7 @@ UINT8 *dc_transmap; // one of the translucency tables
UINT8 *dc_translation;
struct r_lightlist_s *dc_lightlist = NULL;
-INT32 dc_numlights = 0, dc_maxlights, dc_texheight;
+INT32 dc_numlights = 0, dc_maxlights, dc_texheight, dc_postlength;
// =========================================================================
// SPAN DRAWING CODE STUFF
diff --git a/src/r_draw.h b/src/r_draw.h
index 1a828312a7a922353a3ff5b969908dc61dcf0ee6..6a6ab2db1b1d8c07e825c2bab9f96553b8b12895 100644
--- a/src/r_draw.h
+++ b/src/r_draw.h
@@ -41,8 +41,7 @@ extern UINT8 *dc_translation;
extern struct r_lightlist_s *dc_lightlist;
extern INT32 dc_numlights, dc_maxlights;
-//Fix TUTIFRUTI
-extern INT32 dc_texheight;
+extern INT32 dc_texheight, dc_postlength;
// -----------------------
// SPAN DRAWING CODE STUFF
@@ -154,8 +153,12 @@ void R_VideoErase(size_t ofs, INT32 count);
// -----------------
void R_DrawColumn_8(void);
+void R_DrawColumnClamped_8(void);
+void R_Draw2sMultiPatchColumn_8(void);
void R_DrawShadeColumn_8(void);
void R_DrawTranslucentColumn_8(void);
+void R_DrawTranslucentColumnClamped_8(void);
+void R_Draw2sMultiPatchTranslucentColumn_8(void);
void R_DrawDropShadowColumn_8(void);
void R_DrawTranslatedColumn_8(void);
void R_DrawTranslatedTranslucentColumn_8(void);
diff --git a/src/r_draw8.c b/src/r_draw8.c
index 99fb71e289343034bc6327314da0e64b0d687dab..2011e46407cd46469d9ca6f0dd8de7fd4e7f84ef 100644
--- a/src/r_draw8.c
+++ b/src/r_draw8.c
@@ -100,6 +100,281 @@ void R_DrawColumn_8(void)
}
}
+/** \brief The R_DrawColumnClamped_8 function
+ Same as R_DrawColumn_8, but prevents artifacts from showing up (caused by fixed-point imprecisions)
+*/
+void R_DrawColumnClamped_8(void)
+{
+ INT32 count;
+ UINT8 *dest;
+ fixed_t frac;
+ fixed_t fracstep;
+
+ count = dc_yh - dc_yl;
+
+ if (count < 0) // Zero length, column does not exceed a pixel.
+ return;
+
+#ifdef RANGECHECK
+ if ((unsigned)dc_x >= (unsigned)vid.width || dc_yl < 0 || dc_yh >= vid.height)
+ return;
+#endif
+
+ // Framebuffer destination address.
+ dest = &topleft[dc_yl*vid.width + dc_x];
+
+ count++;
+
+ // Determine scaling, which is the only mapping to be done.
+ fracstep = dc_iscale;
+ frac = dc_texturemid + FixedMul((dc_yl << FRACBITS) - centeryfrac, fracstep);
+
+ // Inner loop that does the actual texture mapping, e.g. a DDA-like scaling.
+ // This is as fast as it gets.
+ {
+ const UINT8 *source = dc_source;
+ const lighttable_t *colormap = dc_colormap;
+ INT32 heightmask = dc_texheight-1;
+ INT32 idx;
+ if (dc_texheight & heightmask) // not a power of 2 -- killough
+ {
+ heightmask++;
+ heightmask <<= FRACBITS;
+
+ if (frac < 0)
+ while ((frac += heightmask) < 0);
+ else
+ while (frac >= heightmask)
+ frac -= heightmask;
+
+ do
+ {
+ // Re-map color indices from wall texture column
+ // using a lighting/special effects LUT.
+ // heightmask is the Tutti-Frutti fix
+ idx = frac>>FRACBITS;
+ if (idx >= 0 && idx < dc_postlength)
+ *dest = colormap[source[idx]];
+ dest += vid.width;
+
+ // Avoid overflow.
+ if (fracstep > 0x7FFFFFFF - frac)
+ frac += fracstep - heightmask;
+ else
+ frac += fracstep;
+
+ while (frac >= heightmask)
+ frac -= heightmask;
+ } while (--count);
+ }
+ else
+ {
+ while ((count -= 2) >= 0) // texture height is a power of 2
+ {
+ idx = (frac>>FRACBITS) & heightmask;
+ if (idx >= 0 && idx < dc_postlength)
+ *dest = colormap[source[idx]];
+ dest += vid.width;
+ frac += fracstep;
+ idx = (frac>>FRACBITS) & heightmask;
+ if (idx >= 0 && idx < dc_postlength)
+ *dest = colormap[source[idx]];
+ dest += vid.width;
+ frac += fracstep;
+ }
+ if (count & 1)
+ {
+ idx = (frac>>FRACBITS) & heightmask;
+ if (idx >= 0 && idx < dc_postlength)
+ *dest = colormap[source[idx]];
+ }
+ }
+ }
+}
+
+void R_Draw2sMultiPatchColumn_8(void)
+{
+ INT32 count;
+ register UINT8 *dest;
+ register fixed_t frac;
+ fixed_t fracstep;
+
+ count = dc_yh - dc_yl;
+
+ if (count < 0) // Zero length, column does not exceed a pixel.
+ return;
+
+#ifdef RANGECHECK
+ if ((unsigned)dc_x >= (unsigned)vid.width || dc_yl < 0 || dc_yh >= vid.height)
+ return;
+#endif
+
+ // Framebuffer destination address.
+ dest = &topleft[dc_yl*vid.width + dc_x];
+
+ count++;
+
+ // Determine scaling, which is the only mapping to be done.
+ fracstep = dc_iscale;
+ frac = dc_texturemid + FixedMul((dc_yl << FRACBITS) - centeryfrac, fracstep);
+
+ // Inner loop that does the actual texture mapping, e.g. a DDA-like scaling.
+ // This is as fast as it gets.
+ {
+ register const UINT8 *source = dc_source;
+ register const lighttable_t *colormap = dc_colormap;
+ register INT32 heightmask = dc_texheight-1;
+ register UINT8 val;
+ if (dc_texheight & heightmask) // not a power of 2 -- killough
+ {
+ heightmask++;
+ heightmask <<= FRACBITS;
+
+ if (frac < 0)
+ while ((frac += heightmask) < 0);
+ else
+ while (frac >= heightmask)
+ frac -= heightmask;
+
+ do
+ {
+ // Re-map color indices from wall texture column
+ // using a lighting/special effects LUT.
+ // heightmask is the Tutti-Frutti fix
+ val = source[frac>>FRACBITS];
+
+ if (val != TRANSPARENTPIXEL)
+ *dest = colormap[val];
+
+ dest += vid.width;
+
+ // Avoid overflow.
+ if (fracstep > 0x7FFFFFFF - frac)
+ frac += fracstep - heightmask;
+ else
+ frac += fracstep;
+
+ while (frac >= heightmask)
+ frac -= heightmask;
+ } while (--count);
+ }
+ else
+ {
+ while ((count -= 2) >= 0) // texture height is a power of 2
+ {
+ val = source[(frac>>FRACBITS) & heightmask];
+ if (val != TRANSPARENTPIXEL)
+ *dest = colormap[val];
+ dest += vid.width;
+ frac += fracstep;
+ val = source[(frac>>FRACBITS) & heightmask];
+ if (val != TRANSPARENTPIXEL)
+ *dest = colormap[val];
+ dest += vid.width;
+ frac += fracstep;
+ }
+ if (count & 1)
+ {
+ val = source[(frac>>FRACBITS) & heightmask];
+ if (val != TRANSPARENTPIXEL)
+ *dest = colormap[val];
+ }
+ }
+ }
+}
+
+void R_Draw2sMultiPatchTranslucentColumn_8(void)
+{
+ INT32 count;
+ register UINT8 *dest;
+ register fixed_t frac;
+ fixed_t fracstep;
+
+ count = dc_yh - dc_yl;
+
+ if (count < 0) // Zero length, column does not exceed a pixel.
+ return;
+
+#ifdef RANGECHECK
+ if ((unsigned)dc_x >= (unsigned)vid.width || dc_yl < 0 || dc_yh >= vid.height)
+ return;
+#endif
+
+ // Framebuffer destination address.
+ dest = &topleft[dc_yl*vid.width + dc_x];
+
+ count++;
+
+ // Determine scaling, which is the only mapping to be done.
+ fracstep = dc_iscale;
+ frac = dc_texturemid + FixedMul((dc_yl << FRACBITS) - centeryfrac, fracstep);
+
+ // Inner loop that does the actual texture mapping, e.g. a DDA-like scaling.
+ // This is as fast as it gets.
+ {
+ register const UINT8 *source = dc_source;
+ register const UINT8 *transmap = dc_transmap;
+ register const lighttable_t *colormap = dc_colormap;
+ register INT32 heightmask = dc_texheight-1;
+ register UINT8 val;
+ if (dc_texheight & heightmask) // not a power of 2 -- killough
+ {
+ heightmask++;
+ heightmask <<= FRACBITS;
+
+ if (frac < 0)
+ while ((frac += heightmask) < 0);
+ else
+ while (frac >= heightmask)
+ frac -= heightmask;
+
+ do
+ {
+ // Re-map color indices from wall texture column
+ // using a lighting/special effects LUT.
+ // heightmask is the Tutti-Frutti fix
+ val = source[frac>>FRACBITS];
+
+ if (val != TRANSPARENTPIXEL)
+ *dest = *(transmap + (colormap[val]<<8) + (*dest));
+
+ dest += vid.width;
+
+ // Avoid overflow.
+ if (fracstep > 0x7FFFFFFF - frac)
+ frac += fracstep - heightmask;
+ else
+ frac += fracstep;
+
+ while (frac >= heightmask)
+ frac -= heightmask;
+ } while (--count);
+ }
+ else
+ {
+ while ((count -= 2) >= 0) // texture height is a power of 2
+ {
+ val = source[(frac>>FRACBITS) & heightmask];
+ if (val != TRANSPARENTPIXEL)
+ *dest = *(transmap + (colormap[val]<<8) + (*dest));
+ dest += vid.width;
+ frac += fracstep;
+ val = source[(frac>>FRACBITS) & heightmask];
+ if (val != TRANSPARENTPIXEL)
+ *dest = *(transmap + (colormap[val]<<8) + (*dest));
+ dest += vid.width;
+ frac += fracstep;
+ }
+ if (count & 1)
+ {
+ val = source[(frac>>FRACBITS) & heightmask];
+ if (val != TRANSPARENTPIXEL)
+ *dest = *(transmap + (colormap[val]<<8) + (*dest));
+ }
+ }
+ }
+}
+
/** \brief The R_DrawShadeColumn_8 function
Experiment to make software go faster. Taken from the Boom source
*/
@@ -212,6 +487,90 @@ void R_DrawTranslucentColumn_8(void)
}
}
+/** \brief The R_DrawTranslucentColumnClamped_8 function
+ Same as R_DrawTranslucentColumn_8, but prevents artifacts from showing up (caused by fixed-point imprecisions)
+*/
+void R_DrawTranslucentColumnClamped_8(void)
+{
+ INT32 count;
+ UINT8 *dest;
+ fixed_t frac, fracstep;
+
+ count = dc_yh - dc_yl + 1;
+
+ if (count <= 0) // Zero length, column does not exceed a pixel.
+ return;
+
+#ifdef RANGECHECK
+ if ((unsigned)dc_x >= (unsigned)vid.width || dc_yl < 0 || dc_yh >= vid.height)
+ I_Error("R_DrawTranslucentColumnClamped_8: %d to %d at %d", dc_yl, dc_yh, dc_x);
+#endif
+
+ dest = &topleft[dc_yl*vid.width + dc_x];
+
+ // Looks familiar.
+ fracstep = dc_iscale;
+ frac = dc_texturemid + FixedMul((dc_yl << FRACBITS) - centeryfrac, fracstep);
+
+ // Inner loop that does the actual texture mapping, e.g. a DDA-like scaling.
+ // This is as fast as it gets.
+ {
+ const UINT8 *source = dc_source;
+ const UINT8 *transmap = dc_transmap;
+ const lighttable_t *colormap = dc_colormap;
+ INT32 heightmask = dc_texheight - 1;
+ INT32 idx;
+ if (dc_texheight & heightmask)
+ {
+ heightmask++;
+ heightmask <<= FRACBITS;
+
+ if (frac < 0)
+ while ((frac += heightmask) < 0)
+ ;
+ else
+ while (frac >= heightmask)
+ frac -= heightmask;
+
+ do
+ {
+ // Re-map color indices from wall texture column
+ // using a lighting/special effects LUT.
+ // heightmask is the Tutti-Frutti fix
+ idx = frac>>FRACBITS;
+ if (idx >= 0 && idx < dc_postlength)
+ *dest = *(transmap + (colormap[source[idx]]<<8) + (*dest));
+ dest += vid.width;
+ if ((frac += fracstep) >= heightmask)
+ frac -= heightmask;
+ }
+ while (--count);
+ }
+ else
+ {
+ while ((count -= 2) >= 0) // texture height is a power of 2
+ {
+ idx = (frac>>FRACBITS)&heightmask;
+ if (idx >= 0 && idx < dc_postlength)
+ *dest = *(transmap + (colormap[source[idx]]<<8) + (*dest));
+ dest += vid.width;
+ frac += fracstep;
+ idx = (frac>>FRACBITS)&heightmask;
+ if (idx >= 0 && idx < dc_postlength)
+ *dest = *(transmap + (colormap[source[idx]]<<8) + (*dest));
+ dest += vid.width;
+ frac += fracstep;
+ }
+ if (count & 1)
+ {
+ idx = (frac>>FRACBITS)&heightmask;
+ if (idx >= 0 && idx < dc_postlength)
+ *dest = *(transmap + (colormap[source[idx]]<<8) + (*dest));
+ }
+ }
+ }
+}
+
// Hack: A cut-down copy of R_DrawTranslucentColumn_8 that does not read texture
// data since something about calculating the texture reading address for drop shadows is broken.
// dc_texturemid and dc_iscale get wrong values for drop shadows, however those are not strictly
diff --git a/src/r_fps.c b/src/r_fps.c
index 0773f228d6c8b6fdf266aff91f4f25e07080fee1..7f1f2bb303e23c10104febcdd9646d510a3aba1c 100644
--- a/src/r_fps.c
+++ b/src/r_fps.c
@@ -120,6 +120,19 @@ static vector3_t *R_LerpVector3(const vector3_t *from, const vector3_t *to, fixe
return out;
}
+static double R_LerpDouble(double from, double to, double frac)
+{
+ return from + (frac * (to - from));
+}
+
+static dvector3_t *R_LerpDVector3(const dvector3_t *from, const dvector3_t *to, double frac, dvector3_t *out)
+{
+ DVector3_Subtract(to, from, out);
+ DVector3_Multiply(out, frac, out);
+ DVector3_Add(from, out, out);
+ return out;
+}
+
// recalc necessary stuff for mouseaiming
// slopes are already calculated for the full possible view (which is 4*viewheight).
// 18/08/18: (No it's actually 16*viewheight, thanks Jimita for finding this out)
@@ -497,6 +510,14 @@ void R_CreateInterpolator_DynSlope(thinker_t *thinker, pslope_t *slope)
FV2_Copy(&interp->dynslope.bakd, &slope->d);
interp->dynslope.oldzdelta = interp->dynslope.bakzdelta = slope->zdelta;
+
+ DVector3_Copy(&interp->dynslope.oldorigin, &slope->dorigin);
+ DVector3_Copy(&interp->dynslope.bakorigin, &slope->dorigin);
+
+ DVector3_Copy(&interp->dynslope.oldnormdir, &slope->dnormdir);
+ DVector3_Copy(&interp->dynslope.baknormdir, &slope->dnormdir);
+
+ interp->dynslope.olddzdelta = interp->dynslope.bakdzdelta = slope->dzdelta;
}
void R_InitializeLevelInterpolators(void)
@@ -561,6 +582,21 @@ static void UpdateLevelInterpolatorState(levelinterpolator_t *interp)
FV3_Copy(&interp->dynslope.bako, &interp->dynslope.slope->o);
FV2_Copy(&interp->dynslope.bakd, &interp->dynslope.slope->d);
interp->dynslope.bakzdelta = interp->dynslope.slope->zdelta;
+
+ DVector3_Copy(&interp->dynslope.oldorigin, &interp->dynslope.bakorigin);
+ DVector3_Copy(&interp->dynslope.oldnormdir, &interp->dynslope.baknormdir);
+ interp->dynslope.olddzdelta = interp->dynslope.bakdzdelta;
+
+ if (interp->dynslope.slope->moved)
+ {
+ P_CalculateSlopeVectors(interp->dynslope.slope);
+
+ interp->dynslope.slope->moved = false;
+ }
+
+ DVector3_Copy(&interp->dynslope.bakorigin, &interp->dynslope.slope->dorigin);
+ DVector3_Copy(&interp->dynslope.baknormdir, &interp->dynslope.slope->dnormdir);
+ interp->dynslope.bakdzdelta = interp->dynslope.slope->dzdelta;
break;
}
}
@@ -646,7 +682,13 @@ void R_ApplyLevelInterpolators(fixed_t frac)
R_LerpVector3(&interp->dynslope.oldo, &interp->dynslope.bako, frac, &interp->dynslope.slope->o);
R_LerpVector2(&interp->dynslope.oldd, &interp->dynslope.bakd, frac, &interp->dynslope.slope->d);
interp->dynslope.slope->zdelta = R_LerpFixed(interp->dynslope.oldzdelta, interp->dynslope.bakzdelta, frac);
- interp->dynslope.slope->moved = true;
+ if (rendermode == render_soft)
+ {
+ double dfrac = FixedToDouble(frac);
+ R_LerpDVector3(&interp->dynslope.oldorigin, &interp->dynslope.bakorigin, dfrac, &interp->dynslope.slope->dorigin);
+ R_LerpDVector3(&interp->dynslope.oldnormdir, &interp->dynslope.baknormdir, dfrac, &interp->dynslope.slope->dnormdir);
+ interp->dynslope.slope->dzdelta = R_LerpDouble(interp->dynslope.olddzdelta, interp->dynslope.bakdzdelta, dfrac);
+ }
break;
}
}
@@ -704,6 +746,10 @@ void R_RestoreLevelInterpolators(void)
FV3_Copy(&interp->dynslope.slope->o, &interp->dynslope.bako);
FV2_Copy(&interp->dynslope.slope->d, &interp->dynslope.bakd);
interp->dynslope.slope->zdelta = interp->dynslope.bakzdelta;
+
+ DVector3_Copy(&interp->dynslope.slope->dorigin, &interp->dynslope.bakorigin);
+ DVector3_Copy(&interp->dynslope.slope->dnormdir, &interp->dynslope.baknormdir);
+ interp->dynslope.slope->dzdelta = interp->dynslope.bakdzdelta;
break;
}
}
diff --git a/src/r_fps.h b/src/r_fps.h
index cd40b0a9a572b23b97bb9b2cc493ea6a34a243a7..33224a83a1e728ae1ac3379c9060d6bb3eb35c3d 100644
--- a/src/r_fps.h
+++ b/src/r_fps.h
@@ -115,6 +115,9 @@ typedef struct levelinterpolator_s {
vector3_t oldo, bako;
vector2_t oldd, bakd;
fixed_t oldzdelta, bakzdelta;
+ dvector3_t oldorigin, bakorigin;
+ dvector3_t oldnormdir, baknormdir;
+ double olddzdelta, bakdzdelta;
} dynslope;
};
} levelinterpolator_t;
diff --git a/src/r_main.c b/src/r_main.c
index 4624392944a931b4178f84038de2982f9ff371cb..067b8abdbcf20d9918d582285b6efbe9374f453d 100644
--- a/src/r_main.c
+++ b/src/r_main.c
@@ -390,22 +390,22 @@ fixed_t R_PointToDist(fixed_t x, fixed_t y)
return R_PointToDist2(viewx, viewy, x, y);
}
-line_t *R_GetFFloorLine(const seg_t *seg, const ffloor_t *pfloor)
+line_t *R_GetFFloorLine(const line_t *line, const ffloor_t *pfloor, const sector_t *sector)
{
if (pfloor->master->flags & ML_TFERLINE)
{
- size_t linenum = seg->linedef - pfloor->target->lines[0];
+ size_t linenum = min((size_t)(line - sector->lines[0]), pfloor->master->frontsector->linecount);
return pfloor->master->frontsector->lines[0] + linenum;
}
else
return pfloor->master;
}
-side_t *R_GetFFloorSide(const seg_t *seg, const ffloor_t *pfloor)
+side_t *R_GetFFloorSide(const line_t *line, const ffloor_t *pfloor, const sector_t *sector)
{
if (pfloor->master->flags & ML_TFERLINE)
{
- line_t *newline = R_GetFFloorLine(seg, pfloor);
+ line_t *newline = R_GetFFloorLine(line, pfloor, sector);
return &sides[newline->sidenum[0]];
}
else
diff --git a/src/r_main.h b/src/r_main.h
index aedfeb6ad0f2ca2a0caaba771f38e44ad29e1142..64a69fffe64d0096241d2eca6c25b528069e8aaf 100644
--- a/src/r_main.h
+++ b/src/r_main.h
@@ -86,8 +86,8 @@ subsector_t *R_PointInSubsectorOrNull(fixed_t x, fixed_t y);
boolean R_DoCulling(line_t *cullheight, line_t *viewcullheight, fixed_t vz, fixed_t bottomh, fixed_t toph);
-line_t *R_GetFFloorLine(const seg_t *seg, const ffloor_t *pfloor);
-side_t *R_GetFFloorSide(const seg_t *seg, const ffloor_t *pfloor);
+line_t *R_GetFFloorLine(const line_t *line, const ffloor_t *pfloor, const sector_t *sector);
+side_t *R_GetFFloorSide(const line_t *line, const ffloor_t *pfloor, const sector_t *sector);
// Render stats
diff --git a/src/r_picformats.c b/src/r_picformats.c
index e4a59f2115d3833b3f5a76e38ff4a1cdd7d4ce30..d71657021b6e2cc91efe504b49286f459461095d 100644
--- a/src/r_picformats.c
+++ b/src/r_picformats.c
@@ -1570,7 +1570,7 @@ static void R_ParseSpriteInfo(boolean spr2)
spriteinfo_t *info;
char *sprinfoToken;
size_t sprinfoTokenLength;
- char newSpriteName[5]; // no longer dynamically allocated
+ char newSpriteName[MAXSPRITENAME + 1]; // no longer dynamically allocated
spritenum_t sprnum = NUMSPRITES;
playersprite_t spr2num = NUMPLAYERSPRITES;
INT32 i;
@@ -1584,31 +1584,17 @@ static void R_ParseSpriteInfo(boolean spr2)
I_Error("Error parsing SPRTINFO lump: Unexpected end of file where sprite name should be");
}
sprinfoTokenLength = strlen(sprinfoToken);
- if (sprinfoTokenLength != 4)
- {
- I_Error("Error parsing SPRTINFO lump: Sprite name \"%s\" isn't 4 characters long",sprinfoToken);
- }
- else
- {
- memset(&newSpriteName, 0, 5);
- M_Memcpy(newSpriteName, sprinfoToken, sprinfoTokenLength);
- // ^^ we've confirmed that the token is == 4 characters so it will never overflow a 5 byte char buffer
- strupr(newSpriteName); // Just do this now so we don't have to worry about it
- }
+ if (sprinfoTokenLength > MAXSPRITENAME)
+ I_Error("Error parsing SPRTINFO lump: Sprite name \"%s\" is longer than %d characters", sprinfoToken, MAXSPRITENAME);
+ strcpy(newSpriteName, sprinfoToken);
+ strupr(newSpriteName); // Just do this now so we don't have to worry about it
Z_Free(sprinfoToken);
if (!spr2)
{
- for (i = 0; i <= NUMSPRITES; i++)
- {
- if (i == NUMSPRITES)
- I_Error("Error parsing SPRTINFO lump: Unknown sprite name \"%s\"", newSpriteName);
- if (!memcmp(newSpriteName,sprnames[i],4))
- {
- sprnum = i;
- break;
- }
- }
+ sprnum = R_GetSpriteNumByName(newSpriteName);
+ if (sprnum == NUMSPRITES)
+ I_Error("Error parsing SPRTINFO lump: Unknown sprite name \"%s\"", newSpriteName);
}
else
{
diff --git a/src/r_picformats.h b/src/r_picformats.h
index 3ee9805d867f30cf8eec923285b24d0172038f18..098f927a5619d74ca9813d37658d5bfb75bc8f04 100644
--- a/src/r_picformats.h
+++ b/src/r_picformats.h
@@ -100,7 +100,7 @@ typedef struct
typedef struct
{
- spriteframepivot_t pivot[64];
+ spriteframepivot_t pivot[MAXFRAMENUM];
boolean available;
} spriteinfo_t;
diff --git a/src/r_plane.c b/src/r_plane.c
index 33e3aac1349faebb317d47c1f30ecec5d94a55ce..04272f8d317a790de6f658ddb2592072e50f7393 100644
--- a/src/r_plane.c
+++ b/src/r_plane.c
@@ -910,7 +910,7 @@ void R_DrawSinglePlane(visplane_t *pl)
if (pl->polyobj->translucency == 0 || (pl->extra_colormap && (pl->extra_colormap->flags & CMF_FOG)))
light = (pl->lightlevel >> LIGHTSEGSHIFT);
- else
+ else // TODO: 2.3: Make transparent polyobject planes always use light level
light = LIGHTLEVELS-1;
}
else
@@ -952,7 +952,7 @@ void R_DrawSinglePlane(visplane_t *pl)
if ((spanfunctype == SPANDRAWFUNC_SPLAT) || (pl->extra_colormap && (pl->extra_colormap->flags & CMF_FOG)))
light = (pl->lightlevel >> LIGHTSEGSHIFT);
- else
+ else // TODO: 2.3: Make transparent FOF planes use light level instead of always being fullbright
light = LIGHTLEVELS-1;
}
else if (pl->ffloor->fofflags & FOF_FOG)
diff --git a/src/r_segs.c b/src/r_segs.c
index e07ced86a7c6002c7bd127c1e2867bdae5386419..a8a065c9b4c643f29b107baf34a25e1eb4e36ba5 100644
--- a/src/r_segs.c
+++ b/src/r_segs.c
@@ -94,6 +94,124 @@ transnum_t R_GetLinedefTransTable(fixed_t alpha)
return (20*(FRACUNIT - alpha - 1) + FRACUNIT) >> (FRACBITS+1);
}
+static UINT8 R_SideLightLevel(side_t *side, INT16 base_lightlevel)
+{
+ return max(0, min(255, side->light +
+ ((side->lightabsolute) ? 0 : base_lightlevel)));
+}
+
+/* TODO: implement per-texture lighting
+static UINT8 R_TopLightLevel(side_t *side, INT16 base_lightlevel)
+{
+ return max(0, min(255, side->light_top +
+ ((side->lightabsolute_top) ? 0 : R_SideLightLevel(side, base_lightlevel))));
+}
+
+static UINT8 R_MidLightLevel(side_t *side, INT16 base_lightlevel)
+{
+ return max(0, min(255, side->light_mid +
+ ((side->lightabsolute_mid) ? 0 : R_SideLightLevel(side, base_lightlevel))));
+}
+
+static UINT8 R_BottomLightLevel(side_t *side, INT16 base_lightlevel)
+{
+ return max(0, min(255, side->light_bottom +
+ ((side->lightabsolute_bottom) ? 0 : R_SideLightLevel(side, base_lightlevel))));
+}
+*/
+
+// If we have a multi-patch texture on a 2sided wall (rare) then we draw
+// it using R_DrawColumn, else we draw it using R_DrawMaskedColumn, this
+// way we don't have to store extra post_t info with each column for
+// multi-patch textures. They are not normally needed as multi-patch
+// textures don't have holes in it. At least not for now.
+static void R_Render2sidedMultiPatchColumn(column_t *column, unsigned lengthcol)
+{
+ INT32 topscreen, bottomscreen;
+
+ post_t *post = &column->posts[0];
+ if (!post->length)
+ return;
+
+ topscreen = sprtopscreen;
+ bottomscreen = topscreen + spryscale * lengthcol;
+
+ dc_yl = (sprtopscreen+FRACUNIT-1)>>FRACBITS;
+ dc_yh = (bottomscreen-1)>>FRACBITS;
+
+ if (windowtop != INT32_MAX && windowbottom != INT32_MAX)
+ {
+ dc_yl = ((windowtop + FRACUNIT)>>FRACBITS);
+ dc_yh = (windowbottom - 1)>>FRACBITS;
+ }
+
+ if (dc_yh >= mfloorclip[dc_x])
+ dc_yh = mfloorclip[dc_x] - 1;
+ if (dc_yl <= mceilingclip[dc_x])
+ dc_yl = mceilingclip[dc_x] + 1;
+
+ if (dc_yl >= vid.height || dc_yh < 0)
+ return;
+
+ if (dc_yl <= dc_yh && dc_yh < vid.height && dc_yh > 0)
+ {
+ dc_source = column->pixels + post->data_offset;
+ dc_postlength = post->length;
+
+ if (colfunc == colfuncs[BASEDRAWFUNC])
+ (colfuncs[COLDRAWFUNC_TWOSMULTIPATCH])();
+ else if (colfunc == colfuncs[COLDRAWFUNC_FUZZY])
+ (colfuncs[COLDRAWFUNC_TWOSMULTIPATCHTRANS])();
+ else
+ colfunc();
+ }
+}
+
+static void R_RenderFlipped2sidedMultiPatchColumn(column_t *column, unsigned lengthcol)
+{
+ INT32 topscreen, bottomscreen;
+
+ void (*localcolfunc)(void);
+
+ post_t *post = &column->posts[0];
+ if (!post->length)
+ return;
+
+ topscreen = sprtopscreen;
+ bottomscreen = topscreen + spryscale * lengthcol;
+
+ dc_yl = (sprtopscreen+FRACUNIT-1)>>FRACBITS;
+ dc_yh = (bottomscreen-1)>>FRACBITS;
+
+ if (windowtop != INT32_MAX && windowbottom != INT32_MAX)
+ {
+ dc_yl = ((windowtop + FRACUNIT)>>FRACBITS);
+ dc_yh = (windowbottom - 1)>>FRACBITS;
+ }
+
+ if (dc_yh >= mfloorclip[dc_x])
+ dc_yh = mfloorclip[dc_x] - 1;
+ if (dc_yl <= mceilingclip[dc_x])
+ dc_yl = mceilingclip[dc_x] + 1;
+
+ if (dc_yl >= vid.height || dc_yh < 0)
+ return;
+
+ if (dc_yl <= dc_yh && dc_yh < vid.height && dc_yh > 0)
+ {
+ dc_postlength = post->length;
+
+ if (colfunc == colfuncs[BASEDRAWFUNC])
+ localcolfunc = colfuncs[COLDRAWFUNC_TWOSMULTIPATCH];
+ else if (colfunc == colfuncs[COLDRAWFUNC_FUZZY])
+ localcolfunc = colfuncs[COLDRAWFUNC_TWOSMULTIPATCHTRANS];
+ else
+ localcolfunc = colfunc;
+
+ R_DrawFlippedPost(column->pixels + post->data_offset, post->length, localcolfunc);
+ }
+}
+
void R_RenderMaskedSegRange(drawseg_t *ds, INT32 x1, INT32 x2)
{
size_t pindex;
@@ -181,7 +299,16 @@ void R_RenderMaskedSegRange(drawseg_t *ds, INT32 x1, INT32 x2)
// Texture must be cached
R_CheckTextureCache(texnum);
- if (vertflip) // vertically flipped?
+ // handle case where multipatch texture is drawn on a 2sided wall, multi-patch textures
+ // are not stored per-column with post info in SRB2
+ if (!textures[texnum]->transparency)
+ {
+ if (vertflip) // vertically flipped?
+ colfunc_2s = R_RenderFlipped2sidedMultiPatchColumn;
+ else
+ colfunc_2s = R_Render2sidedMultiPatchColumn;
+ }
+ else if (vertflip) // vertically flipped?
colfunc_2s = R_DrawFlippedMaskedColumn;
else
colfunc_2s = R_DrawMaskedColumn; // render the usual 2sided single-patch packed texture
@@ -223,7 +350,7 @@ void R_RenderMaskedSegRange(drawseg_t *ds, INT32 x1, INT32 x2)
if ((colfunc != colfuncs[COLDRAWFUNC_FUZZY])
|| (rlight->flags & FOF_FOG)
|| (rlight->extra_colormap && (rlight->extra_colormap->flags & CMF_FOG)))
- lightnum = (rlight->lightlevel >> LIGHTSEGSHIFT);
+ lightnum = R_SideLightLevel(curline->sidedef, rlight->lightlevel) >> LIGHTSEGSHIFT;
else
lightnum = LIGHTLEVELS - 1;
@@ -241,7 +368,7 @@ void R_RenderMaskedSegRange(drawseg_t *ds, INT32 x1, INT32 x2)
{
if ((colfunc != colfuncs[COLDRAWFUNC_FUZZY])
|| (frontsector->extra_colormap && (frontsector->extra_colormap->flags & CMF_FOG)))
- lightnum = (frontsector->lightlevel >> LIGHTSEGSHIFT);
+ lightnum = R_SideLightLevel(curline->sidedef, frontsector->lightlevel) >> LIGHTSEGSHIFT;
else
lightnum = LIGHTLEVELS - 1;
@@ -442,26 +569,75 @@ void R_RenderMaskedSegRange(drawseg_t *ds, INT32 x1, INT32 x2)
}
// Loop through R_DrawMaskedColumn calls
+static fixed_t repeatscroll = 0;
+
static void R_DrawRepeatMaskedColumn(column_t *col, unsigned lengthcol)
{
- while (sprtopscreen < sprbotscreen) {
+ fixed_t topscreen = sprtopscreen;
+ fixed_t bottomscreen = sprbotscreen;
+
+ fixed_t texheight = dc_texheight*spryscale;
+
+ fixed_t scroll = -repeatscroll;
+ if (scroll < 0)
+ {
+ scroll = -FixedMul((abs(scroll) % (dc_texheight*FRACUNIT)), spryscale);
+ bottomscreen += texheight; // Draw an extra time
+ }
+ else if (scroll)
+ {
+ scroll = FixedMul(scroll % (dc_texheight*FRACUNIT), spryscale);
+ topscreen -= texheight; // Draw an extra time
+ }
+
+ while (topscreen < bottomscreen)
+ {
+ sprtopscreen = topscreen + scroll;
+
R_DrawMaskedColumn(col, lengthcol);
+
if ((INT64)sprtopscreen + (INT64)dc_texheight*spryscale > (INT64)INT32_MAX) // prevent overflow
- sprtopscreen = INT32_MAX;
- else
- sprtopscreen += dc_texheight*spryscale;
+ break;
+
+ topscreen += texheight;
}
+
+ sprtopscreen = sprbotscreen;
}
static void R_DrawRepeatFlippedMaskedColumn(column_t *col, unsigned lengthcol)
{
- while (sprtopscreen < sprbotscreen) {
+ fixed_t topscreen = sprtopscreen;
+ fixed_t bottomscreen = sprbotscreen;
+
+ fixed_t texheight = dc_texheight*spryscale;
+
+ fixed_t scroll = -repeatscroll;
+ if (scroll < 0)
+ {
+ scroll = -FixedMul((abs(scroll) % (dc_texheight*FRACUNIT)), spryscale);
+ bottomscreen += texheight; // Draw an extra time
+ }
+ else if (scroll)
+ {
+ scroll = FixedMul(scroll % (dc_texheight*FRACUNIT), spryscale);
+ topscreen -= texheight; // Draw an extra time
+ }
+
+ while (topscreen < bottomscreen)
+ {
+ sprtopscreen = topscreen + scroll;
+ sprbotscreen = bottomscreen + scroll;
+
R_DrawFlippedMaskedColumn(col, lengthcol);
+
if ((INT64)sprtopscreen + (INT64)dc_texheight*spryscale > (INT64)INT32_MAX) // prevent overflow
- sprtopscreen = INT32_MAX;
- else
- sprtopscreen += dc_texheight*spryscale;
+ break;
+
+ topscreen += texheight;
}
+
+ sprtopscreen = sprbotscreen;
}
// Returns true if a fake floor is translucent.
@@ -497,7 +673,6 @@ void R_RenderThickSideRange(drawseg_t *ds, INT32 x1, INT32 x2, ffloor_t *pfloor)
sector_t tempsec;
INT32 templight;
INT32 i, p;
- fixed_t offsetvalue;
lightlist_t *light;
r_lightlist_t *rlight;
INT32 range;
@@ -515,6 +690,8 @@ void R_RenderThickSideRange(drawseg_t *ds, INT32 x1, INT32 x2, ffloor_t *pfloor)
fixed_t wall_scalex, wall_scaley;
UINT8 vertflip;
unsigned lengthcol;
+ boolean fog = false;
+ boolean fuzzy = false;
void (*colfunc_2s) (column_t *, unsigned);
@@ -526,13 +703,11 @@ void R_RenderThickSideRange(drawseg_t *ds, INT32 x1, INT32 x2, ffloor_t *pfloor)
curline = ds->curline;
backsector = pfloor->target;
frontsector = curline->frontsector == pfloor->target ? curline->backsector : curline->frontsector;
- sidedef = R_GetFFloorSide(curline, pfloor);
-
- colfunc = colfuncs[BASEDRAWFUNC];
+ sidedef = R_GetFFloorSide(curline->linedef, pfloor, pfloor->target);
if (pfloor->master->flags & ML_TFERLINE)
{
- line_t *newline = R_GetFFloorLine(curline, pfloor);
+ line_t *newline = R_GetFFloorLine(curline->linedef, pfloor, pfloor->target);
do_texture_skew = newline->flags & ML_SKEWTD;
dont_peg_bottom = newline->flags & ML_DONTPEGBOTTOM;
}
@@ -547,7 +722,7 @@ void R_RenderThickSideRange(drawseg_t *ds, INT32 x1, INT32 x2, ffloor_t *pfloor)
if (pfloor->fofflags & FOF_TRANSLUCENT)
{
- boolean fuzzy = true;
+ fuzzy = true;
// Hacked up support for alpha value in software mode Tails 09-24-2002
// ...unhacked by toaster 04-01-2021, re-hacked a little by sphere 19-11-2021
@@ -560,17 +735,14 @@ void R_RenderThickSideRange(drawseg_t *ds, INT32 x1, INT32 x2, ffloor_t *pfloor)
else if (!(dc_transmap = R_GetTranslucencyTable(trans)) || trans == 0)
fuzzy = false; // Opaque
}
-
- if (fuzzy)
- colfunc = colfuncs[COLDRAWFUNC_FUZZY];
}
else if (pfloor->fofflags & FOF_FOG)
+ {
colfunc = colfuncs[COLDRAWFUNC_FOG];
+ fog = true;
+ }
range = max(ds->x2-ds->x1, 1);
- //SoM: Moved these up here so they are available for my lightlist calculations
- rw_scalestep = ds->scalestep;
- spryscale = ds->scale1 + (x1 - ds->x1)*rw_scalestep;
dc_numlights = 0;
if (frontsector->numlights)
@@ -652,9 +824,9 @@ void R_RenderThickSideRange(drawseg_t *ds, INT32 x1, INT32 x2, ffloor_t *pfloor)
// Check if the current light effects the colormap/lightlevel
if (pfloor->fofflags & FOF_FOG)
- rlight->lightnum = (pfloor->master->frontsector->lightlevel >> LIGHTSEGSHIFT);
+ rlight->lightnum = R_SideLightLevel(curline->sidedef, pfloor->master->frontsector->lightlevel) >> LIGHTSEGSHIFT;
else
- rlight->lightnum = (rlight->lightlevel >> LIGHTSEGSHIFT);
+ rlight->lightnum = R_SideLightLevel(curline->sidedef, rlight->lightlevel) >> LIGHTSEGSHIFT;
if (pfloor->fofflags & FOF_FOG || rlight->flags & FOF_FOG || (rlight->extra_colormap && (rlight->extra_colormap->flags & CMF_FOG)))
;
@@ -672,18 +844,17 @@ void R_RenderThickSideRange(drawseg_t *ds, INT32 x1, INT32 x2, ffloor_t *pfloor)
{
// Get correct light level!
if ((frontsector->extra_colormap && (frontsector->extra_colormap->flags & CMF_FOG)))
- lightnum = (frontsector->lightlevel >> LIGHTSEGSHIFT);
- else if (pfloor->fofflags & FOF_FOG)
- lightnum = (pfloor->master->frontsector->lightlevel >> LIGHTSEGSHIFT);
- else if (colfunc == colfuncs[COLDRAWFUNC_FUZZY])
+ lightnum = R_SideLightLevel(curline->sidedef, frontsector->lightlevel) >> LIGHTSEGSHIFT;
+ else if (fog)
+ lightnum = R_SideLightLevel(curline->sidedef, pfloor->master->frontsector->lightlevel) >> LIGHTSEGSHIFT;
+ else if (fuzzy)
lightnum = LIGHTLEVELS-1;
else
- lightnum = R_FakeFlat(frontsector, &tempsec, &templight, &templight, false)
- ->lightlevel >> LIGHTSEGSHIFT;
+ lightnum = R_SideLightLevel(curline->sidedef, R_FakeFlat(frontsector, &tempsec, &templight, &templight, false)->lightlevel) >> LIGHTSEGSHIFT;
if (pfloor->fofflags & FOF_FOG || (frontsector->extra_colormap && (frontsector->extra_colormap->flags & CMF_FOG)));
else if (curline->v1->y == curline->v2->y)
- lightnum--;
+ lightnum--;
else if (curline->v1->x == curline->v2->x)
lightnum++;
@@ -703,6 +874,14 @@ void R_RenderThickSideRange(drawseg_t *ds, INT32 x1, INT32 x2, ffloor_t *pfloor)
vertflip = !vertflip;
}
+ //SoM: Moved these up here so they are available for my lightlist calculations
+ // Lactozilla: Moved them back down
+ // This uses floating point math now, because the fixed-point imprecisions
+ // become more severe the bigger the texture is scaled.
+ double dwall_scaley = FixedToDouble(wall_scaley);
+ double scalestep = FixedToDouble(ds->scalestep) / dwall_scaley;
+ double yscale = (FixedToDouble(ds->scale1) + (x1 - ds->x1)*scalestep) / dwall_scaley;
+
thicksidecol = ffloortexturecolumn;
wall_offsetx = ds->offsetx + sidedef->offsetx_mid;
@@ -734,7 +913,7 @@ void R_RenderThickSideRange(drawseg_t *ds, INT32 x1, INT32 x2, ffloor_t *pfloor)
else
dc_texturemid = FixedMul(*pfloor->topheight - viewz, wall_scaley);
- offsetvalue = sidedef->rowoffset + sidedef->offsety_mid;
+ repeatscroll = sidedef->rowoffset + sidedef->offsety_mid;
if (dont_peg_bottom)
{
@@ -744,7 +923,7 @@ void R_RenderThickSideRange(drawseg_t *ds, INT32 x1, INT32 x2, ffloor_t *pfloor)
dc_texturemid = FixedMul(left_bottom, wall_scaley);
}
else
- offsetvalue -= FixedMul(*pfloor->topheight - *pfloor->bottomheight, wall_scaley);
+ repeatscroll -= FixedMul(*pfloor->topheight - *pfloor->bottomheight, wall_scaley);
}
if (skewslope)
@@ -753,12 +932,21 @@ void R_RenderThickSideRange(drawseg_t *ds, INT32 x1, INT32 x2, ffloor_t *pfloor)
ffloortextureslide = FixedMul(R_GetSlopeTextureSlide(skewslope, lineangle), wall_scaley);
}
- dc_texturemid += offsetvalue;
+ dc_texturemid += repeatscroll;
// Texture must be cached
R_CheckTextureCache(texnum);
- if (vertflip) // vertically flipped?
+ // handle case where multipatch texture is drawn on a 2sided wall, multi-patch textures
+ // are not stored per-column with post info in SRB2
+ if (!textures[texnum]->transparency)
+ {
+ if (vertflip) // vertically flipped?
+ colfunc_2s = R_RenderFlipped2sidedMultiPatchColumn;
+ else
+ colfunc_2s = R_Render2sidedMultiPatchColumn;
+ }
+ else if (vertflip) // vertically flipped?
colfunc_2s = R_DrawRepeatFlippedMaskedColumn;
else
colfunc_2s = R_DrawRepeatMaskedColumn;
@@ -824,15 +1012,41 @@ void R_RenderThickSideRange(drawseg_t *ds, INT32 x1, INT32 x2, ffloor_t *pfloor)
rlight->botheight += rlight->botheightstep;
}
}
- spryscale += rw_scalestep;
+ yscale += scalestep;
continue;
}
- dc_iscale = FixedMul(0xffffffffu / (unsigned)spryscale, wall_scaley);
-
// Get data for the column
col = R_GetColumn(texnum, ((thicksidecol[dc_x] + wall_offsetx) >> FRACBITS));
+ spryscale = DoubleToFixed(yscale);
+
+ // Eh. I tried fixing the scaling artifacts but it still wasn't perfect.
+ // So this checks if the column has gaps in it or not, and if it does, uses a version of the column drawers
+ // that prevents the artifacts from being visible.
+ // Note that if rendering fog then none of this matters because there's no texture mapping to be done
+ if (!fog)
+ {
+ dc_iscale = 0xffffffffu / (unsigned)spryscale;
+
+ // Column has a single post and it matches the texture height, use regular column drawers
+ if (col->num_posts == 1 && col->posts[0].topdelta == 0 && col->posts[0].length == (unsigned)dc_texheight)
+ {
+ if (fuzzy)
+ colfunc = colfuncs[COLDRAWFUNC_FUZZY];
+ else
+ colfunc = colfuncs[BASEDRAWFUNC];
+ }
+ else
+ {
+ // Otherwise use column drawers with extra checks
+ if (fuzzy)
+ colfunc = colfuncs[COLDRAWFUNC_CLAMPEDTRANS];
+ else
+ colfunc = colfuncs[COLDRAWFUNC_CLAMPED];
+ }
+ }
+
// SoM: New code does not rely on R_DrawColumnShadowed_8 which
// will (hopefully) put less strain on the stack.
if (dc_numlights)
@@ -947,7 +1161,7 @@ void R_RenderThickSideRange(drawseg_t *ds, INT32 x1, INT32 x2, ffloor_t *pfloor)
if (windowtop < windowbottom)
colfunc_2s (col, lengthcol);
- spryscale += rw_scalestep;
+ yscale += scalestep;
continue;
}
@@ -966,7 +1180,7 @@ void R_RenderThickSideRange(drawseg_t *ds, INT32 x1, INT32 x2, ffloor_t *pfloor)
// draw the texture
colfunc_2s (col, lengthcol);
- spryscale += rw_scalestep;
+ yscale += scalestep;
}
colfunc = colfuncs[BASEDRAWFUNC];
@@ -1274,7 +1488,7 @@ static void R_RenderSegLoop (void)
for (i = 0; i < dc_numlights; i++)
{
INT32 lightnum;
- lightnum = (dc_lightlist[i].lightlevel >> LIGHTSEGSHIFT);
+ lightnum = R_SideLightLevel(curline->sidedef, dc_lightlist[i].lightlevel) >> LIGHTSEGSHIFT;
if (dc_lightlist[i].extra_colormap)
;
@@ -2461,7 +2675,7 @@ void R_StoreWallRange(INT32 start, INT32 stop)
// use different light tables
// for horizontal / vertical / diagonal
// OPTIMIZE: get rid of LIGHTSEGSHIFT globally
- lightnum = (frontsector->lightlevel >> LIGHTSEGSHIFT);
+ lightnum = R_SideLightLevel(curline->sidedef, frontsector->lightlevel) >> LIGHTSEGSHIFT;
if (curline->v1->y == curline->v2->y)
lightnum--;
diff --git a/src/r_skins.c b/src/r_skins.c
index 29a1556c0f6805fa788f1334628242c80570492f..a341ee80f56cb5162e63f02f50619095a8dd575d 100644
--- a/src/r_skins.c
+++ b/src/r_skins.c
@@ -43,10 +43,9 @@ UINT16 P_GetStateSprite2(state_t *state)
else
{
// Transform the state frame into an animation ID
- UINT32 stateframe = state->frame & FF_FRAMEMASK;
- UINT16 spr2 = stateframe & ~FF_SPR2SUPER;
+ UINT16 spr2 = state->frame & FF_FRAMEMASK;
- if (stateframe & FF_SPR2SUPER)
+ if (state->frame & SPR2F_SUPER)
spr2 |= SPR2F_SUPER;
return spr2;
@@ -70,7 +69,7 @@ boolean P_IsStateSprite2Super(state_t *state)
if (state->sprite2 & SPR2F_SUPER)
return true;
}
- else if (state->frame & FF_SPR2SUPER)
+ else if (state->frame & SPR2F_SUPER)
return true;
return false;
@@ -625,7 +624,7 @@ static void R_LoadSkinSprites(UINT16 wadnum, UINT16 *lump, UINT16 *lastlump, ski
newlastlump++;
// load all sprite sets we are aware of... for super!
for (sprite2 = start_spr2; sprite2 < free_spr2; sprite2++)
- R_AddSingleSpriteDef(spr2names[sprite2], &skin->super.sprites[sprite2], wadnum, newlastlump, *lastlump);
+ R_AddSingleSpriteDef(spr2names[sprite2], &skin->super.sprites[sprite2], wadnum, newlastlump, *lastlump, false);
newlastlump--;
*lastlump = newlastlump; // okay, make the normal sprite set loading end there
@@ -633,10 +632,18 @@ static void R_LoadSkinSprites(UINT16 wadnum, UINT16 *lump, UINT16 *lastlump, ski
// load all sprite sets we are aware of... for normal stuff.
for (sprite2 = start_spr2; sprite2 < free_spr2; sprite2++)
- R_AddSingleSpriteDef(spr2names[sprite2], &skin->sprites[sprite2], wadnum, *lump, *lastlump);
+ R_AddSingleSpriteDef(spr2names[sprite2], &skin->sprites[sprite2], wadnum, *lump, *lastlump, false);
if (skin->sprites[0].numframes == 0)
CONS_Alert(CONS_ERROR, M_GetText("No frames found for sprite SPR2_%s\n"), spr2names[0]);
+
+ // TODO: 2.3: Delete
+ memcpy(&skin->sprites_compat[start_spr2],
+ &skin->sprites[start_spr2],
+ sizeof(spritedef_t) * (free_spr2 - start_spr2));
+ memcpy(&skin->sprites_compat[start_spr2 + NUMPLAYERSPRITES],
+ &skin->super.sprites[start_spr2],
+ sizeof(spritedef_t) * (free_spr2 - start_spr2));
}
// returns whether found appropriate property
diff --git a/src/r_skins.h b/src/r_skins.h
index 1f2c57472d23ffd3026f0370e591dcd18ad77193..5122b53a6b4163d4de408704ca65631933f996b7 100644
--- a/src/r_skins.h
+++ b/src/r_skins.h
@@ -88,6 +88,9 @@ typedef struct
spritedef_t sprites[NUMPLAYERSPRITES];
spriteinfo_t sprinfo[NUMPLAYERSPRITES];
} super;
+
+ // TODO: 2.3: Delete
+ spritedef_t sprites_compat[NUMPLAYERSPRITES * 2];
} skin_t;
/// Externs
diff --git a/src/r_textures.c b/src/r_textures.c
index 59cc114139c5abb24df0f47fa0dddd0e70ec8d72..b61ddb86f849f26c3e53980163c5a7f1ac2e94cd 100644
--- a/src/r_textures.c
+++ b/src/r_textures.c
@@ -147,9 +147,9 @@ static void R_DrawFlippedColumnInCache(column_t *column, UINT8 *cache, texpatch_
if (count > 0)
{
- for (; dest < cache + position + count; --source, is_opaque++)
+ for (; dest < cache + position + count; --source, dest++, is_opaque++)
{
- *dest++ = *source;
+ *dest = *source;
*is_opaque = true;
}
}
@@ -295,7 +295,6 @@ UINT8 *R_GenerateTexture(size_t texnum)
UINT16 lumpnum = patch->lump;
UINT8 *pdata;
softwarepatch_t *realpatch;
- boolean holey = false;
#ifndef NO_PNG_LUMPS
UINT8 header[PNG_HEADER_SIZE];
@@ -310,9 +309,11 @@ UINT8 *R_GenerateTexture(size_t texnum)
pdata = W_CacheLumpNumPwad(wadnum, lumpnum, PU_CACHE);
realpatch = (softwarepatch_t *)pdata;
+ texture->transparency = false;
+
// Check the patch for holes.
if (texture->width > SHORT(realpatch->width) || texture->height > SHORT(realpatch->height))
- holey = true;
+ texture->transparency = true;
else
{
UINT8 *colofs = (UINT8 *)realpatch->columnofs;
@@ -332,12 +333,12 @@ UINT8 *R_GenerateTexture(size_t texnum)
col = (doompost_t *)((UINT8 *)col + col->length + 4);
}
if (y < texture->height)
- holey = true; // this texture is HOLEy! D:
+ texture->transparency = true; // this texture is HOLEy! D:
}
}
// If the patch uses transparency, we have to save it this way.
- if (holey)
+ if (texture->transparency)
{
texture->flip = patch->flip;
@@ -378,6 +379,15 @@ UINT8 *R_GenerateTexture(size_t texnum)
temp_columns = Z_Calloc(sizeof(column_t) * texture->width, PU_STATIC, NULL);
temp_block = Z_Calloc(total_pixels, PU_STATIC, NULL);
+#ifdef TEXTURE_255_IS_TRANSPARENT
+ texture->transparency = false;
+
+ // Transparency hack
+ memset(temp_block, TRANSPARENTPIXEL, total_pixels);
+#else
+ texture->transparency = true;
+#endif
+
for (x = 0; x < texture->width; x++)
{
column_t *column = &temp_columns[x];
@@ -474,13 +484,27 @@ UINT8 *R_GenerateTexture(size_t texnum)
// Now write the columns
column_posts = Z_Calloc(sizeof(unsigned) * texture->width, PU_STATIC, NULL);
+#ifdef TEXTURE_255_IS_TRANSPARENT
+ total_posts = texture->width;
+ temp_posts = Z_Realloc(temp_posts, sizeof(post_t) * total_posts, PU_CACHE, NULL);
+#endif
+
for (x = 0; x < texture->width; x++)
{
post_t *post = NULL;
- boolean was_opaque = false;
column_t *column = &temp_columns[x];
+#ifdef TEXTURE_255_IS_TRANSPARENT
+ post = &temp_posts[x];
+ post->topdelta = 0;
+ post->length = texture->height;
+ post->data_offset = 0;
+ column_posts[x] = x;
+ column->num_posts = 1;
+#else
+ boolean was_opaque = false;
+
column_posts[x] = (unsigned)-1;
for (INT32 y = 0; y < texture->height; y++)
@@ -510,6 +534,7 @@ UINT8 *R_GenerateTexture(size_t texnum)
post->length++;
}
+#endif
}
blocksize = (sizeof(column_t) * texture->width) + (sizeof(post_t) * total_posts) + (sizeof(UINT8) * total_pixels);
@@ -821,8 +846,8 @@ Rloadflats (INT32 i, INT32 w)
UINT8 *flatlump = W_CacheLumpNumPwad(wadnum, lumpnum, PU_CACHE);
if (Picture_PNGDimensions((UINT8 *)flatlump, &texw, &texh, NULL, NULL, lumplength))
{
- width = (INT16)width;
- height = (INT16)height;
+ width = (INT16)texw;
+ height = (INT16)texh;
}
else
{
@@ -1068,6 +1093,98 @@ void R_LoadTexturesPwad(UINT16 wadnum)
R_FinishLoadingTextures(newtextures);
}
+static lumpnum_t W_GetTexPatchLumpNum(const char *name)
+{
+ // Flats as a texture patch crashes horribly, and flats
+ // can share the same name as textures.
+
+ // But even if they worked, we want to prioritize:
+ // Patches -> Textures -> anything else
+
+ enum
+ {
+ USE_PATCHES,
+ USE_TEXTURES,
+ USE__MAX,
+ };
+
+ lumpnum_t lump = LUMPERROR;
+ INT32 lump_type_it;
+
+
+ for (lump_type_it = 0; lump_type_it < USE__MAX; lump_type_it++)
+ {
+ INT32 i;
+
+ for (i = numwadfiles - 1; i >= 0; i--) // Scan wad files backwards so patched lumps take precedent
+ {
+ lumpnum_t start = LUMPERROR;
+ lumpnum_t end = LUMPERROR;
+
+ switch (wadfiles[i]->type)
+ {
+ case RET_WAD:
+ if (lump_type_it == USE_PATCHES)
+ {
+ if ((start = W_CheckNumForMarkerStartPwad("P_START", (UINT16)i, 0)) == INT16_MAX)
+ continue;
+ else if ((end = W_CheckNumForNamePwad("P_END", (UINT16)i, start)) == INT16_MAX)
+ continue;
+ }
+ else if (lump_type_it == USE_TEXTURES)
+ {
+ if ((start = W_CheckNumForMarkerStartPwad("TX_START", (UINT16)i, 0)) == INT16_MAX)
+ continue;
+ else if ((end = W_CheckNumForNamePwad("TX_END", (UINT16)i, start)) == INT16_MAX)
+ continue;
+ }
+ break;
+ case RET_PK3:
+ case RET_FOLDER:
+ if (lump_type_it == USE_PATCHES)
+ {
+ if ((start = W_CheckNumForFolderStartPK3("Patches/", i, 0)) == INT16_MAX)
+ continue;
+ if ((end = W_CheckNumForFolderEndPK3("Patches/", i, start)) == INT16_MAX)
+ continue;
+ }
+ else if (lump_type_it == USE_TEXTURES)
+ {
+ if ((start = W_CheckNumForFolderStartPK3("Textures/", i, 0)) == INT16_MAX)
+ continue;
+ if ((end = W_CheckNumForFolderEndPK3("Textures/", i, start)) == INT16_MAX)
+ continue;
+ }
+ break;
+ default:
+ continue;
+ }
+
+ // Now find lump with specified name in that range.
+ lump = W_CheckNumForNamePwad(name, (UINT16)i, start);
+ if (lump < end)
+ {
+ lump += (i<<16); // found it, in our constraints
+ break;
+ }
+ lump = LUMPERROR;
+ }
+
+ if (lump != LUMPERROR)
+ {
+ break;
+ }
+ }
+
+ if (lump == LUMPERROR)
+ {
+ // Use whatever else you can find.
+ return W_CheckNumForPatchName(name);
+ }
+
+ return lump;
+}
+
static texpatch_t *R_ParsePatch(boolean actuallyLoadPatch)
{
char *texturesToken;
@@ -1240,13 +1357,13 @@ static texpatch_t *R_ParsePatch(boolean actuallyLoadPatch)
if (actuallyLoadPatch == true)
{
// Check lump exists
- patchLumpNum = W_GetNumForName(patchName);
+ patchLumpNum = W_GetTexPatchLumpNum(patchName);
// If so, allocate memory for texpatch_t and fill 'er up
resultPatch = (texpatch_t *)Z_Malloc(sizeof(texpatch_t),PU_STATIC,NULL);
resultPatch->originx = patchXPos;
resultPatch->originy = patchYPos;
- resultPatch->lump = patchLumpNum & 65535;
- resultPatch->wad = patchLumpNum>>16;
+ resultPatch->lump = LUMPNUM(patchLumpNum);
+ resultPatch->wad = WADFILENUM(patchLumpNum);
resultPatch->flip = flip;
resultPatch->alpha = alpha;
resultPatch->style = style;
diff --git a/src/r_textures.h b/src/r_textures.h
index eb68ec09f21d4fe8d847b048ac12ba9bd3a1817d..7e1588851d93093882ae8fb17bca1e70ba0aa61a 100644
--- a/src/r_textures.h
+++ b/src/r_textures.h
@@ -54,6 +54,7 @@ typedef struct
char name[8];
UINT32 hash;
UINT8 type; // TEXTURETYPE_*
+ boolean transparency;
INT16 width, height;
UINT8 flip; // 1 = flipx, 2 = flipy, 3 = both
void *flat; // The texture, as a flat.
diff --git a/src/r_things.c b/src/r_things.c
index 76e68068757fb1d387ac0c296c260f014f15098e..b32181670aa0ad9e3c5c59bcdc9f9fb2a810108d 100644
--- a/src/r_things.c
+++ b/src/r_things.c
@@ -77,7 +77,7 @@ spriteinfo_t spriteinfo[NUMSPRITES];
spritedef_t *sprites;
size_t numsprites;
-static spriteframe_t sprtemp[64];
+static spriteframe_t sprtemp[MAXFRAMENUM];
static size_t maxframe;
static const char *spritename;
@@ -116,6 +116,14 @@ static INT32 drawsegs_xrange_count = 0;
//
// ==========================================================================
+spritenum_t R_GetSpriteNumByName(const char *name)
+{
+ for (spritenum_t i = 0; i < NUMSPRITES; i++)
+ if (!strcmp(name, sprnames[i]))
+ return i;
+ return NUMSPRITES;
+}
+
//
//
//
@@ -128,10 +136,14 @@ static void R_InstallSpriteLump(UINT16 wad, // graphics patch
{
char cn = R_Frame2Char(frame), cr = R_Rotation2Char(rotation); // for debugging
+ char framedescription[256];
+ if (cn != '\xFF')
+ sprintf(framedescription, "%s frame %d (%c)", spritename, frame, cn);
+ else
+ sprintf(framedescription, "%s frame %d", spritename, frame);
+
INT32 r;
- lumpnum_t lumppat = wad;
- lumppat <<= 16;
- lumppat += lump;
+ lumpnum_t lumppat = (wad << 16) + lump;
if (maxframe ==(size_t)-1 || frame > maxframe)
maxframe = frame;
@@ -147,9 +159,9 @@ static void R_InstallSpriteLump(UINT16 wad, // graphics patch
{
// the lump should be used for all rotations
if (sprtemp[frame].rotate == SRF_SINGLE)
- CONS_Debug(DBG_SETUP, "R_InitSprites: Sprite %s frame %c has multiple rot = 0 lump\n", spritename, cn);
+ CONS_Debug(DBG_SETUP, "R_InitSprites: Sprite %s has multiple rot = 0 lump\n", framedescription);
else if (sprtemp[frame].rotate != SRF_NONE) // Let's bundle 1-8/16 and L/R rotations into one debug message.
- CONS_Debug(DBG_SETUP, "R_InitSprites: Sprite %s frame %c has rotations and a rot = 0 lump\n", spritename, cn);
+ CONS_Debug(DBG_SETUP, "R_InitSprites: Sprite %s has rotations and a rot = 0 lump\n", framedescription);
sprtemp[frame].rotate = SRF_SINGLE;
for (r = 0; r < 16; r++)
@@ -169,15 +181,15 @@ static void R_InstallSpriteLump(UINT16 wad, // graphics patch
if (sprtemp[frame].rotate == SRF_NONE)
sprtemp[frame].rotate = SRF_SINGLE;
else if (sprtemp[frame].rotate == SRF_SINGLE)
- CONS_Debug(DBG_SETUP, "R_InitSprites: Sprite %s frame %c has L/R rotations and a rot = 0 lump\n", spritename, cn);
+ CONS_Debug(DBG_SETUP, "R_InitSprites: Sprite %s has L/R rotations and a rot = 0 lump\n", framedescription);
else if (sprtemp[frame].rotate == SRF_3D)
- CONS_Debug(DBG_SETUP, "R_InitSprites: Sprite %s frame %c has both L/R and 1-8 rotations\n", spritename, cn);
+ CONS_Debug(DBG_SETUP, "R_InitSprites: Sprite %s has both L/R and 1-8 rotations\n", framedescription);
else if (sprtemp[frame].rotate == SRF_3DGE)
- CONS_Debug(DBG_SETUP, "R_InitSprites: Sprite %s frame %c has both L/R and 1-G rotations\n", spritename, cn);
+ CONS_Debug(DBG_SETUP, "R_InitSprites: Sprite %s has both L/R and 1-G rotations\n", framedescription);
else if ((sprtemp[frame].rotate & SRF_LEFT) && (rotation == ROT_L))
- CONS_Debug(DBG_SETUP, "R_InitSprites: Sprite %s frame %c has multiple L rotations\n", spritename, cn);
+ CONS_Debug(DBG_SETUP, "R_InitSprites: Sprite %s has multiple L rotations\n", framedescription);
else if ((sprtemp[frame].rotate & SRF_RIGHT) && (rotation == ROT_R))
- CONS_Debug(DBG_SETUP, "R_InitSprites: Sprite %s frame %c has multiple R rotations\n", spritename, cn);
+ CONS_Debug(DBG_SETUP, "R_InitSprites: Sprite %s has multiple R rotations\n", framedescription);
sprtemp[frame].rotate |= ((rotation == ROT_R) ? SRF_RIGHT : SRF_LEFT);
if ((sprtemp[frame].rotate & SRF_2D) == SRF_2D)
@@ -204,9 +216,9 @@ static void R_InstallSpriteLump(UINT16 wad, // graphics patch
if (sprtemp[frame].rotate == SRF_NONE)
sprtemp[frame].rotate = SRF_SINGLE;
else if (sprtemp[frame].rotate == SRF_SINGLE)
- CONS_Debug(DBG_SETUP, "R_InitSprites: Sprite %s frame %c has 1-8/G rotations and a rot = 0 lump\n", spritename, cn);
+ CONS_Debug(DBG_SETUP, "R_InitSprites: Sprite %s has 1-8/G rotations and a rot = 0 lump\n", framedescription);
else if (sprtemp[frame].rotate & SRF_2D)
- CONS_Debug(DBG_SETUP, "R_InitSprites: Sprite %s frame %c has both L/R and 1-8/G rotations\n", spritename, cn);
+ CONS_Debug(DBG_SETUP, "R_InitSprites: Sprite %s has both L/R and 1-8/G rotations\n", framedescription);
// make 0 based
rotation--;
@@ -226,7 +238,12 @@ static void R_InstallSpriteLump(UINT16 wad, // graphics patch
}
if (sprtemp[frame].lumppat[rotation] != LUMPERROR)
- CONS_Debug(DBG_SETUP, "R_InitSprites: Sprite %s: %c%c has two lumps mapped to it\n", spritename, cn, cr);
+ {
+ if (cn != '\xFF')
+ CONS_Debug(DBG_SETUP, "R_InitSprites: Sprite %s: %d_%c (%c%c) has two lumps mapped to it\n", spritename, frame, cr, cn, cr);
+ else
+ CONS_Debug(DBG_SETUP, "R_InitSprites: Sprite %s: %d_%c has two lumps mapped to it\n", spritename, frame, cr);
+ }
// lumppat & lumpid are the same for original Doom, but different
// when using sprites in pwad : the lumppat points the new graphics
@@ -238,24 +255,201 @@ static void R_InstallSpriteLump(UINT16 wad, // graphics patch
sprtemp[frame].flip &= ~(1<<rotation);
}
+static boolean GetFramesAndRotationsFromShortLumpName(
+ const char *name,
+ INT32 *ret_frame,
+ UINT8 *ret_rotation,
+ INT32 *ret_frame2,
+ UINT8 *ret_rotation2
+)
+{
+ size_t namelen = strlen(name);
+
+ if (namelen != 6 && namelen != 8)
+ return false;
+
+ *ret_frame = R_Char2Frame(name[4]);
+ *ret_rotation = R_Char2Rotation(name[5]);
+ if (*ret_frame >= 64 || *ret_rotation == 255)
+ return false;
+
+ if (namelen == 8)
+ {
+ *ret_frame2 = R_Char2Frame(name[6]);
+ *ret_rotation2 = R_Char2Rotation(name[7]);
+ if (*ret_frame2 >= 64 || *ret_rotation2 == 255)
+ return false;
+ }
+ else
+ {
+ *ret_frame2 = -1;
+ *ret_rotation2 = 255;
+ }
+
+ return true;
+}
+
+static boolean GetSingleFrameAndRotation(
+ const char *name,
+ size_t len,
+ INT32 *ret_frame,
+ UINT8 *ret_rotation
+)
+{
+ const char *underscore = strchr(name, '_');
+
+ // Found but past the part of the name we are parsing
+ if ((size_t)(underscore - name) >= len)
+ underscore = NULL;
+
+ size_t framelen = underscore ? (size_t)(underscore - name) : len;
+ if (framelen < 1 || framelen > 4)
+ return false;
+
+ char framepart[4 + 1]; // Max 9999
+ strlcpy(framepart, name, framelen + 1);
+
+ for (size_t i = 0; i < framelen; i++)
+ if (!isdigit(framepart[i]))
+ return false;
+
+ *ret_frame = atoi(framepart);
+ *ret_rotation = underscore ? R_Char2Rotation(*(underscore + 1)) : 0;
+ if (*ret_frame >= MAXFRAMENUM || *ret_rotation == 255)
+ return false;
+
+ return true;
+}
+
+static boolean GetFramesAndRotationsFromLongLumpName(
+ const char *name,
+ INT32 *ret_frame,
+ UINT8 *ret_rotation,
+ INT32 *ret_frame2,
+ UINT8 *ret_rotation2
+)
+{
+ const char *plus = strchr(name, '+');
+
+ if (plus)
+ {
+ size_t len1 = plus - name;
+
+ if (!GetSingleFrameAndRotation(name, len1, ret_frame, ret_rotation))
+ return false;
+ if (!GetSingleFrameAndRotation(plus + 1, strlen(name) - len1 - 1, ret_frame2, ret_rotation2))
+ return false;
+ }
+ else
+ {
+ if (!GetSingleFrameAndRotation(name, strlen(name), ret_frame, ret_rotation))
+ return false;
+
+ *ret_frame2 = -1;
+ *ret_rotation2 = 255;
+ }
+
+ return true;
+}
+
+static UINT8 GetOppositeRotation(UINT8 rotation, UINT8 flags)
+{
+ if (flags & ~SRF_3DMASK)
+ I_Error("GetOppositeRotation: rotation type not supported");
+
+ UINT8 numrotations = (flags == SRF_3D) ? 8 : 16;
+ return (rotation == 1) ? 1 : numrotations + 2 - rotation;
+}
+
+static void MirrorMissingRotations(void)
+{
+ for (UINT32 framenum = 0; framenum < maxframe; framenum++)
+ {
+ spriteframe_t *frame = &sprtemp[framenum];
+
+ if (frame->rotate == SRF_NONE || !(frame->rotate & SRF_3DMASK))
+ continue;
+
+ UINT8 numrotations = frame->rotate == SRF_3D ? 8 : 16;
+
+ for (UINT8 rotation = 1; rotation <= numrotations; rotation++)
+ {
+ if (frame->lumppat[rotation - 1] != LUMPERROR)
+ continue;
+
+ UINT8 baserotation = GetOppositeRotation(rotation, frame->rotate);
+ UINT32 lumpnum = frame->lumppat[baserotation - 1];
+ R_InstallSpriteLump(WADFILENUM(lumpnum), LUMPNUM(lumpnum), frame->lumpid[baserotation], framenum, rotation, 1);
+ }
+ }
+}
+
+// Some checks to help development
+static void CheckFrame(const char *sprname)
+{
+ for (UINT32 frame = 0; frame < maxframe; frame++)
+ {
+ spriteframe_t *spriteframe = &sprtemp[frame];
+
+ char framedescription[256];
+ if (frame < 64)
+ sprintf(framedescription, "%s frame %d (%c)", sprname, frame, R_Frame2Char(frame));
+ else
+ sprintf(framedescription, "%s frame %d", sprname, frame);
+
+ switch (spriteframe->rotate)
+ {
+ case SRF_NONE:
+ // no rotations were found for that frame at all
+ I_Error("R_AddSingleSpriteDef: No patches found for %s", framedescription);
+ break;
+
+ case SRF_SINGLE:
+ // only the first rotation is needed
+ break;
+
+ case SRF_2D: // both Left and Right rotations
+ // we test to see whether the left and right slots are present
+ if ((spriteframe->lumppat[2] == LUMPERROR) || (spriteframe->lumppat[6] == LUMPERROR))
+ I_Error("R_AddSingleSpriteDef: Sprite %s is missing rotations (L-R mode)",
+ framedescription);
+ break;
+
+ default:
+ {
+ // must have all 8/16 frames
+ UINT8 rotation = ((spriteframe->rotate & SRF_3DGE) ? 16 : 8);
+ while (rotation--)
+ {
+ // we test the patch lump, or the id lump whatever
+ // if it was not loaded the two are LUMPERROR
+ if (spriteframe->lumppat[rotation] == LUMPERROR)
+ I_Error("R_AddSingleSpriteDef: Sprite %s is missing rotations (1-%c mode)",
+ framedescription, ((spriteframe->rotate & SRF_3DGE) ? 'G' : '8'));
+ }
+ }
+ break;
+ }
+ }
+}
+
// Install a single sprite, given its identifying name (4 chars)
//
// (originally part of R_AddSpriteDefs)
//
-// Pass: name of sprite : 4 chars
+// Pass: name of sprite
// spritedef_t
// wadnum : wad number, indexes wadfiles[], where patches
// for frames are found
// startlump : first lump to search for sprite frames
// endlump : AFTER the last lump to search
+// longname : whether to use long sprite names or 4-char names
//
// Returns true if the sprite was succesfully added
//
-boolean R_AddSingleSpriteDef(const char *sprname, spritedef_t *spritedef, UINT16 wadnum, UINT16 startlump, UINT16 endlump)
+boolean R_AddSingleSpriteDef(const char *sprname, spritedef_t *spritedef, UINT16 wadnum, UINT16 startlump, UINT16 endlump, boolean longname)
{
UINT16 l;
- UINT8 frame;
- UINT8 rotation;
lumpinfo_t *lumpinfo;
UINT16 numadded = 0;
@@ -282,15 +476,23 @@ boolean R_AddSingleSpriteDef(const char *sprname, spritedef_t *spritedef, UINT16
for (l = startlump; l < endlump; l++)
{
- if (memcmp(lumpinfo[l].name,sprname,4)==0)
+ if (longname && W_IsLumpFolder(wadnum, l))
+ I_Error("R_AddSingleSpriteDef: all frame lumps for a sprite should be contained inside a single folder\n");
+
+ // For long sprites, the startlump-endlump range only includes
+ // relevant lumps, so no check needed in that case
+ if (longname || (strlen(sprname) == 4 && !memcmp(lumpinfo[l].name, sprname, 4)))
{
INT16 width, height;
INT16 topoffset, leftoffset;
+ INT32 frame, frame2;
+ UINT8 rotation, rotation2;
- frame = R_Char2Frame(lumpinfo[l].name[4]);
- rotation = R_Char2Rotation(lumpinfo[l].name[5]);
+ boolean good = longname ?
+ GetFramesAndRotationsFromLongLumpName(lumpinfo[l].longname, &frame, &rotation, &frame2, &rotation2) :
+ GetFramesAndRotationsFromShortLumpName(lumpinfo[l].name, &frame, &rotation, &frame2, &rotation2);
- if (frame >= 64 || rotation == 255) // Give an actual NAME error -_-...
+ if (!good) // Give an actual NAME error -_-...
{
CONS_Alert(CONS_WARNING, M_GetText("Bad sprite name: %s\n"), W_CheckNameForNumPwad(wadnum,l));
continue;
@@ -322,19 +524,8 @@ boolean R_AddSingleSpriteDef(const char *sprname, spritedef_t *spritedef, UINT16
//----------------------------------------------------
R_InstallSpriteLump(wadnum, l, numspritelumps, frame, rotation, 0);
-
- if (lumpinfo[l].name[6])
- {
- frame = R_Char2Frame(lumpinfo[l].name[6]);
- rotation = R_Char2Rotation(lumpinfo[l].name[7]);
-
- if (frame >= 64 || rotation == 255) // Give an actual NAME error -_-...
- {
- CONS_Alert(CONS_WARNING, M_GetText("Bad sprite name: %s\n"), W_CheckNameForNumPwad(wadnum,l));
- continue;
- }
- R_InstallSpriteLump(wadnum, l, numspritelumps, frame, rotation, 1);
- }
+ if (frame2 != -1)
+ R_InstallSpriteLump(wadnum, l, numspritelumps, frame2, rotation2, 1);
if (++numspritelumps >= max_spritelumps)
{
@@ -374,41 +565,10 @@ boolean R_AddSingleSpriteDef(const char *sprname, spritedef_t *spritedef, UINT16
maxframe++;
- //
- // some checks to help development
- //
- for (frame = 0; frame < maxframe; frame++)
- {
- switch (sprtemp[frame].rotate)
- {
- case SRF_NONE:
- // no rotations were found for that frame at all
- I_Error("R_AddSingleSpriteDef: No patches found for %.4s frame %c", sprname, R_Frame2Char(frame));
- break;
+ if (longname)
+ MirrorMissingRotations();
- case SRF_SINGLE:
- // only the first rotation is needed
- break;
-
- case SRF_2D: // both Left and Right rotations
- // we test to see whether the left and right slots are present
- if ((sprtemp[frame].lumppat[2] == LUMPERROR) || (sprtemp[frame].lumppat[6] == LUMPERROR))
- I_Error("R_AddSingleSpriteDef: Sprite %.4s frame %c is missing rotations (L-R mode)",
- sprname, R_Frame2Char(frame));
- break;
-
- default:
- // must have all 8/16 frames
- rotation = ((sprtemp[frame].rotate & SRF_3DGE) ? 16 : 8);
- while (rotation--)
- // we test the patch lump, or the id lump whatever
- // if it was not loaded the two are LUMPERROR
- if (sprtemp[frame].lumppat[rotation] == LUMPERROR)
- I_Error("R_AddSingleSpriteDef: Sprite %.4s frame %c is missing rotations (1-%c mode)",
- sprname, R_Frame2Char(frame), ((sprtemp[frame].rotate & SRF_3DGE) ? 'G' : '8'));
- break;
- }
- }
+ CheckFrame(sprname);
// allocate space for the frames present and copy sprtemp to it
if (spritedef->numframes && // has been allocated
@@ -429,14 +589,10 @@ boolean R_AddSingleSpriteDef(const char *sprname, spritedef_t *spritedef, UINT16
return true;
}
-//
-// Search for sprites replacements in a wad whose names are in namelist
-//
-void R_AddSpriteDefs(UINT16 wadnum)
+static void AddShortSpriteDefs(UINT16 wadnum, size_t *ptr_spritesadded, size_t *ptr_framesadded)
{
- size_t i, addsprites = 0;
+ size_t i;
UINT16 start, end;
- char wadname[MAX_WADPATH];
// Find the sprites section in this resource file.
switch (wadfiles[wadnum]->type)
@@ -474,27 +630,90 @@ void R_AddSpriteDefs(UINT16 wadnum)
return;
}
-
//
// scan through lumps, for each sprite, find all the sprite frames
//
for (i = 0; i < numsprites; i++)
{
- if (sprnames[i][4] && wadnum >= (UINT16)sprnames[i][4])
- continue;
-
- if (R_AddSingleSpriteDef(sprnames[i], &sprites[i], wadnum, start, end))
+ if (R_AddSingleSpriteDef(sprnames[i], &sprites[i], wadnum, start, end, false))
{
// if a new sprite was added (not just replaced)
- addsprites++;
+ (*ptr_spritesadded)++;
#ifndef ZDEBUG
CONS_Debug(DBG_SETUP, "sprite %s set in pwad %d\n", sprnames[i], wadnum);
#endif
}
}
- nameonly(strcpy(wadname, wadfiles[wadnum]->filename));
- CONS_Printf(M_GetText("%s added %d frames in %s sprites\n"), wadname, end-start, sizeu1(addsprites));
+ *ptr_framesadded += end - start;
+}
+
+static void AddLongSpriteDefs(UINT16 wadnum, size_t *ptr_spritesadded, size_t *ptr_framesadded)
+{
+ if (!W_FileHasFolders(wadfiles[wadnum]))
+ return;
+
+ UINT16 start = W_CheckNumForFolderStartPK3("LongSprites/", wadnum, 0);
+ UINT16 end = W_CheckNumForFolderEndPK3("LongSprites/", wadnum, start);
+
+ if (start == INT16_MAX || end == INT16_MAX || start >= end)
+ return;
+
+ size_t lumpnum = start;
+
+ while (lumpnum < end)
+ {
+ if (W_IsLumpFolder(wadnum, lumpnum))
+ {
+ lumpnum++;
+ continue;
+ }
+
+ UINT16 folderstart, folderend;
+ char *folderpath = W_GetLumpFolderPathPK3(wadnum, lumpnum);
+ folderstart = lumpnum;
+ folderend = W_CheckNumForFolderEndPK3(folderpath, wadnum, lumpnum);
+ Z_Free(folderpath);
+
+ spritenum_t sprnum;
+ char *sprname = W_GetLumpFolderNamePK3(wadnum, lumpnum);
+ strupr(sprname);
+ sprnum = R_GetSpriteNumByName(sprname);
+
+ if (sprnum != NUMSPRITES && R_AddSingleSpriteDef(sprname, &sprites[sprnum], wadnum, folderstart, folderend, true))
+ {
+ // A new sprite was added (not just replaced)
+ (*ptr_spritesadded)++;
+#ifndef ZDEBUG
+ CONS_Debug(DBG_SETUP, "long sprite %s set in pwad %d\n", sprname, wadnum);
+#endif
+ }
+
+ Z_Free(sprname);
+
+ lumpnum = folderend;
+ }
+
+ *ptr_framesadded += end - start;
+}
+
+//
+// Search for sprites replacements in a wad whose names are in namelist
+//
+void R_AddSpriteDefs(UINT16 wadnum)
+{
+ char wadname[MAX_WADPATH];
+ size_t spritesadded = 0;
+ size_t framesadded = 0;
+
+ AddShortSpriteDefs(wadnum, &spritesadded, &framesadded);
+ AddLongSpriteDefs(wadnum, &spritesadded, &framesadded);
+
+ if (spritesadded || framesadded)
+ {
+ nameonly(strcpy(wadname, wadfiles[wadnum]->filename));
+ CONS_Printf(M_GetText("%s added %s frames in %s sprites\n"), wadname, sizeu1(framesadded), sizeu2(spritesadded));
+ }
}
//
@@ -620,8 +839,10 @@ void R_DrawMaskedColumn(column_t *column, unsigned lengthcol)
{
post_t *post = &column->posts[i];
+ dc_postlength = post->length;
+
INT32 topscreen = sprtopscreen + spryscale*post->topdelta;
- INT32 bottomscreen = topscreen + spryscale*post->length;
+ INT32 bottomscreen = topscreen + spryscale*dc_postlength;
dc_yl = (topscreen+FRACUNIT-1)>>FRACBITS;
dc_yh = (bottomscreen-1)>>FRACBITS;
@@ -690,10 +911,12 @@ void R_DrawFlippedMaskedColumn(column_t *column, unsigned lengthcol)
if (!post->length)
continue;
- topdelta = lengthcol-post->length-post->topdelta;
+ dc_postlength = post->length;
+
+ topdelta = lengthcol-dc_postlength-post->topdelta;
topscreen = sprtopscreen + spryscale*topdelta;
- bottomscreen = sprbotscreen == INT32_MAX ? topscreen + spryscale*post->length
- : sprbotscreen + spryscale*post->length;
+ bottomscreen = sprbotscreen == INT32_MAX ? topscreen + spryscale*dc_postlength
+ : sprbotscreen + spryscale*dc_postlength;
dc_yl = (topscreen+FRACUNIT-1)>>FRACBITS;
dc_yh = (bottomscreen-1)>>FRACBITS;
@@ -773,6 +996,12 @@ UINT8 *R_GetTranslationForThing(mobj_t *mobj, skincolornum_t color, UINT16 trans
return NULL;
}
+// Based off of R_GetLinedefTransTable
+transnum_t R_GetThingTransTable(fixed_t alpha, transnum_t transmap)
+{
+ return (20*(FRACUNIT - ((alpha * (10 - transmap))/10) - 1) + FRACUNIT) >> (FRACBITS+1);
+}
+
//
// R_DrawVisSprite
// mfloorclip and mceilingclip should also be set.
@@ -1278,6 +1507,7 @@ static void R_ProjectDropShadow(mobj_t *thing, vissprite_t *vis, fixed_t scale,
floordiff = abs((isflipped ? interp.height : 0) + interp.z - groundz);
trans = floordiff / (100*FRACUNIT) + 3;
+ trans = R_GetThingTransTable(thing->alpha, trans);
if (trans >= 9) return;
scalemul = FixedMul(FRACUNIT - floordiff/640, scale);
@@ -1551,6 +1781,10 @@ static void R_ProjectSprite(mobj_t *thing)
}
this_scale = interp.scale;
+
+ if (this_scale < 1)
+ return;
+
radius = interp.radius; // For drop shadows
height = interp.height; // Ditto
@@ -1964,6 +2198,11 @@ 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
+ trans = R_GetThingTransTable(oldthing->alpha, trans);
// Check if this sprite needs to be rendered like a shadow
shadowdraw = (!!(thing->renderflags & RF_SHADOWDRAW) && !(papersprite || splat));
@@ -3425,6 +3664,7 @@ boolean R_ThingVisible (mobj_t *thing)
(thing->sprite == SPR_NULL) || // Don't draw null-sprites
(thing->flags2 & MF2_DONTDRAW) || // Don't draw MF2_LINKDRAW objects
(thing->drawonlyforplayer && thing->drawonlyforplayer != viewplayer) || // Don't draw other players' personal objects
+ (!R_BlendLevelVisible(thing->blendmode, R_GetThingTransTable(thing->alpha, 0))) ||
(!P_MobjWasRemoved(r_viewmobj) && (
(r_viewmobj == thing) || // Don't draw first-person players or awayviewmobj objects
(r_viewmobj->player && r_viewmobj->player->followmobj == thing) || // Don't draw first-person players' followmobj
diff --git a/src/r_things.h b/src/r_things.h
index f68d75a837ef698bcb98fc4e6dc568f97bf8881a..55ab71ec3847d5b85295904a18de516afa6f1b74 100644
--- a/src/r_things.h
+++ b/src/r_things.h
@@ -27,7 +27,9 @@
#define FEETADJUST (4<<FRACBITS) // R_AddSingleSpriteDef
-boolean R_AddSingleSpriteDef(const char *sprname, spritedef_t *spritedef, UINT16 wadnum, UINT16 startlump, UINT16 endlump);
+spritenum_t R_GetSpriteNumByName(const char *name);
+
+boolean R_AddSingleSpriteDef(const char *sprname, spritedef_t *spritedef, UINT16 wadnum, UINT16 startlump, UINT16 endlump, boolean longname);
//faB: find sprites in wadfile, replace existing, add new ones
// (only sprites from namelist are added or replaced)
@@ -91,6 +93,7 @@ boolean R_ThingIsFullDark (mobj_t *thing);
boolean R_ThingIsFlashing (mobj_t *thing);
UINT8 *R_GetTranslationForThing(mobj_t *mobj, skincolornum_t color, UINT16 translation);
+transnum_t R_GetThingTransTable(fixed_t alpha, transnum_t transmap);
void R_ThingOffsetOverlay (mobj_t *thing, fixed_t *outx, fixed_t *outy);
diff --git a/src/s_sound.c b/src/s_sound.c
index 5155b90e8abe03901670bd8e5f38b29a7cdd508c..32353a59c2d590dd8ea1f74b47399de0886684d0 100644
--- a/src/s_sound.c
+++ b/src/s_sound.c
@@ -2256,9 +2256,9 @@ void S_ChangeMusicEx(const char *mmusic, UINT16 mflags, boolean looping, UINT32
return;
strncpy(newmusic, mmusic, sizeof(newmusic)-1);
+ newmusic[6] = 0;
if (LUA_HookMusicChange(music_name, &hook_param))
return;
- newmusic[6] = 0;
// No Music (empty string)
if (newmusic[0] == 0)
diff --git a/src/screen.c b/src/screen.c
index 9a82a15618a4045d651d10aae38a8e963b6711a5..014a20117999065fc2ee47e6d4a00af11f6e0e87 100644
--- a/src/screen.c
+++ b/src/screen.c
@@ -112,6 +112,10 @@ void SCR_SetDrawFuncs(void)
colfuncs[COLDRAWFUNC_SHADE] = R_DrawShadeColumn_8;
colfuncs[COLDRAWFUNC_SHADOWED] = R_DrawColumnShadowed_8;
colfuncs[COLDRAWFUNC_TRANSTRANS] = R_DrawTranslatedTranslucentColumn_8;
+ colfuncs[COLDRAWFUNC_CLAMPED] = R_DrawColumnClamped_8;
+ colfuncs[COLDRAWFUNC_CLAMPEDTRANS] = R_DrawTranslucentColumnClamped_8;
+ colfuncs[COLDRAWFUNC_TWOSMULTIPATCH] = R_Draw2sMultiPatchColumn_8;
+ colfuncs[COLDRAWFUNC_TWOSMULTIPATCHTRANS] = R_Draw2sMultiPatchTranslucentColumn_8;
colfuncs[COLDRAWFUNC_FOG] = R_DrawFogColumn_8;
spanfuncs[SPANDRAWFUNC_TRANS] = R_DrawTranslucentSpan_8;
diff --git a/src/screen.h b/src/screen.h
index 8b952e553a18c30f9cbdaf323bdbc01aa11f0fe4..375b3e04e9f3846a60992b9f230b4054321cf743 100644
--- a/src/screen.h
+++ b/src/screen.h
@@ -30,10 +30,6 @@
#define NUMSCREENS 5
#endif
-// Size of statusbar.
-#define ST_HEIGHT 32
-#define ST_WIDTH 320
-
// used now as a maximum video mode size for extra vesa modes.
// we try to re-allocate a minimum of buffers for stability of the memory,
@@ -97,6 +93,10 @@ enum
COLDRAWFUNC_SHADE,
COLDRAWFUNC_SHADOWED,
COLDRAWFUNC_TRANSTRANS,
+ COLDRAWFUNC_CLAMPED,
+ COLDRAWFUNC_CLAMPEDTRANS,
+ COLDRAWFUNC_TWOSMULTIPATCH,
+ COLDRAWFUNC_TWOSMULTIPATCHTRANS,
COLDRAWFUNC_FOG,
COLDRAWFUNC_MAX
diff --git a/src/sdl/CMakeLists.txt b/src/sdl/CMakeLists.txt
index ee48fa2b154568889c50d4e0a6c8d97c5c2a7bf0..99425108e69b3761fd03de7790d02232e44bb898 100644
--- a/src/sdl/CMakeLists.txt
+++ b/src/sdl/CMakeLists.txt
@@ -33,8 +33,6 @@ target_compile_options(SRB2SDL2 PRIVATE
-Wall
-Wno-trigraphs
-W # Was controlled by RELAXWARNINGS
- -pedantic
- -Wpedantic
-Wfloat-equal
-Wundef
-Wpointer-arith
diff --git a/src/sdl/i_main.c b/src/sdl/i_main.c
index f5fe9fb041b9f02057955afe072815e709b19dc3..b2177e563120fc76cf726353e5cad841e45b1762 100644
--- a/src/sdl/i_main.c
+++ b/src/sdl/i_main.c
@@ -186,6 +186,9 @@ int main(int argc, char **argv)
#endif
#endif
+ // disable text input right off the bat, since we don't need it at the start.
+ I_SetTextInputMode(false);
+
#ifdef LOGMESSAGES
if (!M_CheckParm("-nolog"))
InitLogging();
diff --git a/src/sdl/i_system.c b/src/sdl/i_system.c
index 2d051888dc1f26de5357b8689eced942ab38da59..9fe50a6a2347583f0fe705ff5c6f6a0466ea51a9 100644
--- a/src/sdl/i_system.c
+++ b/src/sdl/i_system.c
@@ -271,75 +271,86 @@ SDL_bool framebuffer = SDL_FALSE;
UINT8 keyboard_started = false;
#ifdef UNIXBACKTRACE
-#define STDERR_WRITE(string) if (fd != -1) I_OutputMsg("%s", string)
-#define CRASHLOG_WRITE(string) if (fd != -1) junk = write(fd, string, strlen(string))
-#define CRASHLOG_STDERR_WRITE(string) \
- if (fd != -1)\
- junk = write(fd, string, strlen(string));\
- I_OutputMsg("%s", string)
+
+static void bt_write_file(int fd, const char *string) {
+ ssize_t written = 0;
+ ssize_t sourcelen = strlen(string);
+
+ while (fd != -1 && (written != -1 && errno != EINTR) && written < sourcelen)
+ written = write(fd, string, sourcelen);
+}
+
+static void bt_write_stderr(const char *string) {
+ bt_write_file(STDERR_FILENO, string);
+}
+
+static void bt_write_all(int fd, const char *string) {
+ bt_write_file(fd, string);
+ bt_write_file(STDERR_FILENO, string);
+}
static void write_backtrace(INT32 signal)
{
int fd = -1;
-#ifndef NOEXECINFO
- size_t size;
-#endif
time_t rawtime;
struct tm timeinfo;
- ssize_t junk;
enum { BT_SIZE = 1024, STR_SIZE = 32 };
#ifndef NOEXECINFO
- void *array[BT_SIZE];
+ void *funcptrs[BT_SIZE];
+ size_t bt_size;
#endif
char timestr[STR_SIZE];
- const char *error = "An error occurred within SRB2! Send this stack trace to someone who can help!\n";
- const char *error2 = "(Or find crash-log.txt in your SRB2 directory.)\n"; // Shown only to stderr.
+ const char *filename = va("%s" PATHSEP "%s", srb2home, "crash-log.txt");
- fd = open(va("%s" PATHSEP "%s", srb2home, "crash-log.txt"), O_CREAT|O_APPEND|O_RDWR, S_IRUSR|S_IWUSR);
+ fd = open(filename, O_CREAT|O_APPEND|O_RDWR, S_IRUSR|S_IWUSR);
- if (fd == -1)
- I_OutputMsg("\nWARNING: Couldn't open crash log for writing! Make sure your permissions are correct. Please save the below report!\n");
+ if (fd == -1) // File handle error
+ bt_write_stderr("\nWARNING: Couldn't open crash log for writing! Make sure your permissions are correct. Please save the below report!\n");
// Get the current time as a string.
time(&rawtime);
localtime_r(&rawtime, &timeinfo);
strftime(timestr, STR_SIZE, "%a, %d %b %Y %T %z", &timeinfo);
- CRASHLOG_WRITE("------------------------\n"); // Nice looking seperator
+ bt_write_file(fd, "------------------------\n"); // Nice looking seperator
+
+ bt_write_all(fd, "\n"); // Newline to look nice for both outputs.
+ bt_write_all(fd, "An error occurred within SRB2! Send this stack trace to someone who can help!\n");
- CRASHLOG_STDERR_WRITE("\n"); // Newline to look nice for both outputs.
- CRASHLOG_STDERR_WRITE(error); // "Oops, SRB2 crashed" message
- STDERR_WRITE(error2); // Tell the user where the crash log is.
+ if (fd != -1) // If the crash log exists,
+ bt_write_stderr("(Or find crash-log.txt in your SRB2 directory.)\n"); // tell the user where the crash log is.
// Tell the log when we crashed.
- CRASHLOG_WRITE("Time of crash: ");
- CRASHLOG_WRITE(timestr);
- CRASHLOG_WRITE("\n");
+ bt_write_file(fd, "Time of crash: ");
+ bt_write_file(fd, timestr);
+ bt_write_file(fd, "\n");
// Give the crash log the cause and a nice 'Backtrace:' thing
// The signal is given to the user when the parent process sees we crashed.
- CRASHLOG_WRITE("Cause: ");
- CRASHLOG_WRITE(strsignal(signal));
- CRASHLOG_WRITE("\n"); // Newline for the signal name
+ bt_write_file(fd, "Cause: ");
+ bt_write_file(fd, strsignal(signal));
+ bt_write_file(fd, "\n"); // Newline for the signal name
-#ifndef NOEXECINFO
- CRASHLOG_STDERR_WRITE("\nBacktrace:\n");
+#ifdef NOEXECINFO
+ bt_write_all(fd, "\nNo Backtrace support\n");
+#else
+ bt_write_all(fd, "\nBacktrace:\n");
// Flood the output and log with the backtrace
- size = backtrace(array, BT_SIZE);
- backtrace_symbols_fd(array, size, fd);
- backtrace_symbols_fd(array, size, STDERR_FILENO);
+ bt_size = backtrace(funcptrs, BT_SIZE);
+ backtrace_symbols_fd(funcptrs, bt_size, fd);
+ backtrace_symbols_fd(funcptrs, bt_size, STDERR_FILENO);
#endif
- CRASHLOG_WRITE("\n"); // Write another newline to the log so it looks nice :)
- (void)junk;
- close(fd);
+ bt_write_file(fd, "\n"); // Write another newline to the log so it looks nice :)
+ if (fd != -1) {
+ fsync(fd); // reaaaaally make sure we got that data written.
+ close(fd);
+ }
}
-#undef STDERR_WRITE
-#undef CRASHLOG_WRITE
-#undef CRASHLOG_STDERR_WRITE
+
#endif // UNIXBACKTRACE
static void I_ReportSignal(int num, int coredumped)
@@ -2976,7 +2987,7 @@ static void pathonly(char *s)
*/
static const char *searchWad(const char *searchDir)
{
- static char tempsw[256] = "";
+ static char tempsw[MAX_WADPATH] = "";
filestatus_t fstemp;
strcpy(tempsw, WADKEYWORD1);
@@ -2992,8 +3003,8 @@ static const char *searchWad(const char *searchDir)
#define CHECKWADPATH(ret) \
do { \
- I_OutputMsg(",%s", returnWadPath); \
- if (isWadPathOk(returnWadPath)) \
+ I_OutputMsg(",%s", ret); \
+ if (isWadPathOk(ret)) \
return ret; \
} while (0)
@@ -3022,7 +3033,9 @@ static const char *locateWad(void)
#ifndef NOCWD
// examine current dir
strcpy(returnWadPath, ".");
- CHECKWADPATH(NULL);
+ I_OutputMsg(",%s", returnWadPath);
+ if (isWadPathOk(returnWadPath))
+ return NULL;
#endif
#ifdef __APPLE__
@@ -3039,9 +3052,16 @@ static const char *locateWad(void)
#ifndef NOHOME
// find in $HOME
- I_OutputMsg(",HOME");
+ I_OutputMsg(",HOME/" DEFAULTDIR);
if ((envstr = I_GetEnv("HOME")) != NULL)
- SEARCHWAD(envstr);
+ {
+ char *tmp = malloc(strlen(envstr) + 1 + sizeof(DEFAULTDIR));
+ strcpy(tmp, envstr);
+ strcat(tmp, "/");
+ strcat(tmp, DEFAULTDIR);
+ CHECKWADPATH(tmp);
+ free(tmp);
+ }
#endif
// search paths
@@ -3275,4 +3295,18 @@ const char *I_GetSysName(void)
return SDL_GetPlatform();
}
+
+void I_SetTextInputMode(boolean active)
+{
+ if (active)
+ SDL_StartTextInput();
+ else
+ SDL_StopTextInput();
+}
+
+boolean I_GetTextInputMode(void)
+{
+ return SDL_IsTextInputActive();
+}
+
#endif
diff --git a/src/sdl/i_video.c b/src/sdl/i_video.c
index 76fe172fce0e27f46ceb491be5a43f1b3e72f770..10c866a1e32ff6dd3c8ac248fb50df2a4e3a30f6 100644
--- a/src/sdl/i_video.c
+++ b/src/sdl/i_video.c
@@ -382,6 +382,8 @@ static INT32 Impl_SDL_Scancode_To_Keycode(SDL_Scancode code)
static boolean ShouldIgnoreMouse(void)
{
+ if (cv_alwaysgrabmouse.value)
+ return false;
if (menuactive)
return !M_MouseNeeded();
if (paused || con_destlines || chat_on)
@@ -1704,7 +1706,7 @@ static void Impl_VideoSetupBuffer(void)
vid.direct = NULL;
if (vid.buffer)
free(vid.buffer);
- vid.buffer = calloc(vid.rowbytes*vid.height, NUMSCREENS);
+ vid.buffer = calloc(NUMSCREENS, vid.rowbytes*vid.height);
if (!vid.buffer)
{
I_Error("%s", M_GetText("Not enough memory for video buffer\n"));
diff --git a/src/snake.c b/src/snake.c
index 2349d5fdbfb6d66af7d4bc55df03b553052153c8..4219d5b8fa54ee69ce1b99167e697e935cd3483b 100644
--- a/src/snake.c
+++ b/src/snake.c
@@ -582,7 +582,7 @@ boolean Snake_JoyGrabber(void *opaque, event_t *ev)
{
snake_t *snake = opaque;
- if (ev->type == ev_joystick && ev->key == 0)
+ if (snake != NULL && ev->type == ev_joystick && ev->key == 0)
{
snake->joyevents[snake->joyeventcount] = ev;
snake->joyeventcount++;
diff --git a/src/st_stuff.c b/src/st_stuff.c
index 7df6f8848dd80c2cb0eb5839fd0389b7c86a3b8b..e088a448c129ed6e2392e8bcadf3cb62e9932525 100644
--- a/src/st_stuff.c
+++ b/src/st_stuff.c
@@ -1269,19 +1269,19 @@ tic_t lt_exitticker = 0, lt_endtime = 0;
//
static void ST_cacheLevelTitle(void)
{
-#define SETPATCH(default, warning, custom, idx) \
+#define SETPATCH(def, warning, custom, idx) \
{ \
lumpnum_t patlumpnum = LUMPERROR; \
if (mapheaderinfo[gamemap-1]->custom[0] != '\0') \
{ \
- patlumpnum = W_CheckNumForName(mapheaderinfo[gamemap-1]->custom); \
+ patlumpnum = W_CheckNumForPatchName(mapheaderinfo[gamemap-1]->custom); \
if (patlumpnum != LUMPERROR) \
lt_patches[idx] = (patch_t *)W_CachePatchNum(patlumpnum, PU_HUDGFX); \
} \
if (patlumpnum == LUMPERROR) \
{ \
if (!(mapheaderinfo[gamemap-1]->levelflags & LF_WARNINGTITLE)) \
- lt_patches[idx] = (patch_t *)W_CachePatchName(default, PU_HUDGFX); \
+ lt_patches[idx] = (patch_t *)W_CachePatchName(def, PU_HUDGFX); \
else \
lt_patches[idx] = (patch_t *)W_CachePatchName(warning, PU_HUDGFX); \
} \
diff --git a/src/w_wad.c b/src/w_wad.c
index 0666c4a600bcf20678f88539fb4055a0d5466992..cc7cdc20167d616083d86db652b05aa8eb182e5e 100644
--- a/src/w_wad.c
+++ b/src/w_wad.c
@@ -98,6 +98,7 @@ typedef struct lumpnum_cache_s
{
char lumpname[32];
lumpnum_t lumpnum;
+ UINT32 hash;
} lumpnum_cache_t;
static lumpnum_cache_t lumpnumcache[LUMPNUMCACHESIZE];
@@ -1349,6 +1350,47 @@ UINT16 W_CheckNumForFolderEndPK3(const char *name, UINT16 wad, UINT16 startlump)
return i;
}
+char *W_GetLumpFolderPathPK3(UINT16 wad, UINT16 lump)
+{
+ const char *fullname = wadfiles[wad]->lumpinfo[lump].fullname;
+
+ const char *slash = strrchr(fullname, '/');
+ INT32 pathlen = slash ? slash - fullname : 0;
+
+ char *path = Z_Calloc(pathlen + 1, PU_STATIC, NULL);
+ strncpy(path, fullname, pathlen);
+
+ return path;
+}
+
+char *W_GetLumpFolderNamePK3(UINT16 wad, UINT16 lump)
+{
+ const char *fullname = wadfiles[wad]->lumpinfo[lump].fullname;
+ size_t start, end;
+
+ INT32 i = strlen(fullname);
+
+ i--;
+ while (i >= 0 && fullname[i] != '/')
+ i--;
+ if (i < 0)
+ return NULL;
+ end = i;
+
+ i--;
+ while (i >= 0 && fullname[i] != '/')
+ i--;
+ if (i < 0)
+ return NULL;
+ start = i + 1;
+
+ size_t namelen = end - start;
+ char *foldername = Z_Calloc(namelen + 1, PU_STATIC, NULL);
+ strncpy(foldername, fullname + start, namelen);
+
+ return foldername;
+}
+
void W_GetFolderLumpsPwad(const char *name, UINT16 wad, UINT32 **list, UINT16 *list_capacity, UINT16 *numlumps)
{
size_t name_length = strlen(name);
@@ -1434,6 +1476,63 @@ UINT16 W_CheckNumForFullNamePK3(const char *name, UINT16 wad, UINT16 startlump)
return INT16_MAX;
}
+static lumpnum_t CheckLumpInCache(const char *name, boolean longname)
+{
+ if (longname)
+ {
+ UINT32 hash = quickncasehash(name, 32);
+
+ // Loop backwards so that we check most recent entries first
+ for (INT32 i = lumpnumcacheindex + LUMPNUMCACHESIZE; i > lumpnumcacheindex; i--)
+ {
+ if (lumpnumcache[i & (LUMPNUMCACHESIZE - 1)].hash == hash
+ && stricmp(lumpnumcache[i & (LUMPNUMCACHESIZE - 1)].lumpname, name) == 0)
+ {
+ lumpnumcacheindex = i & (LUMPNUMCACHESIZE - 1);
+ return lumpnumcache[lumpnumcacheindex].lumpnum;
+ }
+ }
+ }
+ else
+ {
+ UINT32 hash = quickncasehash(name, 8);
+
+ // Loop backwards so that we check most recent entries first
+ for (INT32 i = lumpnumcacheindex + LUMPNUMCACHESIZE; i > lumpnumcacheindex; i--)
+ {
+ if (lumpnumcache[i & (LUMPNUMCACHESIZE - 1)].hash == hash
+ && lumpnumcache[i & (LUMPNUMCACHESIZE - 1)].lumpname[8] == '\0'
+ && strnicmp(lumpnumcache[i & (LUMPNUMCACHESIZE - 1)].lumpname, name, 8) == 0)
+ {
+ lumpnumcacheindex = i & (LUMPNUMCACHESIZE - 1);
+ return lumpnumcache[lumpnumcacheindex].lumpnum;
+ }
+ }
+ }
+
+ return LUMPERROR;
+}
+
+static void AddLumpToCache(lumpnum_t lumpnum, const char *name, boolean longname)
+{
+ if (longname && strlen(name) >= 32)
+ return;
+
+ lumpnumcacheindex = (lumpnumcacheindex + 1) & (LUMPNUMCACHESIZE - 1);
+ memset(lumpnumcache[lumpnumcacheindex].lumpname, '\0', 32);
+ if (longname)
+ {
+ strlcpy(lumpnumcache[lumpnumcacheindex].lumpname, name, 32);
+ lumpnumcache[lumpnumcacheindex].hash = quickncasehash(name, 32);
+ }
+ else
+ {
+ strncpy(lumpnumcache[lumpnumcacheindex].lumpname, name, 8);
+ lumpnumcache[lumpnumcacheindex].hash = quickncasehash(name, 8);
+ }
+ lumpnumcache[lumpnumcacheindex].lumpnum = lumpnum;
+}
+
//
// W_CheckNumForName
// Returns LUMPERROR if name not found.
@@ -1446,17 +1545,10 @@ lumpnum_t W_CheckNumForName(const char *name)
if (!*name) // some doofus gave us an empty string?
return LUMPERROR;
- // Check the lumpnumcache first. Loop backwards so that we check
- // most recent entries first
- for (i = lumpnumcacheindex + LUMPNUMCACHESIZE; i > lumpnumcacheindex; i--)
- {
- if (!lumpnumcache[i & (LUMPNUMCACHESIZE - 1)].lumpname[8]
- && strncmp(lumpnumcache[i & (LUMPNUMCACHESIZE - 1)].lumpname, name, 8) == 0)
- {
- lumpnumcacheindex = i & (LUMPNUMCACHESIZE - 1);
- return lumpnumcache[lumpnumcacheindex].lumpnum;
- }
- }
+ // Check the lumpnumcache first.
+ lumpnum_t cachenum = CheckLumpInCache(name, false);
+ if (cachenum != LUMPERROR)
+ return cachenum;
// scan wad files backwards so patch lump files take precedence
for (i = numwadfiles - 1; i >= 0; i--)
@@ -1470,12 +1562,11 @@ lumpnum_t W_CheckNumForName(const char *name)
else
{
// Update the cache.
- lumpnumcacheindex = (lumpnumcacheindex + 1) & (LUMPNUMCACHESIZE - 1);
- memset(lumpnumcache[lumpnumcacheindex].lumpname, '\0', 32);
- strncpy(lumpnumcache[lumpnumcacheindex].lumpname, name, 8);
- lumpnumcache[lumpnumcacheindex].lumpnum = (i<<16)+check;
+ lumpnum_t lumpnum = (i << 16) + check;
+
+ AddLumpToCache(lumpnum, name, false);
- return lumpnumcache[lumpnumcacheindex].lumpnum;
+ return lumpnum;
}
}
@@ -1493,16 +1584,10 @@ lumpnum_t W_CheckNumForLongName(const char *name)
if (!*name) // some doofus gave us an empty string?
return LUMPERROR;
- // Check the lumpnumcache first. Loop backwards so that we check
- // most recent entries first
- for (i = lumpnumcacheindex + LUMPNUMCACHESIZE; i > lumpnumcacheindex; i--)
- {
- if (strcmp(lumpnumcache[i & (LUMPNUMCACHESIZE - 1)].lumpname, name) == 0)
- {
- lumpnumcacheindex = i & (LUMPNUMCACHESIZE - 1);
- return lumpnumcache[lumpnumcacheindex].lumpnum;
- }
- }
+ // Check the lumpnumcache first.
+ lumpnum_t cachenum = CheckLumpInCache(name, true);
+ if (cachenum != LUMPERROR)
+ return cachenum;
// scan wad files backwards so patch lump files take precedence
for (i = numwadfiles - 1; i >= 0; i--)
@@ -1515,16 +1600,12 @@ lumpnum_t W_CheckNumForLongName(const char *name)
if (check == INT16_MAX) return LUMPERROR;
else
{
- if (strlen(name) < 32)
- {
- // Update the cache.
- lumpnumcacheindex = (lumpnumcacheindex + 1) & (LUMPNUMCACHESIZE - 1);
- memset(lumpnumcache[lumpnumcacheindex].lumpname, '\0', 32);
- strlcpy(lumpnumcache[lumpnumcacheindex].lumpname, name, 32);
- lumpnumcache[lumpnumcacheindex].lumpnum = (i << 16) + check;
- }
+ // Update the cache.
+ lumpnum_t lumpnum = (i << 16) + check;
+
+ AddLumpToCache(lumpnum, name, true);
- return (i << 16) + check;
+ return lumpnum;
}
}
@@ -1606,6 +1687,159 @@ lumpnum_t W_GetNumForLongName(const char *name)
return i;
}
+//
+// Same as W_CheckNumForNamePwad, but handles namespaces.
+//
+static UINT16 W_CheckNumForPatchNamePwad(const char *name, UINT16 wad, boolean longname)
+{
+ UINT16 i, start, end;
+ static char uname[8 + 1] = { 0 };
+ UINT32 hash = 0;
+ lumpinfo_t *lump_p;
+
+ if (!TestValidLump(wad,0))
+ return INT16_MAX;
+
+ if (!longname)
+ {
+ strlcpy(uname, name, sizeof uname);
+ strupr(uname);
+ hash = quickncasehash(uname, 8);
+ }
+
+ // SRB2 doesn't have a specific namespace for graphics, which means someone can do weird things
+ // like placing graphics inside a namespace it doesn't make sense for them to be in, like Sounds/ or SOC/
+ // So for now, this checks for lumps OUTSIDE of the flats namespace.
+ // When this situation changes, change the loops below to check for lumps INSIDE the namespaces to look in.
+ // TODO: cache namespace lump IDs
+ if (W_FileHasFolders(wadfiles[wad]))
+ {
+ start = W_CheckNumForFolderStartPK3("Flats/", wad, 0);
+ end = W_CheckNumForFolderEndPK3("Flats/", wad, start);
+ }
+ else
+ {
+ start = W_CheckNumForMarkerStartPwad("F_START", wad, 0);
+ end = W_CheckNumForNamePwad("F_END", wad, start);
+ if (end != INT16_MAX)
+ end++;
+ }
+
+ lump_p = wadfiles[wad]->lumpinfo;
+
+ if (start == INT16_MAX)
+ start = wadfiles[wad]->numlumps;
+
+ for (i = 0; i < start; i++, lump_p++)
+ {
+ if ((!longname && lump_p->hash == hash && !strncmp(lump_p->name, uname, sizeof(uname) - 1))
+ || (longname && stricmp(lump_p->longname, name) == 0))
+ return i;
+ }
+
+ if (end != INT16_MAX && start < end)
+ {
+ lump_p = wadfiles[wad]->lumpinfo + end;
+
+ for (i = end; i < wadfiles[wad]->numlumps; i++, lump_p++)
+ {
+ if ((!longname && lump_p->hash == hash && !strncmp(lump_p->name, uname, sizeof(uname) - 1))
+ || (longname && stricmp(lump_p->longname, name) == 0))
+ return i;
+ }
+ }
+
+ // not found.
+ return INT16_MAX;
+}
+
+//
+// W_CheckNumForPatchNameInternal
+// Gets a lump number out of a patch name. Returns LUMPERROR if name not found.
+//
+static lumpnum_t W_CheckNumForPatchNameInternal(const char *name, boolean longname)
+{
+ INT32 i;
+ lumpnum_t check = INT16_MAX;
+
+ if (!*name) // some doofus gave us an empty string?
+ return LUMPERROR;
+
+ // Check the lumpnumcache first.
+ lumpnum_t cachenum = CheckLumpInCache(name, longname);
+ if (cachenum != LUMPERROR)
+ return cachenum;
+
+ // scan wad files backwards so patch lump files take precedence
+ for (i = numwadfiles - 1; i >= 0; i--)
+ {
+ check = W_CheckNumForPatchNamePwad(name,(UINT16)i,longname);
+ if (check != INT16_MAX)
+ break; //found it
+ }
+
+ if (check == INT16_MAX) return LUMPERROR;
+ else
+ {
+ // Update the cache.
+ lumpnum_t lumpnum = (i << 16) + check;
+
+ AddLumpToCache(lumpnum, name, longname);
+
+ return lumpnum;
+ }
+}
+
+//
+// W_CheckNumForPatchName
+// Wrapper for W_CheckNumForPatchNameInternal(name, false). Returns LUMPERROR if name not found.
+//
+lumpnum_t W_CheckNumForPatchName(const char *name)
+{
+ return W_CheckNumForPatchNameInternal(name, false);
+}
+
+//
+// Like W_CheckNumForPatchName, but can find entries with long names.
+// Wrapper for W_CheckNumForPatchNameInternal(name, true). Returns LUMPERROR if name not found.
+//
+lumpnum_t W_CheckNumForLongPatchName(const char *name)
+{
+ return W_CheckNumForPatchNameInternal(name, true);
+}
+
+//
+// W_GetNumForPatchName
+//
+// Calls W_CheckNumForPatchName, but bombs out if not found.
+//
+lumpnum_t W_GetNumForPatchName(const char *name)
+{
+ lumpnum_t i;
+
+ i = W_CheckNumForPatchName(name);
+
+ if (i == LUMPERROR)
+ I_Error("W_CheckNumForPatchName: %s not found!\n", name);
+
+ return i;
+}
+
+//
+// Like W_GetNumForPatchName, but can find entries with long names
+//
+lumpnum_t W_GetNumForLongPatchName(const char *name)
+{
+ lumpnum_t i;
+
+ i = W_CheckNumForLongPatchName(name);
+
+ if (i == LUMPERROR)
+ I_Error("W_GetNumForLongPatchName: %s not found!\n", name);
+
+ return i;
+}
+
//
// W_CheckNumForNameInBlock
// Checks only in blocks from blockstart lump to blockend lump
@@ -2250,10 +2484,10 @@ void *W_CachePatchName(const char *name, INT32 tag)
{
lumpnum_t num;
- num = W_CheckNumForName(name);
+ num = W_CheckNumForPatchName(name);
if (num == LUMPERROR)
- return W_CachePatchNum(W_GetNumForName("MISSING"), tag);
+ return W_CachePatchNum(W_GetNumForPatchName("MISSING"), tag);
return W_CachePatchNum(num, tag);
}
@@ -2261,10 +2495,10 @@ void *W_CachePatchLongName(const char *name, INT32 tag)
{
lumpnum_t num;
- num = W_CheckNumForLongName(name);
+ num = W_CheckNumForLongPatchName(name);
if (num == LUMPERROR)
- return W_CachePatchNum(W_GetNumForLongName("MISSING"), tag);
+ return W_CachePatchNum(W_GetNumForLongPatchName("MISSING"), tag);
return W_CachePatchNum(num, tag);
}
#ifndef NOMD5
diff --git a/src/w_wad.h b/src/w_wad.h
index e043e4d62c82f061ce505c4ce6b6a2298d48a4ec..3dcb9b6e8bbc6ee11669f473e9395a0006f84db0 100644
--- a/src/w_wad.h
+++ b/src/w_wad.h
@@ -180,6 +180,8 @@ UINT16 W_CheckNumForMarkerStartPwad(const char *name, UINT16 wad, UINT16 startlu
UINT16 W_CheckNumForFullNamePK3(const char *name, UINT16 wad, UINT16 startlump);
UINT16 W_CheckNumForFolderStartPK3(const char *name, UINT16 wad, UINT16 startlump);
UINT16 W_CheckNumForFolderEndPK3(const char *name, UINT16 wad, UINT16 startlump);
+char *W_GetLumpFolderPathPK3(UINT16 wad, UINT16 lump);
+char *W_GetLumpFolderNamePK3(UINT16 wad, UINT16 lump);
void W_GetFolderLumpsPwad(const char *name, UINT16 wad, UINT32 **list, UINT16 *list_capacity, UINT16 *numlumps);
void W_GetFolderLumps(const char *name, UINT32 **list, UINT16 *list_capacity, UINT16 *numlumps);
@@ -191,6 +193,12 @@ lumpnum_t W_CheckNumForName(const char *name);
lumpnum_t W_CheckNumForLongName(const char *name);
lumpnum_t W_GetNumForName(const char *name); // like W_CheckNumForName but I_Error on LUMPERROR
lumpnum_t W_GetNumForLongName(const char *name);
+
+lumpnum_t W_CheckNumForPatchName(const char *name);
+lumpnum_t W_CheckNumForLongPatchName(const char *name);
+lumpnum_t W_GetNumForPatchName(const char *name); // like W_CheckNumForPatchName but I_Error on LUMPERROR
+lumpnum_t W_GetNumForLongPatchName(const char *name);
+
lumpnum_t W_CheckNumForNameInBlock(const char *name, const char *blockstart, const char *blockend);
UINT8 W_LumpExists(const char *name); // Lua uses this.