3rdparty: nanogl: update

made contributing.md actually readable

.clang-format

@@ -0,0 +1,113 @@
+Language: Cpp
+Standard: c++17
+UseTab: ForContinuationAndIndentation
+TabWidth: 4
+IndentWidth: 4
+ContinuationIndentWidth: 4
+IndentCaseLabels: false
+IndentPPDirectives: None
+NamespaceIndentation: None
+AccessModifierOffset: -4
+IndentAccessModifiers: false
+BreakBeforeBraces: Custom
+BraceWrapping:
+  AfterCaseLabel: true
+  AfterClass: true
+  AfterControlStatement: Always
+  AfterEnum: true
+  AfterFunction: true
+  AfterNamespace: true
+  AfterStruct: true
+  AfterUnion: true
+  AfterExternBlock: false
+  BeforeCatch: true
+  BeforeElse: true
+  BeforeWhile: true
+  IndentBraces: false
+  SplitEmptyFunction: false
+  SplitEmptyRecord: false
+  SplitEmptyNamespace: false
+MaxEmptyLinesToKeep: 2
+KeepEmptyLinesAtTheStartOfBlocks: false
+KeepEmptyLinesAtEOF: false
+SeparateDefinitionBlocks: Always
+InsertNewlineAtEOF: true
+LineEnding: LF
+AllowAllArgumentsOnNextLine: true
+AllowAllParametersOfDeclarationOnNextLine: true
+BinPackArguments: true
+BinPackParameters: true
+AlwaysBreakAfterReturnType: None
+AlwaysBreakAfterDefinitionReturnType: None
+AllowShortFunctionsOnASingleLine: None
+AllowShortBlocksOnASingleLine: Empty
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortIfStatementsOnASingleLine: Never
+AllowShortLoopsOnASingleLine: false
+AllowShortEnumsOnASingleLine: false
+BreakBeforeBinaryOperators: All
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializers: BeforeColon
+PointerAlignment: Right
+DerivePointerAlignment: false
+ReferenceAlignment: Pointer
+SpaceAroundPointerQualifiers: Default
+SpacesInParens: Custom
+SpacesInParensOptions:
+  ExceptDoubleParentheses: true
+  InCStyleCasts: false
+  InConditionalStatements: true
+  InEmptyParentheses: false
+  Other: true
+# XashCollapseParens: true
+SpaceBeforeParens: Never
+SpaceAfterCStyleCast: false
+SpaceAfterLogicalNot: false
+SpaceAfterTemplateKeyword: true
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeCaseColon: false
+SpaceBeforeCpp11BracedList: false
+SpaceBeforeCtorInitializerColon: true
+SpaceBeforeInheritanceColon: true
+SpaceBeforeRangeBasedForLoopColon: true
+SpaceBeforeSquareBrackets: false
+SpaceInEmptyBlock: false
+SpacesInAngles: Never
+SpacesInContainerLiterals: false
+SpacesInSquareBrackets: false
+Cpp11BracedListStyle: false
+SpacesBeforeTrailingComments: 1
+SpacesInLineCommentPrefix:
+  Minimum: 1
+  Maximum: -1
+AlignAfterOpenBracket: DontAlign
+AlignArrayOfStructures: None
+AlignConsecutiveAssignments:
+  Enabled: false
+  AcrossEmptyLines: false
+  AcrossComments: false
+AlignConsecutiveBitFields:
+  Enabled: false
+  AcrossEmptyLines: false
+  AcrossComments: false
+AlignConsecutiveDeclarations:
+  Enabled: false
+  AcrossEmptyLines: false
+  AcrossComments: false
+  AlignCompound: false
+AlignConsecutiveMacros:
+  Enabled: true
+  AcrossEmptyLines: false
+  AcrossComments: false
+AlignEscapedNewlines: Left
+AlignOperands: Align
+AlignTrailingComments:
+  Kind: Always
+  OverEmptyLines: 0
+ColumnLimit: 0
+ReflowComments: false
+SortIncludes: Never
+SortUsingDeclarations: false
+InsertBraces: false
+RemoveBracesLLVM: false
+FixNamespaceComments: false

.github/workflows/c-cpp.yml

@@ -70,6 +70,7 @@ jobs:
     env:
       SDL_VERSION: 2.32.10
       FFMPEG_VERSION: 8.1
+      YY_THUNKS_VERSION: v1.2.1
       GH_CPU_ARCH: ${{ matrix.targetarch }}
       GH_CPU_OS: ${{ matrix.targetos }}
       GH_CROSSCOMPILING: ${{ matrix.cross }}

.gitignore

@@ -361,3 +361,16 @@ cmake-build-*
 3rdparty/SDL
 3rdparty/hlsdk-portable
 !scripts/build-ninja.py
+
+# slop
+CLAUDE.md
+AGENTS.md
+GEMINI.md
+.claude/
+.gemini/
+.cursor*
+.windsurf*
+.aider*
+.continue/
+.codeium/
+.github/copilot-instructions.md

.gitmodules

@@ -43,3 +43,6 @@
 [submodule "3rdparty/library_suffix"]
 	path = 3rdparty/library_suffix
 	url = https://github.com/FWGS/library-suffix.git
+[submodule "3rdparty/mbedtls/mbedtls"]
+	path = 3rdparty/mbedtls/mbedtls
+	url = https://github.com/FWGS/mbedtls-releases.git

3rdparty/extras/wscript

@@ -23,6 +23,6 @@ def build(bld):
 
 	bld(features='zip',
 		name = 'extras.pk3',
-		files = srcdir.ant_glob('**/*'),
+		files = srcdir.ant_glob('**/*', excl=['scripts/**']),
 		relative_to = srcdir,
 		install_path = install_path)

3rdparty/gl4es/wscript

@@ -16,6 +16,8 @@ def build(bld):
 	cflags = []
 	if bld.env.COMPILER_CC != 'msvc':
 		cflags += ['-w', '-fvisibility=hidden', '-std=gnu99']
+	else:
+		cflags += ['-wd4098']
 	bld.stlib(source   = gl4es_srcdir.ant_glob(['gl/*.c', 'gl/*/*.c', 'glx/hardext.c']),
 		target   = 'gl4es',
 		includes = ['gl4es/src', 'gl4es/src/gl', 'gl4es/src/glx', 'gl4es/include'],

3rdparty/mbedtls/compat.c

@@ -0,0 +1,107 @@
+/*
+compat.c - mbedTLS platform overrides for targets upstream doesn't cover
+Copyright (C) 2026 Xash3D FWGS contributors
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+*/
+
+/*
+WinXP: legacy CryptGenRandom via advapi32
+Source: ttps://learn.microsoft.com/en-us/windows/win32/api/wincrypt/nf-wincrypt-cryptgenrandom
+
+PSVita: sceKernelGetRandomNumber from psp2/kernel/rng.h (64-byte cap).
+Source: https://github.com/vitasdk/vita-headers/blob/master/include/psp2/kernel/rng.h
+
+NSwitch: randomGet from libnx.
+Source: https://github.com/switchbrew/libnx/blob/master/nx/include/switch/kernel/random.h
+*/
+
+#include "mbedtls/platform.h"
+#include "psa/crypto.h"
+
+#if defined( MBEDTLS_PLATFORM_MS_TIME_ALT )
+
+mbedtls_ms_time_t mbedtls_ms_time( void )
+{
+	extern double Platform_DoubleTime( void );
+
+	return (mbedtls_ms_time_t)( Platform_DoubleTime() * 1000.0 );
+}
+
+#endif /* MBEDTLS_PLATFORM_MS_TIME_ALT */
+
+#if defined( MBEDTLS_PSA_DRIVER_GET_ENTROPY )
+#if defined( _WIN32 ) && !defined( _WIN64 )
+#include <windows.h>
+#include <wincrypt.h>
+int mbedtls_platform_get_entropy( psa_driver_get_entropy_flags_t flags, size_t *estimate_bits, unsigned char *output, size_t output_size )
+{
+	if( flags != 0 )
+		return PSA_ERROR_NOT_SUPPORTED;
+
+	HCRYPTPROV prov;
+	if( !CryptAcquireContextW( &prov, NULL, NULL, PROV_RSA_FULL,
+		CRYPT_VERIFYCONTEXT | CRYPT_SILENT ))
+		return PSA_ERROR_INSUFFICIENT_ENTROPY;
+
+	if( !CryptGenRandom( prov, (DWORD)output_size, output ))
+	{
+		CryptReleaseContext( prov, 0 );
+		return PSA_ERROR_INSUFFICIENT_ENTROPY;
+	}
+
+	CryptReleaseContext( prov, 0 );
+	*estimate_bits = 8 * output_size;
+	return 0;
+}
+#elif defined( __vita__ )
+#include <psp2/kernel/rng.h>
+
+int mbedtls_platform_get_entropy( psa_driver_get_entropy_flags_t flags, size_t *estimate_bits, unsigned char *output, size_t output_size )
+{
+	if( flags != 0 )
+		return PSA_ERROR_NOT_SUPPORTED;
+
+	size_t total = 0;
+	while( total < output_size )
+	{
+		size_t chunk = output_size - total;
+
+		if( chunk > 64 )
+			chunk = 64;
+
+		if( sceKernelGetRandomNumber( output + total, chunk ) != 0 )
+			return PSA_ERROR_INSUFFICIENT_ENTROPY;
+
+		total += chunk;
+	}
+
+	*estimate_bits = 8 * output_size;
+	return 0;
+}
+
+#elif defined( __SWITCH__ )
+#include <switch.h>
+
+int mbedtls_platform_get_entropy( psa_driver_get_entropy_flags_t flags, size_t *estimate_bits, unsigned char *output, size_t output_size )
+{
+	if( flags != 0 )
+		return PSA_ERROR_NOT_SUPPORTED;
+
+	randomGet( output, output_size );
+	*estimate_bits = 8 * output_size;
+	return 0;
+}
+#else
+#error "MBEDTLS_PSA_DRIVER_GET_ENTROPY enabled but no platform impl in compat.c"
+#endif
+
+#endif /* MBEDTLS_PSA_DRIVER_GET_ENTROPY */

3rdparty/mbedtls/wscript

@@ -0,0 +1,67 @@
+#! /usr/bin/env python
+# encoding: utf-8
+
+def options(opt):
+	grp = opt.add_option_group('mbedTLS options')
+	grp.add_option('--disable-mbedtls', action='store_false', dest='MBEDTLS', default=True,
+		help='disable bundled mbedTLS and built-in HTTPS support [default: enabled]')
+
+def configure(conf):
+	conf.env.MBEDTLS = conf.options.MBEDTLS
+	if not conf.env.MBEDTLS:
+		return
+
+	if not conf.path.find_dir('mbedtls') or not conf.path.find_dir('mbedtls/library'):
+		conf.fatal('Can\'t find mbedtls submodule. Run `git submodule update --init --recursive`.')
+
+	if not conf.path.find_dir('mbedtls/tf-psa-crypto/core'):
+		conf.fatal('mbedTLS nested submodule tf-psa-crypto is missing. Run `git submodule update --init --recursive`.')
+
+def build(bld):
+	if not bld.env.MBEDTLS:
+		return
+
+	sources = bld.path.ant_glob([
+		'mbedtls/library/*.c',
+		'mbedtls/tf-psa-crypto/core/*.c',
+		'mbedtls/tf-psa-crypto/extras/*.c',
+		'mbedtls/tf-psa-crypto/platform/*.c',
+		'mbedtls/tf-psa-crypto/utilities/*.c',
+		'mbedtls/tf-psa-crypto/drivers/builtin/src/*.c',
+	])
+
+	sources += ['compat.c']
+
+	defines = [
+		'MBEDTLS_USER_CONFIG_FILE="xash_mbedtls_config.h"',
+		'TF_PSA_CRYPTO_USER_CONFIG_FILE="xash_psa_config.h"',
+	]
+
+	includes = [
+		'.',
+		'mbedtls/include',
+		'mbedtls/library',
+		'mbedtls/tf-psa-crypto/include',
+		'mbedtls/tf-psa-crypto/drivers/builtin/include',
+		'mbedtls/tf-psa-crypto/core',
+		'mbedtls/tf-psa-crypto/drivers/builtin/src',
+		'mbedtls/tf-psa-crypto/utilities',
+		'mbedtls/tf-psa-crypto/extras',
+		'mbedtls/tf-psa-crypto/platform',
+		'mbedtls/tf-psa-crypto/dispatch',
+	]
+
+	bld.stlib(
+		source = sources,
+		target = 'mbedtls',
+		features = 'c',
+		includes = includes,
+		defines = defines,
+		export_defines = ['XASH_MBEDTLS'],
+		export_includes = [
+			'.',
+			'mbedtls/include',
+			'mbedtls/tf-psa-crypto/include',
+			'mbedtls/tf-psa-crypto/drivers/builtin/include',
+		]
+	)

3rdparty/mbedtls/xash_mbedtls_config.h

@@ -0,0 +1,36 @@
+#ifndef XASH_MBEDTLS_CONFIG_H
+#define XASH_MBEDTLS_CONFIG_H
+
+#undef MBEDTLS_NET_C
+#undef MBEDTLS_PKCS7_C
+#undef MBEDTLS_TIMING_C
+#undef MBEDTLS_SSL_SRV_C
+#undef MBEDTLS_SSL_PROTO_DTLS
+#undef MBEDTLS_SSL_DTLS_ANTI_REPLAY
+#undef MBEDTLS_SSL_DTLS_CONNECTION_ID
+#undef MBEDTLS_SSL_DTLS_HELLO_VERIFY
+#undef MBEDTLS_SSL_DTLS_SRTP
+#undef MBEDTLS_SSL_DTLS_CLIENT_PORT_REUSE
+#undef MBEDTLS_SSL_COOKIE_C
+#undef MBEDTLS_SSL_CACHE_C
+#undef MBEDTLS_SSL_TICKET_C
+#undef MBEDTLS_SSL_SESSION_TICKETS
+#undef MBEDTLS_SSL_RENEGOTIATION
+#undef MBEDTLS_SSL_CONTEXT_SERIALIZATION
+#undef MBEDTLS_SSL_KEYING_MATERIAL_EXPORT
+#undef MBEDTLS_SSL_MAX_FRAGMENT_LENGTH
+#undef MBEDTLS_SSL_ALL_ALERT_MESSAGES
+#undef MBEDTLS_SSL_ALPN
+#undef MBEDTLS_SSL_ENCRYPT_THEN_MAC
+#undef MBEDTLS_KEY_EXCHANGE_PSK_ENABLED
+#undef MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED
+#undef MBEDTLS_SSL_TLS1_3_KEY_EXCHANGE_MODE_PSK_ENABLED
+#undef MBEDTLS_SSL_TLS1_3_KEY_EXCHANGE_MODE_PSK_EPHEMERAL_ENABLED
+#undef MBEDTLS_X509_CREATE_C
+#undef MBEDTLS_X509_CRT_WRITE_C
+#undef MBEDTLS_X509_CSR_PARSE_C
+#undef MBEDTLS_X509_CSR_WRITE_C
+#undef MBEDTLS_X509_CRL_PARSE_C
+#undef MBEDTLS_VERSION_FEATURES
+
+#endif /* XASH_MBEDTLS_CONFIG_H */

3rdparty/mbedtls/xash_psa_config.h

@@ -0,0 +1,82 @@
+#ifndef XASH_PSA_CONFIG_H
+#define XASH_PSA_CONFIG_H
+
+#if (defined( _WIN32 ) && !defined( _WIN64 )) || defined( __vita__ ) || defined( __SWITCH__ )
+/* WinXP, PSVita and NSwitch use entropy paths upstream doesn't cover.
+   compat.c provides mbedtls_platform_get_entropy() for all three. */
+#undef MBEDTLS_PSA_BUILTIN_GET_ENTROPY
+#define MBEDTLS_PSA_DRIVER_GET_ENTROPY
+#endif
+
+#if defined( __vita__ ) || defined( __SWITCH__ )
+/* Upstream has no Vita/NSW support; compat.c fills in */
+#define MBEDTLS_PLATFORM_MS_TIME_ALT
+#endif
+
+#undef MBEDTLS_FS_IO
+#undef MBEDTLS_PSA_ITS_FILE_C
+#undef MBEDTLS_PSA_CRYPTO_STORAGE_C
+#undef MBEDTLS_SELF_TEST
+#undef MBEDTLS_HMAC_DRBG_C
+#undef MBEDTLS_LMS_C
+#undef MBEDTLS_NIST_KW_C
+#undef MBEDTLS_PKCS5_C
+
+#undef PSA_WANT_ALG_CCM
+#undef PSA_WANT_ALG_CCM_STAR_NO_TAG
+#undef PSA_WANT_ALG_CBC_NO_PADDING
+#undef PSA_WANT_ALG_CBC_PKCS7
+#undef PSA_WANT_ALG_CFB
+#undef PSA_WANT_ALG_CMAC
+#undef PSA_WANT_ALG_CTR
+#undef PSA_WANT_ALG_ECB_NO_PADDING
+#undef PSA_WANT_ALG_OFB
+#undef PSA_WANT_ALG_STREAM_CIPHER
+#undef PSA_WANT_ALG_JPAKE
+#undef PSA_WANT_ALG_TLS12_ECJPAKE_TO_PMS
+#undef PSA_WANT_ALG_TLS12_PSK_TO_MS
+#undef PSA_WANT_ALG_FFDH
+#undef PSA_WANT_ALG_PBKDF2_HMAC
+#undef PSA_WANT_ALG_PBKDF2_AES_CMAC_PRF_128
+#undef PSA_WANT_KEY_TYPE_PASSWORD
+#undef PSA_WANT_KEY_TYPE_PASSWORD_HASH
+#undef PSA_WANT_ALG_SHA3_224
+#undef PSA_WANT_ALG_SHA3_256
+#undef PSA_WANT_ALG_SHA3_384
+#undef PSA_WANT_ALG_SHA3_512
+#undef PSA_WANT_ALG_SHAKE128
+#undef PSA_WANT_ALG_SHAKE256
+#undef PSA_WANT_ALG_SHA_224
+#undef PSA_WANT_ALG_SHA_1
+#undef PSA_WANT_ALG_MD5
+#undef PSA_WANT_ALG_RIPEMD160
+#undef PSA_WANT_KEY_TYPE_ARIA
+#undef PSA_WANT_KEY_TYPE_CAMELLIA
+#undef PSA_WANT_ECC_BRAINPOOL_P_R1_256
+#undef PSA_WANT_ECC_BRAINPOOL_P_R1_384
+#undef PSA_WANT_ECC_BRAINPOOL_P_R1_512
+#undef PSA_WANT_ECC_SECP_K1_256
+#undef PSA_WANT_ECC_MONTGOMERY_448
+#undef PSA_WANT_ECC_SECP_R1_521
+#undef PSA_WANT_DH_RFC7919_2048
+#undef PSA_WANT_DH_RFC7919_3072
+#undef PSA_WANT_DH_RFC7919_4096
+#undef PSA_WANT_DH_RFC7919_6144
+#undef PSA_WANT_DH_RFC7919_8192
+#undef PSA_WANT_KEY_TYPE_DH_KEY_PAIR_BASIC
+#undef PSA_WANT_KEY_TYPE_DH_KEY_PAIR_EXPORT
+#undef PSA_WANT_KEY_TYPE_DH_KEY_PAIR_GENERATE
+#undef PSA_WANT_KEY_TYPE_DH_KEY_PAIR_IMPORT
+#undef PSA_WANT_KEY_TYPE_DH_PUBLIC_KEY
+#undef PSA_WANT_KEY_TYPE_ECC_KEY_PAIR_EXPORT
+#undef PSA_WANT_KEY_TYPE_ECC_KEY_PAIR_IMPORT
+#undef PSA_WANT_KEY_TYPE_RSA_KEY_PAIR_EXPORT
+#undef PSA_WANT_KEY_TYPE_RSA_KEY_PAIR_GENERATE
+#undef PSA_WANT_KEY_TYPE_RSA_KEY_PAIR_IMPORT
+#undef MBEDTLS_PEM_WRITE_C
+#undef MBEDTLS_PK_WRITE_C
+#undef MBEDTLS_PK_PARSE_EC_COMPRESSED
+#undef MBEDTLS_PK_PARSE_EC_EXTENDED
+#undef MBEDTLS_ASN1_WRITE_C
+
+#endif /* XASH_PSA_CONFIG_H */

3rdparty/yy-thunks/wscript

@@ -0,0 +1,59 @@
+#! /usr/bin/env python
+# encoding: utf-8
+
+import hashlib
+from waflib import Task, TaskGen, Logs
+
+OBJ_NAME = 'YY_Thunks_for_WinXP.obj'
+OBJ_SHA256 = '51a13c4b667c82181d357e274a50308a273be63f5f85ae958465774857721573'
+DLL_LINKFLAGS = ['-ENTRY:DllMainCRTStartupForYY_Thunks', '-alternatename:_YY_ThunksOriginalDllMainCRTStartup@12=__DllMainCRTStartup@12']
+
+class copy_yy_thunks(Task.Task):
+	color = 'CYAN'
+	def run(self):
+		return self.outputs[0].write(self.inputs[0].read('rb'), 'wb')
+
+@TaskGen.feature('yy_thunks')
+def add_yy_thunks_obj(self):
+	src = self.path.find_node(OBJ_NAME)
+	out = self.path.find_or_declare(OBJ_NAME)
+	self.compiled_tasks = [self.create_task('copy_yy_thunks', src, out)]
+
+@TaskGen.feature('cshlib', 'cxxshlib')
+@TaskGen.after_method('process_use')
+def apply_yy_thunks_dll(self):
+	if 'yy_thunks' not in self.to_list(getattr(self, 'use', [])):
+		return
+
+	try:
+		self.bld.get_tgen_by_name('yy_thunks')
+	except Exception:
+		return
+	self.env.append_value('LINKFLAGS', DLL_LINKFLAGS)
+
+def options(opt):
+	pass
+
+def configure(conf):
+	if conf.env.DEST_OS != 'win32' or conf.env.COMPILER_CC != 'msvc':
+		return
+
+	if conf.env.MSVC_TARGETS[0] not in ['amd64_x86', 'x86']:
+		return
+
+	obj = conf.path.find_node(OBJ_NAME)
+	if not obj:
+		Logs.warn('YY-Thunks: %s not found, XP compatibility disabled' % OBJ_NAME)
+		return
+
+	with open(obj.abspath(), 'rb') as f:
+		digest = hashlib.sha256(f.read()).hexdigest()
+
+	if digest != OBJ_SHA256:
+		conf.fatal('%s checksum mismatch: expected %s, got %s' % (OBJ_NAME, OBJ_SHA256, digest))
+
+	conf.env.YY_THUNKS = True
+
+def build(bld):
+	if bld.env.YY_THUNKS:
+		bld(name='yy_thunks', features='yy_thunks')

CONTRIBUTING.md

@@ -1,53 +1,55 @@
 ## If you are reporting bugs
 
-1. Check you are using latest version. You can build latest Xash3D FWGS for yourself, look to README.md.
-2. Check open issues is your bug is already reported and closed issues if it reported and fixed. Don't send bug if it's already reported.
-3. Re-run engine with `-dev 2 -log` arguments, reproduce bug and post engine.log which can be found in your working directory.
-3. Describe steps to reproduce bug.
+1. Check that you are using the latest version. To build the latest Xash3D FWGS, look at README.md.
+2. Check the open issues to make sure your bug is not already reported and closed issues if it reported and fixed. Don't send a bug if it's already been reported.
+3. Re-run engine with `-dev 2 -log` arguments, then reproduce the bug and post `engine.log` which can be found in your working directory.
+3. Describe the steps to reproduce the bug.
 4. Describe which OS and architecture you are using.
-6. Attach screenshot if it will help clarify the situation.
+6. Attach a screenshot if it will help clarify the situation.
 
 ## If you are contributing code
 
 ### Which branch?
 
-* We recommend using `master` branch.
+* We recommend using the `master` branch.
 
 ### Third-party libraries
 
-* Philosophy of any Xash Project by Uncle Mike: don't be bloated. We follow it too.
-* Adding new library is allowed only if there is a REAL reason to use it. It's will be nice, if you will leave a possibility to remove new dependency at build-time.
-* Adding new dependencies for Waf Build System is not welcomed.
+* The philosophy of any Xash Project by Uncle Mike: don't be bloated. We follow it too.
+* Adding new libraries are allowed only if there is a REAL reason to use it. It will be nice, if you leave a possibility to remove the new dependency at build-time.
+* Adding new dependencies for the Waf Build System is not welcomed.
 
 ### Portability level
 
-* Xash3D have it's own crt library. It's recommended to use it. It most cases it's just a wrappers around standart C library.
-* If your feature need platform-specific code, move it to `engine/platform` and try to implement to every supported OS and every supported compiler or at least leave a stubs.
-* You must put it under appopriate macro. It's a rule: Xash3D FWGS must compile everywhere. For list of platforms we support, refer to public/build.h file.
+* Xash3D has it's own crt library. It's recommended to use it. In most cases it's just a wrapper around the standard C library.
+* If your feature needs platform-specific code, move it to `engine/platform` and try to implement every supported OS and every supported compiler or at least leave a stub.
+* You must put it under the appropriate macro. It's a rule: Xash3D FWGS must compile everywhere. For list of platforms we support, refer to `public/build.h`.
 
 ### Code style
 
-* This project uses mixed Quake's and HLSDK's C/C++ code style convention. 
+* This project uses a mix of Quake's and HLSDK's C/C++ code style convention. 
 * In short:
   * Use spaces in parenthesis, but not when two parentheses are consecutive.
-  * Only tabs for indentation.
+  * Use only tabs for indentation.
   * Any brace must have it's own line.
-  * Short blocks, if statements and loops on single line are allowed.
+  * Use short blocks, if statements and loops on single line are allowed.
   * Prefer generic utilities from libpublic over rolling your own.
   * Avoid magic numbers.
   * While macros are powerful, it's better to avoid overusing them.
-  * If you unsure, try to mimic code style from anywhere else of engine source code.
-* **ANY** commit message should start from declaring a tags, in format:
+  * If you are unsure, try to mimic the code style from anywhere else in the engine source code.
+* **ANY** commit message should start from declaring  tags, in the format:
   
   `tag: added some bugs`
   
   `tag: subtag: fixed some features`
   
-  Tags can be any: subsystem, simple feature name or even just a filename, without extension.
-  Just keep them always same, it helps keep history clean and commit messages short.
+  The tags can be a:
+  * subsystem
+  * simple feature name or even just a filename, without the extension.
+  Just always keep them the same because it helps keep the commit history clean and messages short.
 
 ## LLM-based tools usage.
 
 While we wouldn't recommend using any LLM-based (also misleadingly called AI) tools, we understand that they are here to stay.
 
-Whether you're reporting bug or contributing the code, you take complete authorship and responsibility over provided content and the same rules will apply to you as for everybody else, so validate the bug report or the patch before sending it.
+Whether you're reporting a bug or contributing to the code, you will take complete authorship and responsibility over the provided content, and the same rules will apply to you as for everybody else, so validate the bug report or the patch it before sending it.

Documentation/donate.md

@@ -29,9 +29,7 @@ Initial Xash3D SDL2/Linux port author, Xash3D FWGS engine maintainer, creator of
 
 ## [$_Vladislav](https://github.com/Vladislav4KZ)
 
-[YaPB Project](https://github.com/yapb) member, [Xash3D FWGS](https://github.com/FWGS/xash3d-fwgs) tester,
-editor of the [Official YaPB Documentation](https://github.com/yapb/docs) (in English and Russian), curator of the [YaPB Graph Database](https://github.com/yapb/graph) and author of [YaPB Waypoint/Graph Pack](https://gamebanana.com/mods/40087).
+[YaPB Project](https://github.com/yapb) member and [contributor](https://github.com/yapb/yapb/commits?author=Vladislav4KZ) ([Docs](https://github.com/yapb/docs), [Nav Graphs](https://github.com/yapb/graph), [RU translation](https://github.com/yapb/yapb/blob/master/cfg/addons/yapb/conf/lang/ru_lang.cfg)), Xash3D FWGS [tester](https://github.com/FWGS/xash3d-fwgs/issues?q=is%3Aissue%20state%3Aopen%20author%3AVladislav4KZ) and [contributor](https://github.com/FWGS/xash3d-fwgs/commits?author=Vladislav4KZ) (gyro-aim support, scr-parser, etc.), [CS16Client](https://github.com/Velaron/cs16-client) [contributor](https://github.com/Velaron/cs16-client/commits?author=Vladislav4KZ).
 
-Also does the Russian localization of text, images (gfx/shell), as well as additional menu buttons in English used in Xash3D FWGS for various mods.
-
-* [Boosty page](https://boosty.to/rasstaman1337)
+* [Boosty page](https://boosty.to/rasstaman1337)
+* [PayPal link](https://paypal.me/rasstaman1337)

Documentation/extensions/native-object.md

@@ -16,6 +16,7 @@ Only these objects are guaranteed to be available on all targets.
 |-------------|-----------|
 | `VFileSystem009` | Provides C++ interface to filesystem, binary-compatible with Valve's VFileSystem009. |
 | `XashFileSystemXXX` | Provides C interface to filesystem. This interface is unstable and not recommended for generic use, outside of engine internals. For more info about current version look into `filesystem.h`. |
+| `MenuFactory` | Returns a `CreateInterface` function pointer (`pfnCreateInterface_t`) for the currently loaded menu library. |
 
 #### Android-specific objects
 

Documentation/extensions/xrcon-protocol.md

@@ -0,0 +1,181 @@
+# XRCON Protocol Specification
+
+## Overview
+
+XRCON is a TCP-based remote console protocol implemented as a server within the engine. It provides an alternative to the legacy RCON (which operates over UDP as out-of-band packets). XRCON uses a framed binary protocol over a single persistent TCP connection, accepting at most one client at a time.
+
+Key characteristics:
+
+- Based on TCP (stream-oriented, reliable)
+- Default port is 27000
+- Maximum only one concurrent client
+- Binary framed protocol with a 12-byte header + variable-length payload
+
+
+
+## Configuration
+
+The XRCON server is controlled by two configuration variables, both restricted to privileged users:
+
+| Variable | Default | Description |
+|---|---|---|
+| `xrcon_enable` | `0` (disabled) | Master switch; when enabled, the server starts listening for connections |
+| `xrcon_address` | `127.0.0.1:27000` | Bind address and port; supports both IPv4 and IPv6. Changing this at runtime triggers a XRCON server restart (stop + rebind) |
+
+By default, XRCON binds only to localhost (`127.0.0.1`), providing a degree of access control. The server will not start listening until explicitly enabled.
+
+
+
+## Frame Format
+
+All XRCON messages are encapsulated in a framed binary format. Each frame consists of a fixed 12-byte header followed by a variable-length payload.
+
+### Header (12 bytes)
+
+| Offset | Size | Field | Description |
+|---|---|---|---|
+| 0 | 4 | Type | 4-character message type string (null-terminated, occupies 5 bytes in the structure but the 5th byte is padding) |
+| 4 | 4 | Version | Protocol version (32-bit unsigned integer, network byte order) |
+| 8 | 2 | Length | Total frame length in bytes, including the header (16-bit unsigned integer, network byte order) |
+| 10 | 2 | Handle | Handle or sequence number (16-bit unsigned integer, network byte order; currently always zero) |
+
+
+### Protocol Version
+
+The current protocol version is `0x000000D4` (212 decimal). The server also accepts `0x00D40000` for compatibility with certain third-party clients (e.g., CS2RemoteConsole).
+
+### Maximum Frame Size
+
+- Maximum payload per frame: 4096 bytes
+- Maximum total packet size (header + payload): approximately 4136 bytes
+- Receive buffer size: 4096 + 64 bytes
+- Transmit buffer size: 16384 bytes (4 × maximum frame size)
+
+### Byte Order
+
+Multi-byte integer fields (version, length, handle) are transmitted in **network byte order** (big-endian).
+
+
+
+## Message Types
+
+| Type | Direction | Description |
+|---|---|---|
+| `CMND` | Client → Server | Execute a console command |
+| `PRNT` | Server → Client | Console output / print message |
+| `CHAN` | Server → Client | Channel list (channel metadata) |
+| `AINF` | Server → Client | Application / server info |
+| `ADON` | Server → Client | Additional info / server name |
+
+### CMND — Client Command
+
+**Direction**: Client → Server
+
+Sent by the client to execute a console command on the server.
+
+| Section | Size | Description |
+|---|---|---|
+| Header | 12 bytes | Type = `"CMND"`, version, length, handle |
+| Payload | Variable | Raw command string (null-terminated) |
+
+The command string is injected into the engine's command buffer for execution. There is **no authentication** — any connected client may execute arbitrary commands.
+
+### PRNT — Server Print
+
+**Direction**: Server → Client
+
+Sent by the server to stream console output to the connected client.
+
+| Section | Size | Description |
+|---|---|---|
+| Header | 12 bytes | Type = `"PRNT"`, version, length, handle |
+| Channel ID | 4 bytes | Channel identifier (unsigned 32-bit integer; always 0 for "Console") |
+| Padding | 20 bytes | Reserved (5 × 32-bit unsigned integers, all zero) |
+| Red | 1 byte | Red color component (always 255) |
+| Green | 1 byte | Green color component (always 255) |
+| Blue | 1 byte | Blue color component (always 255) |
+| Alpha | 1 byte | Alpha / opacity component (always 255) |
+| Text | Variable | The console output text (up to 4096 bytes) |
+
+
+### CHAN — Channel List
+
+**Direction**: Server → Client
+
+Sent by the server during the initial handshake (and potentially later) to describe the available console output channels.
+
+| Section | Size | Description |
+|---|---|---|
+| Header | 12 bytes | Type = `"CHAN"`, version, length, handle |
+| Channel Count | 2 bytes | Number of channel records (unsigned 16-bit integer; always 1) |
+
+Each channel record (58 bytes):
+
+| Field | Size | Description |
+|---|---|---|
+| Channel ID | 4 bytes | Unique channel identifier (unsigned 32-bit integer; always 0) |
+| Unknown 1 | 4 bytes | Reserved (unsigned 32-bit integer; always 0) |
+| Unknown 2 | 4 bytes | Reserved (unsigned 32-bit integer; always 0) |
+| Default Verbosity | 4 bytes | Default verbosity level (unsigned 32-bit integer; always 5) |
+| Current Verbosity | 4 bytes | Current verbosity level (unsigned 32-bit integer; always 5) |
+| Red | 1 byte | Red color component for the channel (always 255) |
+| Green | 1 byte | Green color component (always 255) |
+| Blue | 1 byte | Blue color component (always 255) |
+| Alpha | 1 byte | Alpha component (always 255) |
+| Name | 34 bytes | Channel name string, null-padded (always `"Console"`) |
+
+Total payload size for this frame: 2 + 58 = 60 bytes.
+
+### AINF — Application Info
+
+**Direction**: Server → Client
+
+Sent by the server immediately after a client connects, before `ADON` and `CHAN`.
+
+| Section | Size | Description |
+|---|---|---|
+| Header | 12 bytes | Type = `"AINF"`, version, length, handle |
+| Payload | 77 bytes | All zeros (placeholder / reserved for structured application information) |
+
+This packet currently serves as a placeholder and contains no meaningful data. It may be extended in future versions to carry structured metadata about the server application.
+
+### ADON — Additional Info
+
+**Direction**: Server → Client
+
+Sent by the server immediately after `AINF` during the connection handshake.
+
+| Section | Size | Description |
+|---|---|---|
+| Header | 12 bytes | Type = `"ADON"`, version, length, handle |
+| Unknown | 2 bytes | Reserved (unsigned 16-bit integer; always 0) |
+| Name Length | 2 bytes | Length of the name string (unsigned 16-bit integer) |
+| Name | Variable | Server name / identifier string (e.g., `"HLDS"`) |
+
+This packet carries the server application name, which is a short string identifying the server type (e.g., `"HLDS"` for Half-Life Dedicated Server).
+
+
+
+## Security
+
+XRCON has **no built-in authentication or encryption**. There is no password validation or transport-layer security. Any client that can establish a TCP connection to the XRCON port has full command execution access to the engine console.
+
+The only security measures are:
+
+1. **Default localhost binding**: The server binds to `127.0.0.1` by default, accepting connections only from the local machine.
+2. **Disabled by default**: The `xrcon_enable` variable defaults to `0`, so the server does not listen unless explicitly enabled.
+3. **Privileged variables**: Both configuration variables are restricted to privileged users and cannot be modified through unprivileged console commands or external access.
+
+
+
+## Comparison with Legacy RCON
+
+| Feature | XRCON | Legacy RCON |
+|---|---|---|
+| Transport | TCP (stream) | UDP (datagram, out-of-band) |
+| Port | Configurable, default 27000 | Game port (default 27015) |
+| Framing | Binary frame header | Plain text over UDP |
+| Authentication | None | Password-based |
+| Max clients | 1 | Multiple |
+| Interaction format | Full console access | Request-response only for submitted command |
+| Supported environments | Client and server | Server only |

Documentation/opensource-mods.md

@@ -38,6 +38,9 @@ Mirrored on github - https://github.com/solidi/hl-mods/tree/master/cir
 ## Counter-Life
 Available on ModDB - https://www.moddb.com/mods/counter-life/downloads/cl-version-1-source-code
 
+## Crack-Life Anniversary Campaign
+Available on ModDB - https://www.moddb.com/mods/crack-life/downloads/crack-life-anniversary-campaign-sdk
+
 ## Cthulhu
 Uploaded to github by Oleg Cherkasky - https://github.com/gunrunners-paradise/Cthulhu-HLmod-SDK
 
@@ -62,11 +65,14 @@ Available on GamerLab - http://gamer-lab.com/eng/code_mods_goldsrc/Half-Life_2D_
 ## Gang Wars
 Mirrored on github - https://github.com/nekonomicon/gw1.45src
 
-## Go-mod
+## Go-Mod
 Versions 2.0 and 3.0, available in mod archives on ModDB - https://www.moddb.com/mods/go-mod/downloads
 
 Version 3.0, mirrored on github - https://github.com/nekonomicon/Go-mod30
 
+## Go-Mod: Reborn
+Official github repository - https://github.com/LambdaLuke87/Go-Mod-Reborn-Lite-Build
+
 ## GT mod
 Available on GamerLab - http://gamer-lab.com/eng/code_mods_goldsrc/GT_mod_(Polnie_ishodniki)
 
@@ -85,12 +91,21 @@ Available on ModDB - https://www.moddb.com/mods/half-life-echoes
 ## Half-Life: Expanded Arsenal
 Available on ModDB - https://www.moddb.com/mods/half-life-expanded-arsenal
 
+## Half-Life: Featureful
+Branch **featureful** in halflife-featureful - https://github.com/FreeSlave/halflife-featureful
+
 ## Half-Life: Field Intensity
 Branch **field_intensity_1.7** in halflife-featureful - https://github.com/FreeSlave/halflife-featureful/tree/field_intensity_1.7
 
 ## Half-Life: Gravgun mod
 Branch **gravgun** in hlsdk-portable - https://github.com/FWGS/hlsdk-portable/tree/gravgun
 
+## Half-Life: Induction
+Version 1.4: Branch **induction** in halflife-featureful - https://github.com/FreeSlave/halflife-featureful/tree/induction
+
+## Half-Life: Insecure
+Version 1.5 is available on ModDB - https://www.moddb.com/mods/half-life-insecure/downloads/half-life-insecure-map-tools-and-source-code-ver-15
+
 ## Half-Life: Invasion
 Official github repository - https://github.com/jlecorre/hlinvasion
 
@@ -100,6 +115,13 @@ Mirrored on github - https://github.com/solidi/hl-mods/tree/master/pong
 ## Half-Life: Quest Mode
 Available on cs-mapping.com.ua - https://old.cs-mapping.com.ua/forum/showthread.php?t=38030
 
+## Half-Life: Sum
+Original Version: Branch **sum_orig** in halflife-featureful - https://github.com/FreeSlave/halflife-featureful/tree/sum_orig
+
+Version 2022: Branch **sum_2022** in halflife-featureful - https://github.com/FreeSlave/halflife-featureful/tree/sum_2022
+
+Current Version: Branch **sum** in halflife-featureful - https://github.com/FreeSlave/halflife-featureful/tree/sum
+
 ## Half-Life: Top-Down
 Official gitlab repository - https://gitlab.com/Sockman/hltopdown
 
@@ -109,6 +131,9 @@ Official github repository - https://github.com/Fograin/hl-subsmod-ex
 ## Half-Life: Rally
 Official gitlab repository - https://gitlab.com/hlrally/src
 
+## Half-Life: Reprocessing
+Official github repository - https://github.com/EgorYak/ReprocessingSourceCode
+
 ## Half-Life: RXT
 Available on ModDB - https://www.moddb.com/mods/half-life-rxt/downloads/rxt-source-code-v57
 
@@ -147,6 +172,9 @@ Mirrored on github (Includes maps and models source files) - https://github.com/
 ## Ingram Chillin' Mod
 Official SourceForge repository - https://sourceforge.net/projects/icm-hl/
 
+## Intense Force
+Branch **intense_force** in halflife-featureful - https://github.com/FreeSlave/halflife-featureful/tree/intense_force
+
 ## Master Sword
 Official github repository of Master Sword Classic - https://github.com/BerntA/MasterSwordClassic
 
@@ -189,6 +217,9 @@ Available in Valve's Half-Life repository - https://github.com/ValveSoftware/hal
 ## Spirit of Half-Life
 [Logic&Trick's](https://github.com/LogicAndTrick) mirror - https://files.logic-and-trick.com/#/Half-Life/Mods/Spirit%20of%20Half-Life
 
+## The Last Bullet
+Official github repository - https://github.com/GT-Project-Cat/The-Last-Bullet-Updated-Code
+
 ## The Wastes
 Version 1.5: mirrored on code.idtech.space - https://code.idtech.space/vera/halflife-thewastes-sdk
 
@@ -212,6 +243,19 @@ Download page on official site - http://www.thothie.com/ww/
 ## Wrong Door
 Available on ModDB - https://www.moddb.com/mods/wrong-door/downloads/wrong-door-sdk
 
+## XDM
+*This mod is opensource but access to source code is always rebus*
+
+How to get sources of version 3.0.4.3:
+
+Download SFX-archive from ModDB - https://www.moddb.com/mods/xdm/downloads/xdm3043
+
+Extract it.
+
+Open client.dll in HEX-editor and patch header - change `Win!` to `Rar!`
+
+Extract it using unrar - password `iamtheone` 
+
 ## XashXT
 Mirrored on github - https://github.com/a1batross/XashXT_original
 
@@ -220,6 +264,12 @@ Mirrored on github - https://github.com/a1batross/XashXT_original
 
 [Logic&Trick's](https://github.com/LogicAndTrick) mirror - https://files.logic-and-trick.com/#/Half-Life/Mods/Spirit%20of%20Half-Life
 
+## Yet another PS2 Half-Life port
+Official github repository - https://github.com/supadupaplex/ya-ps2hl-dll
+
+## Zombie Panic!
+Official github repository - https://github.com/Monochrome-Inc/ZombiePanic-HL
+
 ## Zombie-X
 Available in mod archive on ModDB - https://www.moddb.com/mods/zombie-x-10-final/downloads/zombie-x-10-dle-beta6-last-version
 
@@ -301,7 +351,7 @@ Unkle Mike's recreation - https://hlfx.ru/forum/showthread.php?s=&threadid=5253
 Reverse-engineered code: branch **bshift** in hlsdk-portable - https://github.com/FWGS/hlsdk-portable/tree/bshift
 
 ## Half-Life: Induction
-Branch **induction** in hlsdk-portable - https://github.com/FWGS/hlsdk-portable/tree/induction
+Version 1.0-1.2: Branch **induction_1.2** in hlsdk-portable - https://github.com/FWGS/hlsdk-portable/tree/induction_1.2
 
 ## Half-Life: Opposing Force
 Recreation by lostgamer aka nillerusr - https://github.com/LostGamerHL/hlsdk-xash3d
@@ -375,6 +425,9 @@ Branch **aghl** in hlsdk-portable - https://github.com/FWGS/hlsdk-portable/tree/
 ## Bubblemod
 Branch **bubblemod** in hlsdk-portable - https://github.com/FWGS/hlsdk-portable/tree/bubblemod
 
+## Counter-Life
+Branch **counter-life** in hlsdk-portable - https://github.com/FWGS/hlsdk-portable/tree/counter-life
+
 ## Deathmatch Classic
 Deathmatch Classic: Adrenaline Gamer Edition - https://github.com/martinwebrant/agmod/tree/master/src/dmc
 
@@ -388,6 +441,9 @@ Branch **delta_particles** in hlsdk-portable - https://github.com/FWGS/hlsdk-por
 ## Half-Life: Echoes
 Branch **echoes** in hlsdk-portable - https://github.com/FWGS/hlsdk-portable/tree/echoes
 
+## Half-Life: Insecure
+Branch **insecure** in hlsdk-portable - https://github.com/FWGS/hlsdk-portable/tree/insecure
+
 ## Half-Life: Invasion
 Port to HLSDK 2.4 by malortie - https://github.com/HL1-Mods-Reimplementations-and-Ports/hl-invasion
 
@@ -421,6 +477,8 @@ Branch **dmc** in hlsdk-portable - https://github.com/FWGS/hlsdk-portable/tree/d
 ## Xen-Warrior
 Branch **sohl1.2** in hlsdk-portable - https://github.com/FWGS/hlsdk-portable/tree/sohl1.2
 
+## Yet another PS2 Half-Life port
+Branch **ps2hl** in hlsdk-portable - https://github.com/FWGS/hlsdk-portable/tree/ps2hl
+
 ## Zombie-X
 Branch **zombie-x** in hlsdk-portable - https://github.com/FWGS/hlsdk-portable/tree/zombie-x
-

Documentation/protocol/02-connectionless.md

@@ -12,14 +12,18 @@ All connectionless packets have `\xff\xff\xff\xff` (32-bit integer set to all on
 
 - [Any](#any)
   - [Any to Any](#any-to-any)
-    - [`A2A_NETINFO`](#a2a_netinfo)
-    - [`A2A_INFO`](#a2a_info)
     - [`A2A_PING` and `A2A_GOLDSRC_PING`](#a2a_ping-and-a2a_goldsrc_ping)
     - [`A2A_ACK` and `A2A_GOLDSRC_ACK`](#a2a_ack-and-a2a_goldsrc_ack)
+    - [Deprecated queries](#deprecated-queries)
+      - [`A2A_NETINFO`](#a2a_netinfo)
+      - [`A2A_INFO`](#a2a_info)
   - [Any to Client](#any-to-client)
     - [`A2C_PRINT` and `A2C_GOLDSRC_PRINT`](#a2c_print-and-a2c_goldsrc_print)
   - [Any to Server and Server to Any](#any-to-server-and-server-to-any)
-    - [`A2S_GOLDSRC_INFO`, `A2S_GOLDSRC_RULES` and `A2S_GOLDSRC_PLAYERS` and their responses](#a2s_goldsrc_info-a2s_goldsrc_rules-and-a2s_goldsrc_players-and-their-responses)
+    - [GoldSrc server queries](#goldsrc-server-queries)
+    - [`A2S_GOLDSRC_INFO`](#a2s_goldsrc_info)
+    - [`A2S_GOLDSRC_PLAYERS`](#a2s_goldsrc_players)
+    - [`A2S_GOLDSRC_RULES`](#a2s_goldsrc_rules)
   - [Any to Master](#any-to-master)
     - [`S2M_SCAN_REQUEST`](#s2m_scan_request)
   - [Master to Any](#master-to-any)
@@ -50,7 +54,23 @@ All connectionless packets have `\xff\xff\xff\xff` (32-bit integer set to all on
 
 ### Any to Any
 
-#### `A2A_NETINFO`
+#### `A2A_PING` and `A2A_GOLDSRC_PING`
+
+Simple ping message.
+* Request, in ASCII: `ping` or `i` in GoldSrc format
+* Response is always `A2A_ACK` or `A2A_GOLDSRC_ACK`
+
+#### `A2A_ACK` and `A2A_GOLDSRC_ACK`
+
+Simple ack message.
+* Request, in ASCII: `ack` or `j` in GoldSrc format
+* Response: none
+
+#### Deprecated queries
+
+These text-based Xash protocol queries are deprecated in favor of [GoldSrc server queries](#goldsrc-server-queries), which Xash3D FWGS servers implement as well. New implementations must not send them. The server still responds to `A2A_INFO` for compatibility with older clients, `A2A_NETINFO` is not handled anymore.
+
+##### `A2A_NETINFO`
 
 Used to implement Half-Life's NetAPI. 
 * Request message, in ASCII: `netinfo <version> <context> <request_id>`
@@ -81,7 +101,7 @@ Possible requests and response formats:
 * On any other server will respond with `neterror` set to `undefined`
 * If protocol version doesn't match, server responds with `neterror` set to `protocol`
 
-#### `A2A_INFO`
+##### `A2A_INFO`
 
 Used to request server's details.
 * Request message, in ASCII: `info <version>`
@@ -101,18 +121,6 @@ Used to request server's details.
   - `password` set to 1 if server is protected with password otherwise 0
   - `host` is server's name
 
-#### `A2A_PING` and `A2A_GOLDSRC_PING`
-
-Simple ping message.
-* Request, in ASCII: `ping` or `i` in GoldSrc format
-* Response is always `A2A_ACK` or `A2A_GOLDSRC_ACK`
-
-#### `A2A_ACK` and `A2A_GOLDSRC_ACK`
-
-Simple ack message.
-* Request, in ASCII: `ack` or `j` in GoldSrc format
-* Response: none
-
 ### Any to Client
 
 #### `A2C_PRINT` and `A2C_GOLDSRC_PRINT`
@@ -124,9 +132,62 @@ Simple print message.
 
 ### Any to Server and Server to Any
 
-#### `A2S_GOLDSRC_INFO`, `A2S_GOLDSRC_RULES` and `A2S_GOLDSRC_PLAYERS` and their responses
+#### GoldSrc server queries
 
-These match Source Engine Query messages used in GoldSrc and Source engine and implemented for compatibility with existing tools. Read documentation for them on VDC: https://developer.valvesoftware.com/wiki/Server_queries
+These match Source Engine Query messages used in GoldSrc and Source engine and implemented for compatibility with existing server browsers and monitoring tools. The client uses them to query GoldSrc servers in the server browser, and as text-based Xash protocol queries are [deprecated](#deprecated-queries), it will use them to query Xash servers as well. Read documentation for them on VDC: https://developer.valvesoftware.com/wiki/Server_queries
+
+Unlike other connectionless messages these are binary: integers are little-endian, floats are 32-bit IEEE 754 and strings are null-terminated.
+
+`A2S_GOLDSRC_PLAYERS` and `A2S_GOLDSRC_RULES` requests carry a 32-bit challenge, `A2S_GOLDSRC_INFO` may have one appended after the query string. When no challenge is known yet, `\xff\xff\xff\xff` is sent in it's place. The server may answer with a challenge instead of the data: byte `A` (`0x41`) followed by a 32-bit challenge value, 9 bytes total with the header. The request is then repeated with the received challenge. Don't confuse this message with textual `S2C_GOLDSRC_CHALLENGE` used during connection, they only share the first byte.
+
+Responses that don't fit into a single packet (usually rules) come from GoldSrc servers split into fragments. Such packets start with `\xfe\xff\xff\xff` instead of `\xff\xff\xff\xff`, followed by a 32-bit sequence number, same in all fragments of one response, and a byte with total fragment count in the lower 4 bits and this fragment's index in the upper 4 bits. Fragment payloads concatenated in index order form a normal `\xff\xff\xff\xff` message. Xash servers never split query responses and send them as single datagrams.
+
+#### `A2S_GOLDSRC_INFO`
+
+Used to request server's details.
+
+* Request: `TSource Engine Query\0`, optionally followed by a 32-bit challenge. Xash servers ignore it.
+* Response: byte `I` (`S2A_GOLDSRC_INFO`), followed by:
+  - byte: protocol version, 48 on GoldSrc, 49 on Xash3D FWGS
+  - string: server's name
+  - string: server's current level
+  - string: game directory name
+  - string: game description
+  - int16: Steam AppID, always 0 on Xash servers
+  - byte: total player count, bots included
+  - byte: max players limit
+  - byte: bot count
+  - byte: server type, `d` for dedicated or `l` for listen server
+  - byte: server's operating system, `w` for Windows, `l` for Linux, `m` for macOS
+  - byte: set to 1 if server is protected with password otherwise 0
+  - byte: set to 1 if server is VAC secured, Xash servers put the `secure` value from gameinfo here
+  - string: server's version
+
+Same as the Source engine response format but without the extra data flag and its fields.
+
+Legacy GoldSrc servers respond with the obsolete `m` format (`S2A_GOLDSRC_LEGACY_INFO`) instead, see VDC for its layout. Xash servers never send it but the client understands it and assumes protocol 48.
+
+#### `A2S_GOLDSRC_PLAYERS`
+
+Used to request server's player list.
+
+* Request: byte `U` (`0x55`), then a 32-bit challenge.
+* Response: byte `D` (`S2A_GOLDSRC_PLAYERS`), followed by a byte with total player count, then for each player:
+  - byte: player's index. Xash servers send sequential indexes starting from 0, GoldSrc servers always send 0 here.
+  - string: player's name
+  - int32: player's kill count
+  - float: time in seconds the player is connected, -1.0 for bots on Xash servers
+
+Xash server doesn't respond at all if the player list is empty, the server is protected with password or exposing the player list is disabled with `sv_expose_player_list` cvar.
+
+#### `A2S_GOLDSRC_RULES`
+
+Used to request server's game rules.
+
+* Request: byte `V` (`0x56`), then a 32-bit challenge.
+* Response: byte `E` (`S2A_GOLDSRC_RULES`), followed by an int16 with total rule count, then rule name and rule value strings for each.
+
+Only server cvars (`FCVAR_SERVER`) are sent. Values of protected cvars (`FCVAR_PROTECTED`) are replaced with `1` if the value is set otherwise `0`. If there are no cvars to expose, server doesn't respond at all.
 
 ### Any to Master
 
@@ -154,7 +215,7 @@ These match Source Engine Query messages used in GoldSrc and Source engine and i
   - `reserved` is single reserved 8-bit byte
   - Following is list of IP addresses in binary form: 6-bytes for IPv4 address + port and 18-bytes for IPv6 address + port
   - If port is 0, it means the end of list, otherwise it's the last IP used for pagination (not implemented in Xash3D)
-* Response: client doesn't make response to master server but might request `A2S_INFO` from servers
+* Response: client doesn't make response to master server but might request `A2S_GOLDSRC_INFO` from servers
 
 ## Master and game server
 

Documentation/protocol/http-server-list.md

@@ -0,0 +1,72 @@
+# Static HTTP server list
+
+Replacement for the UDP `S2M_SCAN_REQUEST` / `M2A_SERVERSLIST` exchange
+described in [02-connectionless.md](02-connectionless.md). Read-only HTTP,
+no NAT punching, no filtering or pagination in the request.
+
+## URL
+
+`xashcomm.lst` carries a base URL per source:
+
+```
+masterstatic http://master.example.org/server-list
+```
+
+The engine appends `/v1/servers/<gamedir>` and `GET`s the result. For
+`gamedir = valve`:
+
+```
+GET http://master.example.org/server-list/v1/servers/valve
+```
+
+Trailing slashes on the base URL are stripped. Multiple `masterstatic`
+lines are allowed; results are merged.
+
+The request is bare: no body, no auth, no cookies, no compressed encodings.
+Only the standard `User-Agent` is set. `POST` / `PUT` / `DELETE` are not
+used; servers register out of band.
+
+## Response
+
+UTF-8 text, parsed line by line. Each line is tokenized with
+`COM_ParseFileSafe` (whitespace separates, `//` and `#` start line
+comments, `"..."` quotes a token). Blank lines and comment-only lines
+are ignored. One directive per line:
+
+* `ip <address>` — Xash3D server (protocol 49).
+* `gs <address>` — GoldSrc server (protocol 48).
+
+`<address>` is parsed by `NET_StringToAdr` (`1.2.3.4:27015`,
+`[2001:db8::1]:27015`, hostnames). Port defaults to `27015`. Lines
+starting with an unknown directive are skipped entirely, so new keywords
+with any number of operands can be added without breaking older clients.
+
+`Content-Type` is not inspected, `text/plain; charset=utf-8` expected.
+
+### Example
+
+```
+# diffusion servers
+ip 192.0.2.10:27015
+ip [2001:db8::1]:27015
+gs 198.51.100.5:27015
+```
+
+A file with zero records is valid and represents an empty list.
+
+### Versioning
+
+The `/v1/` segment is fixed in this revision. A future protocol revision
+adds a sibling `/v2/...` resource without breaking older clients.
+
+## Client behaviour
+
+Each `ip` / `gs` record from the response triggers a probe to the listed
+address, identical to a server discovered through the UDP master. DNS
+errors, non-200 responses, and malformed bodies are reported to the
+console.
+
+## Server behaviour
+
+Any static HTTP server works. A typical setup is a periodic job that
+probes a set of known addresses and writes `v1/servers/<gamedir>`.

Documentation/supported-mod-list.md

@@ -892,6 +892,8 @@ Currently, fresh Xash3D FWGS builds for Android, PS Vita and Nintendo Switch use
 ## List of games and mods with custom gamedll
 For mods from this category - first of all place mod folder beside **valve** folder.
 
+NOTE: Precompiled libraries for some mods from this category may be already available for your platform in [hlsdk-mega-build](https://github.com/FWGS/hlsdk-mega-build) and this mods may be launch on Android out-of-the-box.
+
 1. **[Absolute Redemption](https://www.moddb.com/mods/absolute-redemption)**
 
 To run this mod on specific platforms you may be need to compile libraries from **redemption** branch of [hlsdk-portable](https://github.com/FWGS/hlsdk-portable).
@@ -950,7 +952,11 @@ This mod already supports x86 Linux.
 
 Support for other platforms may be available later.
 
-14. **[Counter Strike 1.6](https://store.steampowered.com/app/10/CounterStrike/)**
+14. **[Counter-Life](https://www.moddb.com/mods/counter-life)**
+
+To run this mod on specific platforms you may be need to compile libraries from **counter-life** branch of [hlsdk-portable](https://github.com/FWGS/hlsdk-portable).
+
+15. **[Counter Strike 1.6](https://store.steampowered.com/app/10/CounterStrike/)**
 
 On x86 you may be need to compile client part.
 
@@ -962,57 +968,65 @@ Client: https://github.com/Velaron/cs16-client/
 
 Server: https://github.com/rehlds/ReGameDLL_CS
 
-15. **[Crack-Life](https://www.moddb.com/mods/crack-life/downloads/crack-life)**
+16. **[Crack-Life](https://www.moddb.com/mods/crack-life/downloads/crack-life)**
 
 To run this mod on specific platforms you may be need to compile libraries from **cracklife** branch of [hlsdk-portable](https://github.com/FWGS/hlsdk-portable).
 
-16. **[Crack-Life: Campaign Mode](https://www.moddb.com/mods/crack-life/downloads/crack-life-campaign-mode)**
+17. **[Crack-Life: Campaign Mode](https://www.moddb.com/mods/crack-life/downloads/crack-life-campaign-mode)**
 
 To run this mod on specific platforms you may be need to compile libraries from **clcampaign** branch of [hlsdk-portable](https://github.com/FWGS/hlsdk-portable).
 
-17. **[Deathmatch Classic](https://store.steampowered.com/app/40/Deathmatch_Classic/)**
+18. **[Deathmatch Classic](https://store.steampowered.com/app/40/Deathmatch_Classic/)**
 
 Steam version already supports x86 Linux.
 
 To run this mod on specific platforms you may be need to compile libraries from **dmc** branch of [hlsdk-portable](https://github.com/FWGS/hlsdk-portable).
 
-18. **[Delta Particles](https://www.moddb.com/mods/half-life-delta)**
+19. **[Delta Particles](https://www.moddb.com/mods/half-life-delta)**
 
 This mod already supports x86 Linux.
 
-Support for other platforms may be available later.
+To run this mod on specific platforms you may be need to compile libraries from **delta_particles** branch of [hlsdk-portable](https://github.com/FWGS/hlsdk-portable).
 
-19. **[Escape from the Darkness](https://www.moddb.com/mods/escape-from-the-darkness)**
+20. **[Escape from the Darkness](https://www.moddb.com/mods/escape-from-the-darkness)**
 
 To run this mod on specific platforms you may be need to compile libraries from **eftd** branch of [hlsdk-portable](https://github.com/FWGS/hlsdk-portable).
 
-20. **[Gang Wars](https://www.moddb.com/mods/gangwars)**
+21. **[Gang Wars](https://www.moddb.com/mods/gangwars)**
 
 This mod already supports x86 Linux.
 
 Support for other platforms may be available later.
 
-21. **[Half-Life: Blue Shift](https://store.steampowered.com/app/130/HalfLife_Blue_Shift/)**
+22. **[Half-Life: Blue Shift](https://store.steampowered.com/app/130/HalfLife_Blue_Shift/)**
 
 To run this mod on specific platforms you may be need to compile libraries from **bshift** branch of [hlsdk-portable](https://github.com/FWGS/hlsdk-portable).
 
-22. **[Half-Life: Decay](https://www.moddb.com/mods/half-life-decay)**
+23. **[Half-Life: Decay](https://www.moddb.com/mods/half-life-decay)**
 
 Currently, you can compile mod libraries for x86 Linux from **decay-pc** branch of [hlsdk-portable](https://github.com/FWGS/hlsdk-portable).
 
 Support for other platforms may be available later.
 
-23. **[Half-Life: Echoes](https://www.moddb.com/mods/half-life-echoes)**
+24. **[Half-Life: Echoes](https://www.moddb.com/mods/half-life-echoes)**
 
 To run this mod on specific platforms you may be need to compile libraries from **echoes** branch of [hlsdk-portable](https://github.com/FWGS/hlsdk-portable).
 
-24. **[Half-Life: Field Intensity](https://www.moddb.com/mods/field-intensity)**
+25. [Half-Life: Featureful](https://freeslave.github.io/halflife-featureful/)
+
+*It's modding SDK*
 
 This mod already supports x86 Linux.
 
-Support for other platforms may be available later.
+To run this mod on specific platforms you may be need to compile libraries from **featureful** branch of [halflife-featureful](https://github.com/FreeSlave/halflife-featureful).
 
-25. **Half-Life: Gravgun** (unfinished) by *mittorn*, *a1batross* and *Solexid*
+26. **[Half-Life: Field Intensity](https://www.moddb.com/mods/field-intensity)**
+
+This mod already supports x86 Linux.
+
+To run this mod on specific platforms you may be need to compile libraries from **field_intensity_1.7** branch of [halflife-featureful](https://github.com/FreeSlave/halflife-featureful).
+
+27. **Half-Life: Gravgun** (unfinished) by *mittorn*, *a1batross* and *Solexid*
 
 *Support temporary abandoned*
 
@@ -1022,163 +1036,197 @@ Currently, MSVC is not supported, use MinGW if you need build for Windows.
 
 Mod files: [1](http://mittorn.fwgs.ru/coop-entpatches/), [2](http://mittorn.fwgs.ru/ggm/), [3](https://github.com/nillerusr/gravgun-extras).
 
-26. **[Half-Life: Induction 1.2](https://www.moddb.com/mods/half-life-induction)**
+28. **[Half-Life: Induction 1.2](https://www.moddb.com/mods/half-life-induction)**
 
 To run this mod on specific platforms you may be need to compile libraries from **induction_1.2** branch of [hlsdk-portable](https://github.com/FWGS/hlsdk-portable).
 
-27. **[Half-Life: Invasion](https://www.moddb.com/mods/half-life-invasion)**
+29. **[Half-Life: Induction 1.4](https://www.moddb.com/mods/half-life-induction)**
 
-This mod supports x86 Linux.
+This mod already supports x86 Linux.
 
-Support for other platforms may be available later.
+To run this mod on specific platforms you may be need to compile libraries from **induction** branch of [halflife-featureful](https://github.com/FreeSlave/halflife-featureful).
 
-28. **[Half-Life: Intense Force](https://www.moddb.com/downloads/intense-force)**
+30. **[Half-Life: Insecure](https://www.moddb.com/mods/half-life-insecure)**
+
+To run this mod on specific platforms you may be need to compile libraries from **insecure** branch of [hlsdk-portable](https://github.com/FWGS/hlsdk-portable).
+
+31. **[Half-Life: Intense Force](https://www.moddb.com/downloads/intense-force)**
 
 This mod already supports x86 Linux.
 
 To run this mod on specific platforms you may be need to compile libraries from **intense_force** branch of [halflife-featureful](https://github.com/FreeSlave/halflife-featureful).
 
-29. **[Half-Life: Opposing Force](https://store.steampowered.com/app/50/HalfLife_Opposing_Force/)**
+32. **[Half-Life: Invasion](https://www.moddb.com/mods/half-life-invasion)**
+
+This mod supports x86 Linux.
+
+Support for other platforms may be available later.
+
+33. **[Half-Life: Opposing Force](https://store.steampowered.com/app/50/HalfLife_Opposing_Force/)**
 
 Steam version already supports x86 Linux.
 
 To run this mod on specific platforms you may be need to compile libraries from **opfor** branch of [hlsdk-portable](https://github.com/FWGS/hlsdk-portable).
 
-30. **[Half-Life: Quest mod](https://csm.dev/threads/half-life-the-quest-mod-isxodniki.38030/)**
+34. **[Half-Life: Quest mod](https://csm.dev/threads/half-life-the-quest-mod-isxodniki.38030/)**
 
 To run this mod on specific platforms you may be need to compile libraries from **sci** branch of [hlsdk-portable](https://github.com/FWGS/hlsdk-portable).
 
-31. **[Half-Life: TopDown](https://www.moddb.com/mods/half-life-top-downs)**
+35. **[Half-Life: Sum](https://www.moddb.com/mods/half-life-sum)**
+
+This mod already supports x86 Linux.
+
+To run this mod on specific platforms you may be need to compile libraries from **sum** branch of [halflife-featureful](https://github.com/FreeSlave/halflife-featureful).
+
+36. **[Half-Life: TopDown](https://www.moddb.com/mods/half-life-top-downs)**
 
 To run this mod on specific platforms you may be need to compile libraries from **topdown** branch of [hlsdk-portable](https://github.com/FWGS/hlsdk-portable).
 
-32. **[Half-Life: Urbicide](https://www.moddb.com/mods/half-life-urbicide)**
+37. **[Half-Life: Urbicide](https://www.moddb.com/mods/half-life-urbicide)**
 
 To run this mod on specific platforms you may be need to compile libraries from **hl_urbicide** branch of [hlsdk-portable](https://github.com/FWGS/hlsdk-portable).
 
-33. **[Half-Life: Visitors](https://www.moddb.com/mods/half-life-visitors)**
+38. **[Half-Life: Visitors](https://www.moddb.com/mods/half-life-visitors)**
 
 To run this mod on specific platforms you may be need to compile libraries from **visitors** branch of [hlsdk-portable](https://github.com/FWGS/hlsdk-portable).
 
-34. **[Half-Rats: Parasomnia](https://www.moddb.com/mods/half-rats-parasomnia/downloads/half-rats-parasomnia-v10b-steamlinux)**
+39. **[Half-Rats: Parasomnia](https://www.moddb.com/mods/half-rats-parasomnia/downloads/half-rats-parasomnia-v10b-steamlinux)**
 
 This mod already supports x86 Linux.
 
 Support for other platforms may be available later.
 
-35. **[Half-Screwed: Death and Rebirth](https://www.moddb.com/mods/half-screwed)**
+40. **[Half-Screwed: Death and Rebirth](https://www.moddb.com/mods/half-screwed)**
 
 To run this mod on specific platforms you may be need to compile libraries from **half-screwed** branch of [hlsdk-portable](https://github.com/FWGS/hlsdk-portable).
 
-36. **[Half-Secret](https://www.moddb.com/mods/half-secret)**
+41. **[Half-Secret](https://www.moddb.com/mods/half-secret)**
 
 To run this mod on specific platforms you may be need to compile libraries from **half-secret** branch of [hlsdk-portable](https://github.com/FWGS/hlsdk-portable).
 
-37. **[Natural Selection](https://www.moddb.com/mods/natural-selection)**
+42. **[Mortal Kombat](https://www.moddb.com/mods/hl-mortal-kombat)**
+
+This mod already supports Android and x86 Linux.
+
+43. **[Natural Selection](https://www.moddb.com/mods/natural-selection)**
 
 This mod already supports x86 Linux.
 
 Support for other platforms may be available later.
 
-38. **[Night at the Office](https://www.moddb.com/mods/night-at-the-office)**
+44. **[Night at the Office](https://www.moddb.com/mods/night-at-the-office)**
 
 To run this mod on specific platforms you may be need to compile libraries from **noffice** branch of [hlsdk-portable](https://github.com/FWGS/hlsdk-portable).
 
-39. **[Paranoia](https://www.moddb.com/mods/paranoia)**
+45. **[Paranoia](https://www.moddb.com/mods/paranoia)**
 
 *Support temporary abandoned*
 
 [Source code](https://github.com/FWGS/paranoia_toolkit).
 
-40. **[Poke646](https://poke646.com/)**
+46. **[Poke646](https://poke646.com/)**
 
 To run this mod on specific platforms you may be need to compile libraries from **poke646** branch of [hlsdk-portable](https://github.com/FWGS/hlsdk-portable).
 
-41. **[Poke646: Vendetta](https://poke646.com/)**
+47. **[Poke646: Vendetta](https://poke646.com/)**
 
 To run this mod on specific platforms you may be need to compile libraries from **poke646_vendetta** branch of [hlsdk-portable](https://github.com/FWGS/hlsdk-portable).
 
-42. [PrimeXT](https://snmetamorph.github.io/PrimeXT/)
+48. [PrimeXT](https://snmetamorph.github.io/PrimeXT/)
+
+*It's modding SDK*
 
 [Source code](https://github.com/SNMetamorph/PrimeXT)
 
-43. **[Quake Remake](https://www.moddb.com/games/quake-remake)**
+49. **[Quake Remake](https://www.moddb.com/games/quake-remake)**
 
 *Support was fully abandoned due Quake Wrapper release.*
 
 [Actual source code](https://github.com/FWGS/quakeremake)
 
-44. **[Rebellion](https://www.moddb.com/mods/rebellion1)**
+50. **[Rebellion](https://www.moddb.com/mods/rebellion1)**
 
 To run this mod on specific platforms you may be need to compile libraries from **rebellion** branch of [hlsdk-portable](https://github.com/FWGS/hlsdk-portable).
 
-45. **[Residual Life](https://www.moddb.com/mods/hl-residual-life)**
+51. **[Residual Life](https://www.moddb.com/mods/hl-residual-life)**
 
 To run this mod on specific platforms you may be need to compile libraries from **residual_point** branch of [hlsdk-portable](https://github.com/FWGS/hlsdk-portable).
 
-46. **[Residual Point](https://www.moddb.com/mods/hl-residual-point)**
+52. **[Residual Point](https://www.moddb.com/mods/hl-residual-point)**
 
 To run this mod on specific platforms you may be need to compile libraries from **residual_point** branch of [hlsdk-portable](https://github.com/FWGS/hlsdk-portable).
 
-47. **[Ricochet](https://store.steampowered.com/app/60/Ricochet/)**
+53. **[Ricochet](https://store.steampowered.com/app/60/Ricochet/)**
 
 This mod already supports x86 Linux.
 
 Support for other platforms may be available later.
 
-48. [Sewer](https://www.moddb.com/games/half-life/addons/sewer-beta)
+54. [Sewer](https://www.moddb.com/games/half-life/addons/sewer-beta)
 
 To run this mod on specific platforms you may be need to compile libraries from **sewer_beta** branch of [hlsdk-portable](https://github.com/FWGS/hlsdk-portable).
 
-49. [Spirit of Half-Life 1.2](https://www.moddb.com/mods/spirit-of-half-life)
+55. [Spirit of Half-Life 1.2](https://www.moddb.com/mods/spirit-of-half-life)
+
+*It's modding SDK*
 
 To run this mod on specific platforms you may be need to compile libraries from **sohl1.2** branch of [hlsdk-portable](https://github.com/FWGS/hlsdk-portable).
 
-50. **[Swiss Cheese Halloween](https://www.moddb.com/mods/half-life-halloween-mod)**
+56. **[Swiss Cheese Halloween](https://www.moddb.com/mods/half-life-halloween-mod)**
 
 To run this mod on specific platforms you may be need to compile libraries from **halloween** branch of [hlsdk-portable](https://github.com/FWGS/hlsdk-portable).
 
-51. **[Team Fortress Classic](https://store.steampowered.com/app/20/Team_Fortress_Classic/)**
+57. **[Team Fortress Classic](https://store.steampowered.com/app/20/Team_Fortress_Classic/)**
 
 This mod already supports x86 Linux.
 
 Currently, only source code of [client part](https://github.com/Velaron/tf15-client) is available.
 
-52. **[The Gate](https://www.moddb.com/mods/the-gate)**
+58. **[The Gate](https://www.moddb.com/mods/the-gate)**
 
 To run this mod on specific platforms you may be need to compile libraries from **thegate** branch of [hlsdk-portable](https://github.com/FWGS/hlsdk-portable).
 
-53. **[They Hunger: Trilogy](https://www.moddb.com/mods/they-hunger)**
+59. **[The Last Bullet](https://www.moddb.com/mods/the-last-bullet-update)**
+
+To run this mod on specific platforms you may be need to compile libraries from **fwgs** branch of [The-Last-Bullet-Updated-Code](https://github.com/GT-Project-Cat/The-Last-Bullet-Updated-Code).
+
+60. **[They Hunger: Trilogy](https://www.moddb.com/mods/they-hunger)**
 
 To run this mod on specific platforms you may be need to compile libraries from **theyhunger** branch of [hlsdk-portable](https://github.com/FWGS/hlsdk-portable).
 
-54. **[ThreeWave CTF](https://www.moddb.com/games/deathmatch-classic/downloads/threewave-ctf)**
+61. **[ThreeWave CTF](https://www.moddb.com/games/deathmatch-classic/downloads/threewave-ctf)**
 
 To run this mod on specific platforms you may be need to compile libraries from **dmc** branch of [hlsdk-portable](https://github.com/FWGS/hlsdk-portable).
 
-55. **[Times of Troubles](https://www.moddb.com/mods/times-of-troubles)**
+62. **[Times of Troubles](https://www.moddb.com/mods/times-of-troubles)**
 
 To run this mod on specific platforms you may be need to compile libraries from **tot** branch of [hlsdk-portable](https://github.com/FWGS/hlsdk-portable).
 
-56. [XashXT](https://csm.dev/threads/xashxt-0-65-rev-4-release-stable.38319/)
+63. [XashXT](https://csm.dev/threads/xashxt-0-65-rev-4-release-stable.38319/)
+
+*It's modding SDK*
 
 *Support was fully abandoned due PrimeXT development*
 
 [Source code](https://github.com/FWGS/XashXT-FWGS/)
 
-57. **[X-Half-Life DeathMatch](https://www.moddb.com/mods/xdm)**
+64. **[X-Half-Life DeathMatch](https://www.moddb.com/mods/xdm)**
 
 This mod already supports x86 Linux.
 
 Support for other platforms may be available later.
 
-58. **[Xen-Warrior](https://www.moddb.com/mods/xen-warrior)**
+65. **[Xen-Warrior](https://www.moddb.com/mods/xen-warrior)**
 
 To run this mod on specific platforms you may be need to compile libraries from **sohl1.2** branch of [hlsdk-portable](https://github.com/FWGS/hlsdk-portable).
 
 Don't forget to enable XENWARRIOR build option!!!
 
-59. [Zombie-X](https://www.moddb.com/mods/zombie-x-10-final)
+66. **[Yet another PS2 Half-Life port](https://www.moddb.com/mods/yet-another-ps2-half-life-pc-port)**
+
+To run this mod on specific platforms you may be need to compile libraries from **ps2hl** branch of [hlsdk-portable](https://github.com/FWGS/hlsdk-portable).
+
+67. [Zombie-X](https://www.moddb.com/mods/zombie-x-10-final)
 
 To run this mod on specific platforms you may be need to compile libraries from **zombie-x** branch of [hlsdk-portable](https://github.com/FWGS/hlsdk-portable).
 

README.md

@@ -1,3 +1,6 @@
+> [!CAUTION]
+> **Only download Xash3D FWGS from official sources.** Third-party builds, "modded launchers", "optimized" repacks and random mirrors are frequently bundled with malware, miners, spyware and credential stealers. We cannot vouch for anything we did not build. Get official binaries only from the [releases page](https://github.com/FWGS/xash3d-fwgs/releases/tag/continuous).
+
 # Xash3D FWGS Engine <img align="right" width="128" height="128" src="https://github.com/FWGS/xash3d-fwgs/raw/master/game_launch/icon-xash-material.png" alt="Xash3D FWGS icon" />
 [![GitHub Actions Status](https://github.com/FWGS/xash3d-fwgs/actions/workflows/c-cpp.yml/badge.svg)](https://github.com/FWGS/xash3d-fwgs/actions/workflows/c-cpp.yml) [![FreeBSD Build Status](https://img.shields.io/cirrus/github/FWGS/xash3d-fwgs?label=freebsd%20build)](https://cirrus-ci.com/github/FWGS/xash3d-fwgs) \
 [![Discord Server](https://img.shields.io/discord/355697768582610945?logo=Discord&label=International%20Discord%20chat)](http://xash.su/discord/) [![Russian speakers Telegram Chat](https://img.shields.io/badge/Russian_speakers_Telegram_chat-gray?logo=Telegram)](https://t.me/flyingwithgauss) \

android/.gitignore

@@ -11,4 +11,5 @@ local.properties
 release/
 *.hprof
 .vscode/
-*.bak
+*.bak
+.kotlin/

android/app/build.gradle.kts

@@ -20,10 +20,12 @@ extensions.configure<ApplicationExtension> {
 		minSdk = 21
 		targetSdk = 35
 
+		buildConfigField("String", "GIT_HASH", "\"${getGitHash()}\"")
+
 		externalNativeBuild {
 			val engineRoot = projectDir.parentFile.parent
 
-			experimentalProperties["ninja.abiFilters"] = setOf("armeabi-v7a", "arm64-v8a", "x86", "x86_64")
+			experimentalProperties["ninja.abiFilters"] = setOf("armeabi-v7a", "arm64-v8a", "x86")
 			experimentalProperties["ninja.path"] = File(engineRoot, "wscript").path
 			experimentalProperties["ninja.configure"] = "run-python"
 			experimentalProperties["ninja.arguments"] = setOf(
@@ -58,6 +60,15 @@ extensions.configure<ApplicationExtension> {
 		buildConfig = true
 	}
 
+	signingConfigs {
+		create("androidDebugKey") {
+			storeFile = File(projectDir.parentFile, "debug.keystore")
+			storePassword = "android"
+			keyAlias = "androiddebugkey"
+			keyPassword = "android"
+		}
+	}
+
 	lint {
 		abortOnError = false
 	}
@@ -91,6 +102,7 @@ extensions.configure<ApplicationExtension> {
 			proguardFiles(
 				getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro"
 			)
+			buildConfigField("boolean", "ENABLE_AUTO_UPDATE", "false")
 		}
 
 		release {
@@ -99,6 +111,7 @@ extensions.configure<ApplicationExtension> {
 			proguardFiles(
 				getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro"
 			)
+			buildConfigField("boolean", "ENABLE_AUTO_UPDATE", "false")
 		}
 
 		register("asan") {
@@ -108,6 +121,8 @@ extensions.configure<ApplicationExtension> {
 		register("continuous") {
 			initWith(getByName("release"))
 			applicationIdSuffix = ".test"
+			buildConfigField("boolean", "ENABLE_AUTO_UPDATE", "true")
+			signingConfig = signingConfigs.getByName("androidDebugKey")
 		}
 	}
 }

android/app/src/debug/res/values/strings.xml

@@ -1,4 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
 <resources>
 	<string name="app_name" translatable="false">Xash3D FWGS (Test)</string>
+	<string name="authority" translatable="false">su.xash.engine.test.documents</string>
 </resources>

android/app/src/main/AndroidManifest.xml

@@ -48,6 +48,8 @@
 	<uses-permission android:name="android.permission.INTERNET" />
 	<!-- Dedicated server -->
 	<uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+	<!-- Self-update: install downloaded APK -->
+	<uses-permission android:name="android.permission.REQUEST_INSTALL_PACKAGES" />
 
 	<application
 		android:name=".MainApplication"
@@ -76,8 +78,16 @@
 			android:grantUriPermissions="true">
 			<meta-data
 				android:name="android.support.FILE_PROVIDER_PATHS"
-				android:resource="@xml/provider_paths" />
+				android:resource="@xml/paths" />
 		</provider>
+		<receiver
+			android:name=".model.InstallStatusReceiver"
+			android:exported="false">
+			<intent-filter>
+				<action android:name="su.xash.engine.INSTALL_RESULT" />
+			</intent-filter>
+		</receiver>
+
 		<activity
 			android:name=".XashActivity"
 			android:alwaysRetainTaskState="true"
@@ -95,5 +105,9 @@
 		<intent>
 			<action android:name="su.xash.engine.MOD" />
 		</intent>
+		<intent>
+			<action android:name="android.intent.action.SENDTO" />
+			<data android:scheme="mailto" />
+		</intent>
 	</queries>
 </manifest>

android/app/src/main/java/su/xash/engine/MainActivity.kt

@@ -1,15 +1,26 @@
 package su.xash.engine
 
+import android.content.ActivityNotFoundException
+import android.content.Context
+import android.content.Intent
 import android.os.Bundle
+import android.provider.Settings
 import androidx.appcompat.app.AlertDialog
 import androidx.appcompat.app.AppCompatActivity
+import androidx.core.net.toUri
+import androidx.lifecycle.lifecycleScope
 import androidx.navigation.NavController
 import androidx.navigation.fragment.NavHostFragment
 import androidx.navigation.ui.AppBarConfiguration
 import androidx.navigation.ui.navigateUp
 import androidx.navigation.ui.setupActionBarWithNavController
+import com.google.android.material.dialog.MaterialAlertDialogBuilder
+import kotlinx.coroutines.launch
 import su.xash.engine.databinding.ActivityMainBinding
+import su.xash.engine.model.AppUpdater
 import su.xash.engine.util.CrashReports
+import su.xash.engine.util.monospaceTextView
+import su.xash.engine.util.showDownloadProgressDialog
 import java.io.File
 import java.text.SimpleDateFormat
 import java.util.Date
@@ -36,6 +47,94 @@ class MainActivity : AppCompatActivity() {
 
 		CrashReports.prune(this)
 		showPendingCrashReport()
+
+		checkForEngineUpdate()
+	}
+
+	private fun checkForEngineUpdate() {
+		val prefs = getSharedPreferences(UPDATE_PREFS, Context.MODE_PRIVATE)
+		val now = System.currentTimeMillis()
+		if (now - prefs.getLong(KEY_LAST_CHECK, 0L) < CHECK_INTERVAL_MS)
+			return
+
+		val updater = AppUpdater(this)
+		lifecycleScope.launch {
+			val info = updater.checkForUpdate()
+			prefs.edit().putLong(KEY_LAST_CHECK, now).apply()
+			if (info == null)
+				return@launch
+			if (prefs.getInt(KEY_DISMISSED_BUILDNUM, -1) >= info.buildNum)
+				return@launch
+			val changelog = updater.fetchChangelog(BuildConfig.GIT_HASH, info.tagName)
+			showEngineUpdateDialog(updater, info.buildNum, changelog, prefs)
+		}
+	}
+
+	private fun showEngineUpdateDialog(
+		updater: AppUpdater,
+		remoteBuildNum: Int,
+		changelog: List<AppUpdater.CommitInfo>?,
+		prefs: android.content.SharedPreferences,
+	) {
+		val builder = MaterialAlertDialogBuilder(this)
+			.setTitle(R.string.engine_update_available)
+			.setMessage(getString(R.string.engine_update_message, remoteBuildNum))
+			.setPositiveButton(R.string.engine_update_download) { _, _ ->
+				showEngineDownloadDialog(updater)
+			}
+			.setNegativeButton(R.string.engine_update_later) { _, _ ->
+				prefs.edit().putInt(KEY_DISMISSED_BUILDNUM, remoteBuildNum).apply()
+			}
+
+		if (!changelog.isNullOrEmpty()) {
+			val text = buildString {
+				append(getString(R.string.engine_update_changelog_header))
+				val shown = changelog.take(CHANGELOG_MAX_LINES)
+				for (c in shown)
+					append("\n• ").append(c.subject)
+				val extra = changelog.size - shown.size
+				if (extra > 0)
+					append("\n").append(getString(R.string.engine_update_changelog_more, extra))
+			}
+			builder.setView(monospaceTextView(this, text))
+		}
+
+		builder.show()
+	}
+
+	private fun showEngineDownloadDialog(updater: AppUpdater) {
+		if (!updater.canInstall()) {
+			promptForInstallPermission()
+			return
+		}
+		showDownloadProgressDialog(
+			ctx = this,
+			titleRes = R.string.engine_update_downloading,
+			cancelable = true,
+			scope = lifecycleScope,
+			download = { onProgress -> updater.downloadAndInstall(onProgress) },
+		)
+	}
+
+	private fun promptForInstallPermission() {
+		MaterialAlertDialogBuilder(this)
+			.setTitle(R.string.engine_update_permission_needed)
+			.setMessage(R.string.engine_update_permission_message)
+			.setPositiveButton(R.string.engine_update_open_settings) { _, _ ->
+				val packageIntent = Intent(Settings.ACTION_MANAGE_UNKNOWN_APP_SOURCES,
+					"package:$packageName".toUri())
+				try {
+					startActivity(packageIntent)
+				} catch (_: ActivityNotFoundException) {
+					try {
+						startActivity(Intent(Settings.ACTION_MANAGE_UNKNOWN_APP_SOURCES))
+					} catch (_: ActivityNotFoundException) {
+						// no settings screen — nothing more we can do
+					}
+				}
+			}
+			.setNegativeButton(android.R.string.cancel, null)
+			.show()
 	}
 
 	override fun onSupportNavigateUp(): Boolean {
@@ -43,26 +142,45 @@ class MainActivity : AppCompatActivity() {
 	}
 
 	private fun showPendingCrashReport() {
-		val pending = CrashReports.pendingFile(this)
+		val pending = CrashReports.pendingStacktrace(this)
 		if (!pending.exists() || pending.length() == 0L)
 			return
 
 		val historyDir = CrashReports.historyDir(this).apply { mkdirs() }
 		val ts = SimpleDateFormat("yyyyMMdd-HHmmss", Locale.US).format(Date())
-		val archived = File(historyDir, "crash-$ts.log")
-		if (!pending.renameTo(archived)) {
-			// fall back to in-place read if move failed; still consume the file
-			archived.writeText(pending.readText())
-			pending.delete()
-		}
+		val entryDir = File(historyDir, "crash-$ts").apply { mkdirs() }
 
-		val content = archived.readText()
+		moveOrCopy(pending, File(entryDir, CrashReports.STACKTRACE_NAME))
+		moveOrCopy(CrashReports.pendingSysinfo(this), File(entryDir, CrashReports.SYSINFO_NAME))
+		moveOrCopy(CrashReports.pendingIntent(this), File(entryDir, CrashReports.INTENT_NAME))
+		moveOrCopy(CrashReports.pendingEngineLog(this), File(entryDir, CrashReports.ENGINELOG_NAME))
+
+		val entry = CrashReports.Entry(entryDir)
 		AlertDialog.Builder(this)
 			.setTitle(R.string.crash_dialog_title)
-			.setView(CrashReports.buildContentView(this, content))
-			.setPositiveButton(R.string.crash_send_to_developers) { _, _ -> CrashReports.sendByEmail(this, content) }
-			.setNeutralButton(R.string.crash_share) { _, _ -> CrashReports.share(this, archived) }
+			.setView(monospaceTextView(this, entry.summary()))
+			.setPositiveButton(R.string.crash_send_to_developers) { _, _ -> CrashReports.sendByEmail(this, entry) }
+			.setNeutralButton(R.string.crash_share) { _, _ -> CrashReports.share(this, entry) }
 			.setNegativeButton(R.string.crash_dismiss, null)
 			.show()
 	}
+
+	private fun moveOrCopy(src: File, dst: File) {
+		if (!src.exists())
+			return
+
+		if (src.renameTo(dst))
+			return
+
+		src.copyTo(dst, overwrite = true)
+		src.delete()
+	}
+
+	companion object {
+		private const val CHANGELOG_MAX_LINES = 15
+		private const val UPDATE_PREFS = "app_updater"
+		private const val KEY_LAST_CHECK = "last_check_ms"
+		private const val KEY_DISMISSED_BUILDNUM = "dismissed_buildnum"
+		private const val CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000L
+	}
 }

android/app/src/main/java/su/xash/engine/XashActivity.java

@@ -1,6 +1,7 @@
 package su.xash.engine;
 
 import android.annotation.SuppressLint;
+import android.content.Intent;
 import android.content.pm.ActivityInfo;
 import android.content.res.AssetManager;
 import android.os.Build;
@@ -14,6 +15,7 @@ import android.view.WindowManager;
 import org.libsdl.app.SDLActivity;
 
 import su.xash.engine.util.AndroidBug5497Workaround;
+import su.xash.engine.util.CrashReports;
 
 import java.io.File;
 import java.util.Arrays;
@@ -121,6 +123,45 @@ public class XashActivity extends SDLActivity {
 		return getWindow().superDispatchKeyEvent(event);
 	}
 
+	private static void appendStringExtra(StringBuilder sb, Intent intent, String key) {
+		String value = intent.getStringExtra(key);
+		if (value != null)
+			sb.append("  ").append(key).append(" = ").append(value).append('\n');
+	}
+
+	// record intent info, so that it could be consumed later for crash reporting
+	private void recordLaunchInfo() {
+		// do not overwrite current launch info with pending crash log, shouldn't happen but might
+		File pendingCrash = new File(getFilesDir(), "crashes/" + CrashReports.STACKTRACE_NAME);
+		if (pendingCrash.exists() && pendingCrash.length() > 0)
+			return;
+
+		// write Android version, fingerprint, supported abis, etc
+		CrashReports.writeSystemInfo(this);
+
+		// now create intent info and pass it to crash reporting
+		Intent intent = getIntent();
+		if (intent == null)
+			return;
+		StringBuilder sb = new StringBuilder();
+		sb.append("Action: ").append(intent.getAction()).append('\n');
+		sb.append("Data: ").append(intent.getDataString()).append('\n');
+		sb.append("Calling package: ").append(getCallingPackage()).append('\n');
+		sb.append("Extras:\n");
+		// only write intent extras that we care about
+		appendStringExtra(sb, intent, "gamedir");
+		appendStringExtra(sb, intent, "gamelibdir");
+		appendStringExtra(sb, intent, "pakfile");
+		appendStringExtra(sb, intent, "basedir");
+		appendStringExtra(sb, intent, "package");
+		appendStringExtra(sb, intent, "argv");
+		sb.append("  usevolume = ").append(intent.getBooleanExtra("usevolume", false)).append('\n');
+		String[] env = intent.getStringArrayExtra("env");
+		if (env != null)
+			sb.append("  env = ").append(Arrays.toString(env)).append('\n');
+		CrashReports.writeIntentInfo(this, sb.toString());
+	}
+
 	// TODO: REMOVE LATER, temporary launchers support?
 	@Override
 	protected String[] getArguments() {
@@ -128,6 +169,8 @@ public class XashActivity extends SDLActivity {
 		crashDir.mkdirs();
 		nativeSetenv("XASH3D_CRASH_DIR", crashDir.getAbsolutePath());
 
+		recordLaunchInfo();
+
 		String gamedir = getIntent().getStringExtra("gamedir");
 		if (gamedir == null) gamedir = "valve";
 		nativeSetenv("XASH3D_GAME", gamedir);

android/app/src/main/java/su/xash/engine/model/AppUpdater.kt

@@ -0,0 +1,205 @@
+package su.xash.engine.model
+
+import android.app.PendingIntent
+import android.content.Context
+import android.content.Intent
+import android.content.pm.PackageInstaller
+import android.os.Build
+import android.util.Log
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ensureActive
+import kotlinx.coroutines.withContext
+import org.json.JSONException
+import org.json.JSONObject
+import su.xash.engine.BuildConfig
+import java.io.File
+import java.io.FileOutputStream
+import java.io.IOException
+import java.net.HttpURLConnection
+import java.net.URL
+import kotlin.coroutines.coroutineContext
+
+class AppUpdater(private val context: Context) {
+
+	data class UpdateInfo(val buildNum: Int, val tagName: String)
+	data class CommitInfo(val sha: String, val subject: String)
+
+	fun canInstall(): Boolean =
+		Build.VERSION.SDK_INT < Build.VERSION_CODES.O ||
+			context.packageManager.canRequestPackageInstalls()
+
+	suspend fun checkForUpdate(): UpdateInfo? {
+		if (!BuildConfig.ENABLE_AUTO_UPDATE) return null
+		return withContext(Dispatchers.IO) {
+			var connection: HttpURLConnection? = null
+			try {
+				connection = URL(RELEASE_API_URL).openConnection() as HttpURLConnection
+				connection.connectTimeout = 5000
+				connection.readTimeout = 5000
+				connection.setRequestProperty("Accept", "application/vnd.github+json")
+				connection.connect()
+
+				if (connection.responseCode != HttpURLConnection.HTTP_OK) {
+					Log.w(TAG, "Release API check failed: HTTP ${connection.responseCode}")
+					return@withContext null
+				}
+
+				val release = JSONObject(connection.inputStream.bufferedReader().readText())
+				val body = release.optString("body", "")
+				val tagName = release.optString("tag_name").ifEmpty { TAG_CONTINUOUS }
+
+				// buildnum is days-since-2015-04-01, same metric as VERSION_CODE / 10000
+				val remote = BUILDNUM_REGEX.find(body)?.groupValues?.get(1)?.toIntOrNull()
+				val localDays = BuildConfig.VERSION_CODE / 10000
+				Log.i(TAG, "Remote buildnum: $remote (tag=$tagName), local: $localDays")
+
+				if (remote != null && remote - localDays >= STALENESS_DAYS)
+					UpdateInfo(remote, tagName)
+				else
+					null
+			} catch (e: CancellationException) {
+				throw e
+			} catch (e: IOException) {
+				Log.w(TAG, "Update check failed: ${e.message}")
+				null
+			} catch (e: JSONException) {
+				Log.w(TAG, "Update check parse failed: ${e.message}")
+				null
+			} finally {
+				connection?.disconnect()
+			}
+		}
+	}
+
+	suspend fun fetchChangelog(fromRef: String, toRef: String): List<CommitInfo>? {
+		if (fromRef.isEmpty() || toRef.isEmpty())
+			return null
+		return withContext(Dispatchers.IO) {
+			var connection: HttpURLConnection? = null
+			try {
+				connection = URL("$COMPARE_API_BASE/$fromRef...$toRef").openConnection() as HttpURLConnection
+				connection.connectTimeout = 5000
+				connection.readTimeout = 5000
+				connection.setRequestProperty("Accept", "application/vnd.github+json")
+				connection.connect()
+
+				if (connection.responseCode != HttpURLConnection.HTTP_OK) {
+					Log.w(TAG, "Compare API failed: HTTP ${connection.responseCode}")
+					return@withContext null
+				}
+
+				val json = JSONObject(connection.inputStream.bufferedReader().readText())
+				val commits = json.optJSONArray("commits") ?: return@withContext null
+				val result = ArrayList<CommitInfo>(commits.length())
+				for (i in 0 until commits.length()) {
+					val c = commits.getJSONObject(i)
+					val sha = c.optString("sha").ifEmpty { continue }
+					val msg = c.optJSONObject("commit")?.optString("message") ?: continue
+					val subject = msg.substringBefore('\n').trim()
+					if (subject.isNotEmpty())
+						result.add(CommitInfo(sha, subject))
+				}
+				// GitHub returns oldest first
+				result.reverse()
+				result
+			} catch (e: CancellationException) {
+				throw e
+			} catch (e: IOException) {
+				Log.w(TAG, "Changelog fetch failed: ${e.message}")
+				null
+			} catch (e: JSONException) {
+				Log.w(TAG, "Changelog parse failed: ${e.message}")
+				null
+			} finally {
+				connection?.disconnect()
+			}
+		}
+	}
+
+	suspend fun downloadAndInstall(onProgress: (Long, Long) -> Unit): Result<Unit> {
+		return withContext(Dispatchers.IO) {
+			val tempFile = File(context.cacheDir, "xash3d-fwgs-update.apk")
+			var connection: HttpURLConnection? = null
+			try {
+				connection = URL(APK_URL).openConnection() as HttpURLConnection
+				connection.connectTimeout = 10000
+				connection.readTimeout = 30000
+				connection.instanceFollowRedirects = true
+				connection.connect()
+
+				if (connection.responseCode != HttpURLConnection.HTTP_OK)
+					return@withContext Result.failure(IOException("HTTP ${connection.responseCode}"))
+
+				val total = connection.contentLengthLong
+				var downloaded = 0L
+				var lastEmit = 0L
+
+				connection.inputStream.use { input ->
+					FileOutputStream(tempFile).use { output ->
+						val buffer = ByteArray(65536)
+						while (true) {
+							coroutineContext.ensureActive()
+							val read = input.read(buffer)
+							if (read < 0)
+								break
+							output.write(buffer, 0, read)
+							downloaded += read
+							val now = System.currentTimeMillis()
+							if (now - lastEmit >= PROGRESS_INTERVAL_MS) {
+								lastEmit = now
+								withContext(Dispatchers.Main) { onProgress(downloaded, total) }
+							}
+						}
+					}
+				}
+				withContext(Dispatchers.Main) { onProgress(downloaded, total) }
+
+				Log.i(TAG, "Downloaded APK: ${tempFile.length()} bytes -> ${tempFile.absolutePath}")
+
+				triggerInstall(tempFile)
+				Result.success(Unit)
+			} catch (e: CancellationException) {
+				tempFile.delete()
+				throw e
+			} catch (e: IOException) {
+				tempFile.delete()
+				Result.failure(e)
+			} finally {
+				connection?.disconnect()
+			}
+		}
+	}
+
+	private fun triggerInstall(apk: File) {
+		val installer = context.packageManager.packageInstaller
+		val params = PackageInstaller.SessionParams(PackageInstaller.SessionParams.MODE_FULL_INSTALL)
+		val sessionId = installer.createSession(params)
+		installer.openSession(sessionId).use { session ->
+			session.openWrite("base.apk", 0, apk.length()).use { out ->
+				apk.inputStream().use { it.copyTo(out) }
+				session.fsync(out)
+			}
+			val statusIntent = Intent(INSTALL_ACTION).setPackage(context.packageName)
+			val piFlags = PendingIntent.FLAG_UPDATE_CURRENT or
+				if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) PendingIntent.FLAG_MUTABLE else 0
+			val pi = PendingIntent.getBroadcast(context, sessionId, statusIntent, piFlags)
+			session.commit(pi.intentSender)
+		}
+	}
+
+	companion object {
+		private const val TAG = "AppUpdater"
+		private const val STALENESS_DAYS = 3
+		private const val PROGRESS_INTERVAL_MS = 100L
+		private const val TAG_CONTINUOUS = "continuous"
+		private const val INSTALL_ACTION = "su.xash.engine.INSTALL_RESULT"
+		private const val APK_URL =
+			"https://github.com/FWGS/xash3d-fwgs/releases/download/continuous/xash3d-fwgs-android.apk"
+		private const val RELEASE_API_URL =
+			"https://api.github.com/repos/FWGS/xash3d-fwgs/releases/tags/continuous"
+		private const val COMPARE_API_BASE =
+			"https://api.github.com/repos/FWGS/xash3d-fwgs/compare"
+		private val BUILDNUM_REGEX = Regex("""buildnum\s+(\d+)""")
+	}
+}

android/app/src/main/java/su/xash/engine/model/Game.kt

@@ -6,17 +6,15 @@ import android.content.pm.PackageInfo
 import android.content.pm.PackageManager
 import android.graphics.Bitmap
 import android.graphics.BitmapFactory
-import android.view.LayoutInflater
-import android.widget.TextView
 import androidx.core.net.toUri
 import com.google.android.material.dialog.MaterialAlertDialogBuilder
-import com.google.android.material.progressindicator.LinearProgressIndicator
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.launch
 import su.xash.engine.R
 import su.xash.engine.XashActivity
+import su.xash.engine.util.showDownloadProgressDialog
 import java.io.File
 import java.io.FileInputStream
 
@@ -139,44 +137,14 @@ class Game(val ctx: Context, val basedir: File, val gameInfoFile: File) {
 	}
 
 	private fun showDownloadDialog(ctx: Context, downloader: GameLibDownloader, commandLineArgs: String) {
-		val view = LayoutInflater.from(ctx).inflate(R.layout.dialog_download_progress, null)
-		val progressBar = view.findViewById<LinearProgressIndicator>(R.id.downloadProgress)
-		val statusText = view.findViewById<TextView>(R.id.downloadStatus)
-
-		val dialog = MaterialAlertDialogBuilder(ctx)
-			.setTitle(R.string.downloading_game_libs)
-			.setView(view)
-			.setCancelable(true)
-			.setNegativeButton(android.R.string.cancel) { d, _ -> d.dismiss() }
-			.create()
-
-		dialog.show()
-
-		val scope = CoroutineScope(Dispatchers.Main + SupervisorJob())
-		val job = scope.launch {
-			val result = downloader.download(basedir.name) { progress ->
-				progressBar.isIndeterminate = false
-				progressBar.progress = (progress * 100).toInt()
-				statusText.text = ctx.getString(R.string.download_progress, (progress * 100).toInt())
-			}
-
-			if (!dialog.isShowing) return@launch
-
-			dialog.dismiss()
-
-			if (result.isSuccess) {
-				launchEngine(ctx, commandLineArgs)
-			} else {
-				MaterialAlertDialogBuilder(ctx)
-					.setTitle(R.string.download_failed)
-					.setMessage(result.exceptionOrNull()?.message
-						?: ctx.getString(R.string.download_error))
-					.setPositiveButton(android.R.string.ok, null)
-					.show()
-			}
-		}
-
-		dialog.setOnDismissListener { job.cancel() }
+		showDownloadProgressDialog(
+			ctx = ctx,
+			titleRes = R.string.downloading_game_libs,
+			cancelable = true,
+			scope = CoroutineScope(Dispatchers.Main + SupervisorJob()),
+			download = { onProgress -> downloader.download(basedir.name, onProgress) },
+			onSuccess = { launchEngine(ctx, commandLineArgs) },
+		)
 	}
 
 	private fun showManifestErrorDialog(ctx: Context, commandLineArgs: String, cause: Throwable) {

android/app/src/main/java/su/xash/engine/model/GameLibDownloader.kt

@@ -199,7 +199,7 @@ class GameLibDownloader(private val context: Context) {
 	private suspend fun tryDownload(
 		url: String,
 		dest: File,
-		onProgress: (Float) -> Unit
+		onProgress: (Long, Long) -> Unit
 	): Exception? {
 		var connection: HttpURLConnection? = null
 		try {
@@ -215,6 +215,7 @@ class GameLibDownloader(private val context: Context) {
 
 			val total = connection.contentLengthLong
 			var downloaded = 0L
+			var lastEmit = 0L
 
 			connection.inputStream.use { input ->
 				FileOutputStream(dest).use { output ->
@@ -226,13 +227,15 @@ class GameLibDownloader(private val context: Context) {
 							break
 						output.write(buffer, 0, read)
 						downloaded += read
-						if (total > 0) {
-							val progress = downloaded.toFloat() / total
-							withContext(Dispatchers.Main) { onProgress(progress) }
+						val now = System.currentTimeMillis()
+						if (now - lastEmit >= PROGRESS_INTERVAL_MS) {
+							lastEmit = now
+							withContext(Dispatchers.Main) { onProgress(downloaded, total) }
 						}
 					}
 				}
 			}
+			withContext(Dispatchers.Main) { onProgress(downloaded, total) }
 
 			return null
 		} catch (e: Exception) {
@@ -242,7 +245,7 @@ class GameLibDownloader(private val context: Context) {
 		}
 	}
 
-	suspend fun download(gamedir: String, onProgress: (Float) -> Unit): Result<Unit> {
+	suspend fun download(gamedir: String, onProgress: (Long, Long) -> Unit): Result<Unit> {
 		return withContext(Dispatchers.IO) {
 			val manifest = fetchManifest()
 				?: return@withContext Result.failure(IOException("Failed to fetch manifest"))
@@ -364,6 +367,7 @@ class GameLibDownloader(private val context: Context) {
 
 	companion object {
 		private const val TAG = "GameLibDownloader"
+		private const val PROGRESS_INTERVAL_MS = 100L
 		private const val RELEASE_BASE_URL =
 			"https://github.com/FWGS/hlsdk-mega-build/releases/download/continuous"
 		private const val MANIFEST_URL =

android/app/src/main/java/su/xash/engine/model/InstallStatusReceiver.kt

@@ -0,0 +1,42 @@
+package su.xash.engine.model
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.pm.PackageInstaller
+import android.os.Build
+import android.util.Log
+import android.widget.Toast
+import su.xash.engine.R
+
+class InstallStatusReceiver : BroadcastReceiver() {
+	override fun onReceive(context: Context, intent: Intent) {
+		val status = intent.getIntExtra(PackageInstaller.EXTRA_STATUS, -1)
+		when (status) {
+			PackageInstaller.STATUS_PENDING_USER_ACTION -> {
+				val confirm: Intent? = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+					intent.getParcelableExtra(Intent.EXTRA_INTENT, Intent::class.java)
+				} else {
+					@Suppress("DEPRECATION")
+					intent.getParcelableExtra(Intent.EXTRA_INTENT)
+				}
+				confirm?.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+				confirm?.let { context.startActivity(it) }
+			}
+			PackageInstaller.STATUS_SUCCESS -> Log.i(TAG, "Install succeeded")
+			else -> {
+				val msg = intent.getStringExtra(PackageInstaller.EXTRA_STATUS_MESSAGE).orEmpty()
+				Log.w(TAG, "Install status $status: $msg")
+				Toast.makeText(
+					context,
+					context.getString(R.string.engine_install_failed, msg),
+					Toast.LENGTH_LONG,
+				).show()
+			}
+		}
+	}
+
+	companion object {
+		private const val TAG = "InstallStatus"
+	}
+}

android/app/src/main/java/su/xash/engine/ui/settings/CrashLogsFragment.kt

@@ -6,7 +6,7 @@ import androidx.preference.Preference
 import androidx.preference.PreferenceFragmentCompat
 import su.xash.engine.R
 import su.xash.engine.util.CrashReports
-import java.io.File
+import su.xash.engine.util.monospaceTextView
 import java.text.SimpleDateFormat
 import java.util.Date
 import java.util.Locale
@@ -26,9 +26,12 @@ class CrashLogsFragment : PreferenceFragmentCompat() {
 		val ctx = requireContext()
 		preferenceScreen.removeAll()
 
-		val files = CrashReports.historyDir(ctx).listFiles()?.sortedByDescending { it.lastModified() } ?: emptyList()
+		val dirs = CrashReports.historyDir(ctx).listFiles()
+			?.filter { it.isDirectory }
+			?.sortedByDescending { it.lastModified() }
+			?: emptyList()
 
-		if (files.isEmpty()) {
+		if (dirs.isEmpty()) {
 			preferenceScreen.addPreference(Preference(ctx).apply {
 				setTitle(R.string.crash_logs_empty)
 				isSelectable = false
@@ -37,28 +40,27 @@ class CrashLogsFragment : PreferenceFragmentCompat() {
 		}
 
 		val fmt = SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.US)
-		files.forEach { file ->
+		dirs.forEach { dir ->
 			preferenceScreen.addPreference(Preference(ctx).apply {
-				title = fmt.format(Date(file.lastModified()))
-				summary = file.name
+				title = fmt.format(Date(dir.lastModified()))
+				summary = dir.name
 				setOnPreferenceClickListener {
-					showCrashLog(file)
+					showCrashLog(CrashReports.Entry(dir))
 					true
 				}
 			})
 		}
 	}
 
-	private fun showCrashLog(file: File) {
+	private fun showCrashLog(entry: CrashReports.Entry) {
 		val ctx = requireContext()
-		val content = file.readText()
 		AlertDialog.Builder(ctx)
-			.setTitle(file.name)
-			.setView(CrashReports.buildContentView(ctx, content))
-			.setPositiveButton(R.string.crash_send_to_developers) { _, _ -> CrashReports.sendByEmail(ctx, content) }
-			.setNeutralButton(R.string.crash_share) { _, _ -> CrashReports.share(ctx, file) }
+			.setTitle(entry.name)
+			.setView(monospaceTextView(ctx, entry.summary()))
+			.setPositiveButton(R.string.crash_send_to_developers) { _, _ -> CrashReports.sendByEmail(ctx, entry) }
+			.setNeutralButton(R.string.crash_share) { _, _ -> CrashReports.share(ctx, entry) }
 			.setNegativeButton(R.string.crash_log_delete) { _, _ ->
-				file.delete()
+				entry.dir.deleteRecursively()
 				populate()
 			}
 			.show()

android/app/src/main/java/su/xash/engine/util/CrashReports.kt

@@ -2,16 +2,17 @@ package su.xash.engine.util
 
 import android.content.Context
 import android.content.Intent
-import android.graphics.Typeface
 import android.net.Uri
-import android.util.TypedValue
-import android.view.View
-import android.widget.ScrollView
-import android.widget.TextView
+import android.os.Build
+import androidx.appcompat.app.AlertDialog
 import androidx.core.content.FileProvider
 import su.xash.engine.BuildConfig
 import su.xash.engine.R
+import java.io.BufferedOutputStream
 import java.io.File
+import java.io.FileOutputStream
+import java.util.zip.ZipEntry
+import java.util.zip.ZipOutputStream
 
 object CrashReports {
 	private const val PREFS = "crash_reports"
@@ -20,7 +21,40 @@ object CrashReports {
 
 	private const val D = "9c8d9e8c97bf9988988cd1989e86"
 
-	fun pendingFile(ctx: Context): File = File(ctx.filesDir, "crashes/crash.log")
+	const val STACKTRACE_NAME = "crash.log"
+	const val SYSINFO_NAME = "sysinfo.txt"
+	const val INTENT_NAME = "intent.txt"
+	const val ENGINELOG_NAME = "engine.log"
+
+	class Entry(val dir: File) {
+		val name: String get() = dir.name
+		val timestamp: Long get() = dir.lastModified()
+		val stacktrace: File get() = File(dir, STACKTRACE_NAME)
+		val sysinfo: File get() = File(dir, SYSINFO_NAME)
+		val intent: File get() = File(dir, INTENT_NAME)
+		val engineLog: File get() = File(dir, ENGINELOG_NAME)
+
+		fun attachments(): List<File> = listOf(stacktrace, sysinfo, intent, engineLog).filter { it.exists() && it.length() > 0 }
+
+		fun summary(): String = buildString {
+			if (stacktrace.exists())
+				append(stacktrace.readText())
+
+			if (sysinfo.exists()) {
+				append("\n--- System info ---\n").append(sysinfo.readText())
+			}
+
+			if (intent.exists()) {
+				append("\n--- XashActivity intent ---\n").append(intent.readText())
+			}
+		}
+	}
+
+	fun pendingDir(ctx: Context): File = File(ctx.filesDir, "crashes")
+	fun pendingStacktrace(ctx: Context): File = File(pendingDir(ctx), STACKTRACE_NAME)
+	fun pendingSysinfo(ctx: Context): File = File(pendingDir(ctx), SYSINFO_NAME)
+	fun pendingIntent(ctx: Context): File = File(pendingDir(ctx), INTENT_NAME)
+	fun pendingEngineLog(ctx: Context): File = File(pendingDir(ctx), ENGINELOG_NAME)
 	fun historyDir(ctx: Context): File = File(ctx.filesDir, "crashes/history")
 
 	// wipe everything on app update; otherwise drop logs older than 30 days
@@ -30,47 +64,109 @@ object CrashReports {
 		val currentVersion = BuildConfig.VERSION_CODE
 
 		if (lastVersion != currentVersion) {
-			historyDir(ctx).listFiles()?.forEach { it.delete() }
-			pendingFile(ctx).delete()
+			historyDir(ctx).deleteRecursively()
+			pendingStacktrace(ctx).delete()
+			pendingSysinfo(ctx).delete()
+			pendingIntent(ctx).delete()
+			pendingEngineLog(ctx).delete()
 			prefs.edit().putInt(KEY_LAST_VERSION, currentVersion).apply()
 			return
 		}
 
 		val cutoff = System.currentTimeMillis() - MAX_AGE_MS
-		historyDir(ctx).listFiles()?.forEach { f ->
-			if (f.lastModified() < cutoff) f.delete()
+		historyDir(ctx).listFiles()?.forEach { entry ->
+			if (entry.lastModified() < cutoff)
+				entry.deleteRecursively()
 		}
 	}
 
-	fun sendByEmail(ctx: Context, content: String) {
-		val addr = D.chunked(2) { (it.toString().toInt(16) xor 0xFF).toChar() }.joinToString("")
-		val intent = Intent(Intent.ACTION_SENDTO).apply {
-			data = Uri.fromParts("mailto", addr, null)
-			putExtra(Intent.EXTRA_SUBJECT, ctx.getString(R.string.crash_email_subject))
-			putExtra(Intent.EXTRA_TEXT, content)
+	@JvmStatic
+	fun writeSystemInfo(ctx: Context) {
+		val text = buildString {
+			append("App version: ").append(BuildConfig.VERSION_NAME).append(" (code ").append(BuildConfig.VERSION_CODE).append(")\n")
+			append("Application ID: ").append(BuildConfig.APPLICATION_ID).append('\n')
+			append("Android: ").append(Build.VERSION.RELEASE).append(" (SDK ").append(Build.VERSION.SDK_INT).append(")\n")
+			append("Manufacturer: ").append(Build.MANUFACTURER).append('\n')
+			append("Brand: ").append(Build.BRAND).append('\n')
+			append("Model: ").append(Build.MODEL).append('\n')
+			append("Device: ").append(Build.DEVICE).append('\n')
+			append("Product: ").append(Build.PRODUCT).append('\n')
+			append("Hardware: ").append(Build.HARDWARE).append('\n')
+			append("Fingerprint: ").append(Build.FINGERPRINT).append('\n')
+			append("Supported ABIs: ").append(Build.SUPPORTED_ABIS.joinToString(", ")).append('\n')
 		}
-		if (intent.resolveActivity(ctx.packageManager) != null) {
-			ctx.startActivity(intent)
+
+		runCatching {
+			pendingDir(ctx).mkdirs()
+			pendingSysinfo(ctx).writeText(text)
 		}
 	}
 
-	fun buildContentView(ctx: Context, content: String): View {
-		val pad = (16 * ctx.resources.displayMetrics.density).toInt()
-		val text = TextView(ctx).apply {
-			text = content
-			typeface = Typeface.MONOSPACE
-			setTextIsSelectable(true)
-			setTextSize(TypedValue.COMPLEX_UNIT_SP, 12f)
-			setPadding(pad, pad, pad, pad)
+	@JvmStatic
+	fun writeIntentInfo(ctx: Context, text: String) {
+		runCatching {
+			pendingDir(ctx).mkdirs()
+			pendingIntent(ctx).writeText(text)
 		}
-		return ScrollView(ctx).apply { addView(text) }
 	}
 
-	fun share(ctx: Context, file: File) {
+	private fun zipUri(ctx: Context, entry: Entry): Uri {
+		val zipDir = File(ctx.cacheDir, "crashes").apply { mkdirs() }
+		val zip = File(zipDir, "${entry.name}.zip")
+		ZipOutputStream(BufferedOutputStream(FileOutputStream(zip))).use { zos ->
+			entry.attachments().forEach { f ->
+				zos.putNextEntry(ZipEntry(f.name))
+				f.inputStream().use { it.copyTo(zos) }
+				zos.closeEntry()
+			}
+		}
 		val authority = "${BuildConfig.APPLICATION_ID}.fileprovider"
-		val uri = FileProvider.getUriForFile(ctx, authority, file)
+		return FileProvider.getUriForFile(ctx, authority, zip)
+	}
+
+	fun sendByEmail(ctx: Context, entry: Entry) {
+		val addr = D.chunked(2) { (it.toString().toInt(16) xor 0xFF).toChar() }.joinToString("")
+
+		val mailtoProbe = Intent(Intent.ACTION_SENDTO, Uri.fromParts("mailto", addr, null))
+		val mailApps = ctx.packageManager.queryIntentActivities(mailtoProbe, 0)
+		if (mailApps.isEmpty()) {
+			AlertDialog.Builder(ctx)
+				.setTitle(R.string.crash_no_mail_app_title)
+				.setMessage(R.string.crash_no_mail_app_message)
+				.setPositiveButton(android.R.string.ok, null)
+				.show()
+			return
+		}
+
+		val uri = zipUri(ctx, entry)
+		val baseSend = Intent(Intent.ACTION_SEND).apply {
+			type = "application/zip"
+			putExtra(Intent.EXTRA_EMAIL, arrayOf(addr))
+			putExtra(Intent.EXTRA_SUBJECT, ctx.getString(R.string.crash_email_subject))
+			putExtra(Intent.EXTRA_TEXT, ctx.getString(R.string.crash_email_body))
+			putExtra(Intent.EXTRA_STREAM, uri)
+			addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
+		}
+
+		val targeted = mailApps.map { ri ->
+			Intent(baseSend).apply { setPackage(ri.activityInfo.packageName) }
+		}
+
+		if (targeted.size == 1) {
+			ctx.startActivity(targeted[0])
+			return
+		}
+
+		// Multiple mail apps — show a chooser limited to them, no other share targets
+		val chooser = Intent.createChooser(targeted[0], ctx.getString(R.string.crash_send_to_developers))
+		chooser.putExtra(Intent.EXTRA_INITIAL_INTENTS, targeted.drop(1).toTypedArray())
+		ctx.startActivity(chooser)
+	}
+
+	fun share(ctx: Context, entry: Entry) {
+		val uri = zipUri(ctx, entry)
 		val intent = Intent(Intent.ACTION_SEND).apply {
-			type = "text/plain"
+			type = "application/zip"
 			putExtra(Intent.EXTRA_SUBJECT, ctx.getString(R.string.crash_email_subject))
 			putExtra(Intent.EXTRA_STREAM, uri)
 			addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)

android/app/src/main/java/su/xash/engine/util/DownloadProgress.kt

@@ -0,0 +1,69 @@
+package su.xash.engine.util
+
+import android.content.Context
+import android.text.format.Formatter
+import android.view.LayoutInflater
+import android.widget.TextView
+import com.google.android.material.dialog.MaterialAlertDialogBuilder
+import com.google.android.material.progressindicator.LinearProgressIndicator
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.launch
+import su.xash.engine.R
+
+fun showDownloadProgressDialog(
+	ctx: Context,
+	titleRes: Int,
+	cancelable: Boolean,
+	scope: CoroutineScope,
+	download: suspend ((Long, Long) -> Unit) -> Result<Unit>,
+	onSuccess: (() -> Unit)? = null,
+) {
+	val view = LayoutInflater.from(ctx).inflate(R.layout.dialog_download_progress, null)
+	val progressBar = view.findViewById<LinearProgressIndicator>(R.id.downloadProgress)
+	val statusText = view.findViewById<TextView>(R.id.downloadStatus)
+
+	val dialog = MaterialAlertDialogBuilder(ctx)
+		.setTitle(titleRes)
+		.setView(view)
+		.setCancelable(cancelable)
+		.apply {
+			if (cancelable)
+				setNegativeButton(android.R.string.cancel) { d, _ -> d.dismiss() }
+		}
+		.create()
+
+	dialog.show()
+
+	val job = scope.launch {
+		val result = download { downloaded, total ->
+			val downloadedStr = Formatter.formatShortFileSize(ctx, downloaded)
+			if (total > 0) {
+				progressBar.isIndeterminate = false
+				progressBar.progress = (downloaded * 100 / total).toInt()
+				val totalStr = Formatter.formatShortFileSize(ctx, total)
+				statusText.text = ctx.getString(R.string.download_progress, downloadedStr, totalStr)
+			} else {
+				statusText.text = ctx.getString(R.string.download_progress_unknown, downloadedStr)
+			}
+		}
+
+		if (!dialog.isShowing)
+			return@launch
+
+		dialog.dismiss()
+
+		if (result.isSuccess) {
+			onSuccess?.invoke()
+		} else {
+			MaterialAlertDialogBuilder(ctx)
+				.setTitle(R.string.download_failed)
+				.setMessage(result.exceptionOrNull()?.message
+					?: ctx.getString(R.string.download_error))
+				.setPositiveButton(android.R.string.ok, null)
+				.show()
+		}
+	}
+
+	if (cancelable)
+		dialog.setOnDismissListener { job.cancel() }
+}

android/app/src/main/java/su/xash/engine/util/MonospaceText.kt

@@ -0,0 +1,19 @@
+package su.xash.engine.util
+
+import android.content.Context
+import android.graphics.Typeface
+import android.util.TypedValue
+import android.view.View
+import android.widget.ScrollView
+import android.widget.TextView
+
+fun monospaceTextView(ctx: Context, content: String): View {
+	val pad = (16 * ctx.resources.displayMetrics.density).toInt()
+	val text = TextView(ctx).apply {
+		text = content
+		typeface = Typeface.MONOSPACE
+		setTextSize(TypedValue.COMPLEX_UNIT_SP, 12f)
+		setPadding(pad, pad, pad, pad)
+	}
+	return ScrollView(ctx).apply { addView(text) }
+}

android/app/src/main/res/values-ru/strings.xml

@@ -30,9 +30,13 @@
 	<string name="crash_logs">Журналы сбоев</string>
 	<string name="crash_logs_empty">Нет сохранённых журналов сбоев</string>
 	<string name="crash_log_delete">Удалить</string>
+	<string name="crash_email_body">К письму прикреплены подробности сбоя. Опишите, пожалуйста, как можно подробнее, что вы делали, когда игра вылетела — любая мелочь поможет нам исправить ошибку!</string>
+	<string name="crash_no_mail_app_title">Почтовое приложение не найдено</string>
+	<string name="crash_no_mail_app_message">На этом устройстве нет почтового клиента. Установите его (или воспользуйтесь кнопкой «Поделиться», чтобы отправить отчёт другим способом) и попробуйте снова.</string>
 	<string name="downloading_game_libs">Загрузка игровых библиотек</string>
 	<string name="downloading">Загрузка…</string>
-	<string name="download_progress">Загрузка… %1$d%%</string>
+	<string name="download_progress">Загрузка… %1$s / %2$s</string>
+	<string name="download_progress_unknown">Загрузка… %1$s</string>
 	<string name="download_failed">Ошибка загрузки</string>
 	<string name="download_error">Произошла ошибка при загрузке игровых библиотек.</string>
 	<string name="update_available">Доступно обновление</string>
@@ -46,4 +50,15 @@
 	<string name="source_branch">Ветка</string>
 	<string name="source_commit">Коммит</string>
 	<string name="downloaded_at">Загружено</string>
+	<string name="engine_update_available">Доступно обновление движка</string>
+	<string name="engine_update_message">Доступна сборка %1$d. Обновить?</string>
+	<string name="engine_update_changelog_header">Изменения с вашей сборки:</string>
+	<string name="engine_update_changelog_more">+ ещё %1$d коммитов</string>
+	<string name="engine_update_download">Обновить</string>
+	<string name="engine_update_later">Позже</string>
+	<string name="engine_update_downloading">Загрузка обновления</string>
+	<string name="engine_update_permission_needed">Нужно разрешение</string>
+	<string name="engine_update_permission_message">Чтобы установить обновление, разрешите Xash3D FWGS устанавливать неизвестные приложения в настройках системы.</string>
+	<string name="engine_update_open_settings">Открыть настройки</string>
+	<string name="engine_install_failed">Не удалось установить обновление: %1$s</string>
 </resources>

android/app/src/main/res/values/strings.xml

@@ -32,9 +32,13 @@
 	<string name="crash_logs_empty">No crash logs recorded</string>
 	<string name="crash_log_delete">Delete</string>
 	<string name="crash_email_subject" translatable="false">Xash3D FWGS crash report</string>
+	<string name="crash_email_body">Crash details are attached. Please describe in as much detail as possible what you were doing when the game crashed — every little thing helps us fix it!</string>
+	<string name="crash_no_mail_app_title">No mail app found</string>
+	<string name="crash_no_mail_app_message">No email client is installed on this device. Install one (or use Share to send the report another way) and try again.</string>
 	<string name="downloading_game_libs">Downloading Game Libraries</string>
 	<string name="downloading">Downloading…</string>
-	<string name="download_progress">Downloading… %1$d%%</string>
+	<string name="download_progress">Downloading… %1$s / %2$s</string>
+	<string name="download_progress_unknown">Downloading… %1$s</string>
 	<string name="download_failed">Download Failed</string>
 	<string name="download_error">An error occurred while downloading game libraries.</string>
 	<string name="update_available">Update Available</string>
@@ -48,4 +52,15 @@
 	<string name="source_branch">Branch</string>
 	<string name="source_commit">Commit</string>
 	<string name="downloaded_at">Downloaded</string>
+	<string name="engine_update_available">Engine Update Available</string>
+	<string name="engine_update_message">Build %1$d is available. Update now?</string>
+	<string name="engine_update_changelog_header">Changes since your build:</string>
+	<string name="engine_update_changelog_more">+ %1$d more commits</string>
+	<string name="engine_update_download">Update</string>
+	<string name="engine_update_later">Later</string>
+	<string name="engine_update_downloading">Downloading Update</string>
+	<string name="engine_update_permission_needed">Permission Required</string>
+	<string name="engine_update_permission_message">To install the update, allow Xash3D FWGS to install unknown apps in system settings.</string>
+	<string name="engine_update_open_settings">Open settings</string>
+	<string name="engine_install_failed">Update install failed: %1$s</string>
 </resources>

android/app/src/main/res/xml/paths.xml

@@ -1,4 +1,4 @@
 <?xml version="1.0" encoding="utf-8"?>
 <paths>
-	<files-path name="crashes" path="crashes/" />
+	<cache-path name="crash_zips" path="crashes/" />
 </paths>

common/q_client.h

@@ -30,7 +30,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 typedef struct usercmd_s
 {
 	int16_t   lerp_msec; // added in HL
-	int8_t    msec;      // added in QW
+	uint8_t   msec;      // added in QW
 	uint8_t   pad1;
 	vec3_t    viewangles;
 

common/xash3d_types.h

@@ -16,6 +16,10 @@
 #define CS_SIZE       64  // size of one config string
 #define CS_TIME	      16  // size of time string
 
+// FIXME: find better place for the shared definition
+#define MAX_CLIENT_BITS 5
+#define MAX_CLIENTS     (1<<MAX_CLIENT_BITS)// 5 bits == 32 clients ( int32 limit )
+
 // platform-specific alignment for types, to not break ABI
 #if XASH_PSP
 	#define MAYBE_ALIGNED( x ) __attribute__(( aligned( 16 )))
@@ -114,6 +118,7 @@ typedef int qboolean;
 	#define FORMAT_CHECK( x )  __attribute__(( format( printf, x, x + 1 )))
 	#define ALLOC_CHECK( x )   __attribute__(( alloc_size( x )))
 	#define WARN_UNUSED_RESULT __attribute__(( warn_unused_result ))
+	#define MAYBE_UNUSED       __attribute__(( unused ))
 	#define RENAME_SYMBOL( x ) asm( x )
 	#if !defined( offsetof )
 		#define offsetof( s, m )   __builtin_offsetof( s, m )
@@ -198,6 +203,10 @@ typedef int qboolean;
 	#define WARN_UNUSED_RESULT
 #endif // !defined( WARN_UNUSED_RESULT )
 
+#if !defined( MAYBE_UNUSED )
+	#define MAYBE_UNUSED
+#endif // !defined( MAYBE_UNUSED )
+
 #if !defined( RENAME_SYMBOL )
 	#define RENAME_SYMBOL( x )
 #endif // !defined( RENAME_SYMBOL )
@@ -268,4 +277,11 @@ typedef int qboolean;
 	#define HostFourCC( a, b, c, d ) LittleFourCC( a, b, c, d )
 #endif
 
+static inline short UnalignedShort( short *x )
+{
+	short y;
+	memcpy( &y, x, sizeof( y ) );
+	return y;
+}
+
 #endif // XASH_TYPES_H

engine/client/avi/avi_ffmpeg.c

@@ -195,7 +195,6 @@ static int AVI_OpenCodecContext( AVCodecContext **dst_dec_ctx, AVFormatContext *
 		AVI_SpewError( quiet, S_ERROR "Failed to allocate %s codec context", dec->name );
 		return AVERROR( ENOMEM );
 	}
-
 	if(( ret = pavcodec_parameters_to_context( dec_ctx, st->codecpar )) < 0 )
 	{
 		AVI_SpewAvError( quiet, "avcodec_parameters_to_context", ret );
@@ -251,8 +250,7 @@ byte *AVI_GetVideoFrame( movie_state_t *Avi, int target )
 
 static void AVI_StreamAudio( movie_state_t *Avi )
 {
-	int buffer_samples, file_samples, file_bytes;
-	rawchan_t *ch = NULL;
+	rawchan_t *ch;
 
 	// keep the same semantics, when S_RAW_SOUND_SOUNDTRACK doesn't play if S_StartStreaming wasn't enabled
 	qboolean disable_stream = Avi->entnum == S_RAW_SOUND_SOUNDTRACK ? !snd.streaming : false;
@@ -273,11 +271,11 @@ static void AVI_StreamAudio( movie_state_t *Avi )
 
 	while( ch->s_rawend < snd.soundtime + ch->max_samples )
 	{
+		int buffer_samples = ch->max_samples - (ch->s_rawend - snd.soundtime);
+		int file_samples = buffer_samples * ((float)Avi->rate / SOUND_DMA_SPEED);
+		int file_bytes;
 		size_t copy;
 
-		buffer_samples = ch->max_samples - (ch->s_rawend - snd.soundtime);
-
-		file_samples = buffer_samples * ((float)Avi->rate / SOUND_DMA_SPEED);
 		if( file_samples <= 1 ) return; // no more samples need
 
 		file_bytes = file_samples * pav_get_bytes_per_sample( Avi->s_fmt ) * Avi->channels;
@@ -308,8 +306,6 @@ static void AVI_HandleAudio( movie_state_t *Avi, const AVFrame *frame )
 {
 	int samples = frame->nb_samples;
 	size_t len = samples * pav_get_bytes_per_sample( Avi->s_fmt ) * Avi->channels;
-	int outsamples;
-	uint8_t *ptr;
 
 	// allocate data
 	if( !Avi->cached_audio )
@@ -337,8 +333,8 @@ static void AVI_HandleAudio( movie_state_t *Avi, const AVFrame *frame )
 		}
 	}
 
-	ptr = Avi->cached_audio + Avi->cached_audio_len;
-	outsamples = pswr_convert( Avi->swr_ctx, &ptr, samples, (void *)frame->data, samples );
+	uint8_t *ptr = Avi->cached_audio + Avi->cached_audio_len;
+	int outsamples = pswr_convert( Avi->swr_ctx, &ptr, samples, (void *)frame->data, samples );
 	Avi->cached_audio_len += outsamples * pav_get_bytes_per_sample( Avi->s_fmt ) * Avi->channels;
 
 	// Con_Printf( "%s: got audio chunk of size %d samples\n", __func__, outsamples );
@@ -463,8 +459,6 @@ qboolean AVI_Think( movie_state_t *Avi )
 
 void AVI_OpenVideo( movie_state_t *Avi, const char *filename, qboolean load_audio, int quiet )
 {
-	byte *dst[4];
-	int dst_linesize[4];
 	int ret;
 
 	if( Avi->active )
@@ -529,6 +523,8 @@ void AVI_OpenVideo( movie_state_t *Avi, const char *filename, qboolean load_audi
 		return;
 	}
 
+	byte *dst[4];
+	int dst_linesize[4];
 	if(( ret = pav_image_alloc( dst, dst_linesize, Avi->xres, Avi->yres, AV_PIX_FMT_BGR0, 1 )) < 0 )
 	{
 		AVI_SpewAvError( quiet, "av_image_alloc", ret );

engine/client/cl_cmds.c

@@ -61,16 +61,14 @@ Emulate audio-cd system
 */
 void CL_PlayCDTrack_f( void )
 {
-	const char	*command;
-	const char	*pszTrack;
 	static int	track = 0;
 	static qboolean	paused = false;
 	static qboolean	looped = false;
 	static qboolean	enabled = true;
 
 	if( Cmd_Argc() < 2 ) return;
-	command = Cmd_Argv( 1 );
-	pszTrack = Cmd_Argv( 2 );
+	const char	*command = Cmd_Argv( 1 );
+	const char	*pszTrack = Cmd_Argv( 2 );
 
 	if( !enabled && Q_stricmp( command, "on" ))
 		return; // CD-player is disabled
@@ -238,9 +236,7 @@ static scrshot_t CL_GetScreenshotTypeFromString( const char *string )
 void CL_GenericShot_f( void )
 {
 	const char *argv0 = Cmd_Argv( 0 );
-	scrshot_t type;
-
-	type = CL_GetScreenshotTypeFromString( argv0 );
+	scrshot_t type = CL_GetScreenshotTypeFromString( argv0 );
 
 	if( type == scrshot_normal || type == scrshot_snapshot )
 	{
@@ -272,7 +268,6 @@ void CL_GenericShot_f( void )
 	case scrshot_snapshot:
 	{
 		string checkname;
-		int i;
 
 		// allow overriding screenshot by users request
 		if( Cmd_Argc() > 1 )
@@ -284,7 +279,7 @@ void CL_GenericShot_f( void )
 		if( type == scrshot_snapshot )
 			FS_AllowDirectPaths( true );
 
-		for( i = 0; i < 9999; i++ )
+		for( int i = 0; i < 9999; i++ )
 		{
 			int ret;
 
@@ -383,17 +378,14 @@ CL_WavePlayLen_f
 */
 void CL_WavePlayLen_f( void )
 {
-	const char *name;
-	uint msecs;
-
 	if( Cmd_Argc() != 2 )
 	{
 		Con_Printf( "waveplaylen <wave file name>: returns approximate number of milliseconds a wave file will take to play.\n" );
 		return;
 	}
 
-	name = Cmd_Argv( 1 );
-	msecs = Sound_GetApproxWavePlayLen( name );
+	const char *name = Cmd_Argv( 1 );
+	uint msecs = Sound_GetApproxWavePlayLen( name );
 
 	if( msecs == 0 )
 	{

engine/client/cl_custom.c

@@ -130,9 +130,7 @@ void CL_MoveToOnHandList( resource_t *pResource )
 
 static void CL_ClearResourceList( resource_t *pList )
 {
-	resource_t	*p, *n;
-
-	for( p = pList->pNext; p != pList && p; p = n )
+	for( resource_t *p = pList->pNext, *n; p != pList && p; p = n )
 	{
 		n = p->pNext;
 

engine/client/cl_debug.c

@@ -50,7 +50,7 @@ const char *CL_MsgInfo( int cmd )
 		// get engine message name
 		const char *svc_string = NULL;
 
-		switch( cls.legacymode )
+		switch( cls.net_protocol )
 		{
 		case PROTO_CURRENT:
 			svc_string = svc_strings[cmd];
@@ -71,9 +71,7 @@ const char *CL_MsgInfo( int cmd )
 	}
 	else if( cmd > svc_lastmsg && cmd <= ( svc_lastmsg + MAX_USER_MESSAGES ))
 	{
-		int	i;
-
-		for( i = 0; i < MAX_USER_MESSAGES; i++ )
+		for( int i = 0; i < MAX_USER_MESSAGES; i++ )
 		{
 			if( clgame.msg[i].number == cmd )
 			{
@@ -106,11 +104,9 @@ record new message params into debug buffer
 */
 void CL_Parse_RecordCommand( int cmd, int startoffset )
 {
-	int	slot;
-
 	if( cmd == svc_nop ) return;
 
-	slot = ( cls_message_debug.currentcmd++ & MSG_MASK );
+	int	slot = ( cls_message_debug.currentcmd++ & MSG_MASK );
 	cls_message_debug.oldcmd[slot].command = cmd;
 	cls_message_debug.oldcmd[slot].starting_offset = startoffset;
 	cls_message_debug.oldcmd[slot].frame_number = host.framecount;
@@ -141,9 +137,7 @@ write net_message into buffer.dat for debugging
 static void CL_WriteErrorMessage( int current_count, sizebuf_t *msg )
 {
 	const char	*buffer_file = "buffer.dat";
-	file_t		*fp;
-
-	fp = FS_Open( buffer_file, "wb", false );
+	file_t		*fp = FS_Open( buffer_file, "wb", false );
 	if( !fp )
 	{
 		Con_Printf( S_ERROR "%s: can't open %s for write\n", __func__, buffer_file );
@@ -152,7 +146,7 @@ static void CL_WriteErrorMessage( int current_count, sizebuf_t *msg )
 
 	FS_Write( fp, &cls.starting_count, sizeof( int ));
 	FS_Write( fp, &current_count, sizeof( int ));
-	FS_Write( fp, &cls.legacymode, sizeof( cls.legacymode ));
+	FS_Write( fp, &cls.net_protocol, sizeof( cls.net_protocol ));
 	FS_Write( fp, MSG_GetData( msg ), MSG_GetMaxBytes( msg ));
 	FS_Close( fp );
 
@@ -170,7 +164,7 @@ void CL_WriteMessageHistory( void )
 {
 	oldcmd_t	*old;
 	sizebuf_t	*msg = &net_message;
-	int	i, thecmd;
+	int	thecmd;
 
 	if( !cls.initialized || cls.state == ca_disconnected )
 		return;
@@ -184,7 +178,7 @@ void CL_WriteMessageHistory( void )
 	thecmd = cls_message_debug.currentcmd - 1;
 	thecmd -= ( MSG_COUNT - 1 );	// back up to here
 
-	for( i = 0; i < MSG_COUNT - 1; i++ )
+	for( int i = 0; i < MSG_COUNT - 1; i++ )
 	{
 		thecmd &= MSG_MASK;
 		old = &cls_message_debug.oldcmd[thecmd];
@@ -213,7 +207,7 @@ void CL_ReplayBufferDat_f( void )
 	FS_Read( f, &current_count, sizeof( current_count ));
 	FS_Read( f, &protocol, sizeof( protocol ));
 
-	cls.legacymode = protocol;
+	cls.net_protocol = protocol;
 
 	len = FS_Read( f, buffer, sizeof( buffer ));
 	FS_Close( f );

engine/client/cl_demo.c

@@ -245,8 +245,6 @@ Writes the demo command header and time-delta
 */
 static void CL_WriteDemoCmdHeader( byte cmd, file_t *file )
 {
-	float	dt;
-
 	Assert( cmd >= 1 && cmd <= dem_lastcmd );
 	if( !file ) return;
 
@@ -254,7 +252,7 @@ static void CL_WriteDemoCmdHeader( byte cmd, file_t *file )
 	FS_Write( file, &cmd, sizeof( byte ));
 
 	// time offset
-	dt = (float)(CL_GetDemoRecordClock() - demo.starttime);
+	float dt = (float)(CL_GetDemoRecordClock() - demo.starttime);
 	FS_Write( file, &dt, sizeof( float ));
 }
 
@@ -395,11 +393,6 @@ Write demo header
 */
 static void CL_WriteDemoHeader( const char *name )
 {
-	double maxfps;
-	int copysize;
-	int savepos;
-	int curpos;
-
 	Con_Printf( "recording to %s.\n", name );
 	cls.demofile = FS_Open( name, "wb", false );
 	cls.demotime = 0.0;
@@ -413,13 +406,13 @@ static void CL_WriteDemoHeader( const char *name )
 	cls.demorecording = true;
 	cls.demowaiting = true;	// don't start saving messages until a non-delta compressed message is received
 
-	maxfps = fps_override.value ? MAX_FPS_HARD : MAX_FPS_SOFT;
+	double maxfps = fps_override.value ? MAX_FPS_HARD : MAX_FPS_SOFT;
 
 	memset( &demo.header, 0, sizeof( demo.header ));
 
 	demo.header.id = IDEMOHEADER;
 	demo.header.dem_protocol = DEMO_PROTOCOL;
-	demo.header.net_protocol = CL_GetDemoNetProtocol( cls.legacymode );
+	demo.header.net_protocol = CL_GetDemoNetProtocol( cls.net_protocol );
 	demo.header.host_fps = host_maxfps.value ? bound( MIN_FPS, host_maxfps.value, maxfps ) : maxfps;
 	Q_strncpy( demo.header.mapname, clgame.mapname, sizeof( demo.header.mapname ));
 	Q_strncpy( demo.header.comment, clgame.maptitle, sizeof( demo.header.comment ));
@@ -442,6 +435,7 @@ static void CL_WriteDemoHeader( const char *name )
 	FS_Flush( cls.demoheader );
 
 	// now copy the stuff we cached from the server.
+	int copysize, savepos;
 	copysize = savepos = FS_Tell( cls.demoheader );
 
 	FS_Seek( cls.demoheader, 0, SEEK_SET );
@@ -458,7 +452,7 @@ static void CL_WriteDemoHeader( const char *name )
 	cls.td_lastframe = -1;			// get a new message this frame
 
 	// now move on to entry # 1, the first data chunk.
-	curpos = FS_Tell( cls.demofile );
+	int curpos = FS_Tell( cls.demofile );
 	demo.entry->length = curpos - demo.entry->offset;
 
 	// now we are writing the first real lump.
@@ -487,19 +481,15 @@ finish recording demo
 */
 static void CL_StopRecord( void )
 {
-	int	i, curpos;
-	float	stoptime;
-	int	frames;
-
 	if( !cls.demorecording ) return;
 
 	// demo playback should read this as an incoming message.
 	CL_WriteDemoCmdHeader( dem_stop, cls.demofile );
 
-	stoptime = CL_GetDemoRecordClock();
+	float stoptime = CL_GetDemoRecordClock();
 	if( clgame.hInstance ) clgame.dllFuncs.pfnReset();
 
-	curpos = FS_Tell( cls.demofile );
+	int curpos = FS_Tell( cls.demofile );
 	demo.entry->length = curpos - demo.entry->offset;
 	demo.entry->playback_time = stoptime - demo.realstarttime;
 	demo.entry->playback_frames = demo.framecount;
@@ -507,7 +497,7 @@ static void CL_StopRecord( void )
 	//  Now write out the directory and free it and touch up the demo header.
 	FS_Write( cls.demofile, &demo.directory.numentries, sizeof( int ));
 
-	for( i = 0; i < demo.directory.numentries; i++ )
+	for( int i = 0; i < demo.directory.numentries; i++ )
 		FS_Write( cls.demofile, &demo.directory.entries[i], sizeof( demoentry_t ));
 
 	Mem_Free( demo.directory.entries );
@@ -525,7 +515,7 @@ static void CL_StopRecord( void )
 	gameui.globals->demoname[0] = '\0';
 	demo.header.host_fps = 0.0;
 
-	frames = cls.td_lastframe - cls.td_startframe;
+	int frames = cls.td_lastframe - cls.td_startframe;
 	Con_Printf( "Completed demo\nRecording time: %02d:%02d, frames %i\n", (int)(cls.demotime / 60.0f), (int)fmod(cls.demotime, 60.0f), frames );
 	cls.demotime = 0.0;
 }
@@ -539,13 +529,12 @@ void CL_DrawDemoRecording( void )
 {
 	char	string[64];
 	rgba_t	color = { 255, 255, 255, 255 };
-	int	pos;
 	int	len;
 
 	if(!( host_developer.value && cls.demorecording ))
 		return;
 
-	pos = FS_Tell( cls.demofile );
+	int pos = FS_Tell( cls.demofile );
 	Q_snprintf( string, sizeof( string ), "^1RECORDING:^7 %s: %s time: %02d:%02d", cls.demoname,
 		Q_memprint( pos ), (int)(cls.demotime / 60.0f ), (int)fmod( cls.demotime, 60.0f ));
 
@@ -734,7 +723,7 @@ static void CL_DemoStartPlayback( int mode )
 
 	demo.starttime = CL_GetDemoPlaybackClock(); // for determining whether to read another message
 
-	CL_SetupNetchanForProtocol( cls.legacymode );
+	CL_SetupNetchanForProtocol( cls.net_protocol );
 
 	memset( demo.cmds, 0, sizeof( demo.cmds ));
 	demo.angle_position = 1;
@@ -847,7 +836,6 @@ static qboolean CL_DemoReadMessageQuake( byte *buffer, size_t *length )
 {
 	vec3_t		viewangles;
 	int		msglen = 0;
-	demoangle_t	*a;
 
 	*length = 0; // assume we fail
 
@@ -888,7 +876,7 @@ static qboolean CL_DemoReadMessageQuake( byte *buffer, size_t *length )
 	{
 		// select entry into circular buffer
 		demo.angle_position = (demo.angle_position + 1) & ANGLE_MASK;
-		a = &demo.cmds[demo.angle_position];
+		demoangle_t *a = &demo.cmds[demo.angle_position];
 
 		// record update
 		a->starttime = demo.timestamp;
@@ -1060,8 +1048,7 @@ qboolean CL_DemoReadMessage( byte *buffer, size_t *length )
 
 static void CL_DemoFindInterpolatedViewAngles( float t, float *frac, demoangle_t **prev, demoangle_t **next )
 {
-	int	i, i0, i1, imod;
-	float	at;
+	int	i0, i1, imod;
 
 	if( cls.timedemo ) return;
 
@@ -1071,9 +1058,9 @@ static void CL_DemoFindInterpolatedViewAngles( float t, float *frac, demoangle_t
 
 	if( demo.cmds[i0].starttime >= t )
 	{
-		for( i = 0; i < ANGLE_BACKUP - 2; i++ )
+		for( int i = 0; i < ANGLE_BACKUP - 2; i++ )
 		{
-			at = demo.cmds[imod & ANGLE_MASK].starttime;
+			float at = demo.cmds[imod & ANGLE_MASK].starttime;
 			if( at == 0.0f ) break;
 
 			if( at < t )
@@ -1114,7 +1101,6 @@ void CL_DemoInterpolateAngles( void )
 {
 	demoangle_t	*prev = NULL, *next = NULL;
 	float		frac = 0.0f;
-	float		curtime;
 
 	if( cls.demoplayback == DEMO_QUAKE1 )
 	{
@@ -1126,7 +1112,7 @@ void CL_DemoInterpolateAngles( void )
 	}
 	else
 	{
-		curtime = (CL_GetDemoPlaybackClock() - demo.starttime) - host.frametime;
+		float curtime = (CL_GetDemoPlaybackClock() - demo.starttime) - host.frametime;
 		if( curtime > demo.timestamp )
 			curtime = demo.timestamp; // don't run too far
 
@@ -1239,7 +1225,6 @@ int GAME_EXPORT CL_GetDemoComment( const char *demoname, char *comment )
 	demodirectory_t	directory;
 	demoentry_t	entry;
 	float		playtime = 0.0f;
-	int		i;
 
 	if( !comment ) return false;
 
@@ -1279,7 +1264,7 @@ int GAME_EXPORT CL_GetDemoComment( const char *demoname, char *comment )
 		return false;
 	}
 
-	for( i = 0; i < directory.numentries; i++ )
+	for( int i = 0; i < directory.numentries; i++ )
 	{
 		FS_Read( demfile, &entry, sizeof( demoentry_t ));
 		playtime += entry.playback_time;
@@ -1388,7 +1373,6 @@ void CL_Record_f( void )
 {
 	string		demoname, demopath;
 	const char	*name;
-	int		n;
 
 	if( Cmd_Argc() == 1 )
 	{
@@ -1425,6 +1409,7 @@ void CL_Record_f( void )
 	if( !Q_stricmp( name, "new" ))
 	{
 		// scan for a free filename
+		int n;
 		for( n = 0; n < 10000; n++ )
 		{
 			CL_DemoGetName( n, demoname, sizeof( demoname ));
@@ -1511,7 +1496,7 @@ void CL_PlayDemo_f( void )
 {
 	char	filename[MAX_QPATH];
 	char	demoname[MAX_QPATH];
-	int	i, ident;
+	int	ident;
 
 	if( Cmd_Argc() < 2 )
 	{
@@ -1570,7 +1555,7 @@ void CL_PlayDemo_f( void )
 
 		if( neg ) cls.forcetrack = -cls.forcetrack;
 		CL_DemoStartPlayback( DEMO_QUAKE1 );
-		cls.legacymode = PROTO_QUAKE;
+		cls.net_protocol = PROTO_QUAKE;
 		return; // quake demo is started
 	}
 
@@ -1584,7 +1569,7 @@ void CL_PlayDemo_f( void )
 	// allocate demo entries
 	demo.directory.entries = Mem_Malloc( cls.mempool, sizeof( *demo.directory.entries ) * demo.directory.numentries );
 
-	for( i = 0; i < demo.directory.numentries; i++ )
+	for( int i = 0; i < demo.directory.numentries; i++ )
 	{
 		demoentry_t *entry = &demo.directory.entries[i];
 
@@ -1606,7 +1591,7 @@ void CL_PlayDemo_f( void )
 	CL_DemoStartPlayback( DEMO_XASH3D );
 
 	// must be after DemoStartPlayback, as CL_Disconnect_f resets the protocol
-	cls.legacymode = CL_GetProtocolFromDemo( demo.header.net_protocol );
+	cls.net_protocol = CL_GetProtocolFromDemo( demo.header.net_protocol );
 
 	// g-cont. is this need?
 	Q_strncpy( cls.servername, demoname, sizeof( cls.servername ));
@@ -1640,15 +1625,13 @@ CL_StartDemos_f
 */
 void CL_StartDemos_f( void )
 {
-	int	i, c;
-
 	if( cls.key_dest != key_menu )
 	{
 		Con_Printf( "'startdemos' is not valid from the console\n" );
 		return;
 	}
 
-	c = Cmd_Argc() - 1;
+	int c = Cmd_Argc() - 1;
 	if( c > MAX_DEMOS )
 	{
 		Con_DPrintf( S_WARN "%s: max %i demos in demoloop\n", __func__, MAX_DEMOS );
@@ -1657,7 +1640,7 @@ void CL_StartDemos_f( void )
 
 	Con_Printf( "%i demo%s in loop\n", c, (c > 1) ? "s" : "" );
 
-	for( i = 1; i < c + 1; i++ )
+	for( int i = 1; i < c + 1; i++ )
 		Q_strncpy( cls.demos[i-1], Cmd_Argv( i ), sizeof( cls.demos[0] ));
 	cls.demos_pending = true;
 }
@@ -1717,7 +1700,6 @@ void CL_ListDemo_f( void )
 	file_t *f;
 	char filename[MAX_QPATH];
 	char demoname[MAX_QPATH];
-	int i;
 
 	if( Cmd_Argc() < 2 )
 	{
@@ -1751,7 +1733,7 @@ void CL_ListDemo_f( void )
 		filename, hdr.net_protocol, hdr.dem_protocol, hdr.host_fps, hdr.mapname,
 		hdr.comment, hdr.gamedir );
 
-	for( i = 0; i < num_entries; i++ )
+	for( int i = 0; i < num_entries; i++ )
 	{
 		demoentry_t entry;
 

engine/client/cl_efrag.c

@@ -39,7 +39,6 @@ static efrag_t *cl_efrags;
 
 static efrag_t *CL_AllocEfrags( int num )
 {
-	int i;
 	efrag_t *efrags;
 
 	if( !cl.worldmodel )
@@ -55,7 +54,7 @@ static efrag_t *CL_AllocEfrags( int num )
 	efrags = Mem_Calloc( cl.worldmodel->mempool, sizeof( *efrags ) * num );
 
 	// initialize linked list
-	for( i = 0; i < num - 1; i++ )
+	for( int i = 0; i < num - 1; i++ )
 		efrags[i].entnext = &efrags[i + 1];
 
 	cl_efrags_num += num;
@@ -81,8 +80,6 @@ R_SplitEntityOnNode
 */
 static void R_SplitEntityOnNode( mnode_t *node )
 {
-	efrag_t	*ef;
-	mleaf_t	*leaf;
 	int	sides;
 
 	if( node->contents == CONTENTS_SOLID )
@@ -91,6 +88,9 @@ static void R_SplitEntityOnNode( mnode_t *node )
 	// add an efrag if the node is a leaf
 	if( node->contents < 0 )
 	{
+		efrag_t	*ef;
+		mleaf_t	*leaf;
+
 		if( !r_pefragtopnode )
 			r_pefragtopnode = node;
 
@@ -142,7 +142,6 @@ void R_AddEfrags( cl_entity_t *ent )
 {
 	matrix3x4	transform;
 	vec3_t	outmins, outmaxs;
-	int	i;
 
 	if( !ent->model )
 		return;
@@ -155,7 +154,7 @@ void R_AddEfrags( cl_entity_t *ent )
 	Matrix3x4_CreateFromEntity( transform, ent->angles, vec3_origin, 1.0f );
 	Matrix3x4_TransformAABB( transform, ent->model->mins, ent->model->maxs, outmins, outmaxs );
 
-	for( i = 0; i < 3; i++ )
+	for( int i = 0; i < 3; i++ )
 	{
 		r_emins[i] = ent->origin[i] + outmins[i];
 		r_emaxs[i] = ent->origin[i] + outmaxs[i];
@@ -174,13 +173,11 @@ R_StoreEfrags
 void R_StoreEfrags( efrag_t **ppefrag, int framecount )
 {
 	efrag_t *pefrag;
-	cl_entity_t *pent;
-	model_t *clmodel;
 
 	while(( pefrag = *ppefrag ) != NULL )
 	{
-		pent = pefrag->entity;
-		clmodel = pent->model;
+		cl_entity_t *pent = pefrag->entity;
+		model_t *clmodel = pent->model;
 
 		// how this could happen?
 		if( unlikely( clmodel->type < mod_brush || clmodel->type > mod_studio ))

engine/client/cl_efx.c

@@ -44,21 +44,17 @@ find nearest color in particle palette
 */
 short GAME_EXPORT R_LookupColor( byte r, byte g, byte b )
 {
-	int	i, best;
-	float	diff, bestdiff;
-	float	rf, gf, bf;
+	float	bestdiff = 999999;
+	int	best = -1;
 
-	bestdiff = 999999;
-	best = -1;
-
-	for( i = 0; i < 256; i++ )
+	for( int i = 0; i < 256; i++ )
 	{
-		rf = r - clgame.palette[i].r;
-		gf = g - clgame.palette[i].g;
-		bf = b - clgame.palette[i].b;
+		float rf = r - clgame.palette[i].r;
+		float gf = g - clgame.palette[i].g;
+		float bf = b - clgame.palette[i].b;
 
 		// convert color to monochrome
-		diff = rf * (rf * 0.2f) + gf * (gf * 0.5f) + bf * (bf * 0.3f);
+		float diff = rf * (rf * 0.2f) + gf * (gf * 0.5f) + bf * (bf * 0.3f);
 
 		if ( diff < bestdiff )
 		{
@@ -90,13 +86,11 @@ CL_InitParticles
 */
 void CL_InitParticles( void )
 {
-	int	i;
-
 	cl_particles = Mem_Calloc( cls.mempool, sizeof( particle_t ) * GI->max_particles );
 	CL_ClearParticles ();
 
 	// this is used for EF_BRIGHTFIELD
-	for( i = 0; i < NUMVERTEXNORMALS; i++ )
+	for( int i = 0; i < NUMVERTEXNORMALS; i++ )
 	{
 		cl_avelocities[i][0] = COM_RandomFloat( 0.0f, 2.55f );
 		cl_avelocities[i][1] = COM_RandomFloat( 0.0f, 2.55f );
@@ -116,15 +110,13 @@ CL_ClearParticles
 */
 void CL_ClearParticles( void )
 {
-	int	i;
-
 	if( !cl_particles ) return;
 
 	cl_free_particles = cl_particles;
 	cl_active_particles = NULL;
 	cl_active_tracers = NULL;
 
-	for( i = 0; i < GI->max_particles - 1; i++ )
+	for( int i = 0; i < GI->max_particles - 1; i++ )
 		cl_particles[i].next = &cl_particles[i+1];
 
 	cl_particles[GI->max_particles-1].next = NULL;
@@ -357,15 +349,13 @@ CL_ClearViewBeams
 */
 void CL_ClearViewBeams( void )
 {
-	int	i;
-
 	if( !cl_viewbeams ) return;
 
 	// clear beams
 	cl_free_beams = cl_viewbeams;
 	cl_active_beams = NULL;
 
-	for( i = 0; i < GI->max_beams - 1; i++ )
+	for( int i = 0; i < GI->max_beams - 1; i++ )
 		cl_viewbeams[i].next = &cl_viewbeams[i+1];
 	cl_viewbeams[GI->max_beams - 1].next = NULL;
 }
@@ -416,7 +406,6 @@ void CL_KillDeadBeams( cl_entity_t *pDeadEntity )
 
 	while( pbeam )
 	{
-		cl_entity_t *beament;
 		pnext = pbeam->next;
 
 		// link into new list.
@@ -471,16 +460,13 @@ Optimized version of pointfile - use beams instead of particles
 */
 void CL_ReadLineFile_f( void )
 {
-	byte *afile;
-	char *pfile;
 	vec3_t		p1, p2;
-	int		count, modelIndex;
+	int		modelIndex;
 	char		filename[MAX_QPATH];
-	model_t		*model;
 	string		token;
 
 	Q_snprintf( filename, sizeof( filename ), "maps/%s.lin", clgame.mapname );
-	afile = FS_LoadFile( filename, NULL, false );
+	byte *afile = FS_LoadFile( filename, NULL, false );
 
 	if( !afile )
 	{
@@ -490,9 +476,9 @@ void CL_ReadLineFile_f( void )
 
 	Con_Printf( "Reading %s...\n", filename );
 
-	count = 0;
-	pfile = (char *)afile;
-	model = CL_LoadModel( DEFAULT_LASERBEAM_PATH, &modelIndex );
+	int count = 0;
+	char *pfile = (char *)afile;
+	model_t *model = CL_LoadModel( DEFAULT_LASERBEAM_PATH, &modelIndex );
 
 	while( 1 )
 	{
@@ -1064,25 +1050,20 @@ set EF_BRIGHTFIELD effect
 */
 void GAME_EXPORT R_EntityParticles( cl_entity_t *ent )
 {
-	float		angle;
-	float		sr, sp, sy, cr, cp, cy;
-	vec3_t		forward;
-	particle_t	*p;
-	int		i;
-
-	for( i = 0; i < NUMVERTEXNORMALS; i++ )
+	for( int i = 0; i < NUMVERTEXNORMALS; i++ )
 	{
-		p = R_AllocParticle( NULL );
+		particle_t *p = R_AllocParticle( NULL );
 		if( !p ) return;
 
-		angle = cl.time * cl_avelocities[i][0];
+		float sr, sp, sy, cr, cp, cy;
+		float angle = cl.time * cl_avelocities[i][0];
 		SinCos( angle, &sy, &cy );
 		angle = cl.time * cl_avelocities[i][1];
 		SinCos( angle, &sp, &cp );
 		angle = cl.time * cl_avelocities[i][2];
 		SinCos( angle, &sr, &cr );
 
-		VectorSet( forward, cp * cy, cp * sy, -sp );
+		vec3_t forward = { cp * cy, cp * sy, -sp };
 
 		p->die = cl.time + 0.001f;
 		p->color = 111; // yellow
@@ -1099,19 +1080,16 @@ R_ParticleExplosion
 */
 void GAME_EXPORT R_ParticleExplosion( const vec3_t org )
 {
-	particle_t	*p;
-	int		i, j;
-
-	for( i = 0; i < 1024; i++ )
+	for( int i = 0; i < 1024; i++ )
 	{
-		p = R_AllocParticle( NULL );
+		particle_t *p = R_AllocParticle( NULL );
 		if( !p ) return;
 
 		p->die = cl.time + 5.0f;
 		p->ramp = COM_RandomLong( 0, 3 );
 		p->color = ramp1[0];
 
-		for( j = 0; j < 3; j++ )
+		for( int j = 0; j < 3; j++ )
 		{
 			p->org[j] = org[j] + COM_RandomFloat( -16.0f, 16.0f );
 			p->vel[j] = COM_RandomFloat( -256.0f, 256.0f );
@@ -1130,15 +1108,12 @@ R_ParticleExplosion2
 */
 void GAME_EXPORT R_ParticleExplosion2( const vec3_t org, int colorStart, int colorLength )
 {
-	int		i, j;
-	int		colorMod = 0, packedColor;
-	particle_t	*p;
+	int colorMod = 0;
+	int packedColor = Host_IsQuakeCompatible( ) ? 255 : 0; // use old code for blob particles
 
-	packedColor = Host_IsQuakeCompatible( ) ? 255 : 0; // use old code for blob particles
-
-	for( i = 0; i < 512; i++ )
+	for( int i = 0; i < 512; i++ )
 	{
-		p = R_AllocParticle( NULL );
+		particle_t *p = R_AllocParticle( NULL );
 		if( !p ) return;
 
 		p->die = cl.time + 0.3f;
@@ -1148,7 +1123,7 @@ void GAME_EXPORT R_ParticleExplosion2( const vec3_t org, int colorStart, int col
 
 		p->type = pt_blob;
 
-		for( j = 0; j < 3; j++ )
+		for( int j = 0; j < 3; j++ )
 		{
 			p->org[j] = org[j] + COM_RandomFloat( -16.0f, 16.0f );
 			p->vel[j] = COM_RandomFloat( -256.0f, 256.0f );
@@ -1164,14 +1139,11 @@ R_BlobExplosion
 */
 void GAME_EXPORT R_BlobExplosion( const vec3_t org )
 {
-	particle_t	*p;
-	int		i, j, packedColor;
+	int packedColor = Host_IsQuakeCompatible( ) ? 255 : 0; // use old code for blob particles
 
-	packedColor = Host_IsQuakeCompatible( ) ? 255 : 0; // use old code for blob particles
-
-	for( i = 0; i < 1024; i++ )
+	for( int i = 0; i < 1024; i++ )
 	{
-		p = R_AllocParticle( NULL );
+		particle_t *p = R_AllocParticle( NULL );
 		if( !p ) return;
 
 		p->die = cl.time + COM_RandomFloat( 1.0f, 1.4f );
@@ -1188,7 +1160,7 @@ void GAME_EXPORT R_BlobExplosion( const vec3_t org )
 			p->color = COM_RandomLong( 150, 155 );
 		}
 
-		for( j = 0; j < 3; j++ )
+		for( int j = 0; j < 3; j++ )
 		{
 			p->org[j] = org[j] + COM_RandomFloat( -16.0f, 16.0f );
 			p->vel[j] = COM_RandomFloat( -256.0f, 256.0f );
@@ -1205,9 +1177,6 @@ PARTICLE_EFFECT on server
 */
 void GAME_EXPORT R_RunParticleEffect( const vec3_t org, const vec3_t dir, int color, int count )
 {
-	particle_t	*p;
-	int		i;
-
 	if( count == 1024 )
 	{
 		// rocket explosion
@@ -1215,9 +1184,9 @@ void GAME_EXPORT R_RunParticleEffect( const vec3_t org, const vec3_t dir, int co
 		return;
 	}
 
-	for( i = 0; i < count; i++ )
+	for( int i = 0; i < count; i++ )
 	{
-		p = R_AllocParticle( NULL );
+		particle_t *p = R_AllocParticle( NULL );
 		if( !p ) return;
 
 		p->color = (color & ~7) + COM_RandomLong( 0, 7 );
@@ -1239,20 +1208,18 @@ particle spray
 void GAME_EXPORT R_Blood( const vec3_t org, const vec3_t ndir, int pcolor, int speed )
 {
 	vec3_t		pos, dir, vec;
-	int		i, j;
 	int		pspeed = speed * 3;
-	particle_t	*p;
 
 	VectorNormalize2( ndir, dir );
 
-	for( i = 0; i < (speed / 2); i++ )
+	for( int i = 0; i < (speed / 2); i++ )
 	{
 		VectorAddScalar( org, COM_RandomFloat( -3.0f, 3.0f ), pos );
 		VectorAddScalar( dir, COM_RandomFloat( -0.06f, 0.06f ), vec );
 
-		for( j = 0; j < 8; j++ )
+		for( int j = 0; j < 8; j++ )
 		{
-			p = R_AllocParticle( NULL );
+			particle_t *p = R_AllocParticle( NULL );
 			if( !p ) return;
 
 			p->die = cl.time + 1.5f;
@@ -1276,17 +1243,15 @@ particle spray 2
 */
 void GAME_EXPORT R_BloodStream( const vec3_t org, const vec3_t ndir, int pcolor, int speed )
 {
-	particle_t	*p;
-	int		i, j;
-	float		arc;
 	int		accel = speed; // must be integer due to bug in GoldSrc
 	vec3_t dir;
 
 	VectorNormalize2( ndir, dir );
 
-	for( arc = 0.05f, i = 0; i < 100; i++ )
+	float arc = 0.05f;
+	for( int i = 0; i < 100; i++ )
 	{
-		p = R_AllocParticle( NULL );
+		particle_t *p = R_AllocParticle( NULL );
 		if( !p ) return;
 
 		p->die = cl.time + 2.0f;
@@ -1302,11 +1267,10 @@ void GAME_EXPORT R_BloodStream( const vec3_t org, const vec3_t ndir, int pcolor,
 		accel -= 0.00001f; // so last few will drip
 	}
 
-	for( arc = 0.075f, i = 0; i < ( speed / 5 ); i++ )
+	arc = 0.075f;
+	for( int i = 0; i < ( speed / 5 ); i++ )
 	{
-		float	num;
-
-		p = R_AllocParticle( NULL );
+		particle_t *p = R_AllocParticle( NULL );
 		if( !p ) return;
 
 		p->die = cl.time + 3.0f;
@@ -1319,14 +1283,14 @@ void GAME_EXPORT R_BloodStream( const vec3_t org, const vec3_t ndir, int pcolor,
 		p->vel[2] -= arc;
 		arc -= 0.005f;
 
-		num = COM_RandomFloat( 0.0f, 1.0f );
+		float num = COM_RandomFloat( 0.0f, 1.0f );
 		accel = speed * num;
 		num *= 1.7f;
 
 		VectorScale( p->vel, num, p->vel );
 		VectorScale( p->vel, accel, p->vel );
 
-		for( j = 0; j < 2; j++ )
+		for( int j = 0; j < 2; j++ )
 		{
 			p = R_AllocParticle( NULL );
 			if( !p ) return;
@@ -1353,18 +1317,15 @@ R_LavaSplash
 */
 void GAME_EXPORT R_LavaSplash( const vec3_t org )
 {
-	particle_t	*p;
-	float		vel;
 	vec3_t		dir;
-	int		i, j, k;
 
-	for( i = -16; i < 16; i++ )
+	for( int i = -16; i < 16; i++ )
 	{
-		for( j = -16; j <16; j++ )
+		for( int j = -16; j <16; j++ )
 		{
-			for( k = 0; k < 1; k++ )
+			for( int k = 0; k < 1; k++ )
 			{
-				p = R_AllocParticle( NULL );
+				particle_t *p = R_AllocParticle( NULL );
 				if( !p ) return;
 
 				p->die = cl.time + COM_RandomFloat( 2.0f, 2.62f );
@@ -1380,7 +1341,7 @@ void GAME_EXPORT R_LavaSplash( const vec3_t org )
 				p->org[2] = org[2] + COM_RandomFloat( 0.0f, 63.0f );
 
 				VectorNormalize( dir );
-				vel = COM_RandomFloat( 50.0f, 113.0f );
+				float vel = COM_RandomFloat( 50.0f, 113.0f );
 				VectorScale( dir, vel, p->vel );
 			}
 		}
@@ -1395,16 +1356,13 @@ R_ParticleBurst
 */
 void GAME_EXPORT R_ParticleBurst( const vec3_t org, int size, int color, float life )
 {
-	particle_t	*p;
 	vec3_t		dir, dest;
-	int		i, j;
-	float		dist;
 
-	for( i = 0; i < 32; i++ )
+	for( int i = 0; i < 32; i++ )
 	{
-		for( j = 0; j < 32; j++ )
+		for( int j = 0; j < 32; j++ )
 		{
-			p = R_AllocParticle( NULL );
+			particle_t *p = R_AllocParticle( NULL );
 			if( !p ) return;
 
 			p->die = cl.time + life + COM_RandomFloat( -0.5f, 0.5f );
@@ -1414,7 +1372,7 @@ void GAME_EXPORT R_ParticleBurst( const vec3_t org, int size, int color, float l
 			VectorCopy( org, p->org );
 			VectorAddScalar( org, COM_RandomFloat( -size, size ), dest );
 			VectorSubtract( dest, p->org, dir );
-			dist = VectorNormalizeLength( dir );
+			float dist = VectorNormalizeLength( dir );
 			VectorScale( dir, ( dist / life ), p->vel );
 		}
 	}
@@ -1428,16 +1386,13 @@ R_LargeFunnel
 */
 void GAME_EXPORT R_LargeFunnel( const vec3_t org, int reverse )
 {
-	particle_t	*p;
-	float		vel, dist;
 	vec3_t		dir, dest;
-	int		i, j;
 
-	for( i = -8; i < 8; i++ )
+	for( int i = -8; i < 8; i++ )
 	{
-		for( j = -8; j < 8; j++ )
+		for( int j = -8; j < 8; j++ )
 		{
-			p = R_AllocParticle( NULL );
+			particle_t *p = R_AllocParticle( NULL );
 			if( !p ) return;
 
 			dest[0] = (i * 32.0f) + org[0];
@@ -1455,10 +1410,10 @@ void GAME_EXPORT R_LargeFunnel( const vec3_t org, int reverse )
 				VectorSubtract( org, p->org, dir );
 			}
 
-			vel = dest[2] / 8.0f;
+			float vel = dest[2] / 8.0f;
 			if( vel < 64.0f ) vel = 64.0f;
 
-			dist = VectorNormalizeLength( dir );
+			float dist = VectorNormalizeLength( dir );
 			vel += COM_RandomFloat( 64.0f, 128.0f );
 			VectorScale( dir, vel, p->vel );
 			p->die = cl.time + (dist / vel );
@@ -1475,18 +1430,15 @@ R_TeleportSplash
 */
 void GAME_EXPORT R_TeleportSplash( const vec3_t org )
 {
-	particle_t	*p;
 	vec3_t		dir;
-	float		vel;
-	int		i, j, k;
 
-	for( i = -16; i < 16; i += 4 )
+	for( int i = -16; i < 16; i += 4 )
 	{
-		for( j = -16; j < 16; j += 4 )
+		for( int j = -16; j < 16; j += 4 )
 		{
-			for( k = -24; k < 32; k += 4 )
+			for( int k = -24; k < 32; k += 4 )
 			{
-				p = R_AllocParticle( NULL );
+				particle_t *p = R_AllocParticle( NULL );
 				if( !p ) return;
 
 				p->die = cl.time + COM_RandomFloat( 0.2f, 0.34f );
@@ -1502,7 +1454,7 @@ void GAME_EXPORT R_TeleportSplash( const vec3_t org )
 				p->org[2] = org[2] + k + COM_RandomFloat( 0.0f, 3.0f );
 
 				VectorNormalize( dir );
-				vel = COM_RandomFloat( 50.0f, 113.0f );
+				float vel = COM_RandomFloat( 50.0f, 113.0f );
 				VectorScale( dir, vel, p->vel );
 			}
 		}
@@ -1639,13 +1591,12 @@ draw line from particles
 */
 static void PM_ParticleLine( const vec3_t start, const vec3_t end, int pcolor, float life, float zvel )
 {
-	float	len, curdist;
 	vec3_t	diff, pos;
 
 	// determine distance
 	VectorSubtract( end, start, diff );
-	len = VectorNormalizeLength( diff );
-	curdist = 0;
+	float len = VectorNormalizeLength( diff );
+	float curdist = 0;
 
 	while( curdist <= len )
 	{
@@ -1679,9 +1630,8 @@ static void PM_DrawBBox( const vec3_t mins, const vec3_t maxs, const vec3_t orig
 {
 	vec3_t	p[8], tmp;
 	float	gap = BOX_GAP;
-	int	i;
 
-	for( i = 0; i < 8; i++ )
+	for( int i = 0; i < 8; i++ )
 	{
 		tmp[0] = (i & 1) ? mins[0] - gap : maxs[0] + gap;
 		tmp[1] = (i & 2) ? mins[1] - gap : maxs[1] + gap ;
@@ -1691,7 +1641,7 @@ static void PM_DrawBBox( const vec3_t mins, const vec3_t maxs, const vec3_t orig
 		VectorCopy( tmp, p[i] );
 	}
 
-	for( i = 0; i < 6; i++ )
+	for( int i = 0; i < 6; i++ )
 	{
 		PM_DrawRectangle( p[boxpnt[i][1]], p[boxpnt[i][0]], p[boxpnt[i][2]], p[boxpnt[i][3]], pcolor, life );
 	}
@@ -1705,9 +1655,7 @@ R_ParticleLine
 */
 void GAME_EXPORT R_ParticleLine( const vec3_t start, const vec3_t end, byte r, byte g, byte b, float life )
 {
-	int	pcolor;
-
-	pcolor = R_LookupColor( r, g, b );
+	int pcolor = R_LookupColor( r, g, b );
 	PM_ParticleLine( start, end, pcolor, life, 0 );
 }
 
@@ -1721,9 +1669,8 @@ void GAME_EXPORT R_ParticleBox( const vec3_t absmin, const vec3_t absmax, byte r
 {
 	vec3_t	mins, maxs;
 	vec3_t	origin;
-	int	pcolor;
 
-	pcolor = R_LookupColor( r, g, b );
+	int pcolor = R_LookupColor( r, g, b );
 
 	VectorAverage( absmax, absmin, origin );
 	VectorSubtract( absmax, origin, maxs );
@@ -1740,20 +1687,18 @@ R_ShowLine
 */
 void GAME_EXPORT R_ShowLine( const vec3_t start, const vec3_t end )
 {
-	vec3_t		dir, org;
-	float		len;
-	particle_t	*p;
+	vec3_t		dir;
 
 	VectorSubtract( end, start, dir );
-	len = VectorNormalizeLength( dir );
+	float len = VectorNormalizeLength( dir );
 	VectorScale( dir, 5.0f, dir );
-	VectorCopy( start, org );
+	vec3_t org = Vec3( start );
 
 	while( len > 0 )
 	{
 		len -= 5.0f;
 
-		p = R_AllocParticle( NULL );
+		particle_t *p = R_AllocParticle( NULL );
 		if( !p ) return;
 
 		p->die = cl.time + 30;
@@ -1772,25 +1717,21 @@ R_BulletImpactParticles
 */
 void GAME_EXPORT R_BulletImpactParticles( const vec3_t pos )
 {
-	int		i, quantity;
-	int		color;
-	float		dist;
 	vec3_t		dir;
-	particle_t	*p;
 
 	VectorSubtract( pos, refState.vieworg, dir );
-	dist = VectorLength( dir );
+	float dist = VectorLength( dir );
 	if( dist > 1000.0f ) dist = 1000.0f;
 
-	quantity = (1000.0f - dist) / 100.0f;
+	int quantity = (1000.0f - dist) / 100.0f;
 	if( quantity == 0 ) quantity = 1;
 
-	color = 3 - ((30 * quantity) / 100 );
+	int color = 3 - ((30 * quantity) / 100 );
 	R_SparkStreaks( pos, 2, -200, 200 );
 
-	for( i = 0; i < quantity * 4; i++ )
+	for( int i = 0; i < quantity * 4; i++ )
 	{
-		p = R_AllocParticle( NULL );
+		particle_t *p = R_AllocParticle( NULL );
 		if( !p ) return;
 
 		VectorCopy( pos, p->org);
@@ -1814,12 +1755,9 @@ R_FlickerParticles
 */
 void GAME_EXPORT R_FlickerParticles( const vec3_t org )
 {
-	particle_t	*p;
-	int		i;
-
-	for( i = 0; i < 15; i++ )
+	for( int i = 0; i < 15; i++ )
 	{
-		p = R_AllocParticle( NULL );
+		particle_t *p = R_AllocParticle( NULL );
 		if( !p ) return;
 
 		VectorCopy( org, p->org );
@@ -1843,15 +1781,13 @@ create a splash of streaks
 void GAME_EXPORT R_StreakSplash( const vec3_t pos, const vec3_t dir, int color, int count, float speed, int velocityMin, int velocityMax )
 {
 	vec3_t		vel, vel2;
-	particle_t	*p;
-	int		i;
 
 	VectorScale( dir, speed, vel );
 
-	for( i = 0; i < count; i++ )
+	for( int i = 0; i < count; i++ )
 	{
 		VectorAddScalar( vel, COM_RandomFloat( velocityMin, velocityMax ), vel2 );
-		p = R_AllocTracer( pos, vel2, COM_RandomFloat( 0.1f, 0.5f ));
+		particle_t *p = R_AllocTracer( pos, vel2, COM_RandomFloat( 0.1f, 0.5f ));
 		if( !p ) return;
 
 		p->type = pt_grav;
@@ -1869,9 +1805,7 @@ pmove debugging particle
 */
 void CL_Particle( const vec3_t org, int color, float life, int zpos, int zvel )
 {
-	particle_t	*p;
-
-	p = R_AllocParticle( NULL );
+	particle_t *p = R_AllocParticle( NULL );
 	if( !p ) return;
 
 	if( org ) VectorCopy( org, p->org );
@@ -1889,17 +1823,15 @@ R_TracerEffect
 void GAME_EXPORT R_TracerEffect( const vec3_t start, const vec3_t end )
 {
 	vec3_t	pos, vel, dir;
-	float	len, speed;
-	float	offset;
 
-	speed = Q_max( tracerspeed.value, 3.0f );
+	float speed = Q_max( tracerspeed.value, 3.0f );
 
 	VectorSubtract( end, start, dir );
-	len = VectorLength( dir );
+	float len = VectorLength( dir );
 	if( len == 0.0f ) return;
 
 	VectorScale( dir, 1.0f / len, dir ); // normalize
-	offset = COM_RandomFloat( -10.0f, 9.0f ) + traceroffset.value;
+	float offset = COM_RandomFloat( -10.0f, 9.0f ) + traceroffset.value;
 	VectorScale( dir, offset, vel );
 	VectorAdd( start, vel, pos );
 	VectorScale( dir, speed, vel );
@@ -1950,17 +1882,15 @@ create a streak tracers
 */
 void GAME_EXPORT R_SparkStreaks( const vec3_t pos, int count, int velocityMin, int velocityMax )
 {
-	particle_t	*p;
 	vec3_t		vel;
-	int		i;
 
-	for( i = 0; i<count; i++ )
+	for( int i = 0; i<count; i++ )
 	{
 		vel[0] = COM_RandomFloat( velocityMin, velocityMax );
 		vel[1] = COM_RandomFloat( velocityMin, velocityMax );
 		vel[2] = COM_RandomFloat( velocityMin, velocityMax );
 
-		p = R_AllocTracer( pos, vel, COM_RandomFloat( 0.1f, 0.5f ));
+		particle_t *p = R_AllocTracer( pos, vel, COM_RandomFloat( 0.1f, 0.5f ));
 		if( !p ) return;
 
 		p->color = 5;
@@ -1980,14 +1910,11 @@ void GAME_EXPORT R_Implosion( const vec3_t end, float radius, int count, float l
 {
 	float		dist = ( radius / 100.0f );
 	vec3_t		start, temp, vel;
-	float		factor;
-	particle_t	*p;
-	int		i;
 
 	if( life <= 0.0f ) life = 0.1f; // to avoid divide by zero
-	factor = -1.0 / life;
+	float factor = -1.0 / life;
 
-	for ( i = 0; i < count; i++ )
+	for( int i = 0; i < count; i++ )
 	{
 		temp[0] = dist * COM_RandomFloat( -100.0f, 100.0f );
 		temp[1] = dist * COM_RandomFloat( -100.0f, 100.0f );
@@ -1995,7 +1922,8 @@ void GAME_EXPORT R_Implosion( const vec3_t end, float radius, int count, float l
 		VectorScale( temp, factor, vel );
 		VectorAdd( temp, end, start );
 
-		if(( p = R_AllocTracer( start, vel, life )) == NULL )
+		particle_t *p = R_AllocTracer( start, vel, life );
+		if( p == NULL )
 			return;
 
 		p->type = pt_explode;
@@ -2060,16 +1988,12 @@ CL_ReadPointFile_f
 */
 void CL_ReadPointFile_f( void )
 {
-	byte *afile;
-	char *pfile;
 	vec3_t		org;
-	int		count;
-	particle_t	*p;
 	char		filename[64];
 	string		token;
 
 	Q_snprintf( filename, sizeof( filename ), "maps/%s.pts", clgame.mapname );
-	afile = FS_LoadFile( filename, NULL, false );
+	byte *afile = FS_LoadFile( filename, NULL, false );
 
 	if( !afile )
 	{
@@ -2079,8 +2003,8 @@ void CL_ReadPointFile_f( void )
 
 	Con_Printf( "Reading %s...\n", filename );
 
-	count = 0;
-	pfile = (char *)afile;
+	int count = 0;
+	char *pfile = (char *)afile;
 
 	while( 1 )
 	{
@@ -2106,7 +2030,7 @@ void CL_ReadPointFile_f( void )
 
 		// NOTE: can't use R_AllocParticle because this command
 		// may be executed from the console, while frametime is 0
-		p = cl_free_particles;
+		particle_t *p = cl_free_particles;
 		cl_free_particles = p->next;
 		p->next = cl_active_particles;
 		cl_active_particles = p;

engine/client/cl_events.c

@@ -42,10 +42,6 @@ compute velocity for a given client
 */
 static void CL_CalcPlayerVelocity( int idx, vec3_t velocity )
 {
-	clientdata_t	*pcd;
-	vec3_t		delta;
-	double		dt;
-
 	VectorClear( velocity );
 
 	if( idx <= 0 || idx > cl.maxclients )
@@ -53,15 +49,16 @@ static void CL_CalcPlayerVelocity( int idx, vec3_t velocity )
 
 	if( idx == cl.playernum + 1 )
 	{
-		pcd = &cl.frames[cl.parsecountmod].clientdata;
+		clientdata_t *pcd = &cl.frames[cl.parsecountmod].clientdata;
 		VectorCopy( pcd->velocity, velocity );
 	}
 	else
 	{
-		dt = clgame.entities[idx].curstate.animtime - clgame.entities[idx].prevstate.animtime;
+		double dt = clgame.entities[idx].curstate.animtime - clgame.entities[idx].prevstate.animtime;
 
 		if( dt != 0.0 )
 		{
+			vec3_t delta;
 			VectorSubtract( clgame.entities[idx].curstate.velocity, clgame.entities[idx].prevstate.velocity, delta );
 			VectorScale( delta, 1.0f / dt, velocity );
 		}
@@ -130,16 +127,13 @@ CL_SetEventIndex
 */
 void CL_SetEventIndex( const char *szEvName, int ev_index )
 {
-	cl_user_event_t	*ev;
-	int		i;
-
 	if( !szEvName || !*szEvName )
 		return; // ignore blank names
 
 	// search event by name to link with
-	for( i = 0; i < MAX_EVENTS; i++ )
+	for( int i = 0; i < MAX_EVENTS; i++ )
 	{
-		ev = clgame.events[i];
+		cl_user_event_t *ev = clgame.events[i];
 		if( !ev ) break;
 
 		if( !Q_stricmp( ev->name, szEvName ))
@@ -158,12 +152,10 @@ CL_EventIndex
 */
 word CL_EventIndex( const char *name )
 {
-	word	i;
-
 	if( COM_StringEmptyOrNULL( name ))
 		return 0;
 
-	for( i = 1; i < MAX_EVENTS && cl.event_precache[i][0]; i++ )
+	for( word i = 1; i < MAX_EVENTS && cl.event_precache[i][0]; i++ )
 	{
 		if( !Q_stricmp( cl.event_precache[i], name ))
 			return i;
@@ -204,28 +196,24 @@ CL_FireEvent
 */
 static qboolean CL_FireEvent( event_info_t *ei, int slot )
 {
-	cl_user_event_t	*ev;
-	const char	*name;
-	int		i, idx;
-
 	if( !ei || !ei->index )
 		return false;
 
 	// get the func pointer
-	for( i = 0; i < MAX_EVENTS; i++ )
+	for( int i = 0; i < MAX_EVENTS; i++ )
 	{
-		ev = clgame.events[i];
+		cl_user_event_t *ev = clgame.events[i];
 
 		if( !ev )
 		{
-			idx = bound( 1, ei->index, ( MAX_EVENTS - 1 ));
+			int idx = bound( 1, ei->index, ( MAX_EVENTS - 1 ));
 			Con_Reportf( S_ERROR "%s: %s not precached\n", __func__, cl.event_precache[idx] );
 			break;
 		}
 
 		if( ev->index == ei->index )
 		{
-			name = cl.event_precache[ei->index];
+			const char *name = cl.event_precache[ei->index];
 
 			if( cl_trace_events.value )
 			{
@@ -261,15 +249,11 @@ called right before draw frame
 */
 void CL_FireEvents( void )
 {
-	event_state_t	*es;
-	event_info_t	*ei;
-	int		i;
+	event_state_t *es = &cl.events;
 
-	es = &cl.events;
-
-	for( i = 0; i < MAX_EVENT_QUEUE; i++ )
+	for( int i = 0; i < MAX_EVENT_QUEUE; i++ )
 	{
-		ei = &es->ei[i];
+		event_info_t *ei = &es->ei[i];
 
 		if( ei->index == 0 )
 			continue;
@@ -294,16 +278,12 @@ find first empty event
 */
 static event_info_t *CL_FindEmptyEvent( void )
 {
-	int		i;
-	event_state_t	*es;
-	event_info_t	*ei;
-
-	es = &cl.events;
+	event_state_t *es = &cl.events;
 
 	// look for first slot where index is != 0
-	for( i = 0; i < MAX_EVENT_QUEUE; i++ )
+	for( int i = 0; i < MAX_EVENT_QUEUE; i++ )
 	{
-		ei = &es->ei[i];
+		event_info_t *ei = &es->ei[i];
 		if( ei->index != 0 )
 			continue;
 		return ei;
@@ -322,15 +302,11 @@ replace only unreliable events
 */
 static event_info_t *CL_FindUnreliableEvent( void )
 {
-	event_state_t	*es;
-	event_info_t	*ei;
-	int		i;
+	event_state_t *es = &cl.events;
 
-	es = &cl.events;
-
-	for ( i = 0; i < MAX_EVENT_QUEUE; i++ )
+	for ( int i = 0; i < MAX_EVENT_QUEUE; i++ )
 	{
-		ei = &es->ei[i];
+		event_info_t *ei = &es->ei[i];
 		if( ei->index != 0 )
 		{
 			// it's reliable, so skip it
@@ -423,16 +399,10 @@ CL_ParseEvent
 */
 void CL_ParseEvent( sizebuf_t *msg, connprotocol_t proto )
 {
-	int		event_index;
-	int		i, num_events;
-	int		packet_index;
 	const event_args_t nullargs = { 0 };
 	event_args_t args = { 0 };
-	entity_state_t	*state;
-	float		delay;
 	int		entity_bits;
-
-	num_events = MSG_ReadUBitLong( msg, 5 );
+	int		num_events = MSG_ReadUBitLong( msg, 5 );
 
 	if( proto == PROTO_GOLDSRC )
 		entity_bits = MAX_GOLDSRC_ENTITY_BITS;
@@ -440,9 +410,11 @@ void CL_ParseEvent( sizebuf_t *msg, connprotocol_t proto )
 		entity_bits = MAX_ENTITY_BITS;
 
 	// parse events queue
-	for( i = 0 ; i < num_events; i++ )
+	for( int i = 0 ; i < num_events; i++ )
 	{
-		event_index = MSG_ReadUBitLong( msg, MAX_EVENT_BITS );
+		int packet_index;
+		float delay;
+		int event_index = MSG_ReadUBitLong( msg, MAX_EVENT_BITS );
 
 		if( MSG_ReadOneBit( msg ))
 		{
@@ -467,7 +439,7 @@ void CL_ParseEvent( sizebuf_t *msg, connprotocol_t proto )
 
 			if( packet_index < frame->num_entities )
 			{
-				state = &cls.packet_entities[(frame->first_entity+packet_index)%cls.num_client_entities];
+				entity_state_t *state = &cls.packet_entities[(frame->first_entity+packet_index)%cls.num_client_entities];
 				args.entindex = state->number;
 
 				if( VectorIsNull( args.origin ))
@@ -515,8 +487,6 @@ CL_PlaybackEvent
 void GAME_EXPORT CL_PlaybackEvent( int flags, const edict_t *pInvoker, word eventindex, float delay, float *origin,
 	float *angles, float fparam1, float fparam2, int iparam1, int iparam2, int bparam1, int bparam2 )
 {
-	event_args_t	args;
-
 	if( FBitSet( flags, FEV_SERVER ))
 		return;
 
@@ -538,20 +508,20 @@ void GAME_EXPORT CL_PlaybackEvent( int flags, const edict_t *pInvoker, word even
 	ClearBits( flags, FEV_NOTHOST|FEV_HOSTONLY|FEV_GLOBAL );
 	if( delay < 0.0f ) delay = 0.0f; // fixup negative delays
 
-	memset( &args, 0, sizeof( args ));
-
-	VectorCopy( origin, args.origin );
-	VectorCopy( angles, args.angles );
-	VectorCopy( cl.simvel, args.velocity );
-	args.entindex = cl.playernum + 1;
-	args.ducking = ( cl.local.usehull == 1 );
-
-	args.fparam1 = fparam1;
-	args.fparam2 = fparam2;
-	args.iparam1 = iparam1;
-	args.iparam2 = iparam2;
-	args.bparam1 = bparam1;
-	args.bparam2 = bparam2;
+	event_args_t	args =
+	{
+		.origin = Vec3( origin ),
+		.angles = Vec3( angles ),
+		.velocity = Vec3( cl.simvel ),
+		.entindex = cl.playernum + 1,
+		.ducking = ( cl.local.usehull == 1 ),
+		.fparam1 = fparam1,
+		.fparam2 = fparam2,
+		.iparam1 = iparam1,
+		.iparam2 = iparam2,
+		.bparam1 = bparam1,
+		.bparam2 = bparam2,
+	};
 
 	CL_QueueEvent( flags, eventindex, delay, &args );
 }

engine/client/cl_font.c

@@ -39,17 +39,14 @@ qboolean CL_FixedFont( cl_font_t *font )
 
 static int CL_LoadFontTexture( const char *fontname, uint texFlags, int *width )
 {
-	int font_width;
-	int tex;
-
 	if( !g_fsapi.FileExists( fontname, false ))
 		return 0;
 
-	tex = ref.dllFuncs.GL_LoadTexture( fontname, NULL, 0, texFlags );
+	int tex = ref.dllFuncs.GL_LoadTexture( fontname, NULL, 0, texFlags );
 	if( !tex )
 		return 0;
 
-	font_width = REF_GET_PARM( PARM_TEX_WIDTH, tex );
+	int font_width = REF_GET_PARM( PARM_TEX_WIDTH, tex );
 	if( !font_width )
 	{
 		ref.dllFuncs.GL_FreeTexture( tex );
@@ -89,7 +86,7 @@ void CL_SetFontColor( cl_font_t *font, const rgba_t color )
 
 qboolean Con_LoadFixedWidthFont( const char *fontname, cl_font_t *font, float scale, convar_t *rendermode, uint texFlags )
 {
-	int font_width, i;
+	int font_width;
 
 	if( !rendermode )
 		return false;
@@ -107,7 +104,7 @@ qboolean Con_LoadFixedWidthFont( const char *fontname, cl_font_t *font, float sc
 	font->rendermode = rendermode;
 	font->charHeight = Q_rint( font_width / 16 * scale );
 
-	for( i = 0; i < ARRAYSIZE( font->fontRc ); i++ )
+	for( int i = 0; i < ARRAYSIZE( font->fontRc ); i++ )
 	{
 		font->fontRc[i].left   = ( i * font_width / 16 ) % font_width;
 		font->fontRc[i].right  = font->fontRc[i].left + font_width / 16;
@@ -124,8 +121,7 @@ qboolean Con_LoadVariableWidthFont( const char *fontname, cl_font_t *font, float
 {
 	fs_offset_t length;
 	qfont_t src;
-	byte *pfile;
-	int font_width, i;
+	int font_width;
 
 	if( !rendermode )
 		return false;
@@ -133,7 +129,7 @@ qboolean Con_LoadVariableWidthFont( const char *fontname, cl_font_t *font, float
 	if( font->valid )
 		return true;
 
-	pfile = g_fsapi.LoadFile( fontname, &length, false );
+	byte *pfile = g_fsapi.LoadFile( fontname, &length, false );
 	if( !pfile )
 		return false;
 
@@ -157,7 +153,7 @@ qboolean Con_LoadVariableWidthFont( const char *fontname, cl_font_t *font, float
 	font->rendermode = rendermode;
 	font->charHeight = Q_rint( src.rowheight * scale );
 
-	for( i = 0; i < ARRAYSIZE( font->fontRc ); i++ )
+	for( int i = 0; i < ARRAYSIZE( font->fontRc ); i++ )
 	{
 		const charinfo *ci = &src.fontinfo[i];
 
@@ -195,11 +191,6 @@ static int CL_CalcTabStop( const cl_font_t *font, int x )
 
 int CL_DrawCharacter( float x, float y, int number, const rgba_t color, cl_font_t *font, int flags )
 {
-	wrect_t *rc;
-	float w, h;
-	float s1, t1, s2, t2, half = 0.5f;
-	int texw, texh;
-
 	if( !font || !font->valid || y < -font->charHeight )
 		return 0;
 
@@ -220,21 +211,23 @@ int CL_DrawCharacter( float x, float y, int number, const rgba_t color, cl_font_
 	if( !number || !font->charWidths[number])
 		return 0;
 
+	int texw, texh;
 	R_GetTextureParms( &texw, &texh, font->hFontTexture );
 	if( !texw || !texh )
 		return font->charWidths[number];
 
-	rc = &font->fontRc[number];
+	wrect_t *rc = &font->fontRc[number];
+	float half = 0.5f;
 
 	if( font->scale <= 1.f || !REF_GET_PARM( PARM_TEX_FILTERING, font->hFontTexture ))
 		half = 0;
 
-	s1 = ((float)rc->left + half ) / texw;
-	t1 = ((float)rc->top + half ) / texh;
-	s2 = ((float)rc->right - half ) / texw;
-	t2 = ((float)rc->bottom - half ) / texh;
-	w = ( rc->right - rc->left ) * font->scale;
-	h = ( rc->bottom - rc->top ) * font->scale;
+	float s1 = ((float)rc->left + half ) / texw;
+	float t1 = ((float)rc->top + half ) / texh;
+	float s2 = ((float)rc->right - half ) / texw;
+	float t2 = ((float)rc->bottom - half ) / texh;
+	float w = ( rc->right - rc->left ) * font->scale;
+	float h = ( rc->bottom - rc->top ) * font->scale;
 
 	if( FBitSet( flags, FONT_DRAW_HUD ))
 		SPR_AdjustSize( &x, &y, &w, &h );

engine/client/cl_frame.c

@@ -41,12 +41,10 @@ Store another position into interpolation circular buffer
 */
 static void CL_UpdatePositions( cl_entity_t *ent )
 {
-	position_history_t	*ph, *prev;
-
-	prev = &ent->ph[ent->current_position];
+	position_history_t *prev = &ent->ph[ent->current_position & HISTORY_MASK];
 
 	ent->current_position = (ent->current_position + 1) & HISTORY_MASK;
-	ph = &ent->ph[ent->current_position];
+	position_history_t *ph = &ent->ph[ent->current_position];
 	VectorCopy( ent->curstate.origin, ph->origin );
 	VectorCopy( ent->curstate.angles, ph->angles );
 
@@ -74,11 +72,10 @@ Interpolation init or reset after teleporting
 */
 static void CL_ResetPositions( cl_entity_t *ent )
 {
-	position_history_t	store;
+	if( !ent )
+		return;
 
-	if( !ent ) return;
-
-	store = ent->ph[ent->current_position];
+	position_history_t store = ent->ph[ent->current_position & HISTORY_MASK];
 	ent->current_position = 1;
 
 	memset( ent->ph, 0, sizeof( position_history_t ) * HISTORY_MAX );
@@ -95,14 +92,13 @@ we don't want interpolate this
 */
 static qboolean CL_EntityTeleported( cl_entity_t *ent )
 {
-	float	len, maxlen;
 	vec3_t	delta;
 
 	VectorSubtract( ent->curstate.origin, ent->prevstate.origin, delta );
 
 	// compute potential max movement in units per frame and compare with entity movement
-	maxlen = ( clgame.movevars.maxvelocity * ( 1.0f / GAME_FPS ));
-	len = VectorLength( delta );
+	float maxlen = ( clgame.movevars.maxvelocity * ( 1.0f / GAME_FPS ));
+	float len = VectorLength( delta );
 
 	return (len > maxlen);
 }
@@ -170,22 +166,23 @@ check for parametrical moved entities
 */
 static qboolean CL_ParametricMove( cl_entity_t *ent )
 {
-	float	frac, dt, t;
 	vec3_t	delta;
 
 	if( ent->curstate.starttime == 0.0f || ent->curstate.impacttime == 0.0f )
 		return false;
 
 	VectorSubtract( ent->curstate.endpos, ent->curstate.startpos, delta );
-	dt = ent->curstate.impacttime - ent->curstate.starttime;
+	float dt = ent->curstate.impacttime - ent->curstate.starttime;
 
 	if( dt != 0.0f )
 	{
+		float t;
+
 		if( ent->lastmove > cl.time )
 			t = ent->lastmove;
 		else t = cl.time;
 
-		frac = ( t - ent->curstate.starttime ) / dt;
+		float frac = ( t - ent->curstate.starttime ) / dt;
 		frac = bound( 0.0f, frac, 1.0f );
 		VectorMA( ent->curstate.startpos, frac, delta, ent->curstate.origin );
 
@@ -240,18 +237,14 @@ CL_GetStudioEstimatedFrame
 */
 static float CL_GetStudioEstimatedFrame( cl_entity_t *ent )
 {
-	studiohdr_t	*pstudiohdr;
-	mstudioseqdesc_t	*pseqdesc;
-	int		sequence;
-
 	if( ent->model != NULL && ent->model->type == mod_studio )
 	{
-		pstudiohdr = (studiohdr_t *)Mod_StudioExtradata( ent->model );
+		studiohdr_t *pstudiohdr = (studiohdr_t *)Mod_StudioExtradata( ent->model );
 
 		if( pstudiohdr && pstudiohdr->numseq > 0 )
 		{
-			sequence = bound( 0, ent->curstate.sequence, pstudiohdr->numseq - 1 );
-			pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex) + sequence;
+			int sequence = bound( 0, ent->curstate.sequence, pstudiohdr->numseq - 1 );
+			mstudioseqdesc_t *pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex) + sequence;
 			return ref.dllFuncs.R_StudioEstimateFrame( ent, pseqdesc, cl.time );
 		}
 	}
@@ -302,8 +295,6 @@ apply changes since new frame received
 */
 static void CL_ProcessEntityUpdate( cl_entity_t *ent )
 {
-	qboolean	parametric;
-
 	ent->model = CL_ModelHandle( ent->curstate.modelindex );
 	ent->index = ent->curstate.number;
 
@@ -325,7 +316,7 @@ static void CL_ProcessEntityUpdate( cl_entity_t *ent )
 			VectorCopy( aiment->origin, ent->curstate.origin );
 	}
 
-	parametric = ent->curstate.starttime != 0.0f && ent->curstate.impacttime != 0.0f;
+	qboolean parametric = ent->curstate.starttime != 0.0f && ent->curstate.impacttime != 0.0f;
 
 	// allow interpolation on bmodels too
 	if( ent->model && ent->model->type == mod_brush )
@@ -364,13 +355,11 @@ find two timestamps
 static qboolean CL_FindInterpolationUpdates( cl_entity_t *ent, double targettime, position_history_t **ph0, position_history_t **ph1 )
 {
 	qboolean	extrapolate = true;
-	uint		i, i0, i1, imod;
+	uint		imod = ent->current_position;
+	uint		i0 = (imod - 0) & HISTORY_MASK;	// curpos (lerp end)
+	uint		i1 = (imod - 1) & HISTORY_MASK;	// oldpos (lerp start)
 
-	imod = ent->current_position;
-	i0 = (imod - 0) & HISTORY_MASK;	// curpos (lerp end)
-	i1 = (imod - 1) & HISTORY_MASK;	// oldpos (lerp start)
-
-	for( i = 1; i < HISTORY_MAX - 1; i++ )
+	for( uint i = 1; i < HISTORY_MAX - 1; i++ )
 	{
 		double at = ent->ph[( imod - i ) & HISTORY_MASK].animtime;
 
@@ -402,19 +391,19 @@ non-local players interpolation
 */
 static void CL_PureOrigin( cl_entity_t *ent, double t, vec3_t outorigin, vec3_t outangles )
 {
-	double		t1, t0, frac;
 	position_history_t	*ph0, *ph1;
-	vec3_t		delta;
 
 	// NOTE: ph0 is next, ph1 is a prev
 	CL_FindInterpolationUpdates( ent, t, &ph0, &ph1 );
 
-	t0 = ph0->animtime;
-	t1 = ph1->animtime;
+	double t0 = ph0->animtime;
+	double t1 = ph1->animtime;
 
 	if( t0 != 0.0 )
 	{
 		vec4_t	q, q1, q2;
+		vec3_t	delta;
+		double	frac;
 
 		VectorSubtract( ph0->origin, ph1->origin, delta );
 
@@ -450,7 +439,6 @@ static int CL_InterpolateModel( cl_entity_t *e )
 {
 	position_history_t  *ph0 = NULL, *ph1 = NULL;
 	vec3_t		origin, angles, delta;
-	double		t, t1, t2, frac;
 	vec4_t		q, q1, q2;
 
 	VectorCopy( e->curstate.origin, e->origin );
@@ -479,11 +467,11 @@ static int CL_InterpolateModel( cl_entity_t *e )
 	if( cl.local.moving && cl.local.onground == e->index )
 		return 1;
 
-	t = cl.time - cl_interp.value;
+	double t = cl.time - cl_interp.value;
 	CL_FindInterpolationUpdates( e, t, &ph0, &ph1 );
 
-	t1 = ph1->animtime;
-	t2 = ph0->animtime;
+	double t1 = ph1->animtime;
+	double t2 = ph0->animtime;
 
 	if( t - t1 < 0.0f )
 		return 0;
@@ -503,7 +491,7 @@ static int CL_InterpolateModel( cl_entity_t *e )
 	}
 
 	VectorSubtract( ph0->origin, ph1->origin, delta );
-	frac = (t - t1) / (t2 - t1);
+	double frac = (t - t1) / (t2 - t1);
 
 	if( frac < 0.0f )
 		return 0;
@@ -533,8 +521,6 @@ interpolate non-local clients
 */
 void CL_ComputePlayerOrigin( cl_entity_t *ent )
 {
-	double	targettime;
-	vec4_t	q, q1, q2;
 	vec3_t	origin;
 	vec3_t	angles;
 
@@ -550,6 +536,8 @@ void CL_ComputePlayerOrigin( cl_entity_t *ent )
 
 	if( cls.demoplayback == DEMO_QUAKE1 )
 	{
+		vec4_t	q, q1, q2;
+
 		// quake lerping is easy
 		VectorLerp( ent->prevstate.origin, cl.lerpFrac, ent->curstate.origin, ent->origin );
 		AngleQuaternion( ent->prevstate.angles, q1, false );
@@ -559,7 +547,7 @@ void CL_ComputePlayerOrigin( cl_entity_t *ent )
 		return;
 	}
 
-	targettime = cl.time - cl_interp.value;
+	double targettime = cl.time - cl_interp.value;
 	CL_PureOrigin( ent, targettime, origin, angles );
 
 	VectorCopy( angles, ent->angles );
@@ -575,9 +563,7 @@ process player states after the new packet has received
 */
 static void CL_ProcessPlayerState( int playerindex, entity_state_t *state )
 {
-	entity_state_t	*ps;
-
-	ps = &cl.frames[cl.parsecountmod].playerstate[playerindex];
+	entity_state_t *ps = &cl.frames[cl.parsecountmod].playerstate[playerindex];
 	ps->number = state->number;
 	ps->messagenum = cl.parsecount;
 	ps->msg_time = cl.mtime[0];
@@ -618,19 +604,15 @@ process player states after the new packet has received
 */
 void CL_ProcessPacket( frame_t *frame )
 {
-	entity_state_t	*state;
-	cl_entity_t	*ent;
-	int		pnum;
-
-	for( pnum = 0; pnum < frame->num_entities; pnum++ )
+	for( int pnum = 0; pnum < frame->num_entities; pnum++ )
 	{
 		// request the entity state from circular buffer
-		state = &cls.packet_entities[(frame->first_entity+pnum) % cls.num_client_entities];
+		entity_state_t *state = &cls.packet_entities[(frame->first_entity+pnum) % cls.num_client_entities];
 		state->messagenum = cl.parsecount;
 		state->msg_time = cl.mtime[0];
 
 		// mark all the players
-		ent = &clgame.entities[state->number];
+		cl_entity_t *ent = &clgame.entities[state->number];
 		ent->player = CL_IsPlayerIndex( state->number );
 
 		if( state->number == ( cl.playernum + 1 ))
@@ -676,7 +658,6 @@ Read and ignore whole entity packet.
 */
 static void CL_FlushEntityPacket( sizebuf_t *msg, connprotocol_t proto )
 {
-	int		newnum;
 	entity_state_t	from, to;
 
 	memset( &from, 0, sizeof( from ));
@@ -687,6 +668,8 @@ static void CL_FlushEntityPacket( sizebuf_t *msg, connprotocol_t proto )
 	// read it all, but ignore it
 	while( 1 )
 	{
+		int newnum;
+
 		if( !CL_ParseEntityNumFromPacket( msg, &newnum, proto ))
 			break; // done
 
@@ -816,22 +799,19 @@ rest of the data stream.
 */
 int CL_ParsePacketEntities( sizebuf_t *msg, qboolean delta, connprotocol_t proto )
 {
-	frame_t		*newframe, *oldframe;
+	frame_t		*oldframe;
 	int		oldindex, newnum, oldnum;
 	int		playerbytes = 0;
-	int		bufStart;
 	entity_state_t	*oldent;
-	qboolean		player;
-	int		count;
 
 	// save first uncompressed packet as timestamp
 	if( cls.changelevel && !delta && cls.demorecording )
 		CL_WriteDemoJumpTime();
 
 	// sentinel count. save it for debug checking
-	count = MSG_ReadUBitLong( msg, MAX_VISIBLE_PACKET_BITS ) + 1;
+	int count = MSG_ReadUBitLong( msg, MAX_VISIBLE_PACKET_BITS ) + 1;
 
-	newframe = &cl.frames[cl.parsecountmod];
+	frame_t *newframe = &cl.frames[cl.parsecountmod];
 
 	// allocate parse entities
 	memset( newframe->flags, 0, sizeof( newframe->flags ));
@@ -872,7 +852,7 @@ int CL_ParsePacketEntities( sizebuf_t *msg, qboolean delta, connprotocol_t proto
 		if( MSG_CheckOverflow( msg ))
 			Host_Error( "%s: overflow\n", __func__ );
 
-		player = CL_IsPlayerIndex( newnum );
+		qboolean player = CL_IsPlayerIndex( newnum );
 
 		while( oldnum < newnum )
 		{
@@ -884,7 +864,7 @@ int CL_ParsePacketEntities( sizebuf_t *msg, qboolean delta, connprotocol_t proto
 		if( oldnum == newnum )
 		{
 			// delta from previous state
-			bufStart = MSG_GetNumBytesRead( msg );
+			int bufStart = MSG_GetNumBytesRead( msg );
 			CL_DeltaEntity( msg, newframe, newnum, oldent, true );
 			if( player ) playerbytes += MSG_GetNumBytesRead( msg ) - bufStart;
 			oldnum = CL_UpdateOldEntNum( ++oldindex, oldframe, &oldent );
@@ -894,7 +874,7 @@ int CL_ParsePacketEntities( sizebuf_t *msg, qboolean delta, connprotocol_t proto
 		if( oldnum > newnum )
 		{
 			// delta from baseline ?
-			bufStart = MSG_GetNumBytesRead( msg );
+			int bufStart = MSG_GetNumBytesRead( msg );
 			CL_DeltaEntity( msg, newframe, newnum, NULL, true );
 			if( player ) playerbytes += MSG_GetNumBytesRead( msg ) - bufStart;
 			continue;
@@ -1030,12 +1010,10 @@ for all current players
 */
 static void CL_LinkPlayers( frame_t *frame )
 {
+	cl_entity_t	*ent = CL_GetLocalPlayer();
 	entity_state_t	*state;
-	cl_entity_t	*ent;
 	int		i;
 
-	ent = CL_GetLocalPlayer();
-
 	// apply muzzleflash to weaponmodel
 	if( ent && FBitSet( ent->curstate.effects, EF_MUZZLEFLASH ))
 		SetBits( clgame.viewent.curstate.effects, EF_MUZZLEFLASH );
@@ -1113,15 +1091,9 @@ CL_LinkPacketEntities
 */
 static void CL_LinkPacketEntities( frame_t *frame )
 {
-	cl_entity_t	*ent;
-	entity_state_t	*state;
-	qboolean		parametric;
-	qboolean		interpolate;
-	int		i;
-
-	for( i = 0; i < frame->num_entities; i++ )
+	for( int i = 0; i < frame->num_entities; i++ )
 	{
-		state = &cls.packet_entities[(frame->first_entity + i) % cls.num_client_entities];
+		entity_state_t *state = &cls.packet_entities[(frame->first_entity + i) % cls.num_client_entities];
 
 		// clients are should be done in CL_LinkPlayers
 		if( state->number >= 1 && state->number <= cl.maxclients )
@@ -1131,7 +1103,7 @@ static void CL_LinkPacketEntities( frame_t *frame )
 		if( !state->modelindex || FBitSet( state->effects, EF_NODRAW ))
 			continue;
 
-		ent = CL_GetEntityByIndex( state->number );
+		cl_entity_t *ent = CL_GetEntityByIndex( state->number );
 
 		if( !ent )
 		{
@@ -1142,7 +1114,7 @@ static void CL_LinkPacketEntities( frame_t *frame )
 		// animtime must keep an actual
 		ent->curstate.animtime = state->animtime;
 		ent->curstate.frame = state->frame;
-		interpolate = false;
+		qboolean interpolate = false;
 
 		if( !ent->model ) continue;
 
@@ -1156,7 +1128,7 @@ static void CL_LinkPacketEntities( frame_t *frame )
 			}
 		}
 
-		parametric = ( ent->curstate.impacttime != 0.0f && ent->curstate.starttime != 0.0f );
+		qboolean parametric = ( ent->curstate.impacttime != 0.0f && ent->curstate.starttime != 0.0f );
 
 		if( !parametric && ent->curstate.movetype != MOVETYPE_COMPOUND )
 		{
@@ -1369,9 +1341,6 @@ SOUND ENGINE IMPLEMENTATION
 */
 qboolean CL_GetEntitySpatialization( channel_t *ch )
 {
-	cl_entity_t	*ent;
-	qboolean		valid_origin;
-
 	if( ch->entnum == 0 )
 	{
 		SetBits( ch->flags, FL_CHAN_STATIC_SOUND );
@@ -1384,8 +1353,8 @@ qboolean CL_GetEntitySpatialization( channel_t *ch )
 		return true;
 	}
 
-	valid_origin = VectorIsNull( ch->origin ) ? false : true;
-	ent = CL_GetEntityByIndex( ch->entnum );
+	qboolean valid_origin = VectorIsNull( ch->origin ) ? false : true;
+	cl_entity_t *ent = CL_GetEntityByIndex( ch->entnum );
 
 	// entity is not present on the client but has valid origin
 	if( !ent || !ent->model || ent->curstate.messagenum != cl.parsecount )

engine/client/cl_netgraph.c

@@ -118,8 +118,7 @@ static void NetGraph_InitColors( void )
 	byte	mincolor[2][3];
 	byte	maxcolor[2][3];
 	float	dc[2][3];
-	int	i, hfrac;
-	float	f;
+	int	hfrac;
 
 	mincolor[0][0] = 63;
 	mincolor[0][1] = 0;
@@ -137,7 +136,7 @@ static void NetGraph_InitColors( void )
 	maxcolor[1][1] = 0;
 	maxcolor[1][2] = 0;
 
-	for( i = 0; i < 3; i++ )
+	for( int i = 0; i < 3; i++ )
 	{
 		dc[0][i] = (float)(maxcolor[0][i] - mincolor[0][i]);
 		dc[1][i] = (float)(maxcolor[1][i] - mincolor[1][i]);
@@ -145,8 +144,10 @@ static void NetGraph_InitColors( void )
 
 	hfrac = NETGRAPH_LERP_HEIGHT / 3;
 
-	for( i = 0; i < NETGRAPH_LERP_HEIGHT; i++ )
+	for( int i = 0; i < NETGRAPH_LERP_HEIGHT; i++ )
 	{
+		float f;
+
 		if( i < hfrac )
 		{
 			f = (float)i / (float)hfrac;
@@ -170,10 +171,9 @@ get frame data info, like chokes, packet losses, also update graph, packet and c
 */
 static void NetGraph_GetFrameData( float *latency, int *latency_count )
 {
-	int		i, choke_count = 0, loss_count = 0;
+	int		choke_count = 0, loss_count = 0;
 	double		newtime = Platform_DoubleTime();
 	static double	nexttime = 0;
-	float		loss, choke;
 
 	*latency_count = 0;
 	*latency = 0.0f;
@@ -185,7 +185,7 @@ static void NetGraph_GetFrameData( float *latency, int *latency_count )
 		nexttime = newtime + 0.05;
 	}
 
-	for( i = cls.netchan.incoming_sequence - CL_UPDATE_BACKUP + 1; i <= cls.netchan.incoming_sequence; i++ )
+	for( int i = cls.netchan.incoming_sequence - CL_UPDATE_BACKUP + 1; i <= cls.netchan.incoming_sequence; i++ )
 	{
 		frame_t *f = cl.frames + ( i & CL_UPDATE_MASK );
 		struct packet_latency_t *p = netstat_packet_latency + ( i & NET_TIMINGS_MASK );
@@ -228,7 +228,7 @@ static void NetGraph_GetFrameData( float *latency, int *latency_count )
 	if( maxmsgbytes > 1000 )
 		maxmsgbytes = 1000;
 
-	for( i = cls.netchan.outgoing_sequence - CL_UPDATE_BACKUP + 1; i <= cls.netchan.outgoing_sequence; i++ )
+	for( int i = cls.netchan.outgoing_sequence - CL_UPDATE_BACKUP + 1; i <= cls.netchan.outgoing_sequence; i++ )
 	{
 		netstat_cmdinfo[i & NET_TIMINGS_MASK].cmd_lerp = cl.commands[i & CL_UPDATE_MASK].frame_lerp;
 		netstat_cmdinfo[i & NET_TIMINGS_MASK].sent = cl.commands[i & CL_UPDATE_MASK].heldback ? false : true;
@@ -236,11 +236,11 @@ static void NetGraph_GetFrameData( float *latency, int *latency_count )
 	}
 
 	// packet loss
-	loss = 100.0f * (float)loss_count / CL_UPDATE_BACKUP;
+	float loss = 100.0f * (float)loss_count / CL_UPDATE_BACKUP;
 	packet_loss = PACKETLOSS_AVG_FRAC * packet_loss + ( 1.0f - PACKETLOSS_AVG_FRAC ) * loss;
 
 	// packet choke
-	choke = 100.0f * (float)choke_count / CL_UPDATE_BACKUP;
+	float choke = 100.0f * (float)choke_count / CL_UPDATE_BACKUP;
 	packet_choke = PACKETCHOKE_AVG_FRAC * packet_choke + ( 1.0f - PACKETCHOKE_AVG_FRAC ) * choke;
 }
 
@@ -252,14 +252,13 @@ NetGraph_DrawTimes
 */
 static void NetGraph_DrawTimes( wrect_t rect, int x, int w )
 {
-	int	i, j, extrap_point = NETGRAPH_LERP_HEIGHT / 3, a, h;
-	rgba_t	colors = { 0.9 * 255, 0.9 * 255, 0.7 * 255, 255 };
+	int	extrap_point = NETGRAPH_LERP_HEIGHT / 3;
 	wrect_t	fill;
 
-	for( a = 0; a < w; a++ )
+	for( int a = 0; a < w; a++ )
 	{
-		i = ( cls.netchan.outgoing_sequence - a ) & NET_TIMINGS_MASK;
-		h = Q_min(( netstat_cmdinfo[i].cmd_lerp / 3.0f ) * NETGRAPH_LERP_HEIGHT, net_graphheight.value * 0.7f);
+		int i = ( cls.netchan.outgoing_sequence - a ) & NET_TIMINGS_MASK;
+		int h = Q_min(( netstat_cmdinfo[i].cmd_lerp / 3.0f ) * NETGRAPH_LERP_HEIGHT, net_graphheight.value * 0.7f);
 
 		fill.left = x + w - a - 1;
 		fill.right = fill.bottom = 1;
@@ -278,7 +277,7 @@ static void NetGraph_DrawTimes( wrect_t rect, int x, int w )
 				start = (h - 1);
 			}
 
-			for( j = start; j < h; j++ )
+			for( int j = start; j < h; j++ )
 			{
 				int color = NETGRAPH_NET_COLORS + j + extrap_point;
 				color = Q_min( color, ARRAYSIZE( netcolors ) - 1 );
@@ -297,7 +296,7 @@ static void NetGraph_DrawTimes( wrect_t rect, int x, int w )
 			if( !net_graphsolid.value )
 				h = 1;
 
-			for( j = 0; j < h; j++ )
+			for( int j = 0; j < h; j++ )
 			{
 				int color = NETGRAPH_NET_COLORS + j + oldh;
 				color = Q_min( color, ARRAYSIZE( netcolors ) - 1 );
@@ -496,15 +495,16 @@ NetGraph_DrawDataUsage
 */
 static void NetGraph_DrawDataUsage( int x, int y, int w, int graphtype )
 {
-	int	a, i, h, lastvalidh = 0, ping;
+	int	lastvalidh = 0;
 	int	pingheight = net_graphheight.value - NETGRAPH_LERP_HEIGHT - 2;
 	wrect_t	fill = { 0 };
 	byte	color[4];
 
-	for( a = 0; a < w; a++ )
+	for( int a = 0; a < w; a++ )
 	{
-		i = (cls.netchan.incoming_sequence - a) & NET_TIMINGS_MASK;
-		h = netstat_packet_latency[i].latency;
+		int ping;
+		int i = (cls.netchan.incoming_sequence - a) & NET_TIMINGS_MASK;
+		int h = netstat_packet_latency[i].latency;
 
 		NetGraph_ColorForHeight( &netstat_packet_latency[i], color, &ping );
 

engine/client/cl_remap.c

@@ -43,7 +43,6 @@ return true if equal
 */
 static qboolean CL_CmpStudioTextures( int numtexs, mstudiotexture_t *p1, remap_info_t *remap )
 {
-	int	i;
 	mstudiotexture_t *p2;
 
 	if( !p1 ) // no textures
@@ -60,7 +59,7 @@ static qboolean CL_CmpStudioTextures( int numtexs, mstudiotexture_t *p1, remap_i
 
 	p2 = remap->ptexture;
 
-	for( i = 0; i < numtexs; i++, p1++, p2++ )
+	for( int i = 0; i < numtexs; i++, p1++, p2++ )
 	{
 		if( p1->flags & STUDIO_NF_COLORMAP )
 			continue;	// colormaps always has different indexes
@@ -116,18 +115,17 @@ static void CL_DuplicateTexture( cl_entity_t *entity, model_t *model, mstudiotex
 	const char *name;
 	texture_t		*tx = NULL;
 	char		texname[128];
-	int		i, index;
 	size_t size;
 	byte		paletteBackup[768];
 	byte		*raw, *pal;
+	int		index = ptexture->index;
 
 	// save off the real texture index
-	index = ptexture->index;
 	name = ref.dllFuncs.GL_TextureName( index );
 	Q_snprintf( texname, sizeof( texname ), "#%i_%s", entity->curstate.number, name + 1 );
 
 	// search for pixels
-	for( i = 0; i < model->numtextures; i++ )
+	for( int i = 0; i < model->numtextures; i++ )
 	{
 		tx = model->textures[i];
 		if( tx->gl_texturenum == index )
@@ -161,7 +159,7 @@ static void CL_UpdateStudioTexture( cl_entity_t *entity, mstudiotexture_t *ptext
 	texture_t		*tx = NULL;
 	char		texname[128], name[128], mdlname[128];
 	const char	*origtexname;
-	int		i, index;
+	int		index;
 	size_t size;
 	byte		paletteBackup[768];
 	byte		*raw, *pal;
@@ -180,7 +178,7 @@ static void CL_UpdateStudioTexture( cl_entity_t *entity, mstudiotexture_t *ptext
 		return; // couldn't find texture
 
 	// search for pixels
-	for( i = 0; i < entity->model->numtextures; i++ )
+	for( int i = 0; i < entity->model->numtextures; i++ )
 	{
 		tx = entity->model->textures[i];
 		if( tx->gl_texturenum == index )
@@ -259,12 +257,10 @@ Release remap info per entity
 */
 static void CL_FreeRemapInfo( remap_info_t *info )
 {
-	int	i;
-
 	Assert( info != NULL );
 
 	// release all colormap texture copies
-	for( i = 0; i < info->numtextures; i++ )
+	for( int i = 0; i < info->numtextures; i++ )
 	{
 		if( info->ptexture != NULL )
 		{
@@ -438,11 +434,9 @@ Release all remap infos
 */
 void CL_ClearAllRemaps( void )
 {
-	int	i;
-
 	if( clgame.remap_info )
 	{
-		for( i = 0; i < clgame.maxRemapInfos; i++ )
+		for( int i = 0; i < clgame.maxRemapInfos; i++ )
 		{
 			if( clgame.remap_info[i] )
 				CL_FreeRemapInfo( clgame.remap_info[i] );

engine/client/cl_scrn.c

@@ -50,9 +50,7 @@ SCR_DrawFPS
 */
 void SCR_DrawFPS( int height )
 {
-	float		calc;
 	rgba_t		color;
-	double		newtime;
 	static double	nexttime = 0, lasttime = 0;
 	static double	framerate = 0;
 	static int	framecount = 0;
@@ -73,7 +71,7 @@ void SCR_DrawFPS( int height )
 	default: return;
 	}
 
-	newtime = Platform_DoubleTime();
+	double newtime = Platform_DoubleTime();
 	if( newtime >= nexttime )
 	{
 		framerate = framecount / (newtime - lasttime);
@@ -82,7 +80,7 @@ void SCR_DrawFPS( int height )
 		framecount = 0;
 	}
 
-	calc = framerate;
+	float calc = framerate;
 	framecount++;
 
 	if( calc < 1.0f )
@@ -120,15 +118,13 @@ Draw local player position, angles and velocity
 void SCR_DrawPos( void )
 {
 	static char     msg[MAX_SYSPATH];
-	float speed;
-	cl_entity_t *ent;
 	rgba_t color;
 
 	if( cls.state != ca_active || !cl_showpos.value || cl.background )
 		return;
 
-	ent = CL_GetLocalPlayer();
-	speed = VectorLength( cl.simvel );
+	cl_entity_t *ent = CL_GetLocalPlayer();
+	float speed = VectorLength( cl.simvel );
 
 	Q_snprintf( msg, MAX_SYSPATH,
 		"pos: %.2f %.2f %.2f\n"
@@ -153,23 +149,22 @@ SCR_DrawEnts
 void SCR_DrawEnts( void )
 {
 	rgba_t color = { 255, 255, 255, 255 };
-	int i;
 
 	if( cls.state != ca_active || !cl_showents.value || ( cl.maxclients > 1 && !cls.demoplayback ))
 		return;
 
 	// this probably better hook CL_AddVisibleEntities
 	// as entities might get added by client.dll
-	for( i = 0; i < clgame.maxEntities; i++ )
+	for( int i = 0; i < clgame.maxEntities; i++ )
 	{
 		const cl_entity_t *ent = &clgame.entities[i];
 		string msg;
-		vec3_t screen, pos;
+		vec3_t screen;
 
 		if( ent->curstate.messagenum != cl.parsecount )
 			continue;
 
-		VectorCopy( ent->origin, pos );
+		vec3_t pos = Vec3( ent->origin );
 
 		if( ent->model != NULL )
 		{
@@ -241,12 +236,12 @@ void SCR_DrawUserCmd( void )
 	};
 	cl_font_t *font = Con_GetCurFont();
 	string msg;
-	int i, ypos = 100;
+	int ypos = 100;
 
 	if( cls.state != ca_active || !cl_showcmd.value )
 		return;
 
-	for( i = 0; i < ARRAYSIZE( buttons ); i++ )
+	for( int i = 0; i < ARRAYSIZE( buttons ); i++ )
 	{
 		rgba_t rgba;
 
@@ -280,7 +275,6 @@ same as r_speeds but for network channel
 void SCR_NetSpeeds( void )
 {
 	static char	msg[MAX_SYSPATH];
-	int		x, y;
 	float		time = cl.mtime[0];
 	static int	min_svfps = 100;
 	static int	max_svfps = 0;
@@ -326,8 +320,8 @@ void SCR_NetSpeeds( void )
 		Q_memprint( cls.netchan.total_sended )
 	);
 
-	x = refState.width - 320 * font->scale;
-	y = 384;
+	int x = refState.width - 320 * font->scale;
+	int y = 384;
 
 	MakeRGBA( color, 255, 255, 255, 255 );
 	CL_DrawString( x, y, msg, color, font, FONT_DRAW_RESETCOLORONLF );
@@ -347,12 +341,11 @@ void SCR_RSpeeds( void )
 
 	if( ref.dllFuncs.R_SpeedsMessage( msg, sizeof( msg )))
 	{
-		int	x, y;
 		rgba_t	color;
 		cl_font_t *font = Con_GetCurFont();
 
-		x = refState.width - 340 * font->scale;
-		y = 64;
+		int x = refState.width - 340 * font->scale;
+		int y = 64;
 
 		MakeRGBA( color, 255, 255, 255, 255 );
 		CL_DrawString( x, y, msg, color, font, FONT_DRAW_RESETCOLORONLF );
@@ -386,11 +379,10 @@ static void VID_WriteOverviewScript( void )
 {
 	ref_overview_t	*ov = &clgame.overView;
 	string		filename;
-	file_t		*f;
 
 	Q_snprintf( filename, sizeof( filename ), "overviews/%s.txt", clgame.mapname );
 
-	f = FS_Open( filename, "w", false );
+	file_t		*f = FS_Open( filename, "w", false );
 	if( !f )
 	{
 		Con_Printf( S_ERROR "%s: can't open %s for write\n", __func__, filename );
@@ -586,7 +578,6 @@ void SCR_TileClear( void )
 {
 	int	i, top, bottom, left, right, texnum;
 	dirty_t	clear;
-	float tw, th;
 
 	if( likely( scr_viewsize.value >= 120 ))
 		return; // full screen rendering
@@ -634,8 +625,8 @@ void SCR_TileClear( void )
 	left = clgame.viewport[0];
 	right = left + clgame.viewport[2] - 1;
 
-	tw = REF_GET_PARM( PARM_TEX_SRC_WIDTH, texnum );
-	th = REF_GET_PARM( PARM_TEX_SRC_HEIGHT, texnum );
+	float tw = REF_GET_PARM( PARM_TEX_SRC_WIDTH, texnum );
+	float th = REF_GET_PARM( PARM_TEX_SRC_HEIGHT, texnum );
 
 	if( clear.y1 < top )
 	{
@@ -749,11 +740,9 @@ void SCR_LoadCreditsFont( void )
 	// copy font size for client.dll
 	if( success )
 	{
-		int i;
-
 		clgame.scrInfo.iCharHeight = cls.creditsFont.charHeight;
 
-		for( i = 0; i < ARRAYSIZE( cls.creditsFont.charWidths ); i++ )
+		for( int i = 0; i < ARRAYSIZE( cls.creditsFont.charWidths ); i++ )
 			clgame.scrInfo.charWidths[i] = cls.creditsFont.charWidths[i];
 	}
 	else Con_DPrintf( S_ERROR "failed to load HUD font\n" );

engine/client/cl_spray.c

@@ -27,10 +27,10 @@ GNU General Public License for more details.
 static void CL_AdjustSprayDimensions( int *width, int *height )
 {
 	float aspect = (float)( *width ) / (float)( *height );
-	int   h, w;
-	for( h = (( *height ) / 16 ) * 16; h >= 16; h -= 16 )
+
+	for( int h = (( *height ) / 16 ) * 16; h >= 16; h -= 16 )
 	{
-		w = ((int)( h * aspect ) / 16 ) * 16;
+		int w = ((int)( h * aspect ) / 16 ) * 16;
 		if( w < 16 || w > *width )
 			continue;
 
@@ -107,7 +107,6 @@ qboolean CL_ConvertImageToWAD3( const char *filename )
 {
 	qboolean	is_indexed_img;
 	int			width = 0, height = 0;
-	int			i;
 	byte		palette[SPRAY_PALETTE_BYTES];
 	byte		*indexed = NULL;
 	rgbdata_t	*image = NULL;
@@ -122,7 +121,7 @@ qboolean CL_ConvertImageToWAD3( const char *filename )
 	if( is_indexed_img )
 	{
 		// copy bmp palette from rgba to rgb
-		for( i = 0; i < 256; ++i )
+		for( int i = 0; i < 256; ++i )
 		{
 			palette[i * 3 + 0] = image->palette[i * 4 + 0]; // R
 			palette[i * 3 + 1] = image->palette[i * 4 + 1]; // G
@@ -141,7 +140,7 @@ qboolean CL_ConvertImageToWAD3( const char *filename )
 		// set index 255 for transparent pixels in rgba images
 		if( image->type == PF_RGBA_32 )
 		{
-			for( i = 0; i < width * height; ++i )
+			for( int i = 0; i < width * height; ++i )
 			{
 				if( image->buffer[i * 4 + 3] <= SPRAY_ALPHA_THRESHOLD )
 					quant->buffer[i] = 255;

engine/client/cl_sprite.c

@@ -33,11 +33,7 @@ assume pModel is valid
 mspriteframe_t *R_GetSpriteFrame( const model_t *pModel, int frame, float yaw )
 {
 	msprite_t      *psprite;
-	mspritegroup_t *pspritegroup;
 	mspriteframe_t *pspriteframe = NULL;
-	float          *pintervals, fullinterval;
-	int             i, numframes;
-	float           targettime;
 
 	if( !pModel )
 		return NULL;
@@ -61,14 +57,15 @@ mspriteframe_t *R_GetSpriteFrame( const model_t *pModel, int frame, float yaw )
 	}
 	else if( psprite->frames[frame].type == SPR_GROUP )
 	{
-		pspritegroup = (mspritegroup_t *)psprite->frames[frame].frameptr;
-		pintervals = pspritegroup->intervals;
-		numframes = pspritegroup->numframes;
-		fullinterval = pintervals[numframes - 1];
+		mspritegroup_t *pspritegroup = (mspritegroup_t *)psprite->frames[frame].frameptr;
+		float          *pintervals = pspritegroup->intervals;
+		int             numframes = pspritegroup->numframes;
+		float           fullinterval = pintervals[numframes - 1];
 
 		// when loading in Mod_LoadSpriteGroup, we guaranteed all interval values
 		// are positive, so we don't have to worry about division by zero
-		targettime = cl.time - ((int)( cl.time / fullinterval )) * fullinterval;
+		float targettime = cl.time - ((int)( cl.time / fullinterval )) * fullinterval;
+		int i;
 
 		for( i = 0; i < ( numframes - 1 ); i++ )
 		{
@@ -82,7 +79,7 @@ mspriteframe_t *R_GetSpriteFrame( const model_t *pModel, int frame, float yaw )
 		int angleframe = (int)( Q_rint(( refState.viewangles[1] - yaw + 45.0f ) / 360 * 8 ) - 4 ) & 7;
 
 		// e.g. doom-style sprite monsters
-		pspritegroup = (mspritegroup_t *)psprite->frames[frame].frameptr;
+		mspritegroup_t *pspritegroup = (mspritegroup_t *)psprite->frames[frame].frameptr;
 		pspriteframe = pspritegroup->frames[angleframe];
 	}
 
@@ -203,16 +200,13 @@ static const byte *Mod_SpriteLoadFrame( model_t *mod, const void *pin, mspritefr
 
 static const byte *Mod_SpriteLoadGroup( model_t *mod, const void *pin, mspriteframe_t **ppframe, int framenum )
 {
-	const dspritegroup_t    *pingroup;
+	const dspritegroup_t    *pingroup = (const dspritegroup_t *)pin;
 	mspritegroup_t          *pspritegroup;
 	const dspriteinterval_t *pin_intervals;
 	float      *poutintervals;
-	int         i, groupsize, numframes;
+	int         groupsize, numframes = pingroup->numframes;
 	const void *ptemp;
 
-	pingroup = (const dspritegroup_t *)pin;
-	numframes = pingroup->numframes;
-
 	groupsize = sizeof( mspritegroup_t ) + ( numframes - 1 ) * sizeof( pspritegroup->frames[0] );
 	pspritegroup = Mem_Calloc( mod->mempool, groupsize );
 	pspritegroup->numframes = numframes;
@@ -222,7 +216,7 @@ static const byte *Mod_SpriteLoadGroup( model_t *mod, const void *pin, mspritefr
 	poutintervals = Mem_Calloc( mod->mempool, numframes * sizeof( float ));
 	pspritegroup->intervals = poutintervals;
 
-	for( i = 0; i < numframes; i++ )
+	for( int i = 0; i < numframes; i++ )
 	{
 		*poutintervals = pin_intervals->interval;
 		if( *poutintervals <= 0.0f )
@@ -232,7 +226,7 @@ static const byte *Mod_SpriteLoadGroup( model_t *mod, const void *pin, mspritefr
 	}
 
 	ptemp = (const void *)pin_intervals;
-	for( i = 0; i < numframes; i++ )
+	for( int i = 0; i < numframes; i++ )
 	{
 		ptemp = Mod_SpriteLoadFrame( mod, ptemp, &pspritegroup->frames[i], framenum * 10 + i );
 	}
@@ -330,13 +324,12 @@ void Mod_SpriteLoadTextures( model_t *mod, const void *buffer )
 void Mod_SpriteUnloadTextures( void *data )
 {
 	msprite_t *psprite = data;
-	int i;
 
 	if( !data )
 		return;
 
 	// release all textures
-	for( i = 0; i < psprite->numframes; i++ )
+	for( int i = 0; i < psprite->numframes; i++ )
 	{
 		if( !psprite->frames[i].frameptr )
 			continue;
@@ -348,9 +341,8 @@ void Mod_SpriteUnloadTextures( void *data )
 		else
 		{
 			mspritegroup_t *pspritegroup = (mspritegroup_t *)psprite->frames[i].frameptr;
-			int j;
 
-			for( j = 0; j < pspritegroup->numframes; j++ )
+			for( int j = 0; j < pspritegroup->numframes; j++ )
 			{
 				if( pspritegroup->frames[j] )
 					ref.dllFuncs.GL_FreeTexture( pspritegroup->frames[j]->gl_texturenum );

engine/client/cl_steam.c

@@ -45,7 +45,7 @@ GNU General Public License for more details.
 #define SBRK_CONNECT_RETRY_DELAY	5.0
 #define SBRK_TICKET_SIZE_MAX 		2048
 
-static CVAR_DEFINE_AUTO( cl_steam_broker_addr, "127.0.0.1:27420", FCVAR_ARCHIVE, "address of steam broker instance" );
+static CVAR_DEFINE_AUTO( cl_steam_broker_addr, "127.0.0.1:27420", FCVAR_PRIVILEGED|FCVAR_ARCHIVE, "address of steam broker instance" );
 
 typedef enum
 {
@@ -220,7 +220,7 @@ static qboolean SteamBroker_ProcessFrame( void )
 
 	// verify frame header
 	char header[SBRK_FRAME_HEADER_SIZE];
-	if( !MSG_ReadBytes( &sb, header, SBRK_FRAME_HEADER_SIZE ))
+	if( !MSG_ReadBytes( &sb, header, sizeof( header ), SBRK_FRAME_HEADER_SIZE ))
 		return false;
 
 	if( memcmp( header, SBRK_FRAME_HEADER, SBRK_FRAME_HEADER_SIZE ) != 0 )
@@ -237,7 +237,7 @@ static qboolean SteamBroker_ProcessFrame( void )
 		return false; // need more data
 
 	char response_header[SBRK_RESPONSE_HEADER_SIZE];
-	if( MSG_ReadBytes( &sb, response_header, SBRK_RESPONSE_HEADER_SIZE ))
+	if( MSG_ReadBytes( &sb, response_header, sizeof( response_header ), SBRK_RESPONSE_HEADER_SIZE ))
 	{
 		if( memcmp( response_header, SBRK_RESPONSE_HEADER, SBRK_RESPONSE_HEADER_SIZE ) == 0 )
 		{
@@ -249,7 +249,7 @@ static qboolean SteamBroker_ProcessFrame( void )
 			else
 			{
 				uint64_t steam_id;
-				MSG_ReadBytes( &sb, &steam_id, sizeof( steam_id ));
+				MSG_ReadBytes( &sb, &steam_id, sizeof( steam_id ), sizeof( steam_id ));
 				uint32_t ticket_size = MSG_ReadDword( &sb );
 				uint8_t ticket_data[SBRK_TICKET_SIZE_MAX];
 
@@ -257,7 +257,7 @@ static qboolean SteamBroker_ProcessFrame( void )
 				{
 					Con_Printf( S_ERROR "%s: ticket size exceeds limit (%u)\n", __func__, ticket_size );
 				}
-				else if( MSG_ReadBytes( &sb, ticket_data, ticket_size ))
+				else if( MSG_ReadBytes( &sb, ticket_data, sizeof( ticket_data ), ticket_size ))
 				{
 					Con_Printf( "%s: SteamID: %"PRIu64", ticket: [%d, %d, %d, %d...]\n", __func__, steam_id, ticket_data[0], ticket_data[1], ticket_data[2], ticket_data[3] );
 
@@ -355,7 +355,7 @@ static void SteamBroker_UpdateIdle( void )
 	}
 }
 
-void SteamBroker_AnnounceGameStart( const char *gamedir )
+static void SteamBroker_AnnounceGameStart( const char *gamedir )
 {
 	if( Q_stricmp( cl_ticket_generator.string, "steam" ) != 0 )
 		return;
@@ -371,7 +371,7 @@ void SteamBroker_AnnounceGameStart( const char *gamedir )
 		SteamBroker_SendFrame( buf, len );
 }
 
-void SteamBroker_AnnounceGameShutdown( void )
+static void SteamBroker_AnnounceGameShutdown( void )
 {
 	if( Q_stricmp( cl_ticket_generator.string, "steam" ) != 0 )
 		return;
@@ -395,9 +395,7 @@ static void SteamBroker_UpdateConnecting( void )
 	FD_ZERO( &writefds );
 	FD_SET( broker.socket, &writefds );
 
-	struct timeval tv;
-	tv.tv_sec = 0;
-	tv.tv_usec = 0;
+	struct timeval tv = { 0 };
 
 #if XASH_WIN32
 	int select_result = select( 0, NULL, &writefds, NULL, &tv );

engine/client/cl_tent.c

@@ -120,21 +120,20 @@ void CL_AddClientResources( void )
 {
 	const char *snd;
 	char	filepath[MAX_QPATH];
-	int	i;
 
 	// don't request resources from localhost or in quake-compatibility mode
 	if( cl.maxclients <= 1 || Host_IsQuakeCompatible( ))
 		return;
 
 	// check sprites first
-	for( i = 0; i < ARRAYSIZE( cl_default_sprites ); i++ )
+	for( int i = 0; i < ARRAYSIZE( cl_default_sprites ); i++ )
 	{
 		if( !FS_FileExists( cl_default_sprites[i], false ))
 			CL_AddClientResource( cl_default_sprites[i], t_model );
 	}
 
 	// then check sounds
-	for( i = 0; ( snd = SoundList_Get( BouncePlayerShell, i )); i++ )
+	for( int i = 0; ( snd = SoundList_Get( BouncePlayerShell, i )); i++ )
 	{
 		Q_snprintf( filepath, sizeof( filepath ), DEFAULT_SOUNDPATH "%s", snd );
 
@@ -142,7 +141,7 @@ void CL_AddClientResources( void )
 			CL_AddClientResource( snd, t_sound );
 	}
 
-	for( i = 0; ( snd = SoundList_Get( BounceWeaponShell, i )); i++ )
+	for( int i = 0; ( snd = SoundList_Get( BounceWeaponShell, i )); i++ )
 	{
 		Q_snprintf( filepath, sizeof( filepath ), DEFAULT_SOUNDPATH "%s", snd );
 
@@ -150,7 +149,7 @@ void CL_AddClientResources( void )
 			CL_AddClientResource( snd, t_sound );
 	}
 
-	for( i = 0; ( snd = SoundList_Get( Explode, i )); i++ )
+	for( int i = 0; ( snd = SoundList_Get( Explode, i )); i++ )
 	{
 		Q_snprintf( filepath, sizeof( filepath ), DEFAULT_SOUNDPATH "%s", snd );
 
@@ -159,7 +158,7 @@ void CL_AddClientResources( void )
 	}
 
 #if 0	// ric sounds was precached by server-side
-	for( i = 0; ( snd = SoundList_Get( Ricochet, i )); i++ )
+	for( int i = 0; ( snd = SoundList_Get( Ricochet, i )); i++ )
 	{
 		Q_snprintf( filepath, sizeof( filepath ), DEFAULT_SOUNDPATH "%s", snd );
 
@@ -177,11 +176,9 @@ CL_ClearTempEnts
 */
 static void CL_ClearTempEnts( void )
 {
-	int	i;
-
 	if( !cl_tempents ) return;
 
-	for( i = 0; i < GI->max_tents - 1; i++ )
+	for( int i = 0; i < GI->max_tents - 1; i++ )
 	{
 		cl_tempents[i].next = &cl_tempents[i+1];
 		cl_tempents[i].entity.trivial_accept = INVALID_HANDLE;
@@ -270,14 +267,12 @@ play collide sound
 */
 static void CL_TempEntPlaySound( TEMPENTITY *pTemp, float damp )
 {
-	float	fvol;
 	const char	*soundname = NULL;
 	qboolean	isshellcasing = false;
-	int	zvel;
 
 	Assert( pTemp != NULL );
 
-	fvol = 0.8f;
+	float fvol = 0.8f;
 
 	switch( pTemp->hitSound )
 	{
@@ -315,7 +310,7 @@ static void CL_TempEntPlaySound( TEMPENTITY *pTemp, float damp )
 	if( !soundname )
 		return;
 
-	zvel = abs( pTemp->entity.baseline.origin[2] );
+	int zvel = abs( pTemp->entity.baseline.origin[2] );
 
 	// only play one out of every n
 	if( isshellcasing )
@@ -333,7 +328,6 @@ static void CL_TempEntPlaySound( TEMPENTITY *pTemp, float damp )
 	if( damp > 0.0f )
 	{
 		int	pitch;
-		sound_t	handle;
 
 		if( isshellcasing )
 			fvol *= Q_min( 1.0f, ((float)zvel) / 350.0f );
@@ -343,7 +337,7 @@ static void CL_TempEntPlaySound( TEMPENTITY *pTemp, float damp )
 			pitch = COM_RandomLong( 95, 105 );
 		else pitch = PITCH_NORM;
 
-		handle = S_RegisterSound( soundname );
+		sound_t handle = S_RegisterSound( soundname );
 		S_StartSound( pTemp->entity.origin, -(pTemp - cl_tempents), CHAN_BODY, handle, fvol, ATTN_NORM, pitch, SND_STOP_LOOPING );
 	}
 }
@@ -571,15 +565,14 @@ void GAME_EXPORT R_FizzEffect( cl_entity_t *ent, int modelIndex, int density )
 {
 	const float base_time = cl.time - 0.1f;
 	model_t	*mod = CL_ModelHandle( modelIndex );
-	vec3_t  volume, mins, maxs;
+	vec3_t  volume;
 	vec2_t  speed;
-	int     i;
 
 	if( !ent || !ent->model || !modelIndex || !mod )
 		return;
 
-	VectorCopy( ent->model->mins, mins );
-	VectorCopy( ent->model->maxs, maxs );
+	vec3_t mins = Vec3( ent->model->mins );
+	vec3_t maxs = Vec3( ent->model->maxs );
 
 	if( ent->angles[1] != 0.0f )
 	{
@@ -592,12 +585,11 @@ void GAME_EXPORT R_FizzEffect( cl_entity_t *ent, int modelIndex, int density )
 
 	VectorSubtract( maxs, mins, volume );
 
-	for( i = 0; i <= density; i++ )
+	for( int i = 0; i <= density; i++ )
 	{
 		TEMPENTITY *tent;
-		vec3_t origin;
+		vec3_t origin = Vec3( mins );
 
-		VectorCopy( mins, origin );
 		origin[0] += COM_RandomLong( 0, (int)volume[0] - 1 );
 		origin[1] += COM_RandomLong( 0, (int)volume[1] - 1 );
 
@@ -628,16 +620,13 @@ Create bubbles
 void GAME_EXPORT R_Bubbles( const vec3_t mins, const vec3_t maxs, float height, int modelIndex, int count, float speed )
 {
 	TEMPENTITY	*pTemp;
-	float		sine, cosine;
-	float		angle, zspeed;
 	vec3_t		origin;
 	model_t		*mod;
-	int		i;
 
 	if(( mod = CL_ModelHandle( modelIndex )) == NULL )
 		return;
 
-	for ( i = 0; i < count; i++ )
+	for( int i = 0; i < count; i++ )
 	{
 		origin[0] = COM_RandomLong( mins[0], maxs[0] );
 		origin[1] = COM_RandomLong( mins[1], maxs[1] );
@@ -649,10 +638,11 @@ void GAME_EXPORT R_Bubbles( const vec3_t mins, const vec3_t maxs, float height,
 
 		pTemp->x = origin[0];
 		pTemp->y = origin[1];
-		angle = COM_RandomFloat( -M_PI, M_PI );
+		float sine, cosine;
+		float angle = COM_RandomFloat( -M_PI, M_PI );
 		SinCos( angle, &sine, &cosine );
 
-		zspeed = COM_RandomLong( 80, 140 );
+		float zspeed = COM_RandomLong( 80, 140 );
 		VectorSet( pTemp->entity.baseline.origin, speed * cosine, speed * sine, zspeed );
 		pTemp->die = cl.time + ((height - (origin[2] - mins[2])) / zspeed) - 0.1f;
 		pTemp->entity.curstate.frame = COM_RandomLong( 0, pTemp->frameMax );
@@ -674,18 +664,15 @@ Create bubble trail
 void GAME_EXPORT R_BubbleTrail( const vec3_t start, const vec3_t end, float height, int modelIndex, int count, float speed )
 {
 	TEMPENTITY	*pTemp;
-	float		sine, cosine, zspeed;
-	float		dist, angle;
 	vec3_t		origin;
 	model_t		*mod;
-	int		i;
 
 	if(( mod = CL_ModelHandle( modelIndex )) == NULL )
 		return;
 
-	for( i = 0; i < count; i++ )
+	for( int i = 0; i < count; i++ )
 	{
-		dist = COM_RandomFloat( 0, 1.0 );
+		float dist = COM_RandomFloat( 0, 1.0 );
 		VectorLerp( start, dist, end, origin );
 		pTemp = CL_TempEntAlloc( origin, mod );
 		if( !pTemp ) return;
@@ -694,10 +681,11 @@ void GAME_EXPORT R_BubbleTrail( const vec3_t start, const vec3_t end, float heig
 
 		pTemp->x = origin[0];
 		pTemp->y = origin[1];
-		angle = COM_RandomFloat( -M_PI, M_PI );
+		float sine, cosine;
+		float angle = COM_RandomFloat( -M_PI, M_PI );
 		SinCos( angle, &sine, &cosine );
 
-		zspeed = COM_RandomLong( 80, 140 );
+		float zspeed = COM_RandomLong( 80, 140 );
 		VectorSet( pTemp->entity.baseline.origin, speed * cosine, speed * sine, zspeed );
 		pTemp->die = cl.time + ((height - (origin[2] - start[2])) / zspeed) - 0.1f;
 		pTemp->entity.curstate.frame = COM_RandomLong( 0, pTemp->frameMax );
@@ -719,7 +707,6 @@ Attaches entity to player
 void GAME_EXPORT R_AttachTentToPlayer( int client, int modelIndex, float zoffset, float life )
 {
 	TEMPENTITY	*pTemp;
-	vec3_t		position;
 	cl_entity_t	*pClient;
 	model_t		*pModel;
 
@@ -734,7 +721,7 @@ void GAME_EXPORT R_AttachTentToPlayer( int client, int modelIndex, float zoffset
 	if(( pModel = CL_ModelHandle( modelIndex )) == NULL )
 		return;
 
-	VectorCopy( pClient->origin, position );
+	vec3_t position = Vec3( pClient->origin );
 	position[2] += zoffset;
 
 	pTemp = CL_TempEntAllocHigh( position, pModel );
@@ -848,11 +835,9 @@ Do muzzleflash
 void GAME_EXPORT R_MuzzleFlash( const vec3_t pos, int type )
 {
 	TEMPENTITY	*pTemp;
-	int		index;
-	float		scale;
 
-	index = ( type % 10 ) % MAX_MUZZLEFLASH;
-	scale = ( type / 10 ) * 0.1f;
+	int index = ( type % 10 ) % MAX_MUZZLEFLASH;
+	float scale = ( type / 10 ) * 0.1f;
 	if( scale == 0.0f ) scale = 0.5f;
 
 	if( !cl_sprite_muzzleflash[index] )
@@ -887,20 +872,16 @@ and some blood drops. This is high-priority tent
 void GAME_EXPORT R_BloodSprite( const vec3_t org, int colorIndex, int modelIndex, int modelIndex2, float size )
 {
 	model_t		*pModel, *pModel2;
-	int		impactindex;
-	int		spatterindex;
-	int		i, splatter;
 	TEMPENTITY	*pTemp;
-	vec3_t		pos;
 
 	colorIndex += COM_RandomLong( 1, 3 );
-	impactindex = colorIndex;
-	spatterindex = colorIndex - 1;
+	int impactindex = colorIndex;
+	int spatterindex = colorIndex - 1;
 
 	// validate the model first
 	if(( pModel = CL_ModelHandle( modelIndex )) != NULL )
 	{
-		VectorCopy( org, pos );
+		vec3_t pos = Vec3( org );
 		pos[2] += COM_RandomFloat( 2.0f, 4.0f ); // make offset from ground (snarks issues)
 
 		// large, single blood sprite is a high-priority tent
@@ -926,9 +907,9 @@ void GAME_EXPORT R_BloodSprite( const vec3_t org, int colorIndex, int modelIndex
 	// validate the model first
 	if(( pModel2 = CL_ModelHandle( modelIndex2 )) != NULL )
 	{
-		splatter = size + ( COM_RandomLong( 1, 8 ) + COM_RandomLong( 1, 8 ));
+		int splatter = size + ( COM_RandomLong( 1, 8 ) + COM_RandomLong( 1, 8 ));
 
-		for( i = 0; i < splatter; i++ )
+		for( int i = 0; i < splatter; i++ )
 		{
 			// create blood drips
 			if(( pTemp = CL_TempEntAlloc( org, pModel2 )) != NULL )
@@ -973,13 +954,11 @@ void GAME_EXPORT R_BreakModel( const vec3_t pos, const vec3_t size, const vec3_t
 {
 	TEMPENTITY	*pTemp;
 	model_t		*pmodel;
-	char		type;
-	int		i, j;
 
 	if(( pmodel = CL_ModelHandle( modelIndex )) == NULL )
 		return;
 
-	type = flags & BREAK_TYPEMASK;
+	char type = flags & BREAK_TYPEMASK;
 
 	if( count == 0 )
 	{
@@ -990,9 +969,10 @@ void GAME_EXPORT R_BreakModel( const vec3_t pos, const vec3_t size, const vec3_t
 	// limit to 100 pieces
 	if( count > 100 ) count = 100;
 
-	for( i = 0; i < count; i++ )
+	for( int i = 0; i < count; i++ )
 	{
 		vec3_t	vecSpot;
+		int j;
 
 		for( j = 0; j < 32; j++ )
 		{
@@ -1209,14 +1189,12 @@ apply params for exploding sprite
 */
 void GAME_EXPORT R_Sprite_Explode( TEMPENTITY *pTemp, float scale, int flags )
 {
-	qboolean noadditive, drawalpha, rotate;
-
 	if( !pTemp )
 		return;
 
-	noadditive = FBitSet( flags, TE_EXPLFLAG_NOADDITIVE );
-	drawalpha  = FBitSet( flags, TE_EXPLFLAG_DRAWALPHA );
-	rotate     = FBitSet( flags, TE_EXPLFLAG_ROTATE );
+	qboolean noadditive = FBitSet( flags, TE_EXPLFLAG_NOADDITIVE );
+	qboolean drawalpha  = FBitSet( flags, TE_EXPLFLAG_DRAWALPHA );
+	qboolean rotate     = FBitSet( flags, TE_EXPLFLAG_ROTATE );
 
 	pTemp->entity.curstate.scale = scale;
 	pTemp->entity.baseline.origin[2] = 8.0f;
@@ -1242,11 +1220,9 @@ apply params for smoke sprite
 */
 void GAME_EXPORT R_Sprite_Smoke( TEMPENTITY *pTemp, float scale )
 {
-	int	iColor;
-
 	if( !pTemp ) return;
 
-	iColor = COM_RandomLong( 20, 35 );
+	int iColor = COM_RandomLong( 20, 35 );
 	pTemp->entity.curstate.rendermode = kRenderTransAlpha;
 	pTemp->entity.curstate.renderfx = kRenderFxNone;
 	pTemp->entity.baseline.origin[2] = 30;
@@ -1262,7 +1238,6 @@ static void R_Spray_Generic( const char *func, const vec3_t pos, const vec3_t di
 	model_t *mod = CL_ModelHandle( modelIndex );
 	float noise = spread / 100.0f;
 	float znoise = noise * 1.5f;
-	int i;
 
 	znoise = Q_min( 1.0f, znoise );
 
@@ -1272,10 +1247,9 @@ static void R_Spray_Generic( const char *func, const vec3_t pos, const vec3_t di
 		return;
 	}
 
-	for( i = 0; i < count; i++ )
+	for( int i = 0; i < count; i++ )
 	{
 		TEMPENTITY *tent = CL_TempEntAlloc( pos, mod );
-		float rand_speed;
 		vec3_t noise_vec, vout;
 
 		if( !tent )
@@ -1290,7 +1264,7 @@ static void R_Spray_Generic( const char *func, const vec3_t pos, const vec3_t di
 		noise_vec[0] = COM_RandomFloat( -noise, noise );
 		noise_vec[1] = COM_RandomFloat( -noise, noise );
 		noise_vec[2] = COM_RandomFloat( 0.0f, znoise );
-		rand_speed = COM_RandomFloat( speed * 0.8f, speed * 1.2f );
+		float rand_speed = COM_RandomFloat( speed * 0.8f, speed * 1.2f );
 
 		VectorAdd( dir, noise_vec, vout );
 		VectorScale( vout, rand_speed, tent->entity.baseline.origin );
@@ -1361,7 +1335,6 @@ void GAME_EXPORT R_Sprite_Trail( int type, vec3_t start, vec3_t end, int modelIn
 	TEMPENTITY	*pTemp;
 	vec3_t		delta, dir;
 	model_t		*pmodel;
-	int		i;
 
 	if(( pmodel = CL_ModelHandle( modelIndex )) == NULL )
 		return;
@@ -1371,7 +1344,7 @@ void GAME_EXPORT R_Sprite_Trail( int type, vec3_t start, vec3_t end, int modelIn
 
 	amp /= 256.0f;
 
-	for( i = 0; i < count; i++ )
+	for( int i = 0; i < count; i++ )
 	{
 		vec3_t	pos, vel;
 
@@ -1412,9 +1385,7 @@ void GAME_EXPORT R_FunnelSprite( const vec3_t org, int modelIndex, int reverse )
 {
 	TEMPENTITY	*pTemp;
 	vec3_t		dir, dest;
-	float		dist, vel;
 	model_t		*pmodel;
-	int		i, j;
 
 	if(( pmodel = CL_ModelHandle( modelIndex )) == NULL )
 	{
@@ -1422,9 +1393,9 @@ void GAME_EXPORT R_FunnelSprite( const vec3_t org, int modelIndex, int reverse )
 		return;
 	}
 
-	for( i = -8; i < 8; i++ )
+	for( int i = -8; i < 8; i++ )
 	{
-		for( j = -8; j < 8; j++ )
+		for( int j = -8; j < 8; j++ )
 		{
 			pTemp = CL_TempEntAlloc( org, pmodel );
 			if( !pTemp ) return;
@@ -1451,9 +1422,9 @@ void GAME_EXPORT R_FunnelSprite( const vec3_t org, int modelIndex, int reverse )
 			pTemp->entity.curstate.framerate = COM_RandomFloat( 0.1f, 0.4f );
 			pTemp->flags = FTENT_ROTATE|FTENT_FADEOUT;
 
-			vel = dest[2] / 8.0f;
+			float vel = dest[2] / 8.0f;
 			if( vel < 64.0f ) vel = 64.0f;
-			dist = VectorNormalizeLength( dir );
+			float dist = VectorNormalizeLength( dir );
 			vel += COM_RandomFloat( 64.0f, 128.0f );
 			VectorScale( dir, vel, pTemp->entity.baseline.origin );
 			pTemp->die = cl.time + (dist / vel) - 0.5f;
@@ -1484,8 +1455,7 @@ Make a random ricochet sound
 */
 static void R_RicochetSoundByName( const vec3_t pos, const char *name )
 {
-	sound_t handle;
-	handle = S_RegisterSound( name );
+	sound_t handle = S_RegisterSound( name );
 	S_StartSound( pos, 0, CHAN_AUTO, handle, VOL_NORM, 1.0, 100, 0 );
 }
 
@@ -1562,10 +1532,9 @@ Spherical shower of models, picks from set
 void GAME_EXPORT R_TempSphereModel( const vec3_t pos, float speed, float life, int count, int modelIndex )
 {
 	TEMPENTITY	*pTemp;
-	int		i;
 
 	// create temp models
-	for( i = 0; i < count; i++ )
+	for( int i = 0; i < count; i++ )
 	{
 		pTemp = CL_TempEntAlloc( pos, CL_ModelHandle( modelIndex ));
 		if( !pTemp ) return;
@@ -1609,8 +1578,6 @@ Create an explosion (scale is magnitude)
 */
 void GAME_EXPORT R_Explosion( vec3_t pos, int model, float scale, float framerate, int flags )
 {
-	sound_t	hSound;
-
 	if( scale != 0.0f )
 	{
 		// create explosion sprite
@@ -1621,10 +1588,8 @@ void GAME_EXPORT R_Explosion( vec3_t pos, int model, float scale, float framerat
 
 		if( !FBitSet( flags, TE_EXPLFLAG_NODLIGHTS ))
 		{
-			dlight_t	*dl;
-
 			// big flash
-			dl = CL_AllocDlight( 0 );
+			dlight_t *dl = CL_AllocDlight( 0 );
 			VectorCopy( pos, dl->origin );
 			dl->radius = 200;
 			dl->color.r = 250;
@@ -1650,7 +1615,7 @@ void GAME_EXPORT R_Explosion( vec3_t pos, int model, float scale, float framerat
 		const char *name = SoundList_GetRandom( Explode );
 		if( name )
 		{
-			hSound = S_RegisterSound( name );
+			sound_t hSound = S_RegisterSound( name );
 			S_StartSound( pos, 0, CHAN_STATIC, hSound, VOL_NORM, 0.3f, PITCH_NORM, 0 );
 		}
 	}
@@ -1667,21 +1632,16 @@ void GAME_EXPORT R_PlayerSprites( int client, int modelIndex, int count, int siz
 {
 	TEMPENTITY	*pTemp;
 	cl_entity_t	*pEnt;
-	vec3_t		position;
 	vec3_t		dir;
-	float		vel;
-	int		i;
 
 	pEnt = CL_GetEntityByIndex( client );
 
 	if( !pEnt || !pEnt->player )
 		return;
 
-	vel = 128;
-
-	for( i = 0; i < count; i++ )
+	for( int i = 0; i < count; i++ )
 	{
-		VectorCopy( pEnt->origin, position );
+		vec3_t position = Vec3( pEnt->origin );
 		position[0] += COM_RandomFloat( -10.0f, 10.0f );
 		position[1] += COM_RandomFloat( -10.0f, 10.0f );
 		position[2] += COM_RandomFloat( -20.0f, 36.0f );
@@ -1732,16 +1692,13 @@ void GAME_EXPORT R_FireField( float *org, int radius, int modelIndex, int count,
 {
 	TEMPENTITY	*pTemp;
 	model_t		*pmodel;
-	float		time;
-	vec3_t		pos;
-	int		i;
 
 	if(( pmodel = CL_ModelHandle( modelIndex )) == NULL )
 		return;
 
-	for( i = 0; i < count; i++ )
+	for( int i = 0; i < count; i++ )
 	{
-		VectorCopy( org, pos );
+		vec3_t pos = Vec3( org );
 		pos[0] += COM_RandomFloat( -radius, radius );
 		pos[1] += COM_RandomFloat( -radius, radius );
 
@@ -1770,7 +1727,7 @@ void GAME_EXPORT R_FireField( float *org, int radius, int modelIndex, int count,
 		}
 
 		pTemp->entity.curstate.framerate = COM_RandomFloat( 0.75f, 1.25f );
-		time = life + COM_RandomFloat( -0.25f, 0.5f );
+		float time = life + COM_RandomFloat( -0.25f, 0.5f );
 		pTemp->die = cl.time + time;
 
 		if( pTemp->frameMax > 1 )
@@ -1807,13 +1764,12 @@ void GAME_EXPORT R_MultiGunshot( const vec3_t org, const vec3_t dir, const vec3_
 {
 	pmtrace_t	trace;
 	vec3_t	right, up;
-	vec3_t	vecSrc, vecDir, vecEnd;
-	int	i, j, decalIndex;
+	vec3_t	vecDir, vecEnd;
 
 	VectorVectors( dir, right, up );
-	VectorCopy( org, vecSrc );
+	vec3_t vecSrc = Vec3( org );
 
-	for( i = 0; i < count; i++ )
+	for( int i = 0; i < count; i++ )
 	{
 		// get circular gaussian spread
 		float x, y, z;
@@ -1823,7 +1779,7 @@ void GAME_EXPORT R_MultiGunshot( const vec3_t org, const vec3_t dir, const vec3_
 			z = x * x + y * y;
 		} while( z > 1.0f );
 
-		for( j = 0; j < 3; j++ )
+		for( int j = 0; j < 3; j++ )
 		{
 			vecDir[j] = dir[j] + x * noise[0] * right[j] + y * noise[1] * up[j];
 			vecEnd[j] = vecSrc[j] + 4096.0f * vecDir[j];
@@ -1845,7 +1801,7 @@ void GAME_EXPORT R_MultiGunshot( const vec3_t org, const vec3_t dir, const vec3_
 			if( pe && ( pe->solid == SOLID_BSP || pe->movetype == MOVETYPE_PUSHSTEP ))
 			{
 				cl_entity_t *e = CL_GetEntityByIndex( pe->info );
-				decalIndex = CL_DecalIndex( decalIndices[COM_RandomLong( 0, decalCount-1 )] );
+				int decalIndex = CL_DecalIndex( decalIndices[COM_RandomLong( 0, decalCount-1 )] );
 				CL_DecalShoot( decalIndex, e->index, 0, trace.endpos, 0 );
 			}
 		}
@@ -1884,7 +1840,6 @@ void CL_ParseTempEntity( sizebuf_t *msg, connprotocol_t proto )
 {
 	sizebuf_t		buf, *pbuf;
 	byte		msg_data[2048];
-	int		iSize;
 	int		type, color, count, flags;
 	int		decalIndex = 0, modelIndex = 0, entityIndex = 0;
 	float		scale, life, frameRate, vel, random;
@@ -1899,14 +1854,18 @@ void CL_ParseTempEntity( sizebuf_t *msg, connprotocol_t proto )
 
 	if( proto != PROTO_GOLDSRC )
 	{
-		iSize = MSG_ReadWord( msg );
+		int iSize = MSG_ReadWord( msg );
 
 		// this will probably be fatal anyway
 		if( iSize > sizeof( msg_data ))
+		{
 			Con_Printf( S_ERROR "%s: Temp buffer overflow!\n", __func__ );
+			MSG_SeekToBit( msg, iSize << 3, SEEK_CUR );
+			return;
+		}
 
 		// parse user message into buffer
-		MSG_ReadBytes( msg, msg_data, iSize );
+		MSG_ReadBytes( msg, msg_data, sizeof( msg_data ), iSize );
 
 		// init a safe tempbuffer
 		MSG_Init( &buf, "TempEntity", msg_data, iSize );
@@ -2429,28 +2388,25 @@ static void CL_ClearLightStyles( void )
 
 void CL_SetLightstyle( int style, const char *s, float f )
 {
-	int i;
-	lightstyle_t *ls;
-
 	if( unlikely( style < 0 || style >= MAX_LIGHTSTYLES ))
 	{
 		Con_Printf( S_WARN "%s: ignored invalid lightstyle id %d\n", __func__, style );
 		return;
 	}
 
-	ls = &cl.lightstyles[style];
+	lightstyle_t *ls = &cl.lightstyles[style];
 
 	ls->length = Q_strncpy( ls->pattern, s, sizeof( ls->pattern ));
 	ls->time = f; // set local time
 
-	for( i = 0; i < ls->length; i++ )
+	for( int i = 0; i < ls->length; i++ )
 		ls->map[i] = (float)(s[i] - 'a');
 
 	ls->interp = (ls->length <= 1) ? false : true;
 
 	// check for allow interpolate
 	// NOTE: fast flickering styles looks ugly when interpolation is running
-	for( i = 0; i < ( ls->length - 1 ); i++ )
+	for( int i = 0; i < ( ls->length - 1 ); i++ )
 	{
 		float val1 = ls->map[( i + 0 ) % ls->length];
 		float val2 = ls->map[( i + 1 ) % ls->length];
@@ -2587,9 +2543,8 @@ void CL_DecayLights( void )
 {
 	const float time = cl.time;
 	const float dt = cl.time - cl.oldtime;
-	int	i;
 
-	for( i = 0; i < MAX_DLIGHTS; i++ )
+	for( int i = 0; i < MAX_DLIGHTS; i++ )
 	{
 		dlight_t *dl = &cl_dlights[i];
 
@@ -2607,7 +2562,7 @@ void CL_DecayLights( void )
 			memset( dl, 0, sizeof( *dl ));
 	}
 
-	for( i = 0; i < MAX_ELIGHTS; i++ )
+	for( int i = 0; i < MAX_ELIGHTS; i++ )
 	{
 		dlight_t *dl = &cl_elights[i];
 
@@ -2649,7 +2604,6 @@ static void CL_UpdateFlashlight( cl_entity_t *ent )
 {
 	vec3_t		forward, view_ofs;
 	vec3_t		vecSrc, vecEnd;
-	float		falloff;
 	pmtrace_t		trace;
 	cl_entity_t	*hit;
 	dlight_t		*dl;
@@ -2694,7 +2648,7 @@ static void CL_UpdateFlashlight( cl_entity_t *ent )
 	VectorCopy( trace->endpos, dl->origin );
 #endif
 	// compute falloff
-	falloff = trace.fraction * FLASHLIGHT_DISTANCE;
+	float falloff = trace.fraction * FLASHLIGHT_DISTANCE;
 	if( falloff < 500.0f ) falloff = 1.0f;
 	else falloff = 500.0f / falloff;
 	falloff *= falloff;
@@ -2878,25 +2832,22 @@ if cl_testlights is set, create 32 lights models
 */
 void CL_TestLights( void )
 {
-	int	i, j, numLights;
 	vec3_t	forward, right;
-	float	f, r;
-	dlight_t	*dl;
 
 	if( !cl_testlights.value )
 		return;
 
-	numLights = bound( 1, cl_testlights.value, MAX_DLIGHTS );
+	int numLights = bound( 1, cl_testlights.value, MAX_DLIGHTS );
 	AngleVectors( cl.viewangles, forward, right, NULL );
 
-	for( i = 0; i < numLights; i++ )
+	for( int i = 0; i < numLights; i++ )
 	{
-		dl = &cl_dlights[i];
+		dlight_t *dl = &cl_dlights[i];
 
-		r = 64 * ((i % 4) - 1.5f );
-		f = 64 * ( i / 4) + 128;
+		float r = 64 * ((i % 4) - 1.5f );
+		float f = 64 * ( i / 4) + 128;
 
-		for( j = 0; j < 3; j++ )
+		for( int j = 0; j < 3; j++ )
 			dl->origin[j] = cl.simorg[j] + forward[j] * f + right[j] * r;
 
 		dl->color.r = ((((i % 6) + 1) & 1)>>0) * 255;
@@ -2996,13 +2947,11 @@ get decal global index from decalname
 */
 int GAME_EXPORT CL_DecalIndexFromName( const char *name )
 {
-	int	i;
-
 	if( COM_StringEmptyOrNULL( name ))
 		return 0;
 
 	// look through the loaded sprite name list for SpriteName
-	for( i = 1; i < MAX_DECALS && host.draw_decals[i][0]; i++ )
+	for( int i = 1; i < MAX_DECALS && host.draw_decals[i][0]; i++ )
 	{
 		if( !Q_stricmp( name, host.draw_decals[i] ))
 			return i;
@@ -3099,13 +3048,11 @@ e.g. by demo request
 */
 void CL_ClearStaticEntities( void )
 {
-	int	i;
-
 	if( host.type == HOST_DEDICATED )
 		return;
 
 	// clear out efrags in case the level hasn't been reloaded
-	for( i = 0; i < cl.worldmodel->numleafs; i++ )
+	for( int i = 0; i < cl.worldmodel->numleafs; i++ )
 		cl.worldmodel->leafs[i+1].efrags = NULL;
 
 	clgame.numStatics = 0;

engine/client/cl_video.c

@@ -192,11 +192,9 @@ SCR_PlayCinematic
 qboolean SCR_PlayCinematic( const char *arg )
 {
 	int x, y, w, h;
-	const char	*fullpath;
+	const char	*fullpath = FS_GetDiskPath( arg, false );
 	double video_ratio, screen_ratio, scale;
 
-	fullpath = FS_GetDiskPath( arg, false );
-
 	if( FS_FileExists( arg, false ) && !fullpath )
 	{
 		Con_Printf( S_ERROR "Couldn't load %s from packfile. Please extract it\n", arg );

engine/client/cl_view.c

@@ -187,18 +187,15 @@ merge refdef with overview settings
 static void V_RefApplyOverview( ref_viewpass_t *rvp )
 {
 	ref_overview_t	*ov = &clgame.overView;
-	float		aspect;
-	float		size_x, size_y;
-	vec2_t		mins, maxs;
 
 	if( !CL_IsDevOverviewMode( ))
 		return;
 
 	// NOTE: Xash3D may use 16:9 or 16:10 aspects
-	aspect = (float)refState.width / (float)refState.height;
+	float aspect = (float)refState.width / (float)refState.height;
 
-	size_x = fabs( 8192.0f / ov->flZoom );
-	size_y = fabs( 8192.0f / (ov->flZoom * aspect ));
+	float size_x = fabs( 8192.0f / ov->flZoom );
+	float size_y = fabs( 8192.0f / (ov->flZoom * aspect ));
 
 	// compute rectangle
 	ov->xLeft = -(size_x / 2);
@@ -214,8 +211,8 @@ static void V_RefApplyOverview( ref_viewpass_t *rvp )
 
 	VectorCopy( ov->origin, rvp->vieworigin );
 	rvp->vieworigin[2] = ov->zFar + ov->zNear;
-	Vector2Copy( rvp->vieworigin, mins );
-	Vector2Copy( rvp->vieworigin, maxs );
+	vec2_t mins = Vec2( rvp->vieworigin );
+	vec2_t maxs = Vec2( rvp->vieworigin );
 
 	mins[!ov->rotated] += ov->xLeft;
 	maxs[!ov->rotated] += ov->xRight;
@@ -238,13 +235,11 @@ V_CalcFov
 */
 static float V_CalcFov( float *fov_x, float width, float height )
 {
-	float	x, half_fov_y;
-
 	if( *fov_x < 1.0f || *fov_x > 179.0f )
 		*fov_x = 90.0f; // default value
 
-	x = width / tan( DEG2RAD( *fov_x ) * 0.5f );
-	half_fov_y = atan( height / x );
+	float x = width / tan( DEG2RAD( *fov_x ) * 0.5f );
+	float half_fov_y = atan( height / x );
 
 	return RAD2DEG( half_fov_y ) * 2;
 }
@@ -500,13 +495,12 @@ static void R_ShowTree( void )
 {
 	float	x = (float)((refState.width - (int)POINT_SIZE) >> 1);
 	float	y = NODE_INTERVAL_Y(1.0f);
-	mleaf_t *viewleaf;
 
 	if( !cl.worldmodel || !r_showtree.value )
 		return;
 
 	world.recursion_level = 0;
-	viewleaf = Mod_PointInLeaf( refState.vieworg, cl.worldmodel->nodes, cl.worldmodel );
+	mleaf_t *viewleaf = Mod_PointInLeaf( refState.vieworg, cl.worldmodel->nodes, cl.worldmodel );
 
 	ref.dllFuncs.TriRenderMode( kRenderTransTexture );
 
@@ -560,6 +554,7 @@ void V_PostRender( void )
 		SCR_DrawNetGraph();
 		SCR_DrawUserCmd();
 		Joy_DrawDebug();
+		IN_GyroDrawDebug();
 		SV_DrawOrthoTriangles();
 		CL_DrawDemoRecording();
 		CL_DrawHUD( CL_CHANGELEVEL );

engine/client/client.h

@@ -445,6 +445,7 @@ typedef struct
 	double			timeout;
 	double			timesend;	// time when request was sended
 	int			flags;	// FNETAPI_MULTIPLE_RESPONSE etc
+	int			challenge;	// GoldSrc query challenge, -1 until received
 } net_request_t;
 
 // new versions of client dlls have a single export with all callbacks
@@ -579,6 +580,7 @@ typedef struct
 	sizebuf_t		datagram;			// unreliable stuff. gets sent in CL_Move about cl_cmdrate times per second.
 	byte		datagram_buf[MAX_DATAGRAM];
 
+	uint64_t		netchan_pending_cookie;	// random NET_EXT_NETCHAN_COOKIE
 	netchan_t		netchan;
 
 	float		packet_loss;
@@ -644,10 +646,9 @@ typedef struct
 	qboolean internetservers_pending; // if true, clean master server pings
 	qboolean internetservers_nat;
 	string   internetservers_customfilter;
-	uint32_t internetservers_key;     // compare key to validate master server reply
 
 	// multiprotocol support
-	connprotocol_t legacymode;
+	connprotocol_t net_protocol;
 	int extensions;
 
 	netadr_t serveradr;
@@ -792,6 +793,8 @@ void CL_SignonReply( connprotocol_t proto );
 void CL_ClearState( void );
 void CL_SetCheatState( qboolean multiplayer, qboolean allow_cheats );
 void CL_SendGoldSrcConnectPacket( netadr_t adr, int challenge, const void *ticket, size_t ticketlen );
+void CL_NotifyServerListResponse( void );
+qboolean CL_NetRequestSend( net_request_t *nr );
 
 //
 // cl_demo.c
@@ -1154,7 +1157,7 @@ void S_StopStreaming( void );
 void S_BeginRegistration( void );
 sound_t S_RegisterSound( const char *sample );
 void S_EndRegistration( void );
-void S_RestoreSound( const vec3_t pos, int ent, int chan, sound_t handle, float fvol, float attn, int pitch, int flags, double sample, double end, int wordIndex );
+void S_RestoreSound( const vec3_t pos, int ent, int chan, sound_t handle, float fvol, float attn, int pitch, int flags, double sample, double end, uint wordIndex );
 void S_StartSound( const vec3_t pos, int ent, int chan, sound_t sfx, float vol, float attn, int pitch, int flags );
 void S_AmbientSound( const vec3_t pos, int ent, sound_t handle, float fvol, float attn, int pitch, int flags );
 void S_SoundFade( int fade_percent, int hold_time, int fade_out_seconds, int fade_in_seconds );

engine/client/console.c

@@ -159,7 +159,7 @@ static void Con_SaveHistory( con_history_t *self );
 Con_BackgroundMapActive
 ================
 */
-qboolean Con_BackgroundMapActive( void )
+static qboolean Con_BackgroundMapActive( void )
 {
 	return sv_background.value != 0.0f || cl.background;
 }
@@ -182,13 +182,11 @@ Con_SetColor
 */
 static void Con_SetColor( void )
 {
-	int r, g, b;
-	int num;
-
 	if( !FBitSet( con_color.flags, FCVAR_CHANGED ))
 		return;
 
-	num = sscanf( con_color.string, "%i %i %i", &r, &g, &b );
+	int r, g, b;
+	int num = sscanf( con_color.string, "%i %i %i", &r, &g, &b );
 
 	switch( num )
 	{
@@ -213,9 +211,7 @@ Con_ClearNotify
 */
 void Con_ClearNotify( void )
 {
-	int	i;
-
-	for( i = 0; i < CON_LINES_COUNT; i++ )
+	for( int i = 0; i < CON_LINES_COUNT; i++ )
 		CON_LINES( i ).addtime = 0.0;
 }
 
@@ -310,15 +306,13 @@ Con_SetTimes_f
 */
 static void Con_SetTimes_f( void )
 {
-	int	newtimes;
-
 	if( Cmd_Argc() != 2 )
 	{
 		Con_Printf( S_USAGE "contimes <n lines>\n" );
 		return;
 	}
 
-	newtimes = Q_atoi( Cmd_Argv( 1 ) );
+	int newtimes = Q_atoi( Cmd_Argv( 1 ) );
 	con.num_times = bound( CON_TIMES, newtimes, CON_MAX_TIMES );
 }
 
@@ -333,15 +327,12 @@ went backwards)
 */
 static void Con_FixTimes( void )
 {
-	double	diff;
-	int	i;
-
 	if( con.lines_count <= 0 ) return;
 
-	diff = cl.time - CON_LINES_LAST().addtime;
+	double diff = cl.time - CON_LINES_LAST().addtime;
 	if( diff >= 0.0 ) return; // nothing to fix
 
-	for( i = 0; i < con.lines_count; i++ )
+	for( int i = 0; i < con.lines_count; i++ )
 		CON_LINES( i ).addtime += diff;
 }
 
@@ -428,8 +419,7 @@ Appends a given string as a new line to the console.
 */
 static void Con_AddLine( const char *line, int length, qboolean newline )
 {
-	char		*putpos;
-	con_lineinfo_t	*p;
+	char *putpos;
 
 	if( !con.initialized || !con.buffer )
 		return;
@@ -442,6 +432,7 @@ static void Con_AddLine( const char *line, int length, qboolean newline )
 	while( !( putpos = Con_BytesLeft( length )) || con.lines_count >= con.maxlines )
 		Con_DeleteLine();
 
+	con_lineinfo_t *p;
 	if( newline )
 	{
 		memcpy( putpos, line, length );
@@ -475,12 +466,11 @@ If the line width has changed, reformat the buffer.
 static void Con_CheckResize( void )
 {
 	int	charWidth = 8;
-	int	i, width;
 
 	if( con.curFont && con.curFont->hFontTexture )
 		charWidth = con.curFont->charWidths['O'] - 1;
 
-	width = ( refState.width / charWidth ) - 2;
+	int width = ( refState.width / charWidth ) - 2;
 	if( !ref.initialized ) width = (640 / 5);
 
 	if( width == con.linewidth )
@@ -611,13 +601,12 @@ Con_LoadConchars
 */
 static void Con_LoadConchars( void )
 {
-	int	i, fontSize;
-
 	// load all the console fonts
-	for( i = 0; i < CON_NUMFONTS; i++ )
+	for( int i = 0; i < CON_NUMFONTS; i++ )
 		Con_LoadConsoleFont( i, con.chars + i );
 
 	// select properly fontsize
+	int fontSize;
 	if( con_fontnum.value >= 0 && con_fontnum.value <= CON_NUMFONTS - 1 )
 		fontSize = con_fontnum.value;
 	else if( refState.width <= 640 )
@@ -675,7 +664,6 @@ int Con_UtfMoveLeft( char *str, int pos )
 {
 	utfstate_t state = { 0 };
 	int k = 0;
-	int i;
 
 	if( !cls.accept_utf8 ) // incoming character is not a UTF-8 sequence
 		return pos - 1;
@@ -683,7 +671,7 @@ int Con_UtfMoveLeft( char *str, int pos )
 	if( pos == 1 )
 		return 0;
 
-	for( i = 0; i < pos - 1; i++ )
+	for( int i = 0; i < pos - 1; i++ )
 	{
 		if( Q_DecodeUTF8( &state, (byte)str[i] ))
 			k = i + 1;
@@ -702,12 +690,11 @@ get next of previous printful char
 int Con_UtfMoveRight( char *str, int pos, int length )
 {
 	utfstate_t state = { 0 };
-	int i;
 
 	if( !cls.accept_utf8 ) // incoming character is not a UTF-8 sequence
 		return pos + 1;
 
-	for( i = pos; i <= length; i++ )
+	for( int i = pos; i <= length; i++ )
 	{
 		if( Q_DecodeUTF8( &state, (byte)str[i] ))
 			return i + 1;
@@ -718,20 +705,15 @@ int Con_UtfMoveRight( char *str, int pos, int length )
 
 static void Con_DrawCharToConback( int num, const byte *conchars, byte *dest )
 {
-	int	row, col;
-	const byte	*source;
-	int	drawline;
-	int	x;
+	int row = num >> 4;
+	int col = num & 15;
+	const byte *source = conchars + (row << 10) + (col << 3);
 
-	row = num >> 4;
-	col = num & 15;
-	source = conchars + (row << 10) + (col << 3);
-
-	drawline = 8;
+	int drawline = 8;
 
 	while( drawline-- )
 	{
-		for( x = 0; x < 8; x++ )
+		for( int x = 0; x < 8; x++ )
 			if( source[x] != 255 )
 				dest[x] = 0x60 + source[x];
 		source += 128;
@@ -1105,7 +1087,7 @@ static void Con_ClearField( field_t *edit )
 Field_Set
 ================
 */
-static void Field_Set( field_t *f, const char *string )
+MAYBE_UNUSED static void Field_Set( field_t *f, const char *string )
 {
 	f->scroll = 0;
 	f->cursor = Q_strncpy( f->buffer, string, sizeof( f->buffer ));
@@ -1118,15 +1100,12 @@ Field_Paste
 */
 static void Field_Paste( field_t *edit )
 {
-	char	*cbd;
-	int	i, pasteLen;
-
-	cbd = Sys_GetClipboardData();
+	char *cbd = Sys_GetClipboardData();
 	if( !cbd ) return;
 
 	// send as if typed, so insert / overstrike works properly
-	pasteLen = Q_strlen( cbd );
-	for( i = 0; i < pasteLen; i++ )
+	int pasteLen = Q_strlen( cbd );
+	for( int i = 0; i < pasteLen; i++ )
 		Field_CharEvent( edit, cbd[i] );
 }
 
@@ -1154,8 +1133,6 @@ Key events are used for non-printable characters, others are gotten from char ev
 */
 static void Field_KeyDownEvent( field_t *edit, int key )
 {
-	int	len;
-
 	// shift-insert is paste
 	if((( key == K_INS ) || ( key == K_KP_INS )) && Key_IsDown( K_SHIFT ))
 	{
@@ -1163,7 +1140,7 @@ static void Field_KeyDownEvent( field_t *edit, int key )
 		return;
 	}
 
-	len = Q_strlen( edit->buffer );
+	int len = Q_strlen( edit->buffer );
 
 	if( key == K_DEL )
 	{
@@ -1225,8 +1202,6 @@ Field_CharEvent
 */
 static void Field_CharEvent( field_t *edit, int ch )
 {
-	int	len;
-
 	if( ch == 'v' - 'a' + 1 )
 	{
 		// ctrl-v is paste
@@ -1241,7 +1216,7 @@ static void Field_CharEvent( field_t *edit, int ch )
 		return;
 	}
 
-	len = Q_strlen( edit->buffer );
+	int len = Q_strlen( edit->buffer );
 
 	if( ch == 'a' - 'a' + 1 )
 	{
@@ -1286,7 +1261,6 @@ Field_DrawInputLine
 */
 static int Field_DrawInputLine( int x, int y, const field_t *edit, byte alpha, qboolean cursor )
 {
-	int curPos;
 	char str[MAX_SYSPATH];
 	rgba_t colorDefault;
 	const int prestep = bound( 0, edit->scroll, sizeof( edit->buffer ) - 1 );
@@ -1303,6 +1277,7 @@ static int Field_DrawInputLine( int x, int y, const field_t *edit, byte alpha, q
 
 	// calc cursor position
 	str[cursorCharPos] = 0;
+	int curPos;
 	CL_DrawStringLen( con.curFont, str, &curPos, NULL, FONT_DRAW_UTF8 );
 
 	// draw the cursor
@@ -1415,10 +1390,7 @@ static void Con_HistoryAppend( con_history_t *self, const field_t *from )
 
 static void Con_LoadHistory( con_history_t *self )
 {
-	file_t *fd;
-	int i;
-
-	fd = FS_Open( "console_history.txt", "rb", true );
+	file_t *fd = FS_Open( "console_history.txt", "rb", true );
 
 	if( !fd )
 		return;
@@ -1448,7 +1420,7 @@ static void Con_LoadHistory( con_history_t *self )
 
 	FS_Close( fd );
 
-	for( i = self->next; i < CON_HISTORY; i++ )
+	for( int i = self->next; i < CON_HISTORY; i++ )
 	{
 		history_line_t *f = &self->lines[i];
 
@@ -1460,17 +1432,15 @@ static void Con_LoadHistory( con_history_t *self )
 
 static void Con_SaveHistory( con_history_t *self )
 {
-	int historyStart = self->next - CON_HISTORY, i;
-	file_t *f;
-
 	// do not save history if nothing was executed
 	if( self->next == 0 )
 		return;
 
+	int historyStart = self->next - CON_HISTORY;
 	if( historyStart < 0 )
 		historyStart = 0;
 
-	f = FS_Open( "console_history.txt", "wb", true );
+	file_t *f = FS_Open( "console_history.txt", "wb", true );
 
 	if( !f )
 	{
@@ -1478,7 +1448,7 @@ static void Con_SaveHistory( con_history_t *self )
 		return;
 	}
 
-	for( i = historyStart; i < self->next; i++ )
+	for( int i = historyStart; i < self->next; i++ )
 	{
 		const char *s = self->lines[i % CON_HISTORY].buffer;
 
@@ -1704,15 +1674,13 @@ The input line scrolls horizontally if typing goes beyond the right edge
 */
 static void Con_DrawInput( int lines )
 {
-	int x, y;
-
 	// don't draw anything (always draw if not active)
 	if( cls.key_dest != key_console || !con.curFont )
 		return;
 
-	y = lines - ( con.curFont->charHeight * 2 );
+	int y = lines - ( con.curFont->charHeight * 2 );
 	CL_DrawCharacter( con.curFont->charWidths[' '], y, ']', g_color_table[7], con.curFont, 0 );
-	x = Field_DrawInputLine( con.curFont->charWidths[' ']*2, y, &con.input, 255, true );
+	int x = Field_DrawInputLine( con.curFont->charWidths[' ']*2, y, &con.input, 255, true );
 
 	// HACKHACK: avoid rendering issues when scroll != 0
 	if( con_showcompletion.value && con.input.scroll == 0 )
@@ -1744,18 +1712,16 @@ Custom debug messages
 static int Con_DrawDebugLines( void )
 {
 	notify_t *notify = con.notify;
-	int	i, count = 0;
-	int	defaultX;
+	int	count = 0;
 	int	y = 20;
-	int	fontTall;
 
 	if( !con.curFont || !con.curFont->valid )
 		return 0;
 
-	defaultX = refState.width / 4;
-	fontTall = con.curFont->charHeight + 1;
+	int defaultX = refState.width / 4;
+	int fontTall = con.curFont->charHeight + 1;
 
-	for( i = 0; i < ARRAYSIZE( con.notify ); i++, notify++ )
+	for( int i = 0; i < ARRAYSIZE( con.notify ); i++, notify++ )
 	{
 		int x, len;
 
@@ -1789,19 +1755,18 @@ Draws the debug messages (not passed to console history)
 void Con_DrawDebug( void )
 {
 	static double	timeStart;
-	string		dlstring;
-	int		x, y;
 
 	if( scr_download.value != -1.0f )
 	{
+		string dlstring;
 		int length;
 		Q_snprintf( dlstring, sizeof( dlstring ), "Downloading [%d remaining]: ^2%s^7 %5.1f%% time %.f secs",
 			host.downloadcount, host.downloadfile, scr_download.value, Platform_DoubleTime() - timeStart );
 
 		Con_DrawStringLen( dlstring, &length, NULL );
 		length = Q_max( length, 300 );
-		x = refState.width - length * 1.05f;
-		y = con.curFont->charHeight * 1.05f;
+		int x = refState.width - length * 1.05f;
+		int y = con.curFont->charHeight * 1.05f;
 		Con_DrawString( x, y, dlstring, g_color_table[7] );
 	}
 	else
@@ -1829,15 +1794,15 @@ Draws the last few lines of output transparently over the game top
 static void Con_DrawNotify( void )
 {
 	double	time = cl.time;
-	int	i, x, y = 0;
+	int	y = 0;
 
 	if( !con.curFont ) return;
 
-	x = con.curFont->charWidths[' ']; // offset one space at left screen side
+	int x = con.curFont->charWidths[' ']; // offset one space at left screen side
 
 	if( host.allow_console && !Con_BackgroundMapActive( ))
 	{
-		for( i = Q_max( 0, CON_LINES_COUNT - con.num_times ); i < CON_LINES_COUNT; i++ )
+		for( int i = Q_max( 0, CON_LINES_COUNT - con.num_times ); i < CON_LINES_COUNT; i++ )
 		{
 			con_lineinfo_t	*l = &CON_LINES( i );
 
@@ -1905,13 +1870,13 @@ of it based on con.backscroll.
 */
 static void Con_LastVisibleLine( int *lastline )
 {
-	int	i, lines_seen = 0;
+	int lines_seen = 0;
 
 	con.backscroll = Q_max( 0, con.backscroll );
 	*lastline = 0;
 
 	// now count until we saw con_backscroll actual lines
-	for( i = CON_LINES_COUNT - 1; i >= 0; i-- )
+	for( int i = CON_LINES_COUNT - 1; i >= 0; i-- )
 	{
 		// line is the last visible line?
 		*lastline = i;
@@ -1935,10 +1900,10 @@ Draws the console with the solid background
 */
 static void Con_DrawSolidConsole( int lines )
 {
-	int	i, x, y;
+	int	x, y;
 	float	fraction;
 	int	start;
-	int	stringLen, width = 0, charH;
+	int	stringLen, charH;
 	string	curbuild;
 	byte	color[4];
 
@@ -2086,8 +2051,6 @@ void Con_DrawVersion( void )
 {
 	// draws the current build
 	byte	*color = g_color_table[7];
-	int	stringLen, charH = 0;
-	int	start, height = refState.height;
 	string	curbuild;
 
 	if( !scr_drawversion.value )
@@ -2116,9 +2079,10 @@ void Con_DrawVersion( void )
 			XASH_ENGINE_NAME " v%i/" XASH_VERSION " (%s-%s build %i)", PROTOCOL_VERSION, Q_buildos(), Q_buildarch(), Q_buildnum( ));
 	}
 
+	int stringLen, charH = 0;
 	Con_DrawStringLen( curbuild, &stringLen, &charH );
-	start = refState.width - stringLen * 1.05f;
-	height -= charH * 1.05f;
+	int start = refState.width - stringLen * 1.05f;
+	int height = refState.height - charH * 1.05f;
 
 	Con_DrawString( start, height, curbuild, color );
 }
@@ -2132,8 +2096,6 @@ Scroll it up or down
 */
 void Con_RunConsole( void )
 {
-	float	lines_per_frame;
-
 	Con_SetColor( );
 
 	// decide on the destination height of the console
@@ -2149,7 +2111,7 @@ void Con_RunConsole( void )
 	}
 	else con.showlines = 0; // none visible
 
-	lines_per_frame = fabs( scr_conspeed.value ) * host.realframetime;
+	float lines_per_frame = fabs( scr_conspeed.value ) * host.realframetime;
 
 	if( con.showlines < con.vislines )
 	{
@@ -2224,9 +2186,7 @@ void Con_CharEvent( int key )
 
 static int Con_LoadSimpleConback( const char *name, int flags )
 {
-	int i;
-
-	for( i = 0; i < 5; i++ )
+	for( int i = 0; i < 5; i++ )
 	{
 		string path;
 
@@ -2311,15 +2271,13 @@ void Con_VidInit( void )
 		{
 			lmp_t	*cb = (lmp_t *)FS_LoadFile( "gfx/conback.lmp", &length, false );
 			char	ver[64];
-			byte	*dest;
-			int	x, y, len;
 
 			if( cb && cb->width == 320 && cb->height == 200 )
 			{
-				len = Q_snprintf( ver, 64, "%i", Q_buildnum( )); // can store only buildnum
-				dest = (byte *)(cb + 1) + 320 * 186 + 320 - 11 - 8 * len;
-				y = len;
-				for( x = 0; x < y; x++ )
+				int len = Q_snprintf( ver, 64, "%i", Q_buildnum( )); // can store only buildnum
+				byte *dest = (byte *)(cb + 1) + 320 * 186 + 320 - 11 - 8 * len;
+				int y = len;
+				for( int x = 0; x < y; x++ )
 					Con_DrawCharToConback( ver[x], buf, dest + (x << 3));
 				con.background = ref.dllFuncs.GL_LoadTexture( "#gfx/conback.lmp", (byte *)cb, length, TF_IMAGE );
 			}
@@ -2344,8 +2302,7 @@ Con_InvalidateFonts
 */
 void Con_InvalidateFonts( void )
 {
-	int i;
-	for( i = 0; i < ARRAYSIZE( con.chars ); i++ )
+	for( int i = 0; i < ARRAYSIZE( con.chars ); i++ )
 		CL_FreeFont( &con.chars[i] );
 	con.curFont = NULL;
 }
@@ -2399,9 +2356,8 @@ static void Test_RunConHistory( void )
 	const char *strs1[] = { "map t0a0", "quit", "wtf", "wtf", "", "nyan" };
 	const char *strs2[] = { "nyan", "wtf", "quit", "map t0a0" };
 	const char *testbackup = "unfinished_edit";
-	int i;
 
-	for( i = 0; i < ARRAYSIZE( strs1 ); i++ )
+	for( int i = 0; i < ARRAYSIZE( strs1 ); i++ )
 	{
 		Field_Set( &input, strs1[i] );
 		Con_HistoryAppend( &hist, &input );
@@ -2409,7 +2365,7 @@ static void Test_RunConHistory( void )
 
 	Field_Set( &input, testbackup );
 
-	for( i = 0; i < ARRAYSIZE( strs2 ); i++ )
+	for( int i = 0; i < ARRAYSIZE( strs2 ); i++ )
 	{
 		Con_HistoryUp( &hist, &input );
 		TASSERT_STR( input.buffer, strs2[i] );
@@ -2418,7 +2374,7 @@ static void Test_RunConHistory( void )
 	// check for overrun
 	Con_HistoryUp( &hist, &input );
 
-	for( i = ARRAYSIZE( strs2 ) - 1; i >= 0; i-- )
+	for( int i = ARRAYSIZE( strs2 ) - 1; i >= 0; i-- )
 	{
 		TASSERT_STR( input.buffer, strs2[i] );
 		Con_HistoryDown( &hist, &input );

engine/client/dll_int/cl_game.c

@@ -172,8 +172,6 @@ Initialize CD playlist
 */
 static void CL_InitCDAudio( const char *filename )
 {
-	byte *afile;
-	char *pfile;
 	string	token;
 	int	c = 0;
 
@@ -183,10 +181,10 @@ static void CL_InitCDAudio( const char *filename )
 		CL_CreatePlaylist( filename );
 	}
 
-	afile = FS_LoadFile( filename, NULL, false );
+	byte *afile = FS_LoadFile( filename, NULL, false );
 	if( !afile ) return;
 
-	pfile = (char *)afile;
+	char *pfile = (char *)afile;
 
 	// format: trackname\n [num]
 	while(( pfile = COM_ParseFile( pfile, token, sizeof( token ))) != NULL )
@@ -318,14 +316,12 @@ draw hudsprite routine
 */
 void SPR_AdjustSize( float *x, float *y, float *w, float *h )
 {
-	float	xscale, yscale;
-
 	if( refState.width == clgame.scrInfo.iWidth && refState.height == clgame.scrInfo.iHeight )
 		return;
 
 	// scale for screen sizes
-	xscale = refState.width / (float)clgame.scrInfo.iWidth;
-	yscale = refState.height / (float)clgame.scrInfo.iHeight;
+	float xscale = refState.width / (float)clgame.scrInfo.iWidth;
+	float yscale = refState.height / (float)clgame.scrInfo.iHeight;
 
 	*x *= xscale;
 	*y *= yscale;
@@ -369,7 +365,6 @@ draw hudsprite routine
 static void SPR_DrawGeneric( int frame, float x, float y, float width, float height, const wrect_t *prc )
 {
 	float	s1, s2, t1, t2;
-	int	texnum;
 
 	if( width == -1 && height == -1 )
 	{
@@ -382,7 +377,7 @@ static void SPR_DrawGeneric( int frame, float x, float y, float width, float hei
 		height = h;
 	}
 
-	texnum = R_GetSpriteTexture( clgame.ds.pSprite, frame );
+	int texnum = R_GetSpriteTexture( clgame.ds.pSprite, frame );
 
 	if( prc )
 	{
@@ -430,11 +425,8 @@ called each frame
 void CL_DrawCenterPrint( void )
 {
 	cl_font_t *font = Con_GetCurFont();
-	char	*pText;
-	int	i, j, x, y;
-	int	width, lineLength;
-	byte	*colorDefault, line[MAX_LINELENGTH];
-	int	charWidth, charHeight;
+	byte	line[MAX_LINELENGTH];
+	int	charHeight;
 
 	if( !clgame.centerPrint.time )
 		return;
@@ -446,17 +438,17 @@ void CL_DrawCenterPrint( void )
 		return;
 	}
 
-	y = clgame.centerPrint.y; // start y
-	colorDefault = g_color_table[7];
-	pText = clgame.centerPrint.message;
+	int y = clgame.centerPrint.y; // start y
+	byte *colorDefault = g_color_table[7];
+	char *pText = clgame.centerPrint.message;
 
 	CL_DrawCharacterLen( font, 0, NULL, &charHeight );
 	CL_SetFontRendermode( font );
 	CL_SetFontColor( font, colorDefault );
-	for( i = 0; i < clgame.centerPrint.lines; i++ )
+	for( int i = 0; i < clgame.centerPrint.lines; i++ )
 	{
-		lineLength = 0;
-		width = 0;
+		int lineLength = 0;
+		int width = 0;
 
 		while( *pText && *pText != '\n' && lineLength < MAX_LINELENGTH )
 		{
@@ -466,6 +458,7 @@ void CL_DrawCenterPrint( void )
 				continue;
 
 			line[lineLength] = number;
+			int charWidth;
 			CL_DrawCharacterLen( font, number, &charWidth, NULL );
 			width += charWidth;
 			lineLength++;
@@ -477,9 +470,9 @@ void CL_DrawCenterPrint( void )
 		pText++; // Skip LineFeed
 		line[lineLength] = 0;
 
-		x = CL_AdjustXPos( -1, width, clgame.centerPrint.totalWidth );
+		int x = CL_AdjustXPos( -1, width, clgame.centerPrint.totalWidth );
 
-		for( j = 0; j < lineLength; j++ )
+		for( int j = 0; j < lineLength; j++ )
 		{
 			if( x >= 0 && y >= 0 && x <= refState.width )
 				x += CL_DrawCharacter( x, y, line[j], NULL, font, FONT_DRAW_HUD | FONT_DRAW_NORENDERMODE | FONT_DRAW_NOCOLOR );
@@ -534,9 +527,7 @@ can be modulated
 static void CL_DrawScreenFade( void )
 {
 	screenfade_t	*sf = &clgame.fade;
-	int		alpha;
-
-	alpha = V_FadeAlpha( sf );
+	int alpha = V_FadeAlpha( sf );
 
 	if( !alpha )
 		return;
@@ -619,11 +610,9 @@ Parse TE_TEXTMESSAGE
 void CL_ParseTextMessage( sizebuf_t *msg )
 {
 	static int		msgindex = 0;
-	client_textmessage_t	*text;
-	int			channel;
 
 	// read channel ( 0 - auto)
-	channel = MSG_ReadByte( msg );
+	int channel = MSG_ReadByte( msg );
 
 	if( channel <= 0 || channel > ( MAX_TEXTCHANNELS - 1 ))
 	{
@@ -632,7 +621,7 @@ void CL_ParseTextMessage( sizebuf_t *msg )
 	}
 
 	// grab message channel
-	text = &cl_textmessage[channel];
+	client_textmessage_t *text = &cl_textmessage[channel];
 
 	text->x = (float)(MSG_ReadShort( msg ) / 8192.0f);
 	text->y = (float)(MSG_ReadShort( msg ) / 8192.0f);
@@ -680,12 +669,9 @@ return soundname from index
 */
 static const char *CL_SoundFromIndex( int index )
 {
-	sfx_t	*sfx = NULL;
-	int	hSound;
-
 	// make sure what we in-bounds
 	index = bound( 0, index, MAX_SOUNDS );
-	hSound = cl.sound_index[index];
+	int hSound = cl.sound_index[index];
 
 	if( !hSound )
 	{
@@ -693,7 +679,7 @@ static const char *CL_SoundFromIndex( int index )
 		return NULL;
 	}
 
-	sfx = S_GetSfxByHandle( hSound );
+	sfx_t *sfx = S_GetSfxByHandle( hSound );
 	if( !sfx )
 	{
 		Con_DPrintf( S_ERROR "%s: bad sfx for index %i\n", __func__, index );
@@ -740,8 +726,6 @@ perform common scissor test
 */
 qboolean CL_Scissor( const scissor_state_t *scissor, float *x, float *y, float *width, float *height, float *u0, float *v0, float *u1, float *v1 )
 {
-	float dudx, dvdy;
-
 	if( !scissor->test )
 		return true;
 
@@ -758,8 +742,8 @@ qboolean CL_Scissor( const scissor_state_t *scissor, float *x, float *y, float *
 	if( *y >= scissor->y + scissor->height )
 		return false;
 
-	dudx = (*u1 - *u0) / *width;
-	dvdy = (*v1 - *v0) / *height;
+	float dudx = (*u1 - *u0) / *width;
+	float dvdy = (*v1 - *v0) / *height;
 
 	if( *x < scissor->x )
 	{
@@ -946,9 +930,7 @@ void CL_DrawHUD( int state )
 
 static void CL_ClearUserMessage( char *pszName, int svc_num )
 {
-	int i;
-
-	for( i = 0; i < MAX_USER_MESSAGES && clgame.msg[i].name[0]; i++ )
+	for( int i = 0; i < MAX_USER_MESSAGES && clgame.msg[i].name[0]; i++ )
 		if( ( clgame.msg[i].number == svc_num ) && Q_stricmp( clgame.msg[i].name, pszName ) )
 			clgame.msg[i].number = 0;
 }
@@ -1072,9 +1054,7 @@ free studio cache on change level
 */
 void CL_ClearSpriteTextures( void )
 {
-	int	i;
-
-	for( i = 1; i < MAX_CLIENT_SPRITES; i++ )
+	for( int i = 1; i < MAX_CLIENT_SPRITES; i++ )
 	{
 		if( clgame.sprites[i].needload == NL_UNREFERENCED )
 			continue;
@@ -1212,8 +1192,6 @@ upload sprite frames
 */
 static qboolean CL_LoadHudSprite( const char *szSpriteName, model_t *m_pSprite, uint type, uint texFlags )
 {
-	byte	*buf;
-	fs_offset_t	size;
 	qboolean	loaded;
 
 	Assert( m_pSprite != NULL );
@@ -1243,7 +1221,8 @@ static qboolean CL_LoadHudSprite( const char *szSpriteName, model_t *m_pSprite,
 		}
 	}
 
-	buf = FS_LoadFile( szSpriteName, &size, false );
+	fs_offset_t size;
+	byte *buf = FS_LoadFile( szSpriteName, &size, false );
 	if( buf == NULL )
 		return false;
 
@@ -1280,7 +1259,7 @@ static model_t *CL_LoadSpriteModel( const char *filename, uint type, uint texFla
 {
 	char	name[MAX_QPATH];
 	model_t	*mod;
-	int	i, start;
+	int	i;
 
 	if( COM_StringEmptyOrNULL( filename ))
 	{
@@ -1310,7 +1289,7 @@ static model_t *CL_LoadSpriteModel( const char *filename, uint type, uint texFla
 	// find a free model slot spot
 	// use low indices only for HUD sprites
 	// for GoldSrc bug compatibility
-	start = type == SPR_HUDSPRITE ? 0 : MAX_CLIENT_SPRITES / 2;
+	int start = type == SPR_HUDSPRITE ? 0 : MAX_CLIENT_SPRITES / 2;
 
 	for( i = 0, mod = &clgame.sprites[start]; i < MAX_CLIENT_SPRITES / 2; i++, mod++ )
 	{
@@ -1356,9 +1335,9 @@ pfnSPR_LoadExt
 */
 HSPRITE pfnSPR_LoadExt( const char *szPicName, uint texFlags )
 {
-	model_t	*spr;
+	model_t *spr = CL_LoadSpriteModel( szPicName, SPR_CLIENT, texFlags );
 
-	if(( spr = CL_LoadSpriteModel( szPicName, SPR_CLIENT, texFlags )) == NULL )
+	if( spr == NULL )
 		return 0;
 
 	return (spr - clgame.sprites) + 1; // return index
@@ -1374,9 +1353,9 @@ function exported for support GoldSrc Monitor utility
 HSPRITE EXPORT pfnSPR_Load( const char *szPicName );
 HSPRITE EXPORT pfnSPR_Load( const char *szPicName )
 {
-	model_t	*spr;
+	model_t *spr = CL_LoadSpriteModel( szPicName, SPR_HUDSPRITE, 0 );
 
-	if(( spr = CL_LoadSpriteModel( szPicName, SPR_HUDSPRITE, 0 )) == NULL )
+	if( spr == NULL )
 		return 0;
 
 	return (spr - clgame.sprites) + 1; // return index
@@ -1390,16 +1369,16 @@ CL_GetSpritePointer
 */
 static const model_t *CL_GetSpritePointer( HSPRITE hSprite )
 {
-	model_t	*mod;
 	int index = hSprite - 1;
 
 	if( index < 0 || index >= MAX_CLIENT_SPRITES )
 		return NULL; // bad image
-	mod = &clgame.sprites[index];
+
+	model_t *mod = &clgame.sprites[index];
 
 	if( mod->needload == NL_NEEDS_LOADED )
 	{
-		int	type = FBitSet( mod->flags, MODEL_CLIENT ) ? SPR_HUDSPRITE : SPR_MAPSPRITE;
+		int type = FBitSet( mod->flags, MODEL_CLIENT ) ? SPR_HUDSPRITE : SPR_MAPSPRITE;
 
 		if( CL_LoadHudSprite( mod->name, mod, type, mod->numtexinfo ))
 			return mod;
@@ -1868,8 +1847,6 @@ pfnGetPlayerInfo
 */
 static void GAME_EXPORT pfnGetPlayerInfo( int ent_num, hud_player_info_t *pinfo )
 {
-	player_info_t	*player;
-
 	ent_num -= 1; // player list if offset by 1 from ents
 
 	if( ent_num >= cl.maxclients || ent_num < 0 || !cl.players[ent_num].name[0] )
@@ -1879,7 +1856,7 @@ static void GAME_EXPORT pfnGetPlayerInfo( int ent_num, hud_player_info_t *pinfo
 		return;
 	}
 
-	player = &cl.players[ent_num];
+	player_info_t *player = &cl.players[ent_num];
 	pinfo->thisplayer = ( ent_num == cl.playernum ) ? true : false;
 	pinfo->name = player->name;
 	pinfo->model = player->model;
@@ -1910,11 +1887,9 @@ pfnPlaySoundByIndex
 */
 static void GAME_EXPORT pfnPlaySoundByIndex( int iSound, float volume )
 {
-	int hSound;
-
 	// make sure what we in-bounds
 	iSound = bound( 0, iSound, MAX_SOUNDS );
-	hSound = cl.sound_index[iSound];
+	int hSound = cl.sound_index[iSound];
 	if( !hSound ) return;
 
 	S_StartSound( NULL, cl.viewentity, CHAN_ITEM, hSound, volume, ATTN_NORM, PITCH_NORM, SND_STOP_LOOPING );
@@ -2200,8 +2175,6 @@ pfnCalcShake
 static void GAME_EXPORT pfnCalcShake( void )
 {
 	screen_shake_t *const shake = &clgame.shake;
-	float frametime, fraction, freq;
-	int i;
 
 	if( cl.time > shake->time || shake->amplitude <= 0 || shake->frequency <= 0 || shake->duration <= 0 )
 	{
@@ -2216,7 +2189,7 @@ static void GAME_EXPORT pfnCalcShake( void )
 		return;
 	}
 
-	frametime = cl_clientframetime();
+	float frametime = cl_clientframetime();
 
 	if( cl.time > shake->next_shake )
 	{
@@ -2224,20 +2197,20 @@ static void GAME_EXPORT pfnCalcShake( void )
 		shake->next_shake = (float)cl.time + shake->frequency / shake->duration;
 
 		// randomize each shake
-		for( i = 0; i < 3; i++ )
+		for( int i = 0; i < 3; i++ )
 			shake->offset[i] = COM_RandomFloat( -shake->amplitude, shake->amplitude );
 		shake->angle = COM_RandomFloat( -shake->amplitude * 0.25f, shake->amplitude * 0.25f );
 	}
 
 	// get initial fraction and frequency values over the duration
-	fraction = ((float)cl.time - shake->time ) / shake->duration;
-	freq = fraction != 0.0f ? ( shake->frequency / fraction ) * shake->frequency : 0.0f;
+	float fraction = ((float)cl.time - shake->time ) / shake->duration;
+	float freq = fraction != 0.0f ? ( shake->frequency / fraction ) * shake->frequency : 0.0f;
 
 	// quickly approach zero but apply time over sine wave
 	fraction *= fraction * sin( cl.time * freq );
 
 	// apply shake offset
-	for( i = 0; i < 3; i++ )
+	for( int i = 0; i < 3; i++ )
 		shake->applied_offset[i] = shake->offset[i] * fraction;
 
 	// apply roll angle
@@ -2349,10 +2322,7 @@ pfnKillEvent
 */
 static void GAME_EXPORT pfnKillEvents( int entnum, const char *eventname )
 {
-	int		i;
-	event_state_t	*es;
-	event_info_t	*ei;
-	word		eventIndex = CL_EventIndex( eventname );
+	word eventIndex = CL_EventIndex( eventname );
 
 	if( eventIndex >= MAX_EVENTS )
 		return;
@@ -2360,12 +2330,12 @@ static void GAME_EXPORT pfnKillEvents( int entnum, const char *eventname )
 	if( entnum < 0 || entnum >= clgame.maxEntities )
 		return;
 
-	es = &cl.events;
+	event_state_t *es = &cl.events;
 
 	// find all events with specified index and kill it
-	for( i = 0; i < MAX_EVENT_QUEUE; i++ )
+	for( int i = 0; i < MAX_EVENT_QUEUE; i++ )
 	{
-		ei = &es->ei[i];
+		event_info_t *ei = &es->ei[i];
 
 		if( ei->index == eventIndex && ei->entity_index == entnum )
 		{
@@ -2395,7 +2365,6 @@ CL_FindModelIndex
 static int GAME_EXPORT CL_FindModelIndex( const char *m )
 {
 	char filepath[MAX_QPATH];
-	int  i;
 
 	if( COM_StringEmptyOrNULL( m ))
 		return 0;
@@ -2403,7 +2372,7 @@ static int GAME_EXPORT CL_FindModelIndex( const char *m )
 	Q_strncpy( filepath, m, sizeof( filepath ));
 	COM_FixSlashes( filepath );
 
-	for( i = 0; i < cl.nummodels; i++ )
+	for( int i = 0; i < cl.nummodels; i++ )
 	{
 		if( !cl.models[i+1] )
 			continue;
@@ -2735,9 +2704,7 @@ pfnLoadMapSprite
 */
 static model_t *pfnLoadMapSprite( const char *filename )
 {
-	model_t *mod;
-
-	mod = Mod_FindName( filename, false );
+	model_t *mod = Mod_FindName( filename, false );
 
 	if( CL_LoadHudSprite( filename, mod, SPR_MAPSPRITE, 0 ))
 		return mod;
@@ -2813,12 +2780,10 @@ PlayerInfo_SetValueForKey
 */
 static void GAME_EXPORT PlayerInfo_SetValueForKey( const char *key, const char *value )
 {
-	convar_t	*var;
-
 	if( !Q_strcmp( Info_ValueForKey( cls.userinfo, key ), value ))
 		return; // no changes ?
 
-	var = Cvar_FindVar( key );
+	convar_t *var = Cvar_FindVar( key );
 
 	if( var && FBitSet( var->flags, FCVAR_USERINFO ))
 	{
@@ -2899,11 +2864,10 @@ pfnGetMousePos
 */
 static void GAME_EXPORT pfnGetMousePos( struct tagPOINT *ppt )
 {
-	int x, y;
-
 	if( !ppt )
 		return;
 
+	int x, y;
 	Platform_GetMousePos( &x, &y );
 
 	ppt->x = x;
@@ -3052,11 +3016,11 @@ static int GAME_EXPORT pfnDrawStringReverse( int x, int y, const char *str, int
 {
 	rgba_t color = { r, g, b, 255 };
 	int flags = FONT_DRAW_HUD | FONT_DRAW_NOLF;
-	int width;
 
 	if( hud_utf8.value )
 		SetBits( flags, FONT_DRAW_UTF8 );
 
+	int width;
 	CL_DrawStringLen( &cls.creditsFont, str, &width, NULL, flags );
 
 	x -= width;
@@ -3236,11 +3200,9 @@ TriBrightness
 */
 void TriBrightness( float brightness )
 {
-	float	r, g, b;
-
-	r = clgame.ds.triRGBA[0] * clgame.ds.triRGBA[3] * brightness;
-	g = clgame.ds.triRGBA[1] * clgame.ds.triRGBA[3] * brightness;
-	b = clgame.ds.triRGBA[2] * clgame.ds.triRGBA[3] * brightness;
+	float r = clgame.ds.triRGBA[0] * clgame.ds.triRGBA[3] * brightness;
+	float g = clgame.ds.triRGBA[1] * clgame.ds.triRGBA[3] * brightness;
+	float b = clgame.ds.triRGBA[2] * clgame.ds.triRGBA[3] * brightness;
 
 	ref.dllFuncs.Color4f( r, g, b, 1.0f );
 }
@@ -3287,11 +3249,9 @@ NOTE: dlights are ignored
 */
 void TriLightAtPoint( float *pos, float *value )
 {
-	colorVec	vLightColor;
-
 	if( !pos || !value ) return;
 
-	vLightColor = ref.dllFuncs.R_LightPoint( pos );
+	colorVec vLightColor = ref.dllFuncs.R_LightPoint( pos );
 
 	value[0] = vLightColor.r;
 	value[1] = vLightColor.g;
@@ -3324,9 +3284,9 @@ bind current texture
 */
 int TriSpriteTexture( model_t *pSpriteModel, int frame )
 {
-	int	gl_texturenum;
+	int gl_texturenum = R_GetSpriteTexture( pSpriteModel, frame );
 
-	if(( gl_texturenum = R_GetSpriteTexture( pSpriteModel, frame )) <= 0 )
+	if( gl_texturenum <= 0 )
 		return 0;
 
 	ref.dllFuncs.GL_Bind( XASH_TEXTURE0, gl_texturenum );
@@ -3404,44 +3364,60 @@ NetAPI_SendRequest
 */
 static void GAME_EXPORT NetAPI_SendRequest( int context, int request, int flags, double timeout, netadr_t *remote_address, net_api_response_func_t response )
 {
-	net_request_t	*nr = NULL;
-	int		i;
-
 	if( !response )
 	{
-		Con_DPrintf( S_ERROR "%s: no callbcak specified for request with context %i!\n", __func__, context );
+		Con_DPrintf( S_ERROR "%s: no callback specified for request with context %i!\n", __func__, context );
 		return;
 	}
 
+	// FIXME: call pfnFunc and tell client.dll about errors?
+
 	if( NET_NetadrType( remote_address ) == NA_IPX || NET_NetadrType( remote_address ) == NA_BROADCAST_IPX )
 		return; // IPX no longer support
 
-	if( request == NETAPI_REQUEST_SERVERLIST )
+	switch( request )
+	{
+	case NETAPI_REQUEST_SERVERLIST:
 		return; // no support for server list requests
+	case NETAPI_REQUEST_PING:
+	case NETAPI_REQUEST_RULES:
+	case NETAPI_REQUEST_PLAYERS:
+	case NETAPI_REQUEST_DETAILS:
+		break;
+	default:
+		Con_Printf( S_ERROR "%s: unknown request type %d, context %i\n", __func__, request, context );
+		return;
+	}
 
 	// find a free request
-	for( i = 0; i < MAX_REQUESTS; i++ )
+	net_request_t *nr = NULL, *oldest_nr = NULL;
+	int i;
+	double max_timeout = 0;
+	for( i = 0; i < ARRAYSIZE( clgame.net_requests ); i++ )
 	{
 		nr = &clgame.net_requests[i];
-		if( !nr->pfnFunc ) break;
-	}
 
-	if( i == MAX_REQUESTS )
-	{
-		double	max_timeout = 0;
-
-		// no free requests? use oldest
-		for( i = 0, nr = NULL; i < MAX_REQUESTS; i++ )
+		if(( host.realtime - nr->timesend ) > max_timeout )
 		{
-			if(( host.realtime - clgame.net_requests[i].timesend ) > max_timeout )
-			{
-				max_timeout = host.realtime - clgame.net_requests[i].timesend;
-				nr = &clgame.net_requests[i];
-			}
+			max_timeout = host.realtime - nr->timesend;
+			oldest_nr = nr;
 		}
+
+		if( !nr->pfnFunc )
+			break;
 	}
 
-	Assert( nr != NULL );
+	if( i == ARRAYSIZE( clgame.net_requests ))
+	{
+		// no free requests? use oldest
+		nr = oldest_nr;
+	}
+
+	if( !nr )
+	{
+		Con_Printf( S_ERROR "%s: no free requests\n", __func__ );
+		return;
+	}
 
 	// clear slot
 	memset( nr, 0, sizeof( *nr ));
@@ -3454,9 +3430,10 @@ static void GAME_EXPORT NetAPI_SendRequest( int context, int request, int flags,
 	nr->resp.type = request;
 	nr->resp.remote_address = *remote_address;
 	nr->flags = flags;
+	nr->challenge = -1;
 
-	// local servers request
-	Netchan_OutOfBandPrint( NS_CLIENT, nr->resp.remote_address, A2A_NETINFO" %i %i %i", PROTOCOL_VERSION, context, request );
+	if( !CL_NetRequestSend( nr ))
+		Con_Printf( S_ERROR "%s: failed to send net request for type %d with context %i\n", __func__, request, context );
 }
 
 /*
@@ -3467,13 +3444,10 @@ NetAPI_CancelRequest
 */
 static void GAME_EXPORT NetAPI_CancelRequest( int context )
 {
-	net_request_t	*nr;
-	int		i;
-;
 	// find a specified request
-	for( i = 0; i < MAX_REQUESTS; i++ )
+	for( int i = 0; i < ARRAYSIZE( clgame.net_requests ); i++ )
 	{
-		nr = &clgame.net_requests[i];
+		net_request_t *nr = &clgame.net_requests[i];
 
 		if( clgame.net_requests[i].resp.context == context )
 		{
@@ -3498,13 +3472,10 @@ NetAPI_CancelAllRequests
 */
 void GAME_EXPORT NetAPI_CancelAllRequests( void )
 {
-	net_request_t	*nr;
-	int		i;
-
 	// tell the user about cancel
-	for( i = 0; i < MAX_REQUESTS; i++ )
+	for( int i = 0; i < ARRAYSIZE( clgame.net_requests ); i++ )
 	{
-		nr = &clgame.net_requests[i];
+		net_request_t *nr = &clgame.net_requests[i];
 		if( !nr->pfnFunc ) continue;	// not used
 		SetBits( nr->resp.error, NET_ERROR_TIMEOUT );
 		nr->resp.ping = host.realtime - nr->timesend;
@@ -3614,6 +3585,16 @@ static void GAME_EXPORT VGui_ViewportPaintBackground( int extents[4] )
 	// stub
 }
 
+static cvar_t* GAME_EXPORT CL_CvarGetPointer( const char *szVarName )
+{
+	cvar_t *result = (cvar_t *)Cvar_FindVar( szVarName );
+
+	if( !result )
+		Con_DPrintf( S_WARN "%s: client tried to get non-existent cvar \"%s\"\n", __func__, szVarName );
+	
+	return result;
+}
+
 // shared between client and server
 triangleapi_t gTriApi;
 
@@ -3836,7 +3817,7 @@ static cl_enginefunc_t gEngfuncs =
 	pfnHookEvent,
 	Con_Visible,
 	pfnGetGameDirectory,
-	pfnCVarGetPointer,
+	CL_CvarGetPointer,
 	Key_LookupBinding,
 	pfnGetLevelName,
 	pfnGetScreenFade,
@@ -3970,7 +3951,7 @@ static engine_studio_api_t gStudioAPI =
 	.Mod_ForName             = pfnStudio_Mod_ForName,
 	.Mod_Extradata           = pfnStudio_Mod_Extradata,
 	.GetModelByIndex         = CL_ModelHandle,
-	.GetCvar                 = pfnCVarGetPointer,
+	.GetCvar                 = CL_CvarGetPointer,
 	.GetChromeSprite         = pfnStudio_GetChromeSprite,
 	.GetAliasScale           = pfnStudio_GetAliasScale,
 	.StudioGetAliasTransform = pfnStudio_GetAliasTransform,
@@ -3981,12 +3962,11 @@ static engine_studio_api_t gStudioAPI =
 static void CL_InitStudioAPI( void )
 {
 	static r_studio_interface_t gDefaultStudioDraw;
-	r_studio_interface_t *pStudioDraw;
 
 	if( !ref.dllFuncs.R_StudioFillAPI( &gStudioAPI, &gDefaultStudioDraw ))
 		return;
 
-	pStudioDraw = &gDefaultStudioDraw;
+	r_studio_interface_t *pStudioDraw = &gDefaultStudioDraw;
 
 	if( clgame.dllFuncs.pfnGetStudioModelInterface )
 		clgame.dllFuncs.pfnGetStudioModelInterface( STUDIO_INTERFACE_VERSION, &pStudioDraw, &gStudioAPI );
@@ -4001,7 +3981,6 @@ qboolean CL_LoadProgs( const char *name )
 	qboolean valid_single_export = false;
 	qboolean missed_exports = false;
 	qboolean try_internal_vgui_support = GI->internal_vgui_support;
-	int i;
 
 	if( clgame.hInstance ) CL_UnloadProgs();
 
@@ -4057,7 +4036,7 @@ qboolean CL_LoadProgs( const char *name )
 	if( GetClientAPI != NULL ) // check critical functions again
 		valid_single_export = ValidateExports( cdll_exports, ARRAYSIZE( cdll_exports ));
 
-	for( i = 0; i < ARRAYSIZE( cdll_exports ); i++ )
+	for( int i = 0; i < ARRAYSIZE( cdll_exports ); i++ )
 	{
 		if( *(cdll_exports[i].func) != NULL )
 			continue; // already got through 'F' or 'GetClientAPI'
@@ -4088,7 +4067,7 @@ qboolean CL_LoadProgs( const char *name )
 	if( !valid_single_export )
 		ClearExports( cdll_new_exports, ARRAYSIZE( cdll_new_exports ));
 
-	for( i = 0; i < ARRAYSIZE( cdll_new_exports ); i++ )
+	for( int i = 0; i < ARRAYSIZE( cdll_new_exports ); i++ )
 	{
 		if( *(cdll_new_exports[i].func) != NULL )
 			continue; // already gott through 'F' or 'GetClientAPI'

engine/client/dll_int/cl_gameui.c

@@ -78,8 +78,6 @@ void UI_MouseMove( int x, int y )
 
 void UI_SetActiveMenu( qboolean fActive )
 {
-	movie_state_t	*cin_state;
-
 	if( !gameui.hInstance )
 	{
 		if( !fActive )
@@ -93,7 +91,7 @@ void UI_SetActiveMenu( qboolean fActive )
 	if( !fActive )
 	{
 		// close logo when menu is shutdown
-		cin_state = AVI_GetState( CIN_LOGO );
+		movie_state_t *cin_state = AVI_GetState( CIN_LOGO );
 		AVI_CloseVideo( cin_state );
 	}
 }
@@ -356,12 +354,10 @@ static float GAME_EXPORT UI_GetLogoLength( void )
 
 static void UI_UpdateUserinfo( void )
 {
-	player_info_t	*player;
-
 	if( !host.userinfo_changed )
 		return;
 
-	player = &gameui.playerinfo;
+	player_info_t *player = &gameui.playerinfo;
 
 	Q_strncpy( player->userinfo, cls.userinfo, sizeof( player->userinfo ));
 	Q_strncpy( player->name, Info_ValueForKey( player->userinfo, "name" ), sizeof( player->name ));
@@ -427,10 +423,8 @@ static void UI_ToOldGameInfo( GAMEINFO *out, const gameinfo2_t *in )
 
 static void UI_GetModsInfo( void )
 {
-	int i;
-
 	gameui.modsInfo = Mem_Calloc( gameui.mempool, sizeof( *gameui.modsInfo ) * FI->numgames );
-	for( i = 0; i < FI->numgames; i++ )
+	for( int i = 0; i < FI->numgames; i++ )
 		UI_ConvertGameInfo( &gameui.modsInfo[i], FI->games[i] );
 }
 
@@ -755,10 +749,9 @@ drawing string like a console string
 */
 static int GAME_EXPORT UI_DrawConsoleString( int x, int y, const char *string )
 {
-	int	drawLen;
-
 	if( !string || !*string ) return 0; // silent ignore
-	drawLen = Con_DrawString( x, y, string, gameui.ds.textColor );
+
+	int drawLen = Con_DrawString( x, y, string, gameui.ds.textColor );
 	MakeRGBA( gameui.ds.textColor, 255, 255, 255, 255 );
 
 	return (x + drawLen); // exclude color prexfixes
@@ -958,14 +951,12 @@ static GAMEINFO ** GAME_EXPORT pfnGetGamesList( int *numGames )
 
 	if( !gameui.oldModsInfo )
 	{
-		int i;
-
 		if( !gameui.modsInfo )
 			UI_GetModsInfo();
 
 		// first allocate array of pointers
 		gameui.oldModsInfo = Mem_Calloc( gameui.mempool, sizeof( *gameui.oldModsInfo ) * FI->numgames );
-		for( i = 0; i < FI->numgames; i++ )
+		for( int i = 0; i < FI->numgames; i++ )
 		{
 			gameui.oldModsInfo[i] = Mem_Calloc( gameui.mempool, sizeof( *gameui.oldModsInfo[i] ));
 			UI_ToOldGameInfo( gameui.oldModsInfo[i], &gameui.modsInfo[i] );
@@ -1135,12 +1126,10 @@ static void GAME_EXPORT pfnCon_DefaultColor( int r, int g, int b )
 
 static void GAME_EXPORT pfnSetCursor( void *hCursor )
 {
-	uintptr_t cursor;
-
 	if( !gameui.use_extended_api )
 		return; // ignore original Xash menus
 
-	cursor = (uintptr_t)hCursor;
+	uintptr_t cursor = (uintptr_t)hCursor;
 	if( cursor < dc_user || cursor > dc_last )
 		return;
 
@@ -1335,6 +1324,14 @@ void UI_UnloadProgs( void )
 	memset( &gameui, 0, sizeof( gameui ));
 }
 
+void *UI_GetMenuFactory( void )
+{
+	if( !gameui.hInstance )
+		return NULL;
+
+	return COM_GetProcAddress( gameui.hInstance, "CreateInterface" );
+}
+
 qboolean UI_LoadProgs( void )
 {
 	static ui_enginefuncs_t	gpEngfuncs;

engine/client/dll_int/cl_mobile.c

@@ -63,12 +63,10 @@ static int pfnDrawScaledCharacter( int x, int y, int number, int r, int g, int b
 	if( fabs( g_font_scale - scale ) > 0.1f ||
 		g_scaled_font.hFontTexture != cls.creditsFont.hFontTexture )
 	{
-		int i;
-
 		g_scaled_font = cls.creditsFont;
 		g_scaled_font.scale *= scale;
 		g_scaled_font.charHeight *= scale;
-		for( i = 0; i < ARRAYSIZE( g_scaled_font.charWidths ); i++ )
+		for( int i = 0; i < ARRAYSIZE( g_scaled_font.charWidths ); i++ )
 			g_scaled_font.charWidths[i] *= scale;
 
 		g_font_scale = scale;

engine/client/dll_int/cl_pmove.c

@@ -101,10 +101,9 @@ CL_SetIdealPitch
 void CL_SetIdealPitch( void )
 {
 	float	angleval, sinval, cosval;
-	int	i, j, step, dir, steps;
+	int	i, dir, steps;
 	float	z[MAX_FORWARD];
 	vec3_t	top, bottom;
-	pmtrace_t	tr;
 
 	if( cl.local.onground == -1 )
 		return;
@@ -116,6 +115,8 @@ void CL_SetIdealPitch( void )
 	// 160 or so units to see what's below
 	for( i = 0; i < MAX_FORWARD; i++ )
 	{
+		pmtrace_t	tr;
+
 		top[0] = cl.simorg[0] + cosval * (i + 3.0f) * 12.0f;
 		top[1] = cl.simorg[1] + sinval * (i + 3.0f) * 12.0f;
 		top[2] = cl.simorg[2] + cl.viewheight[2];
@@ -137,9 +138,10 @@ void CL_SetIdealPitch( void )
 	dir = 0;
 	steps = 0;
 
-	for( j = 1; j < i; j++ )
+	for( int j = 1; j < i; j++ )
 	{
-		step = z[j] - z[j-1];
+		int step = z[j] - z[j-1];
+
 		if( step > -ON_EPSILON && step < ON_EPSILON )
 			continue;
 
@@ -244,15 +246,10 @@ This sets up the first phase.
 */
 void GAME_EXPORT CL_SetUpPlayerPrediction( int dopred, int bIncludeLocalClient )
 {
-	entity_state_t	*state;
-	predicted_player_t	*player;
-	cl_entity_t	*ent;
-	int		i;
-
-	for( i = 0; i < MAX_CLIENTS; i++ )
+	for( int i = 0; i < MAX_CLIENTS; i++ )
 	{
-		state = &cl.frames[cl.parsecountmod].playerstate[i];
-		player = &cls.predicted_players[i];
+		entity_state_t *state = &cl.frames[cl.parsecountmod].playerstate[i];
+		predicted_player_t *player = &cls.predicted_players[i];
 
 		player->active = false;
 
@@ -279,7 +276,7 @@ void GAME_EXPORT CL_SetUpPlayerPrediction( int dopred, int bIncludeLocalClient )
 		}
 		else
 		{
-			ent = CL_GetEntityByIndex( i + 1 );
+			cl_entity_t *ent = CL_GetEntityByIndex( i + 1 );
 
 			CL_ComputePlayerOrigin( ent );
 
@@ -397,16 +394,13 @@ collect solid entities
 */
 static void CL_AddLinksToPmove( frame_t *frame )
 {
-	entity_state_t	*state;
-	model_t		*model;
-	physent_t		*pe;
-	int		i;
-
 	if( !frame->valid ) return;
 
-	for( i = 0; i < frame->num_entities; i++ )
+	for( int i = 0; i < frame->num_entities; i++ )
 	{
-		state = &cls.packet_entities[(frame->first_entity + i) % cls.num_client_entities];
+		entity_state_t *state = &cls.packet_entities[(frame->first_entity + i) % cls.num_client_entities];
+		model_t *model;
+		physent_t *pe;
 
 		if( state->number >= 1 && state->number <= cl.maxclients )
 			continue;
@@ -506,18 +500,14 @@ pmove must be setup with world and solid entity hulls before calling
 */
 void GAME_EXPORT CL_SetSolidPlayers( int playernum )
 {
-	entity_state_t	*state;
-	predicted_player_t	*player;
-	physent_t		*pe;
-	int		i;
-
 	if( !cl_solid_players.value )
 		return;
 
-	for( i = 0; i < MAX_CLIENTS; i++ )
+	for( int i = 0; i < MAX_CLIENTS; i++ )
 	{
-		state = &cl.frames[cl.parsecountmod].playerstate[i];
-		player = &cls.predicted_players[i];
+		entity_state_t *state = &cl.frames[cl.parsecountmod].playerstate[i];
+		predicted_player_t *player = &cls.predicted_players[i];
+		physent_t *pe;
 
 		if( playernum == -1 )
 		{
@@ -562,18 +552,17 @@ CL_WaterEntity
 */
 int GAME_EXPORT CL_WaterEntity( const float *rgflPos )
 {
-	physent_t		*pe;
-	hull_t		*hull;
-	vec3_t		test, offset;
-	int		i, oldhull;
+	int oldhull;
 
 	if( !rgflPos ) return -1;
 
 	oldhull = clgame.pmove->usehull;
 
-	for( i = 0; i < clgame.pmove->numphysent; i++ )
+	for( int i = 0; i < clgame.pmove->numphysent; i++ )
 	{
-		pe = &clgame.pmove->physents[i];
+		physent_t *pe = &clgame.pmove->physents[i];
+		hull_t *hull;
+		vec3_t test, offset;
 
 		if( pe->solid != SOLID_NOT ) // disabled ?
 			continue;
@@ -657,9 +646,8 @@ returns water brush where inside pos
 */
 cl_entity_t *CL_GetWaterEntity( const float *rgflPos )
 {
-	int	entnum;
+	int entnum = CL_WaterEntity( rgflPos );
 
-	entnum = CL_WaterEntity( rgflPos );
 	if( entnum <= 0 ) return NULL; // world or not water
 
 	return CL_GetEntityByIndex( entnum );
@@ -732,8 +720,6 @@ CL_InitClientMove
 */
 void CL_InitClientMove( void )
 {
-	int	i;
-
 	Pmove_Init ();
 
 	clgame.pmove->server = false;	// running at client
@@ -741,7 +727,7 @@ void CL_InitClientMove( void )
 	clgame.pmove->runfuncs = false;
 
 	// enumerate client hulls
-	for( i = 0; i < MAX_MAP_HULLS; i++ )
+	for( int i = 0; i < MAX_MAP_HULLS; i++ )
 	{
 		if( clgame.dllFuncs.pfnGetHullBounds( i, host.player_mins[i], host.player_maxs[i] ))
 			Con_Reportf( "CL: hull%i, player_mins: %g %g %g, player_maxs: %g %g %g\n", i,

engine/client/dll_int/ref_common.c

@@ -72,18 +72,15 @@ static qboolean CheckSkybox( const char *name, char out[SKYBOX_MAX_SIDES][MAX_ST
 {
 	static const char *skybox_ext[3] = { "dds", "tga", "bmp" };
 	static const char *skybox_delim[2] = { "", "_" }; // no space for HL style, underscore for Q1 style
-	int	i;
 
 	// search for skybox images
-	for( i = 0; i <	ARRAYSIZE( skybox_ext ); i++ )
+	for( int i = 0; i <	ARRAYSIZE( skybox_ext ); i++ )
 	{
-		int j;
-
-		for( j = 0; j < ARRAYSIZE( skybox_delim ); j++ )
+		for( int j = 0; j < ARRAYSIZE( skybox_delim ); j++ )
 		{
-			int k, num_checked_sides = 0;
+			int num_checked_sides = 0;
 
-			for( k = 0; k < SKYBOX_MAX_SIDES; k++ )
+			for( int k = 0; k < SKYBOX_MAX_SIDES; k++ )
 			{
 				char sidename[MAX_VA_STRING];
 
@@ -109,7 +106,6 @@ void R_SetupSky( const char *name )
 	char sidenames[SKYBOX_MAX_SIDES][MAX_STRING];
 	int skyboxTextures[SKYBOX_MAX_SIDES] = { 0 };
 	int i, len;
-	qboolean result;
 
 	if( COM_StringEmptyOrNULL( name ))
 	{
@@ -125,10 +121,9 @@ void R_SetupSky( const char *name )
 
 	if( loadname[len - 1] == '_' )
 		loadname[len - 1] = '\0';
-	result = CheckSkybox( loadname, sidenames );
 
 	// to prevent infinite recursion if default skybox was missed
-	if( !result && Q_stricmp( name, DEFAULT_SKYBOX_NAME ))
+	if( !CheckSkybox( loadname, sidenames ) && Q_stricmp( name, DEFAULT_SKYBOX_NAME ))
 	{
 		Con_Reportf( S_WARN "missed or incomplete skybox '%s'\n", name );
 		R_SetupSky( DEFAULT_SKYBOX_NAME ); // force to default

engine/client/gamma.c

@@ -35,7 +35,6 @@ static CVAR_DEFINE( v_gamma, "gamma", "2.5", FCVAR_ARCHIVE, "gamma amount" );
 static void BuildGammaTable( const float gamma, const float brightness, const float texgamma, const float lightgamma )
 {
 	float g1, g2, g3;
-	int i;
 
 	if( gamma != 0.0 )
 		g1 = 1.0 / gamma;
@@ -50,7 +49,7 @@ static void BuildGammaTable( const float gamma, const float brightness, const fl
 	else
 		g3 = 0.05;
 
-	for( i = 0; i < 256; i++ )
+	for( int i = 0; i < 256; i++ )
 	{
 		// keep it float or texgamma test will fail with -ffast-math
 		float d = pow( i / 255.0, (double)g2 );
@@ -58,11 +57,9 @@ static void BuildGammaTable( const float gamma, const float brightness, const fl
 		texgammatable[i] = bound( 0, inf, 255 );
 	}
 
-	for( i = 0; i < 1024; i++ )
+	for( int i = 0; i < 1024; i++ )
 	{
-		double d;
 		float f = pow( i / 1023.0, (double)lightgamma );
-		int inf;
 
 		if( brightness > 1.0 )
 			f *= brightness;
@@ -72,8 +69,8 @@ static void BuildGammaTable( const float gamma, const float brightness, const fl
 		else
 			f = (( f - g3 ) / ( 1.0 - g3 )) * 0.875 + 0.125;
 
-		d = pow( (double)f, (double)g1 ); // do not remove the cast, or tests fail
-		inf = d * 1023.0;
+		double d = pow( (double)f, (double)g1 ); // do not remove the cast, or tests fail
+		int inf = d * 1023.0;
 		lightgammatable[i] = bound( 0, inf, 1023 );
 
 		// do these calculations in the same loop...
@@ -255,11 +252,9 @@ static void Test_PrecomputedGammaTables( void )
 
 	while(( data = Test_GetGammaTables( i )))
 	{
-		int j;
-
 		BuildGammaTable( data->gamma, data->brightness, data->texgamma, data->lightgamma );
 
-		for( j = 0; j < 1024; j++ )
+		for( int j = 0; j < 1024; j++ )
 		{
 			if( j < 256 )
 			{

engine/client/identification.c

@@ -15,14 +15,13 @@ GNU General Public License for more details.
 
 #include "build.h"
 #include <inttypes.h>
+#if XASH_LINUX
 #include <fcntl.h>
-#if !XASH_WIN32
 #include <dirent.h>
-#else
-#include <io.h>
 #endif
 #include "common.h"
 #include "client.h"
+#include "platform/platform.h"
 
 /*
 ==========================================================
@@ -80,7 +79,7 @@ static uint BloomFilter_Weight( bloomfilter_t value )
 	return weight;
 }
 
-static qboolean BloomFilter_ContainsString( bloomfilter_t filter, const char *str )
+MAYBE_UNUSED static qboolean BloomFilter_ContainsString( bloomfilter_t filter, const char *str )
 {
 	bloomfilter_t value = BloomFilter_ProcessStr( str );
 
@@ -97,14 +96,11 @@ IDENTIFICATION
 #define MAXBITS_GEN 30
 #define MAXBITS_CHECK MAXBITS_GEN + 6
 
-static qboolean ID_ProcessFile( bloomfilter_t *value, const char *path );
-
 static void ID_BloomFilter_f( void )
 {
 	bloomfilter_t value = 0;
-	int i;
 
-	for( i = 1; i < Cmd_Argc(); i++ )
+	for( int i = 1; i < Cmd_Argc(); i++ )
 		value |= BloomFilter_ProcessStr( Cmd_Argv( i ) );
 
 	Msg( "%d %016"PRIX64"\n", BloomFilter_Weight( value ), value );
@@ -119,7 +115,6 @@ static qboolean ID_VerifyHEX( const char *hex )
 	uint chars = 0;
 	char prev = 0;
 	qboolean monotonic = true; // detect 11:22...
-	int weight = 0;
 
 	while( *hex++ )
 	{
@@ -142,6 +137,7 @@ static qboolean ID_VerifyHEX( const char *hex )
 	if( monotonic )
 		return false;
 
+	int weight = 0;
 	while( chars )
 	{
 		if( chars & 1 )
@@ -170,7 +166,7 @@ static void ID_VerifyHEX_f( void )
 static qboolean ID_ProcessCPUInfo( bloomfilter_t *value )
 {
 	int cpuinfofd = open( "/proc/cpuinfo", O_RDONLY );
-	char buffer[1024], *pbuf, *pbuf2;
+	char buffer[1024];
 	int ret;
 
 	if( cpuinfofd < 0 )
@@ -189,12 +185,12 @@ static qboolean ID_ProcessCPUInfo( bloomfilter_t *value )
 	if( !ret )
 		return false;
 
-	pbuf = Q_stristr( buffer, "Serial" );
+	char *pbuf = Q_stristr( buffer, "Serial" );
 	if( !pbuf )
 		return false;
 	pbuf += 6;
 
-	pbuf2 = Q_strchrnul( pbuf, '\n' );
+	char *pbuf2 = Q_strchrnul( pbuf, '\n' );
 	*pbuf2 = 0;
 
 	if( !ID_VerifyHEX( pbuf ) )
@@ -204,86 +200,6 @@ static qboolean ID_ProcessCPUInfo( bloomfilter_t *value )
 	return true;
 }
 
-static qboolean ID_ValidateNetDevice( const char *dev )
-{
-	const char *prefix = "/sys/class/net";
-	byte *pfile;
-	int assignType;
-
-	// These devices are fake, their mac address is generated each boot, while assign_type is 0
-	if( !Q_strnicmp( dev, "ccmni", sizeof( "ccmni" ) ) ||
-		!Q_strnicmp( dev, "ifb", sizeof( "ifb" ) ) )
-		return false;
-
-	pfile = FS_LoadDirectFile( va( "%s/%s/addr_assign_type", prefix, dev ), NULL );
-
-	// if NULL, it may be old kernel
-	if( pfile )
-	{
-		assignType = Q_atoi( (char*)pfile );
-
-		Mem_Free( pfile );
-
-		// check is MAC address is constant
-		if( assignType != 0 )
-			return false;
-	}
-
-	return true;
-}
-
-static int ID_ProcessNetDevices( bloomfilter_t *value )
-{
-	const char *prefix = "/sys/class/net";
-	DIR *dir;
-	struct dirent *entry;
-	int count = 0;
-
-	if( !( dir = opendir( prefix ) ) )
-		return 0;
-
-	while( ( entry = readdir( dir ) ) && BloomFilter_Weight( *value ) < MAXBITS_GEN )
-	{
-		if( !Q_strcmp( entry->d_name, "." ) || !Q_strcmp( entry->d_name, ".." ) )
-			continue;
-
-		if( !ID_ValidateNetDevice( entry->d_name ) )
-			continue;
-
-		count += ID_ProcessFile( value, va( "%s/%s/address", prefix, entry->d_name ) );
-	}
-	closedir( dir );
-	return count;
-}
-
-static int ID_CheckNetDevices( bloomfilter_t value )
-{
-	const char *prefix = "/sys/class/net";
-
-	DIR *dir;
-	struct dirent *entry;
-	int count = 0;
-	bloomfilter_t filter = 0;
-
-	if( !( dir = opendir( prefix ) ) )
-		return 0;
-
-	while( ( entry = readdir( dir ) ) )
-	{
-		if( !Q_strcmp( entry->d_name, "." ) || !Q_strcmp( entry->d_name, ".." ) )
-			continue;
-
-		if( !ID_ValidateNetDevice( entry->d_name ) )
-			continue;
-
-		if( ID_ProcessFile( &filter, va( "%s/%s/address", prefix, entry->d_name ) ) )
-			count += ( value & filter ) == filter, filter = 0;
-	}
-
-	closedir( dir );
-	return count;
-}
-
 static void ID_TestCPUInfo_f( void )
 {
 	bloomfilter_t value = 0;
@@ -294,8 +210,6 @@ static void ID_TestCPUInfo_f( void )
 		Msg( "Could not get serial\n" );
 }
 
-#endif
-
 static qboolean ID_ProcessFile( bloomfilter_t *value, const char *path )
 {
 	int fd = open( path, O_RDONLY );
@@ -325,7 +239,6 @@ static qboolean ID_ProcessFile( bloomfilter_t *value, const char *path )
 	return true;
 }
 
-#if !XASH_WIN32
 static int ID_ProcessFiles( bloomfilter_t *value, const char *prefix, const char *postfix )
 {
 	DIR *dir;
@@ -368,7 +281,94 @@ static int ID_CheckFiles( bloomfilter_t value, const char *prefix, const char *p
 	closedir( dir );
 	return count;
 }
-#else
+#endif // XASH_LINUX
+
+#if XASH_POSIX
+#define MAX_NETDEVICES 16
+
+static qboolean ID_IsReservedMAC( uint64_t mac )
+{
+	byte first = ( mac >> 40 ) & 0xff;
+
+	// no address at all
+	if( mac == 0 )
+		return true;
+
+	// group and local bits of the first octet, see https://www.rfc-editor.org/rfc/rfc9542#section-2.1.1
+	if( FBitSet( first, 0x01 ) || FBitSet( first, 0x02 ))
+		return true;
+
+	// IANA OUI, see https://www.iana.org/assignments/ethernet-numbers/ethernet-numbers.xhtml and https://www.rfc-editor.org/rfc/rfc9568#section-7.3
+	if(( mac >> 24 ) == 0x00005e )
+		return true;
+
+	return false;
+}
+
+static void ID_FormatMAC( char *out, size_t size, uint64_t mac )
+{
+	// format exactly like /sys/class/net/ */address contents, so ids generated by older versions stay valid
+	Q_snprintf( out, size, "%02x:%02x:%02x:%02x:%02x:%02x\n",
+		(uint)(( mac >> 40 ) & 0xffu ),
+		(uint)(( mac >> 32 ) & 0xffu ),
+		(uint)(( mac >> 24 ) & 0xffu ),
+		(uint)(( mac >> 16 ) & 0xffu ),
+		(uint)(( mac >> 8  ) & 0xffu ),
+		(uint)( mac & 0xffu ));
+}
+
+static int ID_ProcessNetDevices( bloomfilter_t *value )
+{
+	uint64_t macs[MAX_NETDEVICES];
+	int total = Posix_GetNetDeviceAddresses( macs, MAX_NETDEVICES );
+	int count = 0;
+
+	for( int i = 0; i < total && BloomFilter_Weight( *value ) < MAXBITS_GEN; i++ )
+	{
+		char buf[32];
+
+		if( ID_IsReservedMAC( macs[i] ))
+			continue;
+
+		ID_FormatMAC( buf, sizeof( buf ), macs[i] );
+
+		if( !ID_VerifyHEX( buf ))
+			continue;
+
+		*value |= BloomFilter_ProcessStr( buf );
+		count++;
+	}
+
+	return count;
+}
+
+static int ID_CheckNetDevices( bloomfilter_t value )
+{
+	uint64_t macs[MAX_NETDEVICES];
+	int total = Posix_GetNetDeviceAddresses( macs, MAX_NETDEVICES );
+	int count = 0;
+
+	for( int i = 0; i < total; i++ )
+	{
+		char buf[32];
+
+		if( ID_IsReservedMAC( macs[i] ))
+			continue;
+
+		ID_FormatMAC( buf, sizeof( buf ), macs[i] );
+
+		if( !ID_VerifyHEX( buf ))
+			continue;
+
+		bloomfilter_t filter = BloomFilter_ProcessStr( buf );
+		count += ( value & filter ) == filter;
+	}
+
+	return count;
+}
+#endif // XASH_POSIX
+
+#if XASH_WIN32
 static int ID_GetKeyData( HKEY hRootKey, char *subKey, char *value, LPBYTE data, DWORD cbData )
 {
 	HKEY hKey;
@@ -500,12 +500,10 @@ static int ID_CheckWMIC( bloomfilter_t value, const wchar_t *cmdline )
 	pbuf = COM_ParseFile( buffer, token, sizeof( token )); // Header
 	while(( pbuf = COM_ParseFile( pbuf, token, sizeof( token ))))
 	{
-		bloomfilter_t filter;
-
 		if( !ID_VerifyHEX( token ))
 			continue;
 
-		filter = BloomFilter_ProcessStr( token );
+		bloomfilter_t filter = BloomFilter_ProcessStr( token );
 		count += ( filter & value ) == filter;
 	}
 
@@ -544,6 +542,17 @@ static bloomfilter_t ID_GenerateRawId( void )
 
 	count += ID_ProcessCPUInfo( &value );
 	count += ID_ProcessFiles( &value, "/sys/block", "device/cid" );
+#endif
+#if XASH_OSX
+	char buf[64];
+
+	if( Apple_GetSerialNumber( buf, sizeof( buf )))
+	{
+		value |= BloomFilter_ProcessStr( buf );
+		count++;
+	}
+#endif
+#if XASH_POSIX
 	count += ID_ProcessNetDevices( &value );
 #endif
 #if XASH_WIN32
@@ -592,12 +601,26 @@ static uint ID_CheckRawId( bloomfilter_t filter )
 	}
 
 #endif // !XASH_ANDROID
-	count += ID_CheckNetDevices( filter );
 	count += ID_CheckFiles( filter, "/sys/block", "device/cid" );
 	if( ID_ProcessCPUInfo( &value ) )
 		count += (filter & value) == value;
 #endif
 
+#if XASH_OSX
+	char buf[64];
+
+	if( Apple_GetSerialNumber( buf, sizeof( buf )))
+	{
+		value = BloomFilter_ProcessStr( buf );
+		count += (filter & value) == value;
+		value = 0;
+	}
+#endif
+
+#if XASH_POSIX
+	count += ID_CheckNetDevices( filter );
+#endif
+
 #if XASH_WIN32
 	count += ID_CheckWMIC( filter, L"wmic path win32_physicalmedia get SerialNumber" );
 	count += ID_CheckWMIC( filter, L"wmic bios get serialnumber" );

engine/client/input.h

@@ -43,6 +43,7 @@ void IN_GyroInit( void );
 void IN_GyroCheckAvailability( void );
 void IN_GyroEvent( vec3_t data );
 void IN_GyroFinalizeMove( float *fw, float *side, float *dpitch, float *dyaw );
+void IN_GyroDrawDebug( void );
 
 uint IN_CollectInputDevices( void );
 void IN_LockInputDevices( qboolean lock );

engine/client/input/in_gyro.c

@@ -25,9 +25,11 @@ static CVAR_DEFINE_AUTO( gyro_roll, "0.0", FCVAR_ARCHIVE | FCVAR_FILTERABLE, "bu
 static CVAR_DEFINE_AUTO( gyro_pitch_deadzone, "0.5", FCVAR_ARCHIVE | FCVAR_FILTERABLE, "built-in gyroscope pitch axis deadzone (deg/s)" );
 static CVAR_DEFINE_AUTO( gyro_yaw_deadzone, "0.5", FCVAR_ARCHIVE | FCVAR_FILTERABLE, "built-in gyroscope yaw axis deadzone (deg/s)" );
 static CVAR_DEFINE_AUTO( gyro_roll_deadzone, "0.5", FCVAR_ARCHIVE | FCVAR_FILTERABLE, "built-in gyroscope roll axis deadzone (deg/s)" );
+static CVAR_DEFINE_AUTO( gyro_debug, "0", 0, "visualize built-in device gyroscope" );
 
 // stores the latest instantaneous rotation rates from built-in gyroscope
 static vec3_t gyro_speed;
+static vec3_t gyro_speed_display;
 
 /*
 ==============
@@ -45,6 +47,7 @@ void IN_GyroInit( void )
 	Cvar_RegisterVariable( &gyro_pitch_deadzone );
 	Cvar_RegisterVariable( &gyro_yaw_deadzone );
 	Cvar_RegisterVariable( &gyro_roll_deadzone );
+	Cvar_RegisterVariable( &gyro_debug );
 }
 
 /*
@@ -79,6 +82,28 @@ void IN_GyroEvent( vec3_t data )
 	VectorCopy( data, gyro_speed );
 }
 
+static void IN_GyroMap( const vec3_t src, vec3_t dst )
+{
+	float orient_scale = 1.0f;
+
+	platform_orientation_t orient = Platform_GetDisplayOrientation();
+	if( orient == ORIENTATION_LANDSCAPE_FLIPPED )
+		orient_scale = -1.0f;
+
+	#if XASH_ANDROID || XASH_IOS
+		// In Landscape mode axes are swapped relative to natural (Portrait) orientation
+		// Y axis rotation becomes Pitch (up/down)
+		// X axis rotation becomes Yaw (left/right)
+		dst[0] = -orient_scale * src[1] * ( 180.0f / M_PI );
+		dst[1] = orient_scale * src[0] * ( 180.0f / M_PI );
+		dst[2] = orient_scale * src[2] * ( 180.0f / M_PI );
+	#else
+		dst[0] = orient_scale * src[0] * ( 180.0f / M_PI );
+		dst[1] = orient_scale * src[1] * ( 180.0f / M_PI );
+		dst[2] = orient_scale * src[2] * ( 180.0f / M_PI );
+	#endif
+}
+
 /*
 =============
 IN_GyroFinalizeMove
@@ -88,33 +113,102 @@ Apply gyro movement to view angles
 */
 void IN_GyroFinalizeMove( float *fw, float *side, float *dpitch, float *dyaw )
 {
-	platform_orientation_t orient;
-	float orient_scale = 1.0f;
+	vec3_t mapped_speed;
 
 	if( !gyro_enable.value || !gyro_available.value )
 		return;
 
-	orient = Platform_GetDisplayOrientation();
-	if( orient == ORIENTATION_LANDSCAPE_FLIPPED )
-		orient_scale = -1.0f;
+	IN_GyroMap( gyro_speed, mapped_speed );
+	VectorCopy( mapped_speed, gyro_speed_display );
 
-	// In Landscape mode axes are swapped relative to natural (Portrait) orientation
-	// Y axis rotation becomes Pitch (up/down)
-	// X axis rotation becomes Yaw (left/right)
-	float pitch_speed = -orient_scale * gyro_speed[1] * ( 180.0f / M_PI );
-	float yaw_speed   = orient_scale * gyro_speed[0] * ( 180.0f / M_PI );
-	float roll_speed  = orient_scale * gyro_speed[2] * ( 180.0f / M_PI );
+	if( fabs( mapped_speed[0] ) < gyro_pitch_deadzone.value )
+		mapped_speed[0] = 0.0f;
+	if( fabs( mapped_speed[1] ) < gyro_yaw_deadzone.value )
+		mapped_speed[1] = 0.0f;
+	if( fabs( mapped_speed[2] ) < gyro_roll_deadzone.value )
+		mapped_speed[2] = 0.0f;
 
-	if( fabs( pitch_speed ) < gyro_pitch_deadzone.value )
-		pitch_speed = 0.0f;
-	if( fabs( yaw_speed ) < gyro_yaw_deadzone.value )
-		yaw_speed = 0.0f;
-	if( fabs( roll_speed ) < gyro_roll_deadzone.value )
-		roll_speed = 0.0f;
-
-	*dpitch -= gyro_pitch.value * pitch_speed * host.realframetime;
-	*dyaw   += gyro_yaw.value   * yaw_speed   * host.realframetime;
-	*dyaw   += gyro_roll.value  * roll_speed  * host.realframetime;
+	*dpitch -= gyro_pitch.value * mapped_speed[0] * host.realframetime;
+	*dyaw   += gyro_yaw.value   * mapped_speed[1] * host.realframetime;
+	*dyaw   += gyro_roll.value  * mapped_speed[2] * host.realframetime;
 
 	VectorClear( gyro_speed );
 }
+
+void IN_GyroDrawDebug( void )
+{
+	cl_font_t *font = Con_GetCurFont();
+
+	if( !gyro_debug.value || !gyro_available.value )
+		return;
+
+	float x = 8;
+	float y = 100;
+	const float bar_w = 100;
+	const float halfbar_w = bar_w * 0.5f;
+	const float bar_h = font->charHeight - 2;
+	const float center = x + halfbar_w;
+
+	platform_orientation_t orient = Platform_GetDisplayOrientation();
+	const char *orient_name = "UNKNOWN";
+	switch( orient )
+	{
+	case ORIENTATION_LANDSCAPE:
+		orient_name = "LANDSCAPE";
+		break;
+	case ORIENTATION_LANDSCAPE_FLIPPED:
+		orient_name = "LANDSCAPE FLIPPED";
+		break;
+	case ORIENTATION_PORTRAIT:
+		orient_name = "PORTRAIT";
+		break;
+	case ORIENTATION_PORTRAIT_FLIPPED:
+		orient_name = "PORTRAIT FLIPPED";
+		break;
+	default:
+		orient_name = "UNKNOWN";
+		break;
+	}
+
+	char orient_text[32];
+	Q_snprintf( orient_text, sizeof( orient_text ), "ORIENT: %s", orient_name );
+
+	const rgba_t bar_backcolor = { 40, 40, 40, 180 };
+	const rgba_t bar_fillcolor = { 100, 200, 100, 200 };
+	static const char *gyronames[3] = { "GYRO P", "GYRO Y", "GYRO R" };
+	static const convar_t *const gyro_deadzone[3] =
+	{
+		&gyro_pitch_deadzone,
+		&gyro_yaw_deadzone,
+		&gyro_roll_deadzone,
+	};
+
+	for( int i = 0; i < 3; i++ )
+	{
+		float fval = gyro_speed_display[i] / 180.0f;
+		fval = bound( -1.0f, fval, 1.0f );
+
+		CL_DrawString( x, y, gyronames[i], g_color_table[7], font, 0 );
+		y += font->charHeight;
+
+		ref.dllFuncs.FillRGBA( kRenderTransTexture, x, y, bar_w, bar_h, bar_backcolor[0], bar_backcolor[1], bar_backcolor[2], bar_backcolor[3] );
+
+		float filled = fval * halfbar_w;
+		ref.dllFuncs.FillRGBA( kRenderTransTexture, center + Q_min( 0, filled ), y, fabs( filled ), bar_h, bar_fillcolor[0], bar_fillcolor[1], bar_fillcolor[2], bar_fillcolor[3] );
+
+		float fthreshold = gyro_deadzone[i]->value / 180.0f;
+		fthreshold = bound( 0.0f, fthreshold, 1.0f );
+		if( fthreshold > 0.0f )
+		{
+			float thresh_x = fthreshold * halfbar_w;
+			ref.dllFuncs.FillRGBA( kRenderTransTexture, center - thresh_x, y, thresh_x * 2, bar_h, 180, 40, 40, 120 );
+			ref.dllFuncs.FillRGBA( kRenderTransTexture, center + thresh_x, y, 1, bar_h, 255, 200, 0, 220 );
+			ref.dllFuncs.FillRGBA( kRenderTransTexture, center - thresh_x, y, 1, bar_h, 255, 200, 0, 220 );
+		}
+
+		ref.dllFuncs.FillRGBA( kRenderTransTexture, center, y, 1, bar_h, 180, 180, 180, 220 );
+		y += bar_h + 2;
+	}
+
+	CL_DrawString( x, y, orient_text, g_color_table[1], font, 0 );
+}

engine/client/input/in_joy.c

@@ -129,9 +129,8 @@ static void Joy_HatMotionEvent( int value )
 		{ JOY_HAT_LEFT, K_LEFTARROW },
 		{ JOY_HAT_RIGHT, K_RIGHTARROW },
 	};
-	int i;
 
-	for( i = 0; i < ARRAYSIZE( keys ); i++ )
+	for( int i = 0; i < ARRAYSIZE( keys ); i++ )
 	{
 		if( value & keys[i].mask )
 		{
@@ -317,9 +316,8 @@ void Joy_FinalizeMove( float *fw, float *side, float *dpitch, float *dyaw )
 	if( FBitSet( joy_axis_binding.flags, FCVAR_CHANGED ) )
 	{
 		const char *bind = joy_axis_binding.string;
-		size_t i;
 
-		for( i = 0; bind[i] && i < MAX_AXES; i++ )
+		for( size_t i = 0; bind[i] && i < MAX_AXES; i++ )
 		{
 			switch( bind[i] )
 			{
@@ -535,8 +533,6 @@ void Joy_DrawDebug( void )
 		}
 
 		qboolean pressed = Key_IsDown( buttons[i] );
-		int btn_w = 0;
-		rgba_t color;
 		string name;
 
 		Q_strncpy( name, Key_KeynumToString( buttons[i] ), sizeof( name ));
@@ -545,8 +541,11 @@ void Joy_DrawDebug( void )
 		if( p )
 			*p = 0;
 
+		rgba_t color;
 		MakeRGBA( color, pressed ? 0 : 255, pressed ? 255 : 0, 0, 255 );
 		CL_DrawString( x, y, name, color, font, 0 );
+
+		int btn_w = 0;
 		CL_DrawStringLen( font, name, &btn_w, NULL, 0 );
 		x += btn_w + 6;
 	}

engine/client/input/in_keys.c

@@ -187,8 +187,6 @@ to be configured even if they don't have defined names.
 */
 static int Key_StringToKeynum( const char *str )
 {
-	int i;
-
 	if( !str || !str[0] )
 		return -1;
 
@@ -207,7 +205,7 @@ static int Key_StringToKeynum( const char *str )
 	}
 
 	// scan for a text match
-	for( i = 0; i < ARRAYSIZE( keynames ); i++ )
+	for( int i = 0; i < ARRAYSIZE( keynames ); i++ )
 	{
 		if( !Q_stricmp( str, keynames[i].name ))
 			return keynames[i].keynum;
@@ -293,19 +291,16 @@ Key_GetKey
 */
 static int Key_GetKey( const char *pBinding )
 {
-	int		 i, len;
-	const char	*p;
-
 	if( !pBinding ) return -1;
 
-	len = Q_strlen( pBinding );
+	int len = Q_strlen( pBinding );
 
-	for( i = 0; i < ARRAYSIZE( keys ); i++ )
+	for( int i = 0; i < ARRAYSIZE( keys ); i++ )
 	{
 		if( !keys[i].binding )
 			continue;
 
-		p = keys[i].binding;
+		const char *p = keys[i].binding;
 
 		if( *p == '+' )
 			p++;
@@ -340,15 +335,13 @@ Key_Unbind_f
 */
 static void Key_Unbind_f( void )
 {
-	int	b;
-
 	if( Cmd_Argc() != 2 )
 	{
 		Con_Printf( S_USAGE "unbind <key> : remove commands from a key\n" );
 		return;
 	}
 
-	b = Key_StringToKeynum( Cmd_Argv( 1 ));
+	int b = Key_StringToKeynum( Cmd_Argv( 1 ));
 
 	if( b == -1 )
 	{
@@ -372,9 +365,7 @@ Key_Unbindall_f
 */
 static void Key_Unbindall_f( void )
 {
-	int	i;
-
-	for( i = 0; i < ARRAYSIZE( keys ); i++ )
+	for( int i = 0; i < ARRAYSIZE( keys ); i++ )
 	{
 		if( keys[i].binding )
 			Key_SetBinding( i, "" );
@@ -392,17 +383,15 @@ Key_Reset_f
 */
 static void Key_Reset_f( void )
 {
-	int	i;
-
 	// clear all keys first
-	for( i = 0; i < ARRAYSIZE( keys ); i++ )
+	for( int i = 0; i < ARRAYSIZE( keys ); i++ )
 	{
 		if( keys[i].binding )
 			Key_SetBinding( i, "" );
 	}
 
 	// apply default values
-	for( i = 0; i < ARRAYSIZE( keynames ); i++ )
+	for( int i = 0; i < ARRAYSIZE( keynames ); i++ )
 		Key_SetBinding( keynames[i].keynum, keynames[i].binding );
 }
 
@@ -413,10 +402,7 @@ Key_Bind_f
 */
 static void Key_Bind_f( void )
 {
-	char	cmd[1024];
-	int	i, c, b;
-
-	c = Cmd_Argc();
+	int c = Cmd_Argc();
 
 	if( c < 2 )
 	{
@@ -424,7 +410,7 @@ static void Key_Bind_f( void )
 		return;
 	}
 
-	b = Key_StringToKeynum( Cmd_Argv( 1 ));
+	int b = Key_StringToKeynum( Cmd_Argv( 1 ));
 
 	if( b == -1 )
 	{
@@ -441,9 +427,10 @@ static void Key_Bind_f( void )
 	}
 
 	// copy the rest of the command line
+	char cmd[1024];
 	cmd[0] = 0; // start out with a null string
 
-	for( i = 2; i < c; i++ )
+	for( int i = 2; i < c; i++ )
 	{
 		Q_strncat( cmd, Cmd_Argv( i ), sizeof( cmd ));
 		if( i != ( c - 1 )) Q_strncat( cmd, " ", sizeof( cmd ));
@@ -461,18 +448,16 @@ Writes lines containing "bind key value"
 */
 void Key_WriteBindings( file_t *f )
 {
-	int	i;
-	string newCommand;
-
 	if( !f ) return;
 
 	FS_Printf( f, "unbindall\n" );
 
-	for( i = 0; i < ARRAYSIZE( keys ); i++ )
+	for( int i = 0; i < ARRAYSIZE( keys ); i++ )
 	{
 		if( COM_StringEmptyOrNULL( keys[i].binding ))
 			continue;
 
+		string newCommand;
 		Cmd_Escape( newCommand, keys[i].binding, sizeof( newCommand ));
 
 		// NOTE: as TheKingFireS figured out, some particular mods (like CoF) do not
@@ -491,9 +476,7 @@ Key_Bindlist_f
 */
 static void Key_Bindlist_f( void )
 {
-	int	i;
-
-	for( i = 0; i < ARRAYSIZE( keys ); i++ )
+	for( int i = 0; i < ARRAYSIZE( keys ); i++ )
 	{
 		if( COM_StringEmptyOrNULL( keys[i].binding ))
 			continue;
@@ -514,10 +497,9 @@ qboolean Cmd_GetKeysList( const char *s, char *completedname, int length, qboole
 	size_t i, numkeys;
 	string keys_strings[ARRAYSIZE( keys )];
 	string matchbuf;
-	int len;
 
 	// compare keys list with current keyword
-	len = Q_strlen( s );
+	int len = Q_strlen( s );
 
 	for( i = 0, numkeys = 0; i < ARRAYSIZE( keys ); i++ )
 	{
@@ -569,8 +551,6 @@ Key_Init
 */
 void Key_Init( void )
 {
-	int i;
-
 	// register our functions
 	Cmd_AddRestrictedCommand( "bind", Key_Bind_f, "binds a command to the specified key in bindmap" );
 	Cmd_AddRestrictedCommand( "unbind", Key_Unbind_f, "removes a command on the specified key in bindmap" );
@@ -580,7 +560,7 @@ void Key_Init( void )
 	Cmd_AddCommand( "makehelp", Key_EnumCmds_f, "write help.txt that contains all console cvars and cmds" );
 
 	// setup default binding. "unbindall" from config.cfg will be reset it
-	for( i = 0; i < ARRAYSIZE( keynames ); i++ )
+	for( int i = 0; i < ARRAYSIZE( keynames ); i++ )
 		Key_SetBinding( keynames[i].keynum, keynames[i].binding );
 
 	Cvar_RegisterVariable( &key_rotate );
@@ -594,21 +574,20 @@ Key_AddKeyCommands
 */
 static void Key_AddKeyCommands( int key, const char *kb, qboolean down )
 {
-	char	button[1024];
-	char	*buttonPtr;
-	char	cmd[1024];
-	int	i;
-
 	if( !kb ) return;
-	buttonPtr = button;
 
-	for( i = 0; ; i++ )
+	char button[1024];
+	char *buttonPtr = button;
+
+	for( int i = 0; ; i++ )
 	{
 		if( kb[i] == ';' || !kb[i] )
 		{
 			*buttonPtr = '\0';
 			if( button[0] == '+' )
 			{
+				char cmd[1024];
+
 				// button commands add keynum as a parm
 				if( down ) Q_snprintf( cmd, sizeof( cmd ), "%s %i\n", button, key );
 				else Q_snprintf( cmd, sizeof( cmd ), "-%s %i\n", button + 1, key );
@@ -708,8 +687,6 @@ Called by the system for both key up and key down events
 */
 void GAME_EXPORT Key_Event( int key, int down )
 {
-	const char	*kb;
-
 	key = Key_Rotate( key );
 
 	if( OSK_KeyEvent( key, down ) )
@@ -719,7 +696,7 @@ void GAME_EXPORT Key_Event( int key, int down )
 	if( !keys[key].down && !down )
 		return;
 
-	kb = keys[key].binding;
+	const char *kb = keys[key].binding;
 	keys[key].down = down ? true : false;
 
 #ifdef HACKS_RELATED_HLMODS
@@ -917,13 +894,11 @@ Key_ClearStates
 */
 void GAME_EXPORT Key_ClearStates( void )
 {
-	int	i;
-
 	// don't clear keys during changelevel
 	if( cls.changelevel )
 		return;
 
-	for( i = 0; i < ARRAYSIZE( keys ); i++ )
+	for( int i = 0; i < ARRAYSIZE( keys ); i++ )
 	{
 		if( i >= K_MOUSE1 && i <= K_MOUSE5 )
 			IN_MouseEvent( i - K_MOUSE1, false );

engine/client/input/in_osk.c

@@ -144,8 +144,6 @@ qboolean OSK_KeyEvent( int key, int down )
 			break;
 		default:
 		{
-			int ch;
-
 			if( !down )
 			{
 				if( osk.shift && osk.curlayout & 1 )
@@ -156,7 +154,7 @@ qboolean OSK_KeyEvent( int key, int down )
 				break;
 			}
 
-			ch = (byte)osk.curbutton.val;
+			int ch = (byte)osk.curbutton.val;
 
 			// do not pass UTF-8 sequence into the engine, convert it here
 			if( !cls.accept_utf8 )

engine/client/input/in_touch.c

@@ -249,10 +249,7 @@ Dump config to file
 */
 static qboolean Touch_DumpConfig( const char *name, const char *profilename )
 {
-	file_t *f;
-	const touch_button_t *button;
-
-	f = FS_Open( name, "w", true );
+	file_t *f = FS_Open( name, "w", true );
 
 	if( !f )
 	{
@@ -299,7 +296,7 @@ static qboolean Touch_DumpConfig( const char *name, const char *profilename )
 	FS_Printf( f, "touch_removeall\n" );
 	FS_Printf( f, "touch_aspectratio %g\n", Touch_AspectRatio());
 
-	for( button = touch.list_user.first; button; button = button->next )
+	for( const touch_button_t *button = touch.list_user.first; button; button = button->next )
 		Touch_ExportButtonToConfig( f, button, false );
 
 	FS_Close( f );
@@ -347,9 +344,6 @@ export current touch configuration into profile
 */
 static void Touch_ExportConfig_f( void )
 {
-	const char *name;
-	string profilename;
-
 	if( Cmd_Argc() != 2 )
 	{
 		Con_Printf( S_USAGE "touch_exportconfig <name>\n" );
@@ -362,7 +356,8 @@ static void Touch_ExportConfig_f( void )
 		return;
 	}
 
-	name = Cmd_Argv( 1 );
+	const char *name = Cmd_Argv( 1 );
+	string profilename;
 
 	if( Q_strstr( name, "touch_presets/" ))
 	{
@@ -386,7 +381,6 @@ export current touch configuration into C code
 */
 static void Touch_GenerateCode_f( void )
 {
-	const touch_button_t *button;
 	rgba_t c = { 0 };
 
 	if( !touch.list_user.first )
@@ -395,11 +389,9 @@ static void Touch_GenerateCode_f( void )
 		return;
 	}
 
-	for( button = touch.list_user.first; button; button = button->next )
+	for( const touch_button_t *button = touch.list_user.first; button; button = button->next )
 	{
-		float aspect;
 		int flags = button->flags;
-		int round;
 
 		if( FBitSet( flags, TOUCH_FL_CLIENT ))
 			continue; // skip temporary buttons
@@ -410,7 +402,7 @@ static void Touch_GenerateCode_f( void )
 		if( FBitSet( flags, TOUCH_FL_DEF_HIDE ))
 			SetBits( flags, TOUCH_FL_HIDE );
 
-		aspect = ( button->y2 - button->y1 ) / (( button->x2 - button->x1 ) / Touch_AspectRatio( ));
+		float aspect = ( button->y2 - button->y1 ) / (( button->x2 - button->x1 ) / Touch_AspectRatio( ));
 
 		if( memcmp( c, button->color, sizeof( c )))
 		{
@@ -419,6 +411,7 @@ static void Touch_GenerateCode_f( void )
 			memcpy( c, button->color, sizeof( c ));
 		}
 
+		int round;
 		if( button->type == touch_command )
 		{
 			if( fabs( aspect - 1.0f ) < 0.001 )
@@ -438,22 +431,18 @@ static void Touch_GenerateCode_f( void )
 
 static void Touch_RoundAll_f( void )
 {
-	touch_button_t *button;
-
 	if( !touch_grid_enable.value )
 		return;
 
-	for( button = touch.list_user.first; button; button = button->next )
+	for( touch_button_t *button = touch.list_user.first; button; button = button->next )
 		IN_TouchCheckCoords( &button->x1, &button->y1, &button->x2, &button->y2 );
 }
 
 static void Touch_ListButtons_f( void )
 {
-	touch_button_t *button;
-
 	Touch_InitConfig();
 
-	for( button = touch.list_user.first; button; button = button->next )
+	for( touch_button_t *button = touch.list_user.first; button; button = button->next )
 	{
 		Con_Printf( "%s %s %s %g %g %g %g %d %d %d %d %d\n",
 			button->name, button->texture, button->command,
@@ -483,9 +472,7 @@ static void Touch_Stroke_f( void )
 
 static touch_button_t *Touch_FindNextNoPattern( touch_button_t *buttons, const char *name, qboolean privileged )
 {
-	touch_button_t *b;
-
-	for( b = buttons; b; b = b->next )
+	for( touch_button_t *b = buttons; b; b = b->next )
 	{
 		if( !privileged && !FBitSet( b->flags, TOUCH_FL_UNPRIVILEGED ))
 			continue;
@@ -504,13 +491,12 @@ static touch_button_t *Touch_FindButtonNoPattern( touchbuttonlist_t *list, const
 
 static touch_button_t *Touch_FindNext( touch_button_t *buttons, const char *name, qboolean privileged )
 {
-	touch_button_t *b;
 	qboolean has_pattern = Q_strchr( name, '*' ) != NULL;
 
 	if( !has_pattern )
 		return Touch_FindNextNoPattern( buttons, name, privileged );
 
-	for( b = buttons; b; b = b->next )
+	for( touch_button_t *b = buttons; b; b = b->next )
 	{
 		if( !privileged && !FBitSet( b->flags, TOUCH_FL_UNPRIVILEGED ))
 			continue;
@@ -584,10 +570,9 @@ static void Touch_SetClientOnly_f( void )
 
 static void Touch_RemoveButtonFromList( touchbuttonlist_t *list, const char *name, qboolean privileged )
 {
-	touch_button_t *button;
-
 	IN_TouchEditClear();
 
+	touch_button_t *button;
 	while(( button = Touch_FindFirst( list, name, privileged )))
 	{
 		if( button->prev )
@@ -640,9 +625,7 @@ static void Touch_RemoveAll_f( void )
 
 static void Touch_SetColor( touchbuttonlist_t *list, const char *name, byte *color, qboolean privileged )
 {
-	touch_button_t *b;
-
-	for( b = Touch_FindFirst( list, name, privileged ); b != NULL; b = Touch_FindNext( b->next, name, privileged ))
+	for( touch_button_t *b = Touch_FindFirst( list, name, privileged ); b != NULL; b = Touch_FindNext( b->next, name, privileged ))
 		Vector4Copy( color, b->color );
 }
 
@@ -677,9 +660,7 @@ static void Touch_SetCommand( touch_button_t *button, const char *command )
 
 void Touch_HideButtons( const char *name, byte hide, qboolean privileged )
 {
-	touch_button_t *b;
-
-	for( b = Touch_FindFirst( &touch.list_user, name, privileged ); b != NULL; b = Touch_FindNext( b->next, name, privileged ))
+	for( touch_button_t *b = Touch_FindFirst( &touch.list_user, name, privileged ); b != NULL; b = Touch_FindNext( b->next, name, privileged ))
 	{
 		if( hide )
 			SetBits( b->flags, TOUCH_FL_HIDE );
@@ -718,9 +699,7 @@ static void Touch_Show_f( void )
 
 static void Touch_FadeButtons( touchbuttonlist_t *list, const char *name, float speed, float end, float start, qboolean privileged )
 {
-	touch_button_t *b;
-
-	for( b = Touch_FindFirst( list, name, privileged ); b != NULL; b = Touch_FindNext( b->next, name, privileged ))
+	for( touch_button_t *b = Touch_FindFirst( list, name, privileged ); b != NULL; b = Touch_FindNext( b->next, name, privileged ))
 	{
 		if( start >= 0 )
 			b->fade = start;
@@ -855,8 +834,6 @@ static touch_button_t *Touch_AddButton( touchbuttonlist_t *list, const char *nam
 
 void Touch_AddClientButton( const char *name, const char *texture, const char *command, float x1, float y1, float x2, float y2, byte *color, int round, float aspect, int flags )
 {
-	touch_button_t *button;
-
 	if( !touch.initialized )
 		return;
 
@@ -865,15 +842,14 @@ void Touch_AddClientButton( const char *name, const char *texture, const char *c
 	if( round == round_aspect )
 		y2 = y1 + ( x2 - x1 ) / (Touch_AspectRatio()) * aspect;
 
-	button = Touch_AddButton( &touch.list_user, name, texture, command, x1, y1, x2, y2, color, true );
+	touch_button_t *button = Touch_AddButton( &touch.list_user, name, texture, command, x1, y1, x2, y2, color, true );
 	SetBits( button->flags, TOUCH_FL_CLIENT | TOUCH_FL_NOEDIT );
 	button->aspect = aspect;
 }
 
 static void Touch_LoadDefaults_f( void )
 {
-	int i;
-	for( i = 0; i < g_DefaultButtonsLength; i++ )
+	for( int i = 0; i < g_DefaultButtonsLength; i++ )
 	{
 		touch_button_t *button;
 		float x1 = g_DefaultButtons[i].x1,
@@ -903,11 +879,9 @@ static void Touch_LoadDefaults_f( void )
 // Add default button from client
 void Touch_AddDefaultButton( const char *name, const char *texture, const char *command, float x1, float y1, float x2, float y2, byte *color, int round, float aspect, int flags )
 {
-	touchdefaultbutton_t *b;
-
 	g_DefaultButtons = Mem_Realloc( touch.mempool, g_DefaultButtons, sizeof( *g_DefaultButtons ) * ( g_DefaultButtonsLength + 1 ));
 
-	b = &g_DefaultButtons[g_DefaultButtonsLength];
+	touchdefaultbutton_t *b = &g_DefaultButtons[g_DefaultButtonsLength];
 
 	Q_strncpy( b->name, name, sizeof( b->name ));
 	Q_strncpy( b->texture, texture, sizeof( b->texture ));
@@ -938,22 +912,18 @@ void Touch_ResetDefaultButtons( void )
 
 static void Touch_AddButton_f( void )
 {
-	rgba_t color = { 255, 255, 255, 255 };
-	touch_button_t *button = NULL;
-	const char *name, *command;
-	float x1 = 0.4f, y1 = 0.4f, x2 = 0.6f, y2 = 0.6f;
-	qboolean privileged = Cmd_CurrentCommandIsPrivileged();
-	string texture;
-
 	if( Cmd_Argc( ) < 4 )
 	{
 		Con_Printf( S_USAGE "touch_addbutton <name> <texture> <command> [<x1> <y1> <x2> <y2> [ r g b a ] ]\n" );
 		return;
 	}
 
-	name = Cmd_Argv( 1 );
+	const char *name = Cmd_Argv( 1 );
+	string texture;
 	Q_strncpy( texture, Cmd_Argv( 2 ), sizeof( texture ));
-	command = Cmd_Argv( 3 );
+	const char *command = Cmd_Argv( 3 );
+	float x1 = 0.4f, y1 = 0.4f, x2 = 0.6f, y2 = 0.6f;
+	rgba_t color = { 255, 255, 255, 255 };
 
 	// HACKHACK: old engine specifically used .tga for touch buttons
 	// and because new engine extras.pk3 don't have .tga textures
@@ -980,7 +950,8 @@ static void Touch_AddButton_f( void )
 		color[3] = Q_atoi( Cmd_Argv( 11 ));
 	}
 
-	button = Touch_AddButton( &touch.list_user, name, texture, command, x1, y1, x2, y2, color, privileged );
+	qboolean privileged = Cmd_CurrentCommandIsPrivileged();
+	touch_button_t *button = Touch_AddButton( &touch.list_user, name, texture, command, x1, y1, x2, y2, color, privileged );
 
 	if( Cmd_Argc( ) >= 13 )
 		SetBits( button->flags, Q_atoi( Cmd_Argv( 12 )));
@@ -1023,9 +994,7 @@ static void Touch_EnableEdit_f( void )
 	// convert coordinates to actual aspect ratio after it was updated
 	if( touch.config_aspect_ratio != touch.actual_aspect_ratio )
 	{
-		touch_button_t *button;
-
-		for( button = touch.list_user.first; button; button = button->next )
+		for( touch_button_t *button = touch.list_user.first; button; button = button->next )
 		{
 			button->y1 /= touch.actual_aspect_ratio / touch.config_aspect_ratio;
 			button->y2 /= touch.actual_aspect_ratio / touch.config_aspect_ratio;
@@ -1315,10 +1284,6 @@ static void IN_TouchCheckCoords( float *x1, float *y1, float *x2, float *y2  )
 
 static float Touch_DrawCharacter( float x, float y, int number, float size )
 {
-	float s1, s2, t1, t2, width, height;
-	int w, h;
-	wrect_t *prc;
-
 	if( !cls.creditsFont.valid )
 		return 0;
 
@@ -1328,16 +1293,17 @@ static float Touch_DrawCharacter( float x, float y, int number, float size )
 	if( !number )
 		return 0;
 
+	int w, h;
 	R_GetTextureParms( &w, &h, cls.creditsFont.hFontTexture );
-	prc = &cls.creditsFont.fontRc[number];
+	wrect_t *prc = &cls.creditsFont.fontRc[number];
 
-	s1 = prc->left / (float)w;
-	t1 = prc->top / (float)h;
-	s2 = prc->right / (float)w;
-	t2 = prc->bottom / (float)h;
+	float s1 = prc->left / (float)w;
+	float t1 = prc->top / (float)h;
+	float s2 = prc->right / (float)w;
+	float t2 = prc->bottom / (float)h;
 
-	width = ( prc->right - prc->left ) / 1024.0f * size;
-	height = ( prc->bottom - prc->top ) / 1024.0f * size;
+	float width = ( prc->right - prc->left ) / 1024.0f * size;
+	float height = ( prc->bottom - prc->top ) / 1024.0f * size;
 
 	ref.dllFuncs.R_DrawStretchPic( TO_SCRN_X( x ), TO_SCRN_Y( y ), TO_SCRN_X( width ), TO_SCRN_X( height ),
 		s1, t1, s2, t2, cls.creditsFont.hFontTexture );
@@ -1384,9 +1350,7 @@ static float Touch_DrawText( float x1, float y1, float x2, float y2, const char
 
 static void Touch_DrawButtons( touchbuttonlist_t *list )
 {
-	touch_button_t *b;
-
-	for( b = list->first; b; b = b->next )
+	for( touch_button_t *b = list->first; b; b = b->next )
 	{
 		if( Touch_IsVisible( b ))
 		{
@@ -1506,17 +1470,15 @@ void Touch_Draw( void )
 
 	if( touch.state >= state_edit && touch_grid_enable.value )
 	{
-		float x;
-
 		if( touch_in_menu.value )
 			ref.dllFuncs.FillRGBA( kRenderTransTexture, 0, 0, 1, 1, 32, 32, 32, 255 );
 		else
 			ref.dllFuncs.FillRGBA( kRenderTransTexture, 0, 0, 1, 1, 0, 0, 0, 112 );
 
-		for( x = 0.0f; x < 1.0f; x += GRID_X )
+		for( float x = 0.0f; x < 1.0f; x += GRID_X )
 			ref.dllFuncs.FillRGBA( kRenderTransTexture, TO_SCRN_X( x ), 0, 1, TO_SCRN_Y( 1 ), 0, 224, 224, 112 );
 
-		for( x = 0.0f; x < 1.0f; x += GRID_Y )
+		for( float x = 0.0f; x < 1.0f; x += GRID_Y )
 			ref.dllFuncs.FillRGBA( kRenderTransTexture, 0, TO_SCRN_Y( x ), TO_SCRN_X( 1 ), 1, 0, 224, 224, 112 );
 	}
 
@@ -1738,16 +1700,14 @@ static void Touch_Motion( int fingerID, float x, float y, float dx, float dy )
 
 		if( touch_nonlinear_look.value )
 		{
-			float dabs, dcos, dsin;
-
 			// save angle, modify only velocity
-			dabs = sqrt( dx * dx + dy * dy );
+			float dabs = sqrt( dx * dx + dy * dy );
 
 			if( dabs < 0.000001f )
 				return; // no motion, avoid division by zero
 
-			dcos = dx / dabs;
-			dsin = dy / dabs;
+			float dcos = dx / dabs;
+			float dsin = dy / dabs;
 
 			if( touch_exp_mult.value > 1 )
 				dabs = ( exp( dabs * touch_exp_mult.value ) - 1 ) / touch_exp_mult.value;
@@ -1771,14 +1731,13 @@ static void Touch_Motion( int fingerID, float x, float y, float dx, float dy )
 
 static qboolean Touch_ButtonPress( touchbuttonlist_t *list, touchEventType type, int fingerID, float x, float y )
 {
-	touch_button_t *button;
 	qboolean result = false;
 
 	if( type != event_down && type != event_up )
 		return false;
 
 	// run from end(front) to start(back)
-	for( button = list->last; button; button = button->prev )
+	for( touch_button_t *button = list->last; button; button = button->prev )
 	{
 		// skip invisible buttons
 		if( !Touch_IsVisible( button ))
@@ -1850,14 +1809,12 @@ static qboolean Touch_ButtonPress( touchbuttonlist_t *list, touchEventType type,
 
 				if( touch.look_finger == fingerID )
 				{
-					touch_button_t *newbutton;
-
 					// this is an error, try recover
 					touch.move_finger = touch.look_finger = -1;
 
 					// player touched touch_move with enabled look mode
 					// and same finger id. release all move triggers
-					for( newbutton = list->first; newbutton; newbutton = newbutton->next )
+					for( touch_button_t *newbutton = list->first; newbutton; newbutton = newbutton->next )
 					{
 						if( newbutton->type == touch_move || newbutton->type == touch_look )
 							newbutton->finger = -1;
@@ -1910,14 +1867,12 @@ static qboolean Touch_ButtonPress( touchbuttonlist_t *list, touchEventType type,
 
 				if( touch.move_finger == fingerID )
 				{
-					touch_button_t *newbutton;
-
 					// this is an error, try recover
 					touch.move_finger = touch.look_finger = -1;
 
 					// player touched touch_move with enabled look mode
 					// and same finger id. release all move triggers
-					for( newbutton = list->first; newbutton; newbutton = newbutton->next )
+					for( touch_button_t *newbutton = list->first; newbutton; newbutton = newbutton->next )
 					{
 						if( newbutton->type == touch_move || newbutton->type == touch_look )
 							newbutton->finger = -1;
@@ -1994,8 +1949,6 @@ static qboolean Touch_ButtonPress( touchbuttonlist_t *list, touchEventType type,
 
 static qboolean Touch_ButtonEdit( touchEventType type, int fingerID, float x, float y )
 {
-	touch_button_t *button;
-
 	// edit buttons are on y1
 	if( type == event_down )
 	{
@@ -2010,7 +1963,7 @@ static qboolean Touch_ButtonEdit( touchEventType type, int fingerID, float x, fl
 	}
 
 	// run from end(front) to start(back)
-	for( button = touch.list_user.last; button; button = button->prev )
+	for( touch_button_t *button = touch.list_user.last; button; button = button->prev )
 	{
 		if( type == event_down )
 		{

engine/client/input/input.c

@@ -28,7 +28,6 @@ GNU General Public License for more details.
 
 static qboolean	in_mouseactive;				// false when not focus app
 static qboolean	in_mouseinitialized;
-static qboolean	in_mouse_suspended;
 static struct
 {
 	int x, y;
@@ -338,8 +337,6 @@ IN_MouseMove
 */
 static void IN_MouseMove( void )
 {
-	int x, y;
-
 	if( !in_mouseinitialized )
 		return;
 
@@ -351,6 +348,7 @@ static void IN_MouseMove( void )
 	}
 
 	// find mouse movement
+	int x, y;
 	Platform_GetMousePos( &x, &y );
 
 	VGui_MouseMove( x, y );
@@ -587,18 +585,15 @@ Called from cl_main.c after generating command in client
 */
 void IN_EngineAppendMove( float frametime, usercmd_t *cmd, qboolean active )
 {
-	float forward, side, pitch, yaw;
-
 	if( clgame.dllFuncs.pfnLookEvent )
 		return;
 
 	if( cls.key_dest != key_game || cl.paused || cl.intermission )
 		return;
 
-	forward = side = pitch = yaw = 0;
-
 	if( active )
 	{
+		float forward = 0, side = 0, pitch = 0, yaw = 0;
 		float sensitivity = 1;//( (float)cl.local.scr_fov / (float)90.0f );
 
 		IN_CollectInput( &forward, &side, &pitch, &yaw, false );

engine/client/mod_dbghulls.c

@@ -67,18 +67,13 @@ static winding_t * winding_alloc( uint numpoints )
 
 static void free_winding( winding_t *w )
 {
-	// simple sentinel by Carmack
-	if( *(unsigned *)w == 0xDEADC0DE )
-		Host_Error( "%s: freed a freed winding\n", __func__ );
 	*(unsigned *)w = 0xDEADC0DE;
 	free( w );
 }
 
 static winding_t *winding_copy( winding_t *w )
 {
-	winding_t	*neww;
-
-	neww = winding_alloc( w->numpoints );
+	winding_t	*neww = winding_alloc( w->numpoints );
 	memcpy( neww, w, offsetof( winding_t, p[w->numpoints] ) );
 
 	return neww;
@@ -86,12 +81,9 @@ static winding_t *winding_copy( winding_t *w )
 
 static void winding_reverse( winding_t *w )
 {
-	vec3_t	point;
-	int	i;
-
-	for( i = 0; i < w->numpoints / 2; i++ )
+	for( int i = 0; i < w->numpoints / 2; i++ )
 	{
-		VectorCopy( w->p[i], point );
+		vec3_t point = Vec3( w->p[i] );
 		VectorCopy( w->p[w->numpoints - i - 1], w->p[i] );
 		VectorCopy( point, w->p[w->numpoints - i - 1] );
 	}
@@ -120,15 +112,13 @@ winding_for_plane
 static winding_t *winding_for_plane( const mplane_t *p )
 {
 	vec3_t	org, vright, vup;
-	int	i, axis;
-	vec_t	max, v;
-	winding_t	*w;
+	vec_t	v;
 
 	// find the major axis
-	max = -BOGUS_RANGE;
-	axis = -1;
+	vec_t max = -BOGUS_RANGE;
+	int axis = -1;
 
-	for( i = 0; i < 3; i++ )
+	for( int i = 0; i < 3; i++ )
 	{
 		v = fabs( p->normal[i] );
 		if( v > max )
@@ -162,7 +152,7 @@ static winding_t *winding_for_plane( const mplane_t *p )
 	VectorScale( vright, BOGUS_RANGE, vright );
 
 	// project a really big axis aligned box onto the plane
-	w = winding_alloc( 4 );
+	winding_t *w = winding_alloc( 4 );
 	memset( w->p, 0, sizeof( vec3_t ) * 4 );
 	w->numpoints = 4;
 	w->plane = p;
@@ -251,46 +241,42 @@ If keepon is true, an exactly on-plane winding will be saved, otherwise
 */
 static winding_t *winding_clip( winding_t *in, const mplane_t *split, qboolean keepon, int side, vec_t epsilon )
 {
-	vec_t	*dists;
-	int	*sides;
 	int	counts[3];
-	vec_t	dot;
-	int	i, j;
-	winding_t *neww;
-	vec_t	*p1, *p2, *mid;
-	int	maxpts;
 
-	dists = (vec_t *)malloc(( in->numpoints + 1 ) * sizeof( vec_t ));
-	sides = (int *)malloc(( in->numpoints + 1 ) * sizeof( int ));
+	vec_t *dists = (vec_t *)malloc(( in->numpoints + 1 ) * sizeof( vec_t ));
+	int *sides = (int *)malloc(( in->numpoints + 1 ) * sizeof( int ));
 	CalcSides( in, split, sides, dists, counts, epsilon );
 
 	if( keepon && !counts[SIDE_FRONT] && !counts[SIDE_BACK] )
 	{
-		neww = in;
-		goto out_free;
+		free( dists );
+		free( sides );
+		return in;
 	}
 
 	if( !counts[side] )
 	{
 		free_winding( in );
-		neww = NULL;
-		goto out_free;
+		free( dists );
+		free( sides );
+		return NULL;
 	}
 
 	if( !counts[side ^ 1] )
 	{
-		neww = in;
-		goto out_free;
+		free( dists );
+		free( sides );
+		return in;
 	}
 
-	maxpts = in->numpoints + 4;
-	neww = winding_alloc( maxpts );
+	int maxpts = in->numpoints + 4;
+	winding_t *neww = winding_alloc( maxpts );
 	neww->numpoints = 0;
 	neww->plane = in->plane;
 
-	for( i = 0; i < in->numpoints; i++ )
+	for( int i = 0; i < in->numpoints; i++ )
 	{
-		p1 = in->p[i];
+		vec_t *p1 = in->p[i];
 
 		if( sides[i] == SIDE_ON )
 		{
@@ -309,11 +295,11 @@ static winding_t *winding_clip( winding_t *in, const mplane_t *split, qboolean k
 			continue;
 
 		// generate a split point
-		p2 = in->p[(i + 1) % in->numpoints];
-		mid = neww->p[neww->numpoints++];
+		vec_t *p2 = in->p[(i + 1) % in->numpoints];
+		vec_t *mid = neww->p[neww->numpoints++];
 
-		dot = dists[i] / (dists[i] - dists[i + 1]);
-		for( j = 0; j < 3; j++ )
+		vec_t dot = dists[i] / (dists[i] - dists[i + 1]);
+		for( int j = 0; j < 3; j++ )
 		{
 			// avoid round off error when possible
 			if( in->plane->normal[j] == 1.0f )
@@ -336,7 +322,6 @@ static winding_t *winding_clip( winding_t *in, const mplane_t *split, qboolean k
 
 	// Shrink the winding back to just what it needs...
 	neww = winding_shrink(neww);
-out_free:
 	free( dists );
 	free( sides );
 
@@ -355,17 +340,10 @@ new windings will be created.
 */
 static void winding_split( winding_t *in, const mplane_t *split, winding_t **pfront, winding_t **pback )
 {
-	vec_t	*dists;
-	int	*sides;
 	int	counts[3];
-	vec_t	dot;
-	int	i, j;
-	winding_t	*front, *back;
-	vec_t	*p1, *p2, *mid;
-	int	maxpts;
 
-	dists = (vec_t *)malloc(( in->numpoints + 1 ) * sizeof( vec_t ));
-	sides = (int *)malloc(( in->numpoints + 1 ) * sizeof( int ));
+	vec_t *dists = (vec_t *)malloc(( in->numpoints + 1 ) * sizeof( vec_t ));
+	int *sides = (int *)malloc(( in->numpoints + 1 ) * sizeof( int ));
 	CalcSides(in, split, sides, dists, counts, 0.04f );
 
 	if( !counts[0] && !counts[1] )
@@ -373,34 +351,40 @@ static void winding_split( winding_t *in, const mplane_t *split, winding_t **pfr
 		// winding on the split plane - return copies on both sides
 		*pfront = winding_copy( in );
 		*pback = winding_copy( in );
-		goto out_free;
+		free( dists );
+		free( sides );
+		return;
 	}
 
 	if( !counts[0] )
 	{
 		*pfront = NULL;
 		*pback = in;
-		goto out_free;
+		free( dists );
+		free( sides );
+		return;
 	}
 
 	if( !counts[1] )
 	{
 		*pfront = in;
 		*pback = NULL;
-		goto out_free;
+		free( dists );
+		free( sides );
+		return;
 	}
 
-	maxpts = in->numpoints + 4;
-	front = winding_alloc( maxpts );
+	int maxpts = in->numpoints + 4;
+	winding_t *front = winding_alloc( maxpts );
 	front->numpoints = 0;
 	front->plane = in->plane;
-	back = winding_alloc( maxpts );
+	winding_t *back = winding_alloc( maxpts );
 	back->numpoints = 0;
 	back->plane = in->plane;
 
-	for( i = 0; i < in->numpoints; i++ )
+	for( int i = 0; i < in->numpoints; i++ )
 	{
-		p1 = in->p[i];
+		vec_t *p1 = in->p[i];
 
 		if( sides[i] == SIDE_ON )
 		{
@@ -426,11 +410,11 @@ static void winding_split( winding_t *in, const mplane_t *split, winding_t **pfr
 			continue;
 
 		// generate a split point
-		p2 = in->p[(i + 1) % in->numpoints];
-		mid = front->p[front->numpoints++];
+		vec_t *p2 = in->p[(i + 1) % in->numpoints];
+		vec_t *mid = front->p[front->numpoints++];
 
-		dot = dists[i] / (dists[i] - dists[i + 1]);
-		for( j = 0; j < 3; j++ )
+		vec_t dot = dists[i] / (dists[i] - dists[i + 1]);
+		for( int j = 0; j < 3; j++ )
 		{
 			// avoid round off error when possible
 			if( in->plane->normal[j] == 1.0f )
@@ -452,7 +436,6 @@ static void winding_split( winding_t *in, const mplane_t *split, winding_t **pfr
 
 	*pfront = winding_shrink( front );
 	*pback = winding_shrink( back );
-out_free:
 	free( dists );
 	free( sides );
 }
@@ -725,7 +708,7 @@ static void R_DrawHull( hull_model_t *hull )
 	{
 		int i;
 
-		srand((unsigned int)poly );
+		srand((unsigned int)(uintptr_t)poly );
 		ref.dllFuncs.Color4ub( rand() & 255, rand() & 255, rand() & 255, 255 );
 
 		ref.dllFuncs.Begin( TRI_POLYGON );

engine/client/parse/cl_parse.c

@@ -60,35 +60,33 @@ CL_ParseSoundPacket
 */
 static void CL_ParseSoundPacket( sizebuf_t *msg, qboolean restore )
 {
-	vec3_t	pos;
-	int 	chan, sound;
-	float 	volume, attn;
-	int	flags, pitch, entnum, wordIndex = 0;
-	sound_t	handle = 0;
-	double samplePos = 0, forcedEnd = 0;
-
-	flags = MSG_ReadUBitLong( msg, MAX_SND_FLAGS_BITS );
-	sound = MSG_ReadUBitLong( msg, MAX_SOUND_BITS );
-	chan = MSG_ReadUBitLong( msg, MAX_SND_CHAN_BITS );
+	int flags = MSG_ReadUBitLong( msg, MAX_SND_FLAGS_BITS );
+	int sound = MSG_ReadUBitLong( msg, MAX_SOUND_BITS );
+	int chan = MSG_ReadUBitLong( msg, MAX_SND_CHAN_BITS );
 
+	float volume;
 	if( FBitSet( flags, SND_VOLUME ))
 		volume = (float)MSG_ReadByte( msg ) / 255.0f;
 	else volume = VOL_NORM;
 
+	float attn;
 	if( FBitSet( flags, SND_ATTENUATION ))
 		attn = (float)MSG_ReadByte( msg ) / 64.0f;
 	else attn = ATTN_NONE;
 
+	int pitch;
 	if( FBitSet( flags, SND_PITCH ))
 		pitch = MSG_ReadByte( msg );
 	else pitch = PITCH_NORM;
 
 	// entity reletive
-	entnum = MSG_ReadUBitLong( msg, MAX_ENTITY_BITS );
+	int entnum = MSG_ReadUBitLong( msg, MAX_ENTITY_BITS );
 
 	// positioned in space
+	vec3_t pos;
 	MSG_ReadVec3Coord( msg, pos );
 
+	sound_t handle = 0;
 	if( FBitSet( flags, SND_SENTENCE ))
 	{
 		char	sentenceName[32];
@@ -101,13 +99,15 @@ static void CL_ParseSoundPacket( sizebuf_t *msg, qboolean restore )
 	}
 	else handle = cl.sound_index[sound];	// see precached sound
 
+	uint wordIndex = 0;
+	double samplePos = 0, forcedEnd = 0;
 	if( restore )
 	{
 		wordIndex = MSG_ReadByte( msg );
 
 		// 16 bytes here
-		MSG_ReadBytes( msg, &samplePos, sizeof( samplePos ));
-		MSG_ReadBytes( msg, &forcedEnd, sizeof( forcedEnd ));
+		MSG_ReadBytes( msg, &samplePos, sizeof( samplePos ), sizeof( samplePos ));
+		MSG_ReadBytes( msg, &forcedEnd, sizeof( forcedEnd ), sizeof( forcedEnd ));
 	}
 
 	if( !cl.audio_prepped )
@@ -129,8 +129,6 @@ CL_ParseServerTime
 */
 void CL_ParseServerTime( sizebuf_t *msg, connprotocol_t proto )
 {
-	double	dt;
-
 	cl.mtime[1] = cl.mtime[0];
 	cl.mtime[0] = MSG_ReadFloat( msg );
 
@@ -140,7 +138,7 @@ void CL_ParseServerTime( sizebuf_t *msg, connprotocol_t proto )
 	if( cl.maxclients == 1 )
 		cl.time = cl.mtime[0];
 
-	dt = cl.time - cl.mtime[0];
+	double dt = cl.time - cl.mtime[0];
 
 	if( fabs( dt ) > cl_clockreset.value )	// 0.1 by default
 	{
@@ -212,29 +210,26 @@ CL_ParseParticles
 */
 static void CL_ParseParticles( sizebuf_t *msg, connprotocol_t proto )
 {
-	vec3_t		org, dir;
-	int		i, count, color;
-	float		life;
+	vec3_t org, dir;
 
 	MSG_ReadVec3Coord( msg, org );
 
-	for( i = 0; i < 3; i++ )
+	for( int i = 0; i < 3; i++ )
 		dir[i] = MSG_ReadChar( msg ) * 0.0625f;
 
-	count = MSG_ReadByte( msg );
-	color = MSG_ReadByte( msg );
+	int count = MSG_ReadByte( msg );
+	int color = MSG_ReadByte( msg );
 	if( count == 255 )
 		count = 1024;
 
+	float life;
 	if( proto == PROTO_GOLDSRC )
 		life = 0.0f;
 	else life = MSG_ReadByte( msg ) * 0.125f;
 
 	if( life != 0.0f && count == 1 )
 	{
-		particle_t	*p;
-
-		p = R_AllocParticle( NULL );
+		particle_t *p = R_AllocParticle( NULL );
 		if( !p ) return;
 
 		p->die += life;
@@ -256,25 +251,23 @@ static client entity
 */
 static void CL_ParseStaticEntity( sizebuf_t *msg )
 {
-	int		i, newnum;
 	const entity_state_t from = { 0 };
 	entity_state_t to;
-	cl_entity_t	*ent;
 
 	if( !clgame.static_entities )
 		clgame.static_entities = Mem_Calloc( clgame.mempool, sizeof( cl_entity_t ) * MAX_STATIC_ENTITIES );
 
-	newnum = MSG_ReadUBitLong( msg, MAX_ENTITY_BITS );
+	MSG_ReadUBitLong( msg, MAX_ENTITY_BITS );
 	MSG_ReadDeltaEntity( msg, &from, &to, 0, DELTA_STATIC, cl.mtime[0] );
 
-	i = clgame.numStatics;
+	int i = clgame.numStatics;
 	if( i >= MAX_STATIC_ENTITIES )
 	{
 		Con_Printf( S_ERROR "MAX_STATIC_ENTITIES limit exceeded!\n" );
 		return;
 	}
 
-	ent = &clgame.static_entities[i];
+	cl_entity_t *ent = &clgame.static_entities[i];
 	clgame.numStatics++;
 
 	// all states are same
@@ -315,7 +308,7 @@ Set new weapon animation
 */
 void GAME_EXPORT CL_WeaponAnim( int iAnim, int body )
 {
-	cl_entity_t	*view = &clgame.viewent;
+	cl_entity_t *view = &clgame.viewent;
 
 	cl.local.weaponstarttime = 0.0f;
 	cl.local.weaponsequence = iAnim;
@@ -339,20 +332,18 @@ CL_ParseStaticDecal
 */
 void CL_ParseStaticDecal( sizebuf_t *msg )
 {
-	vec3_t		origin;
-	int		decalIndex, entityIndex, modelIndex;
-	float		scale;
-	int		flags;
+	vec3_t origin;
 
 	MSG_ReadVec3Coord( msg, origin );
-	decalIndex = MSG_ReadWord( msg );
-	entityIndex = MSG_ReadShort( msg );
+	int decalIndex = MSG_ReadWord( msg );
+	int entityIndex = MSG_ReadShort( msg );
 
+	int modelIndex;
 	if( entityIndex > 0 )
 		modelIndex = MSG_ReadWord( msg );
 	else modelIndex = 0;
-	flags = MSG_ReadByte( msg );
-	scale = (float)MSG_ReadWord( msg ) / 4096.0f;
+	int flags = MSG_ReadByte( msg );
+	float scale = (float)MSG_ReadWord( msg ) / 4096.0f;
 
 	CL_FireCustomDecal( CL_DecalIndex( decalIndex ), entityIndex, modelIndex, origin, flags, scale );
 }
@@ -381,11 +372,9 @@ CL_RequestMissingResources
 */
 qboolean CL_RequestMissingResources( void )
 {
-	resource_t	*p;
-
 	if( !cls.dl.doneregistering && ( cls.dl.custom || cls.state == ca_validate ))
 	{
-		p = cl.resourcesneeded.pNext;
+		resource_t *p = cl.resourcesneeded.pNext;
 
 		if( p == &cl.resourcesneeded )
 		{
@@ -404,17 +393,16 @@ qboolean CL_RequestMissingResources( void )
 
 void CL_BatchResourceRequest( qboolean initialize )
 {
-	byte		data[MAX_INIT_MSG];
-	resource_t	*p, *n;
-	sizebuf_t		msg;
-	qboolean		done_downloading = true;
+	byte data[MAX_INIT_MSG];
+	sizebuf_t msg;
+	qboolean done_downloading = true;
 
 	MSG_Init( &msg, "Resource Batch", data, sizeof( data ));
 
 	// client resources is not precached by server
 	if( initialize ) CL_AddClientResources();
 
-	for( p = cl.resourcesneeded.pNext; p && p != &cl.resourcesneeded; p = n )
+	for( resource_t *p = cl.resourcesneeded.pNext, *n; p && p != &cl.resourcesneeded; p = n )
 	{
 		n = p->pNext;
 
@@ -481,7 +469,7 @@ void CL_BatchResourceRequest( qboolean initialize )
 	{
 		if( done_downloading && CL_PrecacheResources( ))
 		{
-			CL_RegisterResources( &msg, cls.legacymode );
+			CL_RegisterResources( &msg, cls.net_protocol );
 		}
 
 		Netchan_CreateFragments( &cls.netchan, &msg );
@@ -491,10 +479,9 @@ void CL_BatchResourceRequest( qboolean initialize )
 
 int CL_EstimateNeededResources( void )
 {
-	resource_t	*p;
-	int		nTotalSize = 0;
+	int nTotalSize = 0;
 
-	for( p = cl.resourcesneeded.pNext; p != &cl.resourcesneeded; p = p->pNext )
+	for( resource_t *p = cl.resourcesneeded.pNext; p != &cl.resourcesneeded; p = p->pNext )
 	{
 		switch( p->type )
 		{
@@ -570,9 +557,7 @@ static void CL_StartResourceDownloading( const char *pszMessage, qboolean bCusto
 
 static customization_t *CL_PlayerHasCustomization( int nPlayerNum, resourcetype_t type )
 {
-	customization_t	*pList;
-
-	for( pList = cl.players[nPlayerNum].customdata.pNext; pList; pList = pList->pNext )
+	for( customization_t *pList = cl.players[nPlayerNum].customdata.pNext; pList; pList = pList->pNext )
 	{
 		if( pList->resource.type == type )
 			return pList;
@@ -582,10 +567,8 @@ static customization_t *CL_PlayerHasCustomization( int nPlayerNum, resourcetype_
 
 static void CL_RemoveCustomization( int nPlayerNum, customization_t *pRemove )
 {
-	customization_t	*pList;
-	customization_t	*pNext;
-
-	for( pList = cl.players[nPlayerNum].customdata.pNext; pList; pList = pNext )
+	customization_t *pNext;
+	for( customization_t *pList = cl.players[nPlayerNum].customdata.pNext; pList; pList = pNext )
 	{
 		pNext = pList->pNext;
 
@@ -619,17 +602,11 @@ CL_ParseCustomization
 */
 static void CL_ParseCustomization( sizebuf_t *msg )
 {
-	customization_t	*pExistingCustomization;
-	customization_t	*pList;
-	qboolean		bFound;
-	resource_t	*pRes;
-	int		i;
-
-	i = MSG_ReadByte( msg );
+	int i = MSG_ReadByte( msg );
 	if( i >= MAX_CLIENTS )
 		Host_Error( "Bogus player index during customization parsing.\n" );
 
-	pRes = Mem_Calloc( cls.mempool, sizeof( resource_t ));
+	resource_t *pRes = Mem_Calloc( cls.mempool, sizeof( resource_t ));
 	pRes->type = MSG_ReadByte( msg );
 
 	Q_strncpy( pRes->szFileName, MSG_ReadString( msg ), sizeof( pRes->szFileName ));
@@ -639,7 +616,7 @@ static void CL_ParseCustomization( sizebuf_t *msg )
 	pRes->pNext = pRes->pPrev = NULL;
 
 	if( FBitSet( pRes->ucFlags, RES_CUSTOM ))
-		MSG_ReadBytes( msg, pRes->rgucMD5_hash, 16 );
+		MSG_ReadBytes( msg, pRes->rgucMD5_hash, sizeof( pRes->rgucMD5_hash ), 16 );
 	pRes->playernum = i;
 
 	if( !cl_allow_download.value )
@@ -656,13 +633,13 @@ static void CL_ParseCustomization( sizebuf_t *msg )
 		return;
 	}
 
-	pExistingCustomization = CL_PlayerHasCustomization( i, pRes->type );
+	customization_t *pExistingCustomization = CL_PlayerHasCustomization( i, pRes->type );
 
 	if( pExistingCustomization )
 		CL_RemoveCustomization( i, pExistingCustomization );
-	bFound = false;
 
-	for( pList = cl.players[pRes->playernum].customdata.pNext; pList; pList = pList->pNext )
+	qboolean bFound = false;
+	for( customization_t *pList = cl.players[pRes->playernum].customdata.pNext; pList; pList = pList->pNext )
 	{
 		if( !memcmp( pList->resource.rgucMD5_hash, pRes->rgucMD5_hash, 16 ))
 		{
@@ -673,11 +650,11 @@ static void CL_ParseCustomization( sizebuf_t *msg )
 
 	if( HPAK_GetDataPointer( hpk_custom_file.string, pRes, NULL, NULL ))
 	{
-		qboolean	bError = false;
+		qboolean bError = false;
 
 		if( !bFound )
 		{
-			pList = &cl.players[pRes->playernum].customdata;
+			customization_t *pList = &cl.players[pRes->playernum].customdata;
 
 			if( !COM_CreateCustomization( pList, pRes, pRes->playernum, FCUST_FROMHPAK, NULL, NULL ))
 				bError = true;
@@ -707,15 +684,14 @@ CL_ParseResourceRequest
 */
 void CL_SendResourceList( const resource_t *list, int count )
 {
-	byte	buffer[MAX_INIT_MSG];
-	sizebuf_t	sbuf;
-	int	i;
+	byte buffer[MAX_INIT_MSG];
+	sizebuf_t sbuf;
 
 	MSG_Init( &sbuf, "ResourceBlock", buffer, sizeof( buffer ));
 	MSG_BeginClientCmd( &sbuf, clc_resourcelist );
 	MSG_WriteShort( &sbuf, count );
 
-	for( i = 0; i < count; i++ )
+	for( int i = 0; i < count; i++ )
 	{
 		MSG_WriteString( &sbuf, list[i].szFileName );
 		MSG_WriteByte( &sbuf, list[i].type );
@@ -733,10 +709,8 @@ void CL_SendResourceList( const resource_t *list, int count )
 
 static void CL_ParseResourceRequest( sizebuf_t *msg )
 {
-	int	arg, nStartIndex;
-
-	arg = MSG_ReadLong( msg );
-	nStartIndex = MSG_ReadLong( msg );
+	int arg = MSG_ReadLong( msg );
+	int nStartIndex = MSG_ReadLong( msg );
 
 	if( cl.servercount != arg )
 		return;
@@ -756,16 +730,12 @@ loading custom decal for self
 */
 static void CL_CreateCustomizationList( void )
 {
-	resource_t	*pResource;
-	player_info_t	*pPlayer;
-	int		i;
-
-	pPlayer = &cl.players[cl.playernum];
+	player_info_t *pPlayer = &cl.players[cl.playernum];
 	pPlayer->customdata.pNext = NULL;
 
-	for( i = 0; i < cl.num_resources; i++ )
+	for( int i = 0; i < cl.num_resources; i++ )
 	{
-		pResource = &cl.resourcelist[i];
+		resource_t *pResource = &cl.resourcelist[i];
 
 		if( !COM_CreateCustomization( &pPlayer->customdata, pResource, cl.playernum, 0, NULL, NULL ))
 			Con_Printf( "problem with client customization %s, ignoring...", pResource->szFileName );
@@ -843,7 +813,7 @@ static void CL_ParseServerData( sizebuf_t *msg, connprotocol_t proto )
 		byte clientdllmd5[16];
 		const char *s;
 
-		MSG_ReadBytes( msg, clientdllmd5, sizeof( clientdllmd5 ));
+		MSG_ReadBytes( msg, clientdllmd5, sizeof( clientdllmd5 ), sizeof( clientdllmd5 ));
 		cl.maxclients = MSG_ReadByte( msg );
 		cl.playernum = MSG_ReadByte( msg );
 		COM_UnMunge3((byte *)&cl.checksum, sizeof( cl.checksum ), ( 0xff - cl.playernum ) & 0xff );
@@ -891,6 +861,15 @@ static void CL_ParseServerData( sizebuf_t *msg, connprotocol_t proto )
 		}
 	}
 
+	if( cl.playernum < 0 || cl.playernum >= MAX_CLIENTS || cl.maxclients <= 0 || cl.maxclients > MAX_CLIENTS )
+	{
+		Con_Printf( S_ERROR "%s: invalid playernum or maxclients (%d and %d must be less than %d)\n", __func__,
+			cl.playernum, cl.maxclients, MAX_CLIENTS );
+		CL_Disconnect_f();
+		Host_AbortCurrentFrame();
+		return;
+	}
+
 	Q_snprintf( mapfile, sizeof( mapfile ), "maps/%s.bsp", clgame.mapname );
 	if( CRC32_MapFile( &cl.worldmapCRC, mapfile, cl.maxclients > 1 ))
 	{
@@ -1207,8 +1186,8 @@ void CL_ParseBaseline( sizebuf_t *msg, connprotocol_t proto )
 			int type = MSG_ReadUBitLong( msg, 2 );
 			int delta_type;
 
-			if( player ) delta_type = DT_ENTITY_STATE_PLAYER_T;
-			else if( type != ENTITY_NORMAL ) delta_type = DT_CUSTOM_ENTITY_STATE_T;
+			if( FBitSet( type, ENTITY_BEAM )) delta_type = DT_CUSTOM_ENTITY_STATE_T;
+			else if( player ) delta_type = DT_ENTITY_STATE_PLAYER_T;
 			else delta_type = DT_ENTITY_STATE_T;
 
 			Delta_ReadGSFields( msg, delta_type, &ent->prevstate, &ent->baseline, 1.0f );
@@ -1238,12 +1217,10 @@ CL_ParseLightStyle
 */
 static void CL_ParseLightStyle( sizebuf_t *msg, connprotocol_t proto )
 {
-	int		style;
-	const char	*s;
-	float		f = cl.mtime[0];
+	float f = cl.mtime[0];
 
-	style = MSG_ReadByte( msg );
-	s = MSG_ReadString( msg );
+	int style = MSG_ReadByte( msg );
+	const char *s = MSG_ReadString( msg );
 	if( proto != PROTO_GOLDSRC && proto != PROTO_QUAKE )
 		f = MSG_ReadFloat( msg );
 
@@ -1271,10 +1248,7 @@ add the view angle yaw
 */
 static void CL_ParseAddAngle( sizebuf_t *msg )
 {
-	pred_viewangle_t	*a;
-	float		delta_yaw;
-
-	delta_yaw = MSG_ReadBitAngle( msg, 16 );
+	float delta_yaw = MSG_ReadBitAngle( msg, 16 );
 #if 0
 	cl.viewangles[YAW] += delta_yaw;
 	return;
@@ -1284,7 +1258,7 @@ static void CL_ParseAddAngle( sizebuf_t *msg )
 
 	// select entry into circular buffer
 	cl.angle_position = (cl.angle_position + 1) & ANGLE_MASK;
-	a = &cl.predicted_angle[cl.angle_position];
+	pred_viewangle_t *a = &cl.predicted_angle[cl.angle_position];
 
 	// record update
 	a->starttime = cl.mtime[0];
@@ -1314,20 +1288,18 @@ reading decals, etc.
 */
 static void CL_ParseRestore( sizebuf_t *msg )
 {
-	string		filename;
-	int		i, mapCount;
-	char		*pMapName;
+	string filename;
 
 	// mapname.HL2
 	Q_strncpy( filename, MSG_ReadString( msg ), sizeof( filename ));
-	mapCount = MSG_ReadByte( msg );
+	int mapCount = MSG_ReadByte( msg );
 
 	// g-cont. acutally in Xash3D this does nothing.
 	// decals already restored on a server, and correctly transferred through levels
 	// but i'm leave this message for backward compatibility
-	for( i = 0; i < mapCount; i++ )
+	for( int i = 0; i < mapCount; i++ )
 	{
-		pMapName = MSG_ReadString( msg );
+		char *pMapName = MSG_ReadString( msg );
 		Con_Printf( "Loading decals from %s\n", pMapName );
 	}
 }
@@ -1341,10 +1313,9 @@ register new user message or update existing
 */
 static void CL_RegisterUserMessage( sizebuf_t *msg, connprotocol_t proto )
 {
-	char *pszName;
 	char szName[17];
-	int size;
 	int svc_num = MSG_ReadByte( msg );
+	int size;
 
 	if( proto == PROTO_GOLDSRC )
 	{
@@ -1359,9 +1330,10 @@ static void CL_RegisterUserMessage( sizebuf_t *msg, connprotocol_t proto )
 			size = -1;
 	}
 
+	char *pszName;
 	if( proto == PROTO_GOLDSRC )
 	{
-		MSG_ReadBytes( msg, szName, sizeof( szName ) - 1 );
+		MSG_ReadBytes( msg, szName, sizeof( szName ), sizeof( szName ) - 1 );
 		szName[16] = 0;
 		pszName = szName;
 	}
@@ -1379,9 +1351,8 @@ collect userinfo from all players
 */
 static void CL_UpdateUserinfo( sizebuf_t *msg, connprotocol_t proto )
 {
-	int		slot, id;
-	qboolean		active;
-	player_info_t	*player;
+	int slot, id;
+	qboolean active;
 
 	if( proto == PROTO_GOLDSRC )
 	{
@@ -1399,7 +1370,7 @@ static void CL_UpdateUserinfo( sizebuf_t *msg, connprotocol_t proto )
 	if( slot >= MAX_CLIENTS )
 		Host_Error( "%s: svc_updateuserinfo >= MAX_CLIENTS\n", __func__ );
 
-	player = &cl.players[slot];
+	player_info_t *player = &cl.players[slot];
 
 	if( active )
 	{
@@ -1409,7 +1380,7 @@ static void CL_UpdateUserinfo( sizebuf_t *msg, connprotocol_t proto )
 		player->topcolor = Q_atoi( Info_ValueForKey( player->userinfo, "topcolor" ));
 		player->bottomcolor = Q_atoi( Info_ValueForKey( player->userinfo, "bottomcolor" ));
 		player->spectator = Q_atoi( Info_ValueForKey( player->userinfo, "*hltv" ));
-		MSG_ReadBytes( msg, player->hashedcdkey, sizeof( player->hashedcdkey ));
+		MSG_ReadBytes( msg, player->hashedcdkey, sizeof( player->hashedcdkey ), sizeof( player->hashedcdkey ));
 
 		if( proto == PROTO_GOLDSRC && ( COM_StringEmpty( player->userinfo ) || COM_StringEmpty( player->name )))
 			active = false;
@@ -1440,9 +1411,7 @@ downloading and precache resource in-game
 */
 void CL_ParseResource( sizebuf_t *msg )
 {
-	resource_t	*pResource;
-
-	pResource = Mem_Calloc( cls.mempool, sizeof( resource_t ));
+	resource_t *pResource = Mem_Calloc( cls.mempool, sizeof( resource_t ));
 	pResource->type = MSG_ReadUBitLong( msg, 4 );
 
 	Q_strncpy( pResource->szFileName, MSG_ReadString( msg ), sizeof( pResource->szFileName ));
@@ -1451,36 +1420,36 @@ void CL_ParseResource( sizebuf_t *msg )
 	pResource->ucFlags = MSG_ReadUBitLong( msg, 3 ) & ~RES_WASMISSING;
 
 	if( FBitSet( pResource->ucFlags, RES_CUSTOM ))
-		MSG_ReadBytes( msg, pResource->rgucMD5_hash, sizeof( pResource->rgucMD5_hash ));
+		MSG_ReadBytes( msg, pResource->rgucMD5_hash, sizeof( pResource->rgucMD5_hash ), sizeof( pResource->rgucMD5_hash ));
 
 	if( MSG_ReadOneBit( msg ))
-		MSG_ReadBytes( msg, pResource->rguc_reserved, sizeof( pResource->rguc_reserved ));
+		MSG_ReadBytes( msg, pResource->rguc_reserved, sizeof( pResource->rguc_reserved ), sizeof( pResource->rguc_reserved ));
 
-	if( pResource->type == t_sound && pResource->nIndex > MAX_SOUNDS )
+	if( pResource->type == t_sound && pResource->nIndex >= MAX_SOUNDS )
 	{
 		Mem_Free( pResource );
 		Host_Error( "bad sound index\n" );
 	}
 
-	if( pResource->type == t_model && pResource->nIndex > MAX_MODELS )
+	if( pResource->type == t_model && pResource->nIndex >= MAX_MODELS )
 	{
 		Mem_Free( pResource );
 		Host_Error( "bad model index\n" );
 	}
 
-	if( pResource->type == t_eventscript && pResource->nIndex > MAX_EVENTS )
+	if( pResource->type == t_eventscript && pResource->nIndex >= MAX_EVENTS )
 	{
 		Mem_Free( pResource );
 		Host_Error( "bad event index\n" );
 	}
 
-	if( pResource->type == t_generic && pResource->nIndex > MAX_CUSTOM )
+	if( pResource->type == t_generic && pResource->nIndex >= MAX_CUSTOM )
 	{
 		Mem_Free( pResource );
 		Host_Error( "bad file index\n" );
 	}
 
-	if( pResource->type == t_decal && pResource->nIndex > MAX_DECALS )
+	if( pResource->type == t_decal && pResource->nIndex >= MAX_DECALS )
 	{
 		Mem_Free( pResource );
 		Host_Error( "bad decal index\n" );
@@ -1502,13 +1471,10 @@ void CL_UpdateUserPings( sizebuf_t *msg )
 	// because pings message always ends by null bit
 	while( 1 )
 	{
-		int slot;
-		player_info_t *player;
-
 		if( !MSG_ReadOneBit( msg ))
 			break; // end of message
 
-		slot = MSG_ReadUBitLong( msg, MAX_CLIENT_BITS );
+		int slot = MSG_ReadUBitLong( msg, MAX_CLIENT_BITS );
 
 		if( unlikely( slot >= MAX_CLIENTS ))
 		{
@@ -1516,7 +1482,7 @@ void CL_UpdateUserPings( sizebuf_t *msg )
 			return;
 		}
 
-		player = &cl.players[slot];
+		player_info_t *player = &cl.players[slot];
 		player->ping = MSG_ReadUBitLong( msg, 12 );
 		player->packet_loss = MSG_ReadUBitLong( msg, 7 );
 	}
@@ -1541,18 +1507,14 @@ static const char *CL_CheckTypeToString( int check_type )
 
 static void CL_SendConsistencyInfo( sizebuf_t *msg, connprotocol_t proto )
 {
-	qboolean user_changed_diskfile;
-	vec3_t   mins, maxs;
-	string   filename;
-	byte     md5[16] = { 0 };
-	int      pos;
+	byte md5[16] = { 0 };
 
 	if( !cl.need_force_consistency_response )
 		return;
 	cl.need_force_consistency_response = false;
 
 	MSG_BeginClientCmd( msg, clc_fileconsistency );
-	pos = MSG_GetNumBytesWritten( msg );
+	int pos = MSG_GetNumBytesWritten( msg );
 	if( proto == PROTO_GOLDSRC )
 	{
 		MSG_WriteShort( msg, 0 );
@@ -1564,9 +1526,11 @@ static void CL_SendConsistencyInfo( sizebuf_t *msg, connprotocol_t proto )
 	for( int i = 0; i < cl.num_consistency; i++ )
 	{
 		qboolean have_file = true;
+		qboolean user_changed_diskfile = false;
+		vec3_t mins, maxs;
+		string filename;
 		consistency_t *pc = &cl.consistency_list[i];
 
-		user_changed_diskfile = false;
 		MSG_WriteOneBit( msg, 1 );
 		MSG_WriteUBitLong( msg, pc->orig_index, MAX_MODEL_BITS );
 
@@ -1645,10 +1609,9 @@ static void CL_SendConsistencyInfo( sizebuf_t *msg, connprotocol_t proto )
 
 	if( proto == PROTO_GOLDSRC )
 	{
-		int len;
 		MSG_EndBitWriting( msg );
 
-		len = MSG_GetNumBytesWritten( msg ) - pos - 2;
+		int len = MSG_GetNumBytesWritten( msg ) - pos - 2;
 		*(short *)&msg->pData[pos] = len;
 
 		COM_Munge( &msg->pData[pos + 2], len, cl.servercount );
@@ -1664,11 +1627,10 @@ static void CL_StartDark( void )
 {
 	if( v_dark.value )
 	{
-		screenfade_t		*sf = &clgame.fade;
-		float			fadetime = 5.0f;
-		client_textmessage_t	*title;
+		screenfade_t *sf = &clgame.fade;
+		float fadetime = 5.0f;
 
-		title = CL_TextMessageGet( "GAMETITLE" );
+		client_textmessage_t *title = CL_TextMessageGet( "GAMETITLE" );
 		if( Host_IsQuakeCompatible( ))
 			fadetime = 1.0f;
 
@@ -1780,20 +1742,12 @@ void CL_RegisterResources( sizebuf_t *msg, connprotocol_t proto )
 
 static void CL_ParseConsistencyInfo( sizebuf_t *msg, connprotocol_t proto )
 {
-	int		lastcheck;
-	int		delta;
-	int		i;
-	int		isdelta;
-	resource_t	*pResource;
-	resource_t	*skip_crc_change;
-	int		skip;
-	consistency_t	*pc;
-	byte		nullbuffer[32];
+	byte nullbuffer[32];
 
 	memset( nullbuffer, 0, 32 );
 
 	cl.need_force_consistency_response = MSG_ReadOneBit( msg );
-	pResource = cl.resourcesneeded.pNext;
+	resource_t *pResource = cl.resourcesneeded.pNext;
 
 	if( !cl.need_force_consistency_response )
 		return;
@@ -1807,19 +1761,20 @@ static void CL_ParseConsistencyInfo( sizebuf_t *msg, connprotocol_t proto )
 	if( cl_trace_consistency.value )
 		Con_Printf( "Server wants consistency of the following resources:\n" );
 
-	skip_crc_change = NULL;
-	lastcheck = 0;
+	resource_t *skip_crc_change = NULL;
+	int lastcheck = 0;
 
 	while( MSG_ReadOneBit( msg ))
 	{
-		isdelta = MSG_ReadOneBit( msg );
+		int isdelta = MSG_ReadOneBit( msg );
+		int delta;
 
 		if( isdelta ) delta = MSG_ReadUBitLong( msg, 5 ) + lastcheck;
 		else delta = MSG_ReadUBitLong( msg, proto == PROTO_GOLDSRC ? MAX_GOLDSRC_MODEL_BITS : MAX_MODEL_BITS );
 
-		skip = delta - lastcheck;
+		int skip = delta - lastcheck;
 
-		for( i = 0; i < skip; i++ )
+		for( int i = 0; i < skip; i++ )
 		{
 			if( pResource != skip_crc_change && Q_strstr( pResource->szFileName, "models/" ))
 				Mod_NeedCRC( pResource->szFileName, false );
@@ -1835,7 +1790,7 @@ static void CL_ParseConsistencyInfo( sizebuf_t *msg, connprotocol_t proto )
 		if( cl.num_consistency >= MAX_MODELS )
 			Host_Error( "%s: MAX_MODELS limit exceeded (%d)\n", __func__, MAX_MODELS );
 
-		pc = &cl.consistency_list[cl.num_consistency];
+		consistency_t *pc = &cl.consistency_list[cl.num_consistency];
 		cl.num_consistency++;
 
 		memset( pc, 0, sizeof( *pc ));
@@ -1867,14 +1822,11 @@ CL_ParseResourceList
 */
 void CL_ParseResourceList( sizebuf_t *msg, connprotocol_t proto )
 {
-	resource_t	*pResource;
-	int		i, total;
+	int total = MSG_ReadUBitLong( msg, proto == PROTO_GOLDSRC ? MAX_GOLDSRC_RESOURCE_BITS : MAX_RESOURCE_BITS );
 
-	total = MSG_ReadUBitLong( msg, proto == PROTO_GOLDSRC ? MAX_GOLDSRC_RESOURCE_BITS : MAX_RESOURCE_BITS );
-
-	for( i = 0; i < total; i++ )
+	for( int i = 0; i < total; i++ )
 	{
-		pResource = Mem_Calloc( cls.mempool, sizeof( resource_t ));
+		resource_t *pResource = Mem_Calloc( cls.mempool, sizeof( resource_t ));
 		pResource->type = MSG_ReadUBitLong( msg, 4 );
 
 		Q_strncpy( pResource->szFileName, MSG_ReadString( msg ), sizeof( pResource->szFileName ));
@@ -1883,10 +1835,10 @@ void CL_ParseResourceList( sizebuf_t *msg, connprotocol_t proto )
 		pResource->ucFlags = MSG_ReadUBitLong( msg, 3 ) & ~RES_WASMISSING;
 
 		if( FBitSet( pResource->ucFlags, RES_CUSTOM ))
-			MSG_ReadBytes( msg, pResource->rgucMD5_hash, sizeof( pResource->rgucMD5_hash ));
+			MSG_ReadBytes( msg, pResource->rgucMD5_hash, sizeof( pResource->rgucMD5_hash ), sizeof( pResource->rgucMD5_hash ));
 
 		if( MSG_ReadOneBit( msg ))
-			MSG_ReadBytes( msg, pResource->rguc_reserved, sizeof( pResource->rguc_reserved ));
+			MSG_ReadBytes( msg, pResource->rguc_reserved, sizeof( pResource->rguc_reserved ), sizeof( pResource->rguc_reserved ));
 
 		CL_AddToResourceList( pResource, &cl.resourcesneeded );
 	}
@@ -1955,7 +1907,7 @@ static void CL_ParseVoiceData( sizebuf_t *msg, connprotocol_t proto )
 	if ( !size )
 		return;
 
-	MSG_ReadBytes( msg, received, size );
+	MSG_ReadBytes( msg, received, sizeof( received ), size );
 
 	Voice_AddIncomingData( idx, received, size, frames );
 }
@@ -2035,7 +1987,7 @@ static void CL_ParseDirector( sizebuf_t *msg )
 	byte	pbuf[256];
 
 	// parse user message into buffer
-	MSG_ReadBytes( msg, pbuf, iSize );
+	MSG_ReadBytes( msg, pbuf, sizeof( pbuf ), iSize );
 	clgame.dllFuncs.pfnDirectorMessage( iSize, pbuf );
 }
 
@@ -2071,14 +2023,12 @@ Set screen fade
 */
 static void CL_ParseScreenFade( sizebuf_t *msg )
 {
-	float		duration, holdTime;
-	screenfade_t	*sf = &clgame.fade;
-	float		flScale;
+	screenfade_t *sf = &clgame.fade;
 
-	duration = (float)MSG_ReadWord( msg );
-	holdTime = (float)MSG_ReadWord( msg );
+	float duration = (float)MSG_ReadWord( msg );
+	float holdTime = (float)MSG_ReadWord( msg );
 	sf->fadeFlags = MSG_ReadShort( msg );
-	flScale = FBitSet( sf->fadeFlags, FFADE_LONGFADE ) ? (1.0f / 256.0f) : (1.0f / 4096.0f);
+	float flScale = FBitSet( sf->fadeFlags, FFADE_LONGFADE ) ? (1.0f / 256.0f) : (1.0f / 4096.0f);
 
 	sf->fader = MSG_ReadByte( msg );
 	sf->fadeg = MSG_ReadByte( msg );
@@ -2187,9 +2137,6 @@ Exec map/class specific configs
 */
 static void CL_ParseExec( sizebuf_t *msg )
 {
-	qboolean is_class;
-	int class_idx;
-	string mapname;
 	const char *class_cfgs[] = {
 		"",
 		"exec scout.cfg\n",
@@ -2205,17 +2152,18 @@ static void CL_ParseExec( sizebuf_t *msg )
 		"exec civilian.cfg\n"
 	};
 
-	is_class = MSG_ReadByte( msg );
+	qboolean is_class = MSG_ReadByte( msg );
 
 	if( is_class )
 	{
-		class_idx = MSG_ReadByte( msg );
+		int class_idx = MSG_ReadByte( msg );
 
 		if( class_idx >= 0 && class_idx <= 11 && !Q_stricmp( GI->gamefolder, "tfc" ) )
 			Cbuf_AddText( class_cfgs[class_idx] );
 	}
 	else if( !Q_stricmp( GI->gamefolder, "tfc" ) )
 	{
+		string mapname;
 		Cbuf_AddText( "exec mapdefault.cfg\n" );
 
 		COM_FileBase( clgame.mapname, mapname, sizeof( mapname ));
@@ -2323,7 +2271,7 @@ void CL_ParseUserMessage( sizebuf_t *msg, int svc_num, connprotocol_t proto )
 	}
 
 	// parse user message into buffer
-	MSG_ReadBytes( msg, pbuf, iSize );
+	MSG_ReadBytes( msg, pbuf, sizeof( pbuf ), iSize );
 
 	if( cl_trace_messages.value )
 	{
@@ -2369,17 +2317,15 @@ show display finale or cutscene message
 */
 static void CL_ParseFinaleCutscene( sizebuf_t *msg, int level )
 {
-	static int		msgindex = 0;
-	client_textmessage_t	*text;
-	int			channel;
+	static int msgindex = 0;
 
 	cl.intermission = level;
 
-	channel = msgindex;
+	int channel = msgindex;
 	msgindex = (msgindex + 1) & (MAX_TEXTCHANNELS - 1);
 
 	// grab message channel
-	text = &cl_textmessage[channel];
+	client_textmessage_t *text = &cl_textmessage[channel];
 
 	// NOTE: svc_finale and svc_cutscene has a
 	// predefined settings like Quake-style
@@ -2591,9 +2537,9 @@ dispatch messages
 */
 void CL_ParseServerMessage( sizebuf_t *msg )
 {
-	size_t		bufStart, playerbytes;
-	int		cmd;
-	int		old_background;
+	size_t bufStart, playerbytes;
+	int cmd;
+	int old_background;
 
 	// parse the message
 	while( 1 )

engine/client/parse/cl_parse_gs.c

@@ -285,19 +285,17 @@ static void CL_CopyPacketEntity( frame_t *frame, int num, const entity_state_t *
 
 static int CL_ParsePacketEntitiesGS( sizebuf_t *msg, qboolean delta )
 {
-	frame_t *frame, *oldframe;
-	int oldindex, oldnum, numbase = 0;
-	entity_state_t *oldent;
-	int count;
+	frame_t *oldframe;
+	int numbase = 0;
 	int playerbytes = 0;
 
 	// save first uncompressed packet as timestamp
 	if( cls.changelevel && !delta && cls.demorecording )
 		CL_WriteDemoJumpTime();
 
-	count = MSG_ReadWord( msg );
+	int count = MSG_ReadWord( msg );
 
-	frame = &cl.frames[cl.parsecountmod];
+	frame_t *frame = &cl.frames[cl.parsecountmod];
 	memset( frame->flags, 0, sizeof( frame->flags ));
 	frame->first_entity = cls.next_client_entities;
 	frame->num_entities = 0;
@@ -326,9 +324,9 @@ static int CL_ParsePacketEntitiesGS( sizebuf_t *msg, qboolean delta )
 
 	MSG_StartBitWriting( msg );
 
-	oldent = NULL;
-	oldindex = 0;
-	oldnum = CL_UpdateOldEntNum( oldindex, oldframe, &oldent );
+	entity_state_t *oldent = NULL;
+	int oldindex = 0;
+	int oldnum = CL_UpdateOldEntNum( oldindex, oldframe, &oldent );
 
 	// read it all but ignore it
 	while( 1 )
@@ -415,10 +413,9 @@ static int CL_ParsePacketEntitiesGS( sizebuf_t *msg, qboolean delta )
 static float MSG_ReadGSBitCoord( sizebuf_t *sb )
 {
 	float value = 0;
-	int ival, fval;
 
-	ival = MSG_ReadOneBit( sb );
-	fval = MSG_ReadOneBit( sb );
+	int ival = MSG_ReadOneBit( sb );
+	int fval = MSG_ReadOneBit( sb );
 
 	if( ival || fval )
 	{
@@ -439,13 +436,11 @@ static float MSG_ReadGSBitCoord( sizebuf_t *sb )
 
 static void MSG_ReadGSBitVec3Coord( sizebuf_t *sb, vec3_t fa )
 {
-	qboolean x, y, z;
-
 	VectorClear( fa );
 
-	x = MSG_ReadOneBit( sb );
-	y = MSG_ReadOneBit( sb );
-	z = MSG_ReadOneBit( sb );
+	qboolean x = MSG_ReadOneBit( sb );
+	qboolean y = MSG_ReadOneBit( sb );
+	qboolean z = MSG_ReadOneBit( sb );
 	if( x )
 		fa[0] = MSG_ReadGSBitCoord( sb );
 	if( y )
@@ -456,31 +451,32 @@ static void MSG_ReadGSBitVec3Coord( sizebuf_t *sb, vec3_t fa )
 
 static void CL_ParseSoundPacketGS( sizebuf_t *msg )
 {
-	vec3_t	pos;
-	int 	chan, sound;
-	float 	volume, attn;
-	int	flags, pitch, entnum;
 	sound_t	handle = 0;
 
 	MSG_StartBitWriting( msg );
 
-	flags = MSG_ReadUBitLong( msg, 9 );
+	int flags = MSG_ReadUBitLong( msg, 9 );
 
+	float volume;
 	if( FBitSet( flags, SND_VOLUME ))
 		volume = (float)MSG_ReadByte( msg ) / 255.0f;
 	else volume = VOL_NORM;
 
+	float attn;
 	if( FBitSet( flags, SND_ATTENUATION ))
 		attn = (float)MSG_ReadByte( msg ) / 64.0f;
-	else attn = ATTN_NONE;
+	else attn = 1.0f;
 
-	chan = MSG_ReadUBitLong( msg, 3 );
-	entnum = MSG_ReadUBitLong( msg, MAX_GOLDSRC_ENTITY_BITS );
+	int chan = MSG_ReadUBitLong( msg, 3 );
+	int entnum = MSG_ReadUBitLong( msg, MAX_GOLDSRC_ENTITY_BITS );
+	int sound;
 	if( FBitSet( flags, SND_GOLDSRC_LARGE_INDEX ))
 		sound = MSG_ReadWord( msg );
 	else sound = MSG_ReadByte( msg );
+	vec3_t pos;
 	MSG_ReadGSBitVec3Coord( msg, pos );
 
+	int pitch;
 	if( FBitSet( flags, SND_PITCH ))
 		pitch = MSG_ReadByte( msg );
 	else pitch = PITCH_NORM;
@@ -514,17 +510,15 @@ static void CL_ParseSoundPacketGS( sizebuf_t *msg )
 static void CL_ParseSpawnStaticSound( sizebuf_t *msg )
 {
 	vec3_t pos;
-	int sound, entnum, pitch, flags;
-	float volume, attn;
 	sound_t handle = 0;
 
 	MSG_ReadVec3Coord( msg, pos );
-	sound  = MSG_ReadShort( msg );
-	volume = MSG_ReadByte( msg ) * ( 1.0f / 255.0f );
-	attn   = MSG_ReadByte( msg ) * ( 1.0f / 64.0f );
-	entnum = MSG_ReadShort( msg );
-	pitch  = MSG_ReadByte( msg );
-	flags  = MSG_ReadByte( msg );
+	int sound    = MSG_ReadShort( msg );
+	float volume = MSG_ReadByte( msg ) * ( 1.0f / 255.0f );
+	float attn   = MSG_ReadByte( msg ) * ( 1.0f / 64.0f );
+	int entnum   = MSG_ReadShort( msg );
+	int pitch    = MSG_ReadByte( msg );
+	int flags    = MSG_ReadByte( msg );
 
 	if( FBitSet( flags, SND_SENTENCE ))
 	{

engine/client/parse/cl_qparse.c

@@ -80,14 +80,13 @@ we don't want interpolate this
 */
 static qboolean CL_QuakeEntityTeleported( cl_entity_t *ent, entity_state_t *newstate )
 {
-	float	len, maxlen;
-	vec3_t	delta;
+	vec3_t delta;
 
 	VectorSubtract( newstate->origin, ent->prevstate.origin, delta );
 
 	// compute potential max movement in units per frame and compare with entity movement
-	maxlen = ( clgame.movevars.maxvelocity * ( 1.0f / GAME_FPS ));
-	len = VectorLength( delta );
+	float maxlen = ( clgame.movevars.maxvelocity * ( 1.0f / GAME_FPS ));
+	float len = VectorLength( delta );
 
 	return (len > maxlen);
 }
@@ -139,33 +138,30 @@ CL_ParseQuakeSound
 */
 static void CL_ParseQuakeSound( sizebuf_t *msg )
 {
-	int 	channel, sound;
-	int	flags, entnum;
-	float 	volume, attn;
-	sound_t	handle;
-	vec3_t	pos;
-
-	flags = MSG_ReadByte( msg );
+	int flags = MSG_ReadByte( msg );
 
+	float volume;
 	if( FBitSet( flags, SND_VOLUME ))
 		volume = (float)MSG_ReadByte( msg ) / 255.0f;
 	else volume = VOL_NORM;
 
+	float attn;
 	if( FBitSet( flags, SND_ATTENUATION ))
 		attn = (float)MSG_ReadByte( msg ) / 64.0f;
 	else attn = ATTN_NONE;
 
-	channel = MSG_ReadWord( msg );
-	sound = MSG_ReadByte( msg );	// Quake1 have max 255 precached sounds. erm
+	int channel = MSG_ReadWord( msg );
+	int sound = MSG_ReadByte( msg );	// Quake1 have max 255 precached sounds. erm
 
 	// positioned in space
+	vec3_t pos;
 	MSG_ReadVec3Coord( msg, pos );
 
-	entnum = channel >> 3;	// entity reletive
+	int entnum = channel >> 3;	// entity reletive
 	channel &= 7;
 
 	// see precached sound
-	handle = cl.sound_index[sound];
+	sound_t handle = cl.sound_index[sound];
 
 	if( !cl.audio_prepped )
 		return; // too early
@@ -181,11 +177,6 @@ CL_ParseQuakeServerInfo
 */
 static void CL_ParseQuakeServerInfo( sizebuf_t *msg )
 {
-	resource_t	*pResource;
-	const char	*pResName;
-	int		gametype;
-	int		i;
-
 	Con_Reportf( "Serverdata packet received.\n" );
 	cls.timestart = Platform_DoubleTime();
 
@@ -198,7 +189,7 @@ static void CL_ParseQuakeServerInfo( sizebuf_t *msg )
 	cls.state = ca_connected;
 
 	// parse protocol version number
-	i = MSG_ReadLong( msg );
+	int i = MSG_ReadLong( msg );
 
 	if( i != PROTOCOL_VERSION_QUAKE )
 	{
@@ -208,7 +199,7 @@ static void CL_ParseQuakeServerInfo( sizebuf_t *msg )
 	}
 
 	cl.maxclients = MSG_ReadByte( msg );
-	gametype = MSG_ReadByte( msg );
+	int gametype = MSG_ReadByte( msg );
 	clgame.maxEntities = GI->max_edicts;
 	clgame.maxEntities = bound( 600, clgame.maxEntities, MAX_EDICTS );
 	clgame.maxModels = MAX_MODELS;
@@ -264,12 +255,12 @@ static void CL_ParseQuakeServerInfo( sizebuf_t *msg )
 	// Quake just have a large packet of initialization data
 	for( i = 1; i < MAX_MODELS; i++ )
 	{
-		pResName = MSG_ReadString( msg );
+		const char *pResName = MSG_ReadString( msg );
 
 		if( COM_StringEmptyOrNULL( pResName ))
 			break; // end of list
 
-		pResource = Mem_Calloc( cls.mempool, sizeof( resource_t ));
+		resource_t *pResource = Mem_Calloc( cls.mempool, sizeof( resource_t ));
 		pResource->type = t_model;
 
 		Q_strncpy( pResource->szFileName, pResName, sizeof( pResource->szFileName ));
@@ -282,12 +273,12 @@ static void CL_ParseQuakeServerInfo( sizebuf_t *msg )
 
 	for( i = 1; i < MAX_SOUNDS; i++ )
 	{
-		pResName = MSG_ReadString( msg );
+		const char *pResName = MSG_ReadString( msg );
 
 		if( COM_StringEmptyOrNULL( pResName ))
 			break; // end of list
 
-		pResource = Mem_Calloc( cls.mempool, sizeof( resource_t ));
+		resource_t *pResource = Mem_Calloc( cls.mempool, sizeof( resource_t ));
 		pResource->type = t_sound;
 
 		Q_strncpy( pResource->szFileName, pResName, sizeof( pResource->szFileName ));
@@ -340,15 +331,12 @@ CL_ParseQuakeClientData
 */
 static void CL_ParseQuakeClientData( sizebuf_t *msg )
 {
-	int	i, bits = MSG_ReadWord( msg );
-	frame_t	*frame;
+	int bits = MSG_ReadWord( msg );
 
 	// this is the frame update that this message corresponds to
-	i = cls.netchan.incoming_sequence;
-
-	cl.parsecount = i;					// ack'd incoming messages.
+	cl.parsecount = cls.netchan.incoming_sequence;		// ack'd incoming messages.
 	cl.parsecountmod = cl.parsecount & CL_UPDATE_MASK;	// index into window.
-	frame = &cl.frames[cl.parsecountmod];			// frame at index.
+	frame_t *frame = &cl.frames[cl.parsecountmod];		// frame at index.
 	frame->time = cl.mtime[0];				// mark network received time
 	frame->receivedtime = host.realtime;			// time now that we are parsing.
 	memset( &frame->graphdata, 0, sizeof( netbandwidthgraph_t ));
@@ -365,7 +353,7 @@ static void CL_ParseQuakeClientData( sizebuf_t *msg )
 		cl.local.idealpitch = MSG_ReadChar( msg );
 	else cl.local.idealpitch = 0;
 
-	for( i = 0; i < 3; i++ )
+	for( int i = 0; i < 3; i++ )
 	{
 		if( FBitSet( bits, SU_PUNCH1 << i ))
 			frame->clientdata.punchangle[i] = (float)MSG_ReadChar( msg );
@@ -568,15 +556,14 @@ CL_ParseQuakeParticles
 */
 static void CL_ParseQuakeParticle( sizebuf_t *msg )
 {
-	int	count, color;
-	vec3_t	org, dir;
+	vec3_t org, dir;
 
 	MSG_ReadVec3Coord( msg, org );
 	dir[0] = MSG_ReadChar( msg ) * 0.0625f;
 	dir[1] = MSG_ReadChar( msg ) * 0.0625f;
 	dir[2] = MSG_ReadChar( msg ) * 0.0625f;
-	count = MSG_ReadByte( msg );
-	color = MSG_ReadByte( msg );
+	int count = MSG_ReadByte( msg );
+	int color = MSG_ReadByte( msg );
 	if( count == 255 ) count = 1024;
 
 	R_RunParticleEffect( org, dir, color, count );
@@ -590,14 +577,12 @@ CL_ParseQuakeStaticSound
 */
 static void CL_ParseQuakeStaticSound( sizebuf_t *msg )
 {
-	int	sound_num;
-	float 	vol, attn;
-	vec3_t	org;
+	vec3_t org;
 
 	MSG_ReadVec3Coord( msg, org );
-	sound_num = MSG_ReadByte( msg );
-	vol = (float)MSG_ReadByte( msg ) / 255.0f;
-	attn = (float)MSG_ReadByte( msg ) / 64.0f;
+	int sound_num = MSG_ReadByte( msg );
+	float vol = (float)MSG_ReadByte( msg ) / 255.0f;
+	float attn = (float)MSG_ReadByte( msg ) / 64.0f;
 
 	S_StartSound( org, 0, CHAN_STATIC, cl.sound_index[sound_num], vol, attn, PITCH_NORM, 0 );
 }
@@ -628,8 +613,6 @@ CL_ParseStaticEntity
 static void CL_ParseQuakeStaticEntity( sizebuf_t *msg )
 {
 	entity_state_t state = { 0 };
-	cl_entity_t	*ent;
-	int		i;
 
 	if( !clgame.static_entities )
 		clgame.static_entities = Mem_Calloc( clgame.mempool, sizeof( cl_entity_t ) * MAX_STATIC_ENTITIES );
@@ -645,14 +628,14 @@ static void CL_ParseQuakeStaticEntity( sizebuf_t *msg )
 	state.origin[2] = MSG_ReadCoord( msg );
 	state.angles[2] = MSG_ReadAngle( msg );
 
-	i = clgame.numStatics;
+	int i = clgame.numStatics;
 	if( i >= MAX_STATIC_ENTITIES )
 	{
 		Con_Printf( S_ERROR "%s: static entities limit exceeded!\n", __func__ );
 		return;
 	}
 
-	ent = &clgame.static_entities[i];
+	cl_entity_t *ent = &clgame.static_entities[i];
 	clgame.numStatics++;
 
 	ent->index = 0; // ???
@@ -692,16 +675,13 @@ CL_ParseQuakeBaseline
 */
 static void CL_ParseQuakeBaseline( sizebuf_t *msg )
 {
-	entity_state_t	state;
-	cl_entity_t	*ent;
-	int		newnum;
-
-	newnum = MSG_ReadWord( msg ); // entnum
+	int newnum = MSG_ReadWord( msg ); // entnum
 
 	if( newnum >= clgame.maxEntities )
 		Host_Error( "%s: no free edicts\n", __func__ );
 
 	// parse baseline
+	entity_state_t state;
 	memset( &state, 0, sizeof( state ));
 	state.modelindex = MSG_ReadByte( msg );
 	state.frame = MSG_ReadByte( msg );
@@ -714,7 +694,7 @@ static void CL_ParseQuakeBaseline( sizebuf_t *msg )
 	state.origin[2] = MSG_ReadCoord( msg );
 	state.angles[2] = MSG_ReadAngle( msg );
 
-	ent = CL_EDICT_NUM( newnum );
+	cl_entity_t *ent = CL_EDICT_NUM( newnum );
 	ent->index = newnum;
 	ent->player = CL_IsPlayerIndex( newnum );
 	ent->prevstate = ent->baseline = state;
@@ -973,12 +953,21 @@ void CL_ParseQuakeMessage( sizebuf_t *msg )
 			break;
 		case svc_updatename:
 			param1 = MSG_ReadByte( msg );
+			if( param1 >= ARRAYSIZE( cl.players ))
+			{
+				MSG_ReadString( msg );
+				break;
+			}
+
 			Q_strncpy( cl.players[param1].name, MSG_ReadString( msg ), sizeof( cl.players[0].name ));
 			Q_strncpy( cl.players[param1].model, "player", sizeof( cl.players[0].name ));
 			break;
 		case svc_updatefrags:
 			param1 = MSG_ReadByte( msg );
 			param2 = MSG_ReadShort( msg );
+			if( param1 >= ARRAYSIZE( cl.players ))
+				break;
+
 			// HACKHACK: store frags into spectator
 			cl.players[param1].spectator = param2;
 			break;
@@ -994,6 +983,9 @@ void CL_ParseQuakeMessage( sizebuf_t *msg )
 		case svc_updatecolors:
 			param1 = MSG_ReadByte( msg );
 			param2 = MSG_ReadByte( msg );
+			if( param1 >= ARRAYSIZE( cl.players ) || param2 >= ARRAYSIZE( cl.players ))
+				break;
+
 			cl.players[param1].topcolor = param2 & 0xF;
 			cl.players[param1].bottomcolor = (param2 & 0xF0) >> 4;
 			break;

engine/client/sound/s_dsp.c

@@ -386,13 +386,14 @@ Do stereo processing
 static void DLY_DoStereoDelay( portable_samplepair_t *paint, int count )
 {
 	dly_t *dly = &stereodly;
-	int delay, samplexf;
 
 	if( !dly->lpdelayline )
 		return; // inactive
 
 	for( ; count; count--, paint++ )
 	{
+		int delay;
+
 		if( dly->mod && --dly->modcur < 0 )
 			dly->modcur = dly->mod;
 
@@ -414,7 +415,7 @@ static void DLY_DoStereoDelay( portable_samplepair_t *paint, int count )
 			// modify delay, if crossfading
 			if( dly->xfade )
 			{
-				samplexf = dly->lpdelayline[dly->idelayoutputxf] * (128 - dly->xfade) >> 7;
+				int samplexf = dly->lpdelayline[dly->idelayoutputxf] * (128 - dly->xfade) >> 7;
 				delay = samplexf + ((delay * dly->xfade) >> 7);
 
 				if( ++dly->idelayoutputxf >= dly->cdelaysamplesmax )
@@ -496,14 +497,13 @@ Do delay processing
 static void DLY_DoDelay( portable_samplepair_t *paint, int count )
 {
 	dly_t *dly = &monodly;
-	int delay;
 
 	if( !dly->lpdelayline || !count )
 		return; // inactive
 
 	for( ; count; count--, paint++ )
 	{
-		delay = dly->lpdelayline[dly->idelayoutput];
+		int delay = dly->lpdelayline[dly->idelayoutput];
 
 		// don't process if delay line and left/right samples are zero
 		if( delay || paint->left || paint->right )
@@ -613,8 +613,6 @@ Do reverberation for one dly
 static int RVB_DoReverbForOneDly( dly_t *dly, const int vlr, const portable_samplepair_t *samplepair )
 {
 	int	delay;
-	int	samplexf;
-	int	val, valt;
 	int	voutm = 0;
 
 	if( --dly->modcur < 0 )
@@ -624,6 +622,8 @@ static int RVB_DoReverbForOneDly( dly_t *dly, const int vlr, const portable_samp
 
 	if( dly->xfade || delay || samplepair->left || samplepair->right )
 	{
+		int	val, valt;
+
 		// modulate delay rate
 		if( !dly->mod )
 		{
@@ -636,7 +636,7 @@ static int RVB_DoReverbForOneDly( dly_t *dly, const int vlr, const portable_samp
 
 		if( dly->xfade )
 		{
-			samplexf = (dly->lpdelayline[dly->idelayoutputxf] * (REVERB_XFADE - dly->xfade)) / REVERB_XFADE;
+			int samplexf = (dly->lpdelayline[dly->idelayoutputxf] * (REVERB_XFADE - dly->xfade)) / REVERB_XFADE;
 			delay = ((delay * dly->xfade) / REVERB_XFADE) + samplexf;
 
 			if( ++dly->idelayoutputxf >= dly->cdelaysamplesmax )
@@ -688,14 +688,14 @@ static void RVB_DoReverb( portable_samplepair_t *paint, int count )
 {
 	dly_t *dly1 = &reverbdly[0];
 	dly_t *dly2 = &reverbdly[1];
-	int vlr, voutm;
 
 	if( !dly1->lpdelayline )
 		return;
 
 	for( ; count; count--, paint++ )
 	{
-		vlr = ( paint->left + paint->right ) >> 1;
+		int vlr = ( paint->left + paint->right ) >> 1;
+		int voutm;
 
 		voutm = RVB_DoReverbForOneDly( dly1, vlr, paint );
 		voutm += RVB_DoReverbForOneDly( dly2, vlr, paint );
@@ -881,9 +881,8 @@ static void SX_Profiling_f( void )
 	portable_samplepair_t	testbuffer[512];
 	float			oldroom = room_type.value;
 	double			start, end;
-	int			i, calls;
 
-	for( i = 0; i < ARRAYSIZE( testbuffer ); i++ )
+	for( int i = 0; i < ARRAYSIZE( testbuffer ); i++ )
 	{
 		testbuffer[i].left = COM_RandomLong( 0, 3000 );
 		testbuffer[i].right = COM_RandomLong( 0, 3000 );
@@ -899,7 +898,7 @@ static void SX_Profiling_f( void )
 	Con_Printf( "Profiling 10000 calls to DSP. Sample count is 512, room_type is %i\n", idsp_room );
 
 	start = Platform_DoubleTime();
-	for( calls = 10000; calls; calls-- )
+	for( int calls = 10000; calls; calls-- )
 	{
 		SX_RoomFX( testbuffer, 512 );
 	}

engine/client/sound/s_load.c

@@ -39,17 +39,16 @@ S_SoundList_f
 */
 void S_SoundList_f( void )
 {
-	sfx_t		*sfx;
-	wavdata_t		*sc;
-	int		i, totalSfx = 0;
-	int		totalSize = 0;
+	sfx_t	*sfx;
+	int	i, totalSfx = 0;
+	int	totalSize = 0;
 
 	for( i = 0, sfx = s_knownSfx; i < s_numSfx; i++, sfx++ )
 	{
 		if( !sfx->name[0] )
 			continue;
 
-		sc = sfx->cache;
+		wavdata_t *sc = sfx->cache;
 		if( sc )
 		{
 			totalSize += sc->size;
@@ -149,7 +148,7 @@ S_FindName
 sfx_t *S_FindName( const char *pname, qboolean *pfInCache )
 {
 	sfx_t	*sfx;
-	uint	i, hash;
+	uint	i;
 	string	name;
 
 	if( COM_StringEmptyOrNULL( pname ) || !snd.initialized )
@@ -162,7 +161,7 @@ sfx_t *S_FindName( const char *pname, qboolean *pfInCache )
 	COM_FixSlashes( name );
 
 	// see if already loaded
-	hash = COM_HashKey( name, MAX_SFX_HASH );
+	uint hash = COM_HashKey( name, MAX_SFX_HASH );
 	for( sfx = s_sfxHashList[hash]; sfx; sfx = sfx->hashNext )
 	{
 		if( !Q_strcmp( sfx->name, name ))
@@ -210,17 +209,14 @@ S_FreeSound
 */
 void S_FreeSound( sfx_t *sfx )
 {
-	sfx_t	*hashSfx;
-	sfx_t	**prev;
-
 	if( !sfx || !sfx->name[0] )
 		return;
 
 	// de-link it from the hash tree
-	prev = &s_sfxHashList[sfx->hashValue];
+	sfx_t **prev = &s_sfxHashList[sfx->hashValue];
 	while( 1 )
 	{
-		hashSfx = *prev;
+		sfx_t *hashSfx = *prev;
 		if( !hashSfx )
 			break;
 
@@ -251,12 +247,10 @@ S_BeginRegistration
 */
 void S_BeginRegistration( void )
 {
-	int	i;
-
 	snd.have_ambient_sfx = false;
 
 	// check for automatic ambient sounds
-	for( i = 0; i < NUM_AMBIENTS; i++ )
+	for( int i = 0; i < NUM_AMBIENTS; i++ )
 	{
 		if( !GI->ambientsound[i][0] )
 			continue;	// empty slot
@@ -386,6 +380,7 @@ void S_FreeSounds( void )
 	for( i = 0, sfx = s_knownSfx; i < s_numSfx; i++, sfx++ )
 		S_FreeSound( sfx );
 
+
 	memset( s_knownSfx, 0, sizeof( s_knownSfx ));
 	memset( s_sfxHashList, 0, sizeof( s_sfxHashList ));
 

engine/client/sound/s_main.c

@@ -290,8 +290,6 @@ static int SND_GetChannelTimeLeft( const channel_t *ch )
 
 	if( ch->words ) // sentences are special, count all remaining words
 	{
-		int i;
-
 		if( FBitSet( ch->flags, FL_CHAN_SENTENCE_FINISHED ) )
 			return 0;
 
@@ -300,7 +298,7 @@ static int SND_GetChannelTimeLeft( const channel_t *ch )
 
 		// here we count all remaining words, stopping if no sfx or sound file is available
 		// see VOX_LoadWord
-		for( i = ch->word_index + 1; i < CVOXWORDMAX; i++ )
+		for( int i = ch->word_index + 1; i < CVOXWORDMAX; i++ )
 		{
 			wavdata_t *sc;
 			int end;
@@ -341,14 +339,9 @@ exceptions).
 */
 channel_t *SND_PickDynamicChannel( int entnum, int channel, sfx_t *sfx, qboolean *ignore )
 {
-	int	ch_idx;
-	int	first_to_die;
-	int	life_left;
-	int	timeleft;
+	int	first_to_die = -1;
+	int	life_left = 0x7fffffff;
 
-	// check for replacement sound, or find the best one to replace
-	first_to_die = -1;
-	life_left = 0x7fffffff;
 	if( ignore ) *ignore = false;
 
 	if( channel == CHAN_STREAM && SND_FStreamIsPlaying( sfx ))
@@ -358,9 +351,10 @@ channel_t *SND_PickDynamicChannel( int entnum, int channel, sfx_t *sfx, qboolean
 		return NULL;
 	}
 
-	for( ch_idx = NUM_AMBIENTS; ch_idx < MAX_DYNAMIC_CHANNELS; ch_idx++ )
+	for( int ch_idx = NUM_AMBIENTS; ch_idx < MAX_DYNAMIC_CHANNELS; ch_idx++ )
 	{
 		channel_t	*ch = &snd.channels[ch_idx];
+		int	timeleft;
 
 		// Never override a streaming sound that is currently playing or
 		// voice over IP data that is playing or any sound on CHAN_VOICE( acting )
@@ -627,8 +621,8 @@ void S_StartSound( const vec3_t pos, int ent, int chan, sound_t handle, float fv
 {
 	wavdata_t	*pSource;
 	sfx_t	*sfx = NULL;
-	channel_t	*target_chan, *check;
-	int	vol, ch_idx;
+	channel_t	*target_chan;
+	int	vol;
 	qboolean	bIgnore = false;
 
 	if( !snd.initialized ) return;
@@ -746,7 +740,7 @@ S_RestoreSound
 Restore a sound effect for the given entity on the given channel
 ====================
 */
-void S_RestoreSound( const vec3_t pos, int ent, int chan, sound_t handle, float fvol, float attn, int pitch, int flags, double sample, double end, int wordIndex )
+void S_RestoreSound( const vec3_t pos, int ent, int chan, sound_t handle, float fvol, float attn, int pitch, int flags, double sample, double end, uint wordIndex )
 {
 	wavdata_t	*pSource;
 	sfx_t	*sfx = NULL;
@@ -810,15 +804,30 @@ void S_RestoreSound( const vec3_t pos, int ent, int chan, sound_t handle, float
 		// not a first word in sentence!
 		if( wordIndex != 0 )
 		{
-			VOX_FreeWord( target_chan );		// release first loaded word
-			target_chan->word_index = wordIndex;	// restore current word
-			VOX_LoadWord( target_chan );
+			uint word_count = 0;
 
-			if( !FBitSet( target_chan->flags, FL_CHAN_SENTENCE_FINISHED ))
+			if( target_chan->words )
 			{
-				target_chan->sfx = target_chan->words[target_chan->word_index].sfx;
-				sfx = target_chan->sfx;
-				pSource = sfx->cache;
+				while( word_count < CVOXWORDMAX && target_chan->words[word_count].sfx )
+					word_count++;
+			}
+
+			if( wordIndex >= word_count )
+			{
+				SetBits( target_chan->flags, FL_CHAN_SENTENCE_FINISHED );
+			}
+			else
+			{
+				VOX_FreeWord( target_chan ); // release first loaded word
+				target_chan->word_index = wordIndex; // restore current word
+				VOX_LoadWord( target_chan );
+
+				if( !FBitSet( target_chan->flags, FL_CHAN_SENTENCE_FINISHED ))
+				{
+					target_chan->sfx = target_chan->words[target_chan->word_index].sfx;
+					sfx = target_chan->sfx;
+					pSource = sfx->cache;
+				}
 			}
 		}
 		else
@@ -874,7 +883,7 @@ void S_AmbientSound( const vec3_t pos, int ent, sound_t handle, float fvol, floa
 	channel_t	*ch;
 	wavdata_t	*pSource = NULL;
 	sfx_t	*sfx = NULL;
-	int	vol, fvox = 0;
+	int	vol;
 
 	if( !snd.initialized ) return;
 	sfx = S_GetSfxByHandle( handle );
@@ -911,7 +920,6 @@ void S_AmbientSound( const vec3_t pos, int ent, sound_t handle, float fvol, floa
 		Q_strncpy( ch->name, sfx->name, sizeof( ch->name ));
 		sfx = ch->sfx;
 		if( sfx ) pSource = sfx->cache;
-		fvox = 1;
 	}
 	else
 	{
@@ -1020,14 +1028,14 @@ grab all static sounds playing at current channel
 int S_GetCurrentDynamicSounds( soundlist_t *pout, int size )
 {
 	int	sounds_left = size;
-	int	i, looped;
 
 	if( !snd.initialized )
 		return 0;
 
-	for( i = 0; i < snd.max_channels && sounds_left; i++ )
+	for( int i = 0; i < snd.max_channels && sounds_left; i++ )
 	{
 		const channel_t *ch = &snd.channels[i];
+		int looped;
 
 		if( !ch->sfx || !ch->sfx->name[0] || !Q_stricmp( ch->sfx->name, "*default" ))
 			continue;	// don't serialize default sounds
@@ -1085,8 +1093,6 @@ S_UpdateAmbientSounds
 */
 static void S_UpdateAmbientSounds( void )
 {
-	int ambient_channel;
-
 	if( !snd.have_ambient_sfx )
 		return;
 
@@ -1117,7 +1123,7 @@ static void S_UpdateAmbientSounds( void )
 			continue;
 		}
 
-		float vol = s_ambient_level.value * leaf->ambient_sound_level[ambient_channel];
+		float vol = s_ambient_level.value * leaf->ambient_sound_level[i];
 		if( vol < 0.0f )
 			vol = 0.0f;
 
@@ -1223,14 +1229,13 @@ S_RawSamplesStereo
 */
 uint S_RawSamplesStereo( portable_samplepair_t *rawsamples, uint rawend, uint max_samples, uint samples, uint rate, word width, word channels, const byte *data )
 {
-	uint	fracstep, samplefrac;
-	uint	src, dst;
+	uint	src;
 
 	if( rawend < snd.paintedtime )
 		rawend = snd.paintedtime;
 
-	fracstep = ((double) rate / (double)SOUND_DMA_SPEED) * (double)(1 << S_RAW_SAMPLES_PRECISION_BITS);
-	samplefrac = 0;
+	uint fracstep = ((double) rate / (double)SOUND_DMA_SPEED) * (double)(1 << S_RAW_SAMPLES_PRECISION_BITS);
+	uint samplefrac = 0;
 
 	if( width == 2 )
 	{
@@ -1240,7 +1245,7 @@ uint S_RawSamplesStereo( portable_samplepair_t *rawsamples, uint rawend, uint ma
 		{
 			for( src = 0; src < samples; samplefrac += fracstep, src = ( samplefrac >> S_RAW_SAMPLES_PRECISION_BITS ))
 			{
-				dst = rawend++ & ( max_samples - 1 );
+				uint dst = rawend++ & ( max_samples - 1 );
 				rawsamples[dst].left = in[src*2+0];
 				rawsamples[dst].right = in[src*2+1];
 			}
@@ -1249,7 +1254,7 @@ uint S_RawSamplesStereo( portable_samplepair_t *rawsamples, uint rawend, uint ma
 		{
 			for( src = 0; src < samples; samplefrac += fracstep, src = ( samplefrac >> S_RAW_SAMPLES_PRECISION_BITS ))
 			{
-				dst = rawend++ & ( max_samples - 1 );
+				uint dst = rawend++ & ( max_samples - 1 );
 				rawsamples[dst].left = in[src];
 				rawsamples[dst].right = in[src];
 			}
@@ -1263,7 +1268,7 @@ uint S_RawSamplesStereo( portable_samplepair_t *rawsamples, uint rawend, uint ma
 
 			for( src = 0; src < samples; samplefrac += fracstep, src = ( samplefrac >> S_RAW_SAMPLES_PRECISION_BITS ))
 			{
-				dst = rawend++ & ( max_samples - 1 );
+				uint dst = rawend++ & ( max_samples - 1 );
 				rawsamples[dst].left = in[src*2+0] << 8;
 				rawsamples[dst].right = in[src*2+1] << 8;
 			}
@@ -1272,7 +1277,7 @@ uint S_RawSamplesStereo( portable_samplepair_t *rawsamples, uint rawend, uint ma
 		{
 			for( src = 0; src < samples; samplefrac += fracstep, src = ( samplefrac >> S_RAW_SAMPLES_PRECISION_BITS ))
 			{
-				dst = rawend++ & ( max_samples - 1 );
+				uint dst = rawend++ & ( max_samples - 1 );
 				rawsamples[dst].left = ( data[src] - 128 ) << 8;
 				rawsamples[dst].right = ( data[src] - 128 ) << 8;
 			}
@@ -1312,9 +1317,7 @@ Free raw channel that have been idling for too long.
 */
 static void S_FreeIdleRawChannels( void )
 {
-	int	i;
-
-	for( i = 0; i < snd.max_raw_channels; i++ )
+	for( int i = 0; i < snd.max_raw_channels; i++ )
 	{
 		rawchan_t *ch = snd.raw_channels[i];
 
@@ -1347,9 +1350,7 @@ S_ClearRawChannels
 */
 static void S_ClearRawChannels( void )
 {
-	int	i;
-
-	for( i = 0; i < snd.max_raw_channels; i++ )
+	for( int i = 0; i < snd.max_raw_channels; i++ )
 	{
 		rawchan_t *ch = snd.raw_channels[i];
 
@@ -1467,12 +1468,10 @@ S_StopAllSounds
 */
 void S_StopAllSounds( qboolean ambient )
 {
-	int	i;
-
 	if( !snd.initialized ) return;
 	snd.total_channels = MAX_DYNAMIC_CHANNELS;	// no statics
 
-	for( i = 0; i < snd.max_channels; i++ )
+	for( int i = 0; i < snd.max_channels; i++ )
 	{
 		if( !snd.channels[i].sfx )
 			continue;
@@ -1506,14 +1505,13 @@ update global soundtime
 static int S_GetSoundtime( void )
 {
 	static int buffers, oldsamplepos;
-	int samplepos, fullsamples;
 
-	fullsamples = snd.samples / 2;
+	int fullsamples = snd.samples / 2;
 
 	// it is possible to miscount buffers
 	// if it has wrapped twice between
 	// calls to S_Update.  Oh well.
-	samplepos = snd.samplepos;
+	int samplepos = snd.samplepos;
 
 	if( samplepos < oldsamplepos )
 	{
@@ -1779,13 +1777,12 @@ static void S_Music_f( void )
 	{
 		string	intro, main, track;
 		const char	*ext[] = { "mp3", "wav" };
-		int	i;
 
 		Q_strncpy( track, Cmd_Argv( 1 ), sizeof( track ));
 		Q_snprintf( intro, sizeof( intro ), "%s_intro", Cmd_Argv( 1 ));
 		Q_snprintf( main, sizeof( main ), "%s_main", Cmd_Argv( 1 ));
 
-		for( i = 0; i < 2; i++ )
+		for( int i = 0; i < 2; i++ )
 		{
 			char intro_path[MAX_VA_STRING];
 			char main_path[MAX_VA_STRING];
@@ -1863,8 +1860,8 @@ static void S_SoundFade_f( void )
 	int c = Cmd_Argc();
 	int fade_percent;
 	int hold_time;
-	int fade_out_seconds;
-	int fade_in_seconds;
+	int fade_out_seconds = 0;
+	int fade_in_seconds = 0;
 
 	if( c != 3 && c != 5 )
 	{

engine/client/sound/s_mix.c

@@ -71,6 +71,39 @@ static portable_samplepair_t roombuffer[(PAINTBUFFER_SIZE+1)], paintbuffer[(PAIN
 		} \
 	} \
 
+#define S_MakeMixMonoLerp( x ) \
+	static void S_MixMonoLerp ## x( portable_samplepair_t *pbuf, const int *volume, const void *buf, double offset_frac, double rate_scale, int num_samples ) \
+	{ \
+		const int##x##_t *data = buf; \
+		uint sample_idx = 0; \
+		for( int i = 0; i < num_samples; i++ ) \
+		{ \
+			int s = (int)( data[sample_idx] * ( 1.0 - offset_frac ) + data[sample_idx + 1] * offset_frac ); \
+			pbuf[i].left  += ( s * volume[0] ) >> ( x - 8 ); \
+			pbuf[i].right += ( s * volume[1] ) >> ( x - 8 ); \
+			offset_frac += rate_scale; \
+			sample_idx += (uint)offset_frac; \
+			offset_frac -= (uint)offset_frac; \
+		} \
+	} \
+
+#define S_MakeMixStereoLerp( x ) \
+	static void S_MixStereoLerp ## x( portable_samplepair_t *pbuf, const int *volume, const void *buf, double offset_frac, double rate_scale, int num_samples ) \
+	{ \
+		const int##x##_t *data = buf; \
+		uint sample_idx = 0; \
+		for( int i = 0; i < num_samples; i++ ) \
+		{ \
+			int sl = (int)( data[sample_idx + 0] * ( 1.0 - offset_frac ) + data[sample_idx + 2] * offset_frac ); \
+			int sr = (int)( data[sample_idx + 1] * ( 1.0 - offset_frac ) + data[sample_idx + 3] * offset_frac ); \
+			pbuf[i].left  += ( sl * volume[0] ) >> ( x - 8 ); \
+			pbuf[i].right += ( sr * volume[1] ) >> ( x - 8 ); \
+			offset_frac += rate_scale; \
+			sample_idx += (uint)offset_frac << 1; \
+			offset_frac -= (uint)offset_frac; \
+		} \
+	} \
+
 S_MakeMixMono( 8 )
 S_MakeMixMono( 16 )
 S_MakeMixStereo( 8 )
@@ -79,10 +112,14 @@ S_MakeMixMonoPitch( 8 )
 S_MakeMixMonoPitch( 16 )
 S_MakeMixStereoPitch( 8 )
 S_MakeMixStereoPitch( 16 )
+S_MakeMixMonoLerp( 8 )
+S_MakeMixMonoLerp( 16 )
+S_MakeMixStereoLerp( 8 )
+S_MakeMixStereoLerp( 16 )
 
-static void S_MixAudio( portable_samplepair_t *pbuf, const int *pvol, const void *buf, int channels, int width, double offset_frac, double rate_scale, int num_samples )
+static void S_MixAudio( portable_samplepair_t *pbuf, const int *pvol, const void *buf, int channels, int width, double offset_frac, double rate_scale, int num_samples, qboolean lerp )
 {
-	if( Q_equal( rate_scale, 1.0 ))
+	if( Q_equal( rate_scale, 1.0 ) && Q_equal( offset_frac, 0.0 ))
 	{
 		if( channels == 1 )
 		{
@@ -99,6 +136,23 @@ static void S_MixAudio( portable_samplepair_t *pbuf, const int *pvol, const void
 				S_MixStereo16( pbuf, pvol, buf, num_samples );
 		}
 	}
+	else if( lerp )
+	{
+		if( channels == 1 )
+		{
+			if( width == 1 )
+				S_MixMonoLerp8( pbuf, pvol, buf, offset_frac, rate_scale, num_samples );
+			else
+				S_MixMonoLerp16( pbuf, pvol, buf, offset_frac, rate_scale, num_samples );
+		}
+		else
+		{
+			if( width == 1 )
+				S_MixStereoLerp8( pbuf, pvol, buf, offset_frac, rate_scale, num_samples );
+			else
+				S_MixStereoLerp16( pbuf, pvol, buf, offset_frac, rate_scale, num_samples );
+		}
+	}
 	else
 	{
 		if( channels == 1 )
@@ -163,13 +217,16 @@ static int S_MixChannelToBuffer( portable_samplepair_t *pbuf, channel_t *chan, i
 	if( num_samples == 0 )
 		return 0;
 
+	// linear interpolation needs one sample of lookahead beyond the last read position
+	const int lookahead = s_lerping.value ? 1 : 0;
+
 	while( num_samples > 0 )
 	{
 		// calculate the last sample position
 		double end_sample = chan->sample + rate * num_samples * timecompress_rate;
 
-		// and get total amount of samples we want
-		int	request_num_samples = (int)(ceil( end_sample ) - floor( chan->sample ));
+		// and get total amount of samples we want, including lookahead for interpolation
+		int request_num_samples = (int)(ceil( end_sample ) - floor( chan->sample )) + lookahead;
 
 		// get sample pointer and also amount of samples available
 		const void *audio = NULL;
@@ -181,13 +238,30 @@ static int S_MixChannelToBuffer( portable_samplepair_t *pbuf, channel_t *chan, i
 
 		double sample_frac = chan->sample - floor( chan->sample );
 
+		// can interpolate only when at least two source samples are available
+		qboolean lerp = lookahead && available >= 2;
+
 		// this is how much data we output
 		int out_count = num_samples;
-		if( request_num_samples > available ) // but we can't write more than we have
-			out_count = (int)ceil(( available - sample_frac ) / ( rate ));
+		if( request_num_samples > available )
+		{
+			// lerp needs sample_idx + 1 to stay within available, so cap by available - 1
+			if( lerp )
+				out_count = (int)floor(( available - 1 - sample_frac ) / rate );
+			else
+				out_count = (int)ceil(( available - sample_frac ) / rate );
+		}
+
+		// near a buffer boundary (e.g. just before a loop wrap) lerp may yield zero;
+		// fall back to nearest for one sample to keep chan->sample advancing
+		if( out_count <= 0 )
+		{
+			lerp = false;
+			out_count = 1;
+		}
 
 		const wavdata_t *wav = chan->sfx->cache;
-		S_MixAudio( pbuf + offset, pvol, audio, wav->channels, wav->width, sample_frac, rate, out_count );
+		S_MixAudio( pbuf + offset, pvol, audio, wav->channels, wav->width, sample_frac, rate, out_count, lerp );
 
 		chan->sample += out_count * rate * timecompress_rate;
 		offset += out_count;
@@ -231,11 +305,12 @@ static int VOX_MixChannelToBuffer( portable_samplepair_t *pbuf, channel_t *chan,
 	return offset;
 }
 
-static int S_MixNormalChannels( portable_samplepair_t *dst, int end, int rate )
+static int S_MixNormalChannelsToRoombuffer( portable_samplepair_t *dst, int end )
 {
 	const qboolean sp = Host_IsSinglePlayerGame();
 	const qboolean ingame = CL_IsInGame();
-	const int num_samples = ( end - snd.paintedtime ) / ( SOUND_DMA_SPEED / rate );
+	const int out_rate = snd.format.speed;
+	const int num_samples = end - snd.paintedtime;
 
 	// FWGS feature: make everybody sound like chipmunks when we're going fast
 	const float pitch_mult = ( sys_timescale.value + 1 ) / 2;
@@ -284,7 +359,7 @@ static int S_MixNormalChannels( portable_samplepair_t *dst, int end, int rate )
 		// if the sound is unaudible, skip it
 		// if it's also not looping, free it
 		if( ch->leftvol < 8 && ch->rightvol < 8 )
-		{	
+		{
 			if( !FBitSet( sc->flags, SOUND_LOOPED ) || !FBitSet( ch->flags, FL_CHAN_USE_LOOP ))
 			{
 				if( ch->inauduble_free_time == 0.0f )
@@ -298,19 +373,18 @@ static int S_MixNormalChannels( portable_samplepair_t *dst, int end, int rate )
 
 		ch->inauduble_free_time = 0.0f;
 
-		if( rate != sc->rate )
-			continue;
-
 		if( ch->entchannel == CHAN_VOICE || ch->entchannel == CHAN_STREAM )
 		{
 			cl_entity_t *ent = CL_GetEntityByIndex( ch->entnum );
 
 			if( ent != NULL )
 			{
+				int mouth_count = (int)( num_samples * (double)sc->rate / out_rate );
+
 				if( sc->width == 1 )
-					SND_MoveMouth8( &ent->mouth, ch->sample, sc, num_samples, FBitSet( ch->flags, FL_CHAN_USE_LOOP ));
+					SND_MoveMouth8( &ent->mouth, ch->sample, sc, mouth_count, FBitSet( ch->flags, FL_CHAN_USE_LOOP ));
 				else
-					SND_MoveMouth16( &ent->mouth, ch->sample, sc, num_samples, FBitSet( ch->flags, FL_CHAN_USE_LOOP ));
+					SND_MoveMouth16( &ent->mouth, ch->sample, sc, mouth_count, FBitSet( ch->flags, FL_CHAN_USE_LOOP ));
 			}
 		}
 
@@ -320,14 +394,14 @@ static int S_MixNormalChannels( portable_samplepair_t *dst, int end, int rate )
 
 		if( ch->words )
 		{
-			VOX_MixChannelToBuffer( dst, ch, num_samples, rate, pitch );
+			VOX_MixChannelToBuffer( dst, ch, num_samples, out_rate, pitch );
 
 			if( FBitSet( ch->flags, FL_CHAN_SENTENCE_FINISHED ))
 				S_FreeChannel( ch );
 		}
 		else
 		{
-			S_MixChannelToBuffer( dst, ch, num_samples, rate, pitch, 0, 0 );
+			S_MixChannelToBuffer( dst, ch, num_samples, out_rate, pitch, 0, 0 );
 
 			if( FBitSet( ch->flags, FL_CHAN_FINISHED ))
 				S_FreeChannel( ch );
@@ -337,63 +411,6 @@ static int S_MixNormalChannels( portable_samplepair_t *dst, int end, int rate )
 	return num_mixed_channels;
 }
 
-static int S_AverageSample( int a, int b )
-{
-	return ( a >> 1 ) + ( b >> 1 ) + ((( a & 1 ) + ( b & 1 )) >> 1 );
-}
-
-static void S_UpsampleBuffer( portable_samplepair_t *dst, size_t num_samples )
-{
-	if( s_lerping.value )
-	{
-		// copy even positions and average odd
-		for( size_t i = num_samples - 1; i > 0; i-- )
-		{
-			dst[i * 2] = dst[i];
-
-			dst[i * 2 + 1].left = S_AverageSample( dst[i].left, dst[i - 1].left );
-			dst[i * 2 + 1].right = S_AverageSample( dst[i].right, dst[i - 1].right );
-		}
-	}
-	else
-	{
-		// copy into even and odd positions
-		for( size_t i = num_samples - 1; i > 0; i-- )
-		{
-			dst[i * 2] = dst[i];
-			dst[i * 2 + 1] = dst[i];
-		}
-	}
-
-	dst[1] = dst[0];
-}
-
-static int S_MixNormalChannelsToRoombuffer( int end, int count )
-{
-	// for room buffer we only support CD rates like 11k, 22k, and 44k
-	// TODO: 48k output would require support from platform-specific backends first
-	// until there is no real usecase, let's keep it simple
-	int num_mixed_channels = S_MixNormalChannels( roombuffer, end, SOUND_11k );
-
-	if( snd.format.speed >= SOUND_22k )
-	{
-		if( num_mixed_channels > 0 )
-			S_UpsampleBuffer( roombuffer, count / ( SOUND_22k / SOUND_11k ));
-
-		num_mixed_channels += S_MixNormalChannels( roombuffer, end, SOUND_22k );
-	}
-
-	if( snd.format.speed >= SOUND_44k )
-	{
-		if( num_mixed_channels > 0 )
-			S_UpsampleBuffer( roombuffer, count / ( SOUND_44k / SOUND_22k ));
-
-		num_mixed_channels += S_MixNormalChannels( roombuffer, end, SOUND_44k );
-	}
-
-	return num_mixed_channels;
-}
-
 static int S_MixRawChannels( int end )
 {
 	int num_room_channels = 0;
@@ -537,7 +554,7 @@ void S_PaintChannels( int endtime )
 
 		S_ClearBuffers( num_samples );
 
-		int room_channels = S_MixNormalChannelsToRoombuffer( end, num_samples );
+		int room_channels = S_MixNormalChannelsToRoombuffer( roombuffer, end );
 
 		room_channels += S_MixRawChannels( end );
 

engine/client/sound/s_mouth.c

@@ -36,20 +36,17 @@ static void SND_CommitMouthValue( mouth_t *mouth, int savg, int scount )
 void SND_MoveMouth8( mouth_t *mouth, int pos, const wavdata_t *sc, int count, qboolean use_loop )
 {
 	const int8_t *pdata = NULL;
-	int		scount;
-	int		savg, data;
-	uint 		i;
 
 	count = S_RetrieveAudioSamples( sc, (const void **)&pdata, pos, count, use_loop );
 	if( pdata == NULL ) return;
 
-	i = 0;
-	scount = mouth->sndcount;
-	savg = 0;
+	uint i = 0;
+	int scount = mouth->sndcount;
+	int savg = 0;
 
 	while( i < count && scount < CAVGSAMPLES )
 	{
-		data = pdata[i];
+		int data = pdata[i];
 		savg += abs( data );
 
 		i += 80 + ((byte)data & 0x1F);
@@ -62,20 +59,17 @@ void SND_MoveMouth8( mouth_t *mouth, int pos, const wavdata_t *sc, int count, qb
 void SND_MoveMouth16( mouth_t *mouth, int pos, const wavdata_t *sc, int count, qboolean use_loop )
 {
 	const int16_t *pdata = NULL;
-	int		savg, data;
-	int		scount;
-	uint 		i;
 
 	count = S_RetrieveAudioSamples( sc, (const void **)&pdata, pos, count, use_loop );
 	if( pdata == NULL ) return;
 
-	i = 0;
-	scount = mouth->sndcount;
-	savg = 0;
+	uint i = 0;
+	int scount = mouth->sndcount;
+	int savg = 0;
 
 	while( i < count && scount < CAVGSAMPLES )
 	{
-		data = pdata[i];
+		int data = pdata[i];
 		data = (bound( -32767, data, 0x7ffe ) >> 8);
 		savg += abs( data );
 
@@ -88,9 +82,7 @@ void SND_MoveMouth16( mouth_t *mouth, int pos, const wavdata_t *sc, int count, q
 
 void SND_ForceInitMouth( int entnum )
 {
-	cl_entity_t *clientEntity;
-
-	clientEntity = CL_GetEntityByIndex( entnum );
+	cl_entity_t *clientEntity = CL_GetEntityByIndex( entnum );
 
 	if( clientEntity )
 	{
@@ -102,9 +94,7 @@ void SND_ForceInitMouth( int entnum )
 
 void SND_ForceCloseMouth( int entnum )
 {
-	cl_entity_t *clientEntity;
-
-	clientEntity = CL_GetEntityByIndex( entnum );
+	cl_entity_t *clientEntity = CL_GetEntityByIndex( entnum );
 
 	if( clientEntity )
 		clientEntity->mouth.mouthopen = 0;
@@ -112,17 +102,13 @@ void SND_ForceCloseMouth( int entnum )
 
 void SND_MoveMouthRaw( mouth_t *mouth, const portable_samplepair_t *buf, int count )
 {
-	int		savg, data;
-	int		scount = 0;
-	uint 		i;
-
-	i = 0;
-	scount = mouth->sndcount;
-	savg = 0;
+	uint i = 0;
+	int scount = mouth->sndcount;
+	int savg = 0;
 
 	while ( i < count && scount < CAVGSAMPLES )
 	{
-		data = buf[i].left; // mono sound anyway
+		int data = buf[i].left; // mono sound anyway
 		data = ( bound( -32767, data, 0x7ffe ) >> 8 );
 		savg += abs( data );
 

engine/client/sound/s_stream.c

@@ -66,14 +66,14 @@ S_GetMusicVolume
 */
 float S_GetMusicVolume( void )
 {
-	float	scale = 1.0f;
-
 	if( host.status == HOST_NOFOCUS && snd_mute_losefocus.value != 0.0f )
 	{
 		// we return zero volume to keep sounds running
 		return 0.0f;
 	}
 
+	float scale = 1.0f;
+
 	if( cls.key_dest != key_menu && musicfade.percent != 0 )
 	{
 		scale = bound( 0.0f, musicfade.percent / 100.0f, 1.0f );
@@ -191,11 +191,7 @@ S_StreamBackgroundTrack
 */
 void S_StreamBackgroundTrack( void )
 {
-	int	bufferSamples;
-	int	fileSamples;
 	byte	raw[MAX_RAW_SAMPLES];
-	int	r, fileBytes;
-	rawchan_t	*ch = NULL;
 
 	if( !snd.initialized || !s_bgTrack.stream || snd.streaming )
 		return;
@@ -213,7 +209,7 @@ void S_StreamBackgroundTrack( void )
 	else if( cls.key_dest == key_console )
 		return;
 
-	ch = S_FindRawChannel( S_RAW_SOUND_BACKGROUNDTRACK, true );
+	rawchan_t *ch = S_FindRawChannel( S_RAW_SOUND_BACKGROUNDTRACK, true );
 
 	Assert( ch != NULL );
 
@@ -225,14 +221,14 @@ void S_StreamBackgroundTrack( void )
 	{
 		const stream_t *info = s_bgTrack.stream;
 
-		bufferSamples = ch->max_samples - (ch->s_rawend - snd.soundtime);
+		int bufferSamples = ch->max_samples - (ch->s_rawend - snd.soundtime);
 
 		// decide how much data needs to be read from the file
-		fileSamples = bufferSamples * ((float)info->rate / SOUND_DMA_SPEED );
+		int fileSamples = bufferSamples * ((float)info->rate / SOUND_DMA_SPEED );
 		if( fileSamples <= 1 ) return; // no more samples need
 
 		// our max buffer size
-		fileBytes = fileSamples * ( info->width * info->channels );
+		int fileBytes = fileSamples * ( info->width * info->channels );
 
 		if( fileBytes > sizeof( raw ))
 		{
@@ -241,7 +237,7 @@ void S_StreamBackgroundTrack( void )
 		}
 
 		// read
-		r = FS_ReadStream( s_bgTrack.stream, fileBytes, raw );
+		int r = FS_ReadStream( s_bgTrack.stream, fileBytes, raw );
 
 		if( r < fileBytes )
 		{

engine/client/sound/s_vox.c

@@ -52,7 +52,7 @@ static qboolean S_ShouldTrimSample16( const int16_t *buf, int channels )
 
 static int S_TrimStart( const wavdata_t *wav, int start )
 {
-	size_t channels = wav->channels, width = wav->width, i;
+	size_t channels = wav->channels, width = wav->width;
 
 	if( wav->type != WF_PCMDATA )
 		return start;
@@ -61,7 +61,7 @@ static int S_TrimStart( const wavdata_t *wav, int start )
 	{
 		const int8_t *data = (const int8_t *)&wav->buffer[channels * width * start];
 
-		for( i = 0; i < TRIM_SCAN_MAX && start < wav->samples; i++ )
+		for( size_t i = 0; i < TRIM_SCAN_MAX && start < wav->samples; i++ )
 		{
 			if( !S_ShouldTrimSample8( data, wav->channels ))
 				break;
@@ -74,7 +74,7 @@ static int S_TrimStart( const wavdata_t *wav, int start )
 	{
 		const int16_t *data = (const int16_t *)&wav->buffer[channels * width * start];
 
-		for( i = 0; i < TRIM_SCAN_MAX && start < wav->samples; i++ )
+		for( size_t i = 0; i < TRIM_SCAN_MAX && start < wav->samples; i++ )
 		{
 			if( !S_ShouldTrimSample16( data, wav->channels ))
 				break;
@@ -89,7 +89,7 @@ static int S_TrimStart( const wavdata_t *wav, int start )
 
 static int S_TrimEnd( const wavdata_t *wav, int end )
 {
-	size_t channels = wav->channels, width = wav->width, i;
+	size_t channels = wav->channels, width = wav->width;
 
 	if( wav->type != WF_PCMDATA )
 		return end;
@@ -98,7 +98,7 @@ static int S_TrimEnd( const wavdata_t *wav, int end )
 	{
 		const int8_t *data = (const int8_t *)&wav->buffer[channels * width * ( end - 1 )];
 
-		for( i = 0; i < TRIM_SCAN_MAX && end > 0; i++ )
+		for( size_t i = 0; i < TRIM_SCAN_MAX && end > 0; i++ )
 		{
 			if( !S_ShouldTrimSample8( data, wav->channels ))
 				break;
@@ -111,7 +111,7 @@ static int S_TrimEnd( const wavdata_t *wav, int end )
 	{
 		const int16_t *data = (const int16_t *)&wav->buffer[channels * width * ( end - 1 )];
 
-		for( i = 0; i < TRIM_SCAN_MAX && end > 0; i++ )
+		for( size_t i = 0; i < TRIM_SCAN_MAX && end > 0; i++ )
 		{
 			if( !S_ShouldTrimSample16( data, wav->channels ))
 				break;
@@ -222,9 +222,6 @@ float VOX_ModifyPitch( channel_t *ch, float pitch )
 
 static const char *VOX_GetDirectory( char *szpath, const char *psz, int nsize )
 {
-	const char *p;
-	int len;
-
 	// HACKHACK: some modders send strings like "/fvox/_period four"
 	// which should get parsed as "_period four" said by fvox
 	// it might be incorrect but ignore first slash here for now
@@ -232,7 +229,7 @@ static const char *VOX_GetDirectory( char *szpath, const char *psz, int nsize )
 		psz++;
 
 	// search / backwards
-	p = Q_strrchr( psz, '/' );
+	const char *p = Q_strrchr( psz, '/' );
 
 	if( !p )
 	{
@@ -240,7 +237,7 @@ static const char *VOX_GetDirectory( char *szpath, const char *psz, int nsize )
 		return psz;
 	}
 
-	len = p - psz + 1;
+	int len = p - psz + 1;
 
 	if( len > nsize )
 	{
@@ -256,8 +253,7 @@ static const char *VOX_GetDirectory( char *szpath, const char *psz, int nsize )
 
 static const char *VOX_LookupString( const char *pszin )
 {
-	int i = -1, len;
-	const char *c;
+	int i = -1;
 
 	// check if we are an immediate sentence
 	if( *pszin == '#' )
@@ -289,9 +285,9 @@ static const char *VOX_LookupString( const char *pszin )
 	if( i == cszrawsentences )
 		return NULL;
 
-	len = Q_strlen( rgpszrawsentence[i] );
+	int len = Q_strlen( rgpszrawsentence[i] );
 
-	c = &rgpszrawsentence[i][len + 1];
+	const char *c = &rgpszrawsentence[i][len + 1];
 	for( ; *c == ' ' || *c == '\t'; c++ );
 
 	return c;
@@ -362,12 +358,11 @@ static void VOX_MakeDefaultWordParams( voxword_t *voxword )
 
 static qboolean VOX_ParseWordParams( char *psz, voxword_t *pvoxword, voxword_t *default_voxword )
 {
-	int len, i;
 	char sznum[8], *pszsave = psz;
 
 	*pvoxword = *default_voxword;
 
-	len = Q_strlen( psz );
+	int len = Q_strlen( psz );
 
 	if( len == 0 )
 		return false;
@@ -388,6 +383,7 @@ static qboolean VOX_ParseWordParams( char *psz, voxword_t *pvoxword, voxword_t *
 	for( ;; )
 	{
 		char command;
+		int i;
 
 		// find command
 		for( ; *psz &&
@@ -446,7 +442,7 @@ void VOX_LoadSound( channel_t *ch, const char *pszin )
 	char buffer[512] = { 0 }, szpath[32] = { 0 };
 	char *rgpparseword[CVOXWORDMAX] = { 0 };
 	const char *psz;
-	int i, j;
+	int j;
 	int num_words;
 	voxword_t default_voxword;
 	voxword_t words_buf[CVOXWORDMAX + 1]; // local scratch: parsed words + null terminator
@@ -490,7 +486,8 @@ void VOX_LoadSound( channel_t *ch, const char *pszin )
 	VOX_MakeDefaultWordParams( &default_voxword );
 	memset( words_buf, 0, sizeof( words_buf ));
 
-	for( i = 0, j = 0; i < num_words; i++ )
+	j = 0;
+	for( int i = 0; i < num_words; i++ )
 	{
 		char pathbuffer[MAX_SYSPATH];
 
@@ -589,9 +586,7 @@ void VOX_Init( void )
 
 void VOX_Shutdown( void )
 {
-	int i;
-
-	for( i = 0; i < cszrawsentences; i++ )
+	for( int i = 0; i < cszrawsentences; i++ )
 		Mem_Free( rgpszrawsentence[i] );
 
 	cszrawsentences = 0;
@@ -609,9 +604,8 @@ static void Test_VOX_GetDirectory( void )
 		"barney/meow", "meow", "barney/",
 		"/fvox/_period", "_period", "fvox/",
 	};
-	int i;
 
-	for( i = 0; i < sizeof( data ) / sizeof( data[0] ); i += 3 )
+	for( int i = 0; i < sizeof( data ) / sizeof( data[0] ); i += 3 )
 	{
 		string szpath;
 		const char *p = VOX_GetDirectory( szpath, data[i+0], sizeof( szpath ));
@@ -623,7 +617,6 @@ static void Test_VOX_GetDirectory( void )
 
 static void Test_VOX_LookupString( void )
 {
-	int i;
 	const char *p, *data[] =
 	{
 		"0", "123",
@@ -645,7 +638,7 @@ static void Test_VOX_LookupString( void )
 	rgpszrawsentence[cszrawsentences++] = (char*)"SentenceWithSpaces\0  SPAAACE";
 	rgpszrawsentence[cszrawsentences++] = (char*)"SentenceWithTabsAndSpaces\0\t \t\t MEOW";
 
-	for( i = 0; i < sizeof( data ) / sizeof( data[0] ); i += 2 )
+	for( int i = 0; i < sizeof( data ) / sizeof( data[0] ); i += 2 )
 	{
 		p = VOX_LookupString( data[i] );
 

engine/client/sound/voice.c

@@ -381,18 +381,17 @@ Apply automatic gain control to voice samples
 */
 static void Voice_ApplyGainAdjust( int16_t *samples, int count, float scale )
 {
-	float gain, modifiedMax;
-	int   average, blockOffset = 0;
+	int   blockOffset = 0;
 
 	for( ;; )
 	{
-		int i, localMax = 0, localSum = 0;
+		int localMax = 0, localSum = 0;
 		int blockSize = Q_min( count - blockOffset, voice.autogain.block_size );
 
 		if( blockSize < 1 )
 			break;
 
-		for( i = 0; i < blockSize; ++i )
+		for( int i = 0; i < blockSize; ++i )
 		{
 			int sample = samples[blockOffset + i];
 			int absSample = abs( sample );
@@ -401,14 +400,14 @@ static void Voice_ApplyGainAdjust( int16_t *samples, int count, float scale )
 				localMax = absSample;
 
 			localSum += absSample;
-			gain = voice.autogain.current_gain + i * voice.autogain.gain_multiplier;
+			float gain = voice.autogain.current_gain + i * voice.autogain.gain_multiplier;
 			samples[blockOffset + i] = bound( SHRT_MIN, (int)( sample * gain ), SHRT_MAX );
 		}
 
 		if( blockOffset % voice.autogain.block_size == 0 )
 		{
-			average = localSum / blockSize;
-			modifiedMax = average + ( localMax - average ) * voice_avggain.value;
+			int average = localSum / blockSize;
+			float modifiedMax = average + ( localMax - average ) * voice_avggain.value;
 
 			voice.autogain.current_gain = voice.autogain.next_gain * scale;
 			voice.autogain.next_gain = Q_min((float)SHRT_MAX / ( modifiedMax > 1 ? modifiedMax : 1 ), voice_maxgain.value ) * scale;
@@ -435,13 +434,11 @@ static uint Voice_GetOpusCompressedData( byte *out, uint maxsize, uint *frames )
 
 	if( voice.input_file )
 	{
-		uint   numbytes;
-		double updateInterval, curtime = Platform_DoubleTime();
-
-		updateInterval = curtime - voice.start_time;
+		double curtime = Platform_DoubleTime();
+		double updateInterval = curtime - voice.start_time;
 		voice.start_time = curtime;
 
-		numbytes = updateInterval * voice.samplerate * voice.width * VOICE_PCM_CHANNELS;
+		uint numbytes = updateInterval * voice.samplerate * voice.width * VOICE_PCM_CHANNELS;
 		numbytes = Q_min( numbytes, voice.input_file->size - voice.input_file_pos );
 		numbytes = Q_min( numbytes, sizeof( voice.input_buffer ) - voice.input_buffer_pos );
 
@@ -510,13 +507,11 @@ static uint Voice_GetGSCompressedData( byte *out, uint maxsize, uint *frames )
 
 	if( voice.input_file )
 	{
-		uint   numbytes;
-		double updateInterval, curtime = Platform_DoubleTime();
-
-		updateInterval = curtime - voice.start_time;
+		double curtime = Platform_DoubleTime();
+		double updateInterval = curtime - voice.start_time;
 		voice.start_time = curtime;
 
-		numbytes = updateInterval * voice.samplerate * voice.width * VOICE_PCM_CHANNELS;
+		uint numbytes = updateInterval * voice.samplerate * voice.width * VOICE_PCM_CHANNELS;
 		numbytes = Q_min( numbytes, voice.input_file->size - voice.input_file_pos );
 		numbytes = Q_min( numbytes, sizeof( voice.input_buffer ) - voice.input_buffer_pos );
 
@@ -597,24 +592,15 @@ Process GoldSrc voice data and return number of samples
 */
 static int Voice_ProcessGSData( int ent, const uint8_t *data, uint32_t size )
 {
-	uint32_t    crc_in_packet;
-	uint32_t    crc;
-	size_t      offset;
 	size_t      samples;
-	uint16_t    sample_rate;
 	uint8_t     vpc_type;
 	uint16_t    data_len;
-	OpusDecoder *decoder;
-	size_t      opus_offset;
-	int decoded;
-	size_t      silence_samples;
-	uint16_t    frame_size;
 
 	if( !data || ent <= 0 || ent > cl.maxclients )
 		return 0;
 
-	crc_in_packet = LittleLong( *(uint32_t *)( data + size - sizeof( uint32_t )));
-	crc = CRC32_INIT_VALUE;
+	uint32_t crc_in_packet = LittleLong( *(uint32_t *)( data + size - sizeof( uint32_t )));
+	uint32_t crc = CRC32_INIT_VALUE;
 	CRC32_ProcessBuffer( &crc, data, size - sizeof( uint32_t ));
 	crc = CRC32_Final( crc );
 
@@ -624,7 +610,7 @@ static int Voice_ProcessGSData( int ent, const uint8_t *data, uint32_t size )
 		return 0;
 	}
 
-	offset = sizeof( uint64_t );
+	size_t offset = sizeof( uint64_t );
 	samples = 0;
 
 	if( offset >= size - sizeof( uint32_t ) || data[offset] != GS_VPC_SETSAMPLERATE )
@@ -637,7 +623,6 @@ static int Voice_ProcessGSData( int ent, const uint8_t *data, uint32_t size )
 	if( offset + sizeof( uint32_t ) > size - sizeof( uint32_t ))
 		return 0;
 
-	sample_rate = LittleShort( *(uint16_t *)( data + offset ));
 	offset += sizeof( uint16_t );
 
 	vpc_type = data[offset++];
@@ -646,7 +631,9 @@ static int Voice_ProcessGSData( int ent, const uint8_t *data, uint32_t size )
 
 	if( vpc_type == GS_VPC_VDATA_OPUS_PLC )
 	{
-		decoder = voice.gs_decoders[ent - 1];
+		OpusDecoder *decoder = voice.gs_decoders[ent - 1];
+		size_t opus_offset;
+
 		if( !decoder )
 		{
 			Con_Printf( S_WARN "No decoder available for entity %d\n", ent );
@@ -655,7 +642,7 @@ static int Voice_ProcessGSData( int ent, const uint8_t *data, uint32_t size )
 		opus_offset = 0;
 		while( opus_offset + sizeof( uint32_t ) <= data_len )
 		{
-			frame_size = LittleShort( *(uint16_t *)( data + offset + opus_offset ));
+			uint16_t frame_size = LittleShort( *(uint16_t *)( data + offset + opus_offset ));
 			opus_offset += sizeof( uint32_t );
 			// if frame size is 0, it means silence
 			if( frame_size == 0 )
@@ -679,7 +666,7 @@ static int Voice_ProcessGSData( int ent, const uint8_t *data, uint32_t size )
 				Con_Printf( S_WARN "Opus frame size exceeds data length\n" );
 				return 0;
 			}
-			decoded = opus_decode( decoder, data + offset + opus_offset, frame_size,
+			int decoded = opus_decode( decoder, data + offset + opus_offset, frame_size,
 					       ( (int16_t *)voice.decompress_buffer ) + samples, voice.frame_size, 0 );
 			if( decoded < 0 )
 			{
@@ -692,7 +679,7 @@ static int Voice_ProcessGSData( int ent, const uint8_t *data, uint32_t size )
 	}
 	else if( vpc_type == GS_VPC_VDATA_SILENCE )
 	{
-		silence_samples = data_len / 2;
+		size_t silence_samples = data_len / 2;
 		if( silence_samples > GS_MAX_DECOMPRESSED_SAMPLES )
 		{
 			Con_Printf( S_WARN "Silence data too large\n" );
@@ -908,8 +895,6 @@ stop recording and notify user dlls
 */
 void Voice_Disconnect( void )
 {
-	int i;
-
 	Voice_RecordStop();
 
 	if( voice.local.talking_ack )
@@ -918,7 +903,7 @@ void Voice_Disconnect( void )
 		voice.local.talking_ack = false;
 	}
 
-	for( i = 1; i <= MAX_CLIENTS; i++ )
+	for( int i = 1; i <= MAX_CLIENTS; i++ )
 		Voice_Status( i, false );
 
 	VoiceCapture_Shutdown();
@@ -987,7 +972,6 @@ void Voice_AddIncomingData( int ent, const byte *data, uint size, uint frames )
 	const int playernum = ent - 1;
 	int samples = 0;
 	int ofs = 0;
-	voice_status_t *status = NULL;
 
 	if( !voice.initialized || !voice_enable.value )
 		return;
@@ -1041,7 +1025,7 @@ Encode our voice data and send it to server
 void CL_AddVoiceToDatagram( void )
 {
 	byte buffer[VOICE_MAX_DATA_SIZE];
-	uint size, frames;
+	uint size, frames = 0;
 
 	if( cls.state != ca_active || !voice.device_opened || !Voice_IsRecording())
 		return;
@@ -1131,8 +1115,6 @@ Run timeout for clients
 */
 void Voice_Idle( double frametime )
 {
-	int i;
-
 	if( FBitSet( voice_enable.flags, FCVAR_CHANGED ))
 	{
 		ClearBits( voice_enable.flags, FCVAR_CHANGED );
@@ -1203,10 +1185,12 @@ qboolean Voice_Init( const char *pszCodecName, int quality, qboolean preinit )
 
 voice_audio_info_t Voice_GetAudioInfo( void )
 {
-	voice_audio_info_t info;
+	voice_audio_info_t info =
+	{
+		.width = voice.width,
+		.samplerate = voice.samplerate,
+		.frame_size = voice.frame_size,
+	};
 
-	info.width = voice.width;
-	info.samplerate = voice.samplerate;
-	info.frame_size = voice.frame_size;
 	return info;
 }

engine/client/soundlib/snd_main.c

@@ -59,7 +59,6 @@ wavdata_t *FS_LoadSound( const char *filename, const byte *buffer, size_t size )
 	const char *ext = COM_FileExtension( filename );
 	string loadname;
 	qboolean anyformat = true;
-	const loadwavfmt_t *format;
 
 	Sound_Reset(); // clear old sounddata
 	Q_strncpy( loadname, filename, sizeof( loadname ));
@@ -68,7 +67,7 @@ wavdata_t *FS_LoadSound( const char *filename, const byte *buffer, size_t size )
 	{
 		// we needs to compare file extension with list of supported formats
 		// and be sure what is real extension, not a filename with dot
-		for( format = sound.loadformats; format && format->ext; format++ )
+		for( const loadwavfmt_t *format = sound.loadformats; format && format->ext; format++ )
 		{
 			if( !Q_stricmp( format->ext, ext ))
 			{
@@ -84,18 +83,17 @@ wavdata_t *FS_LoadSound( const char *filename, const byte *buffer, size_t size )
 		goto load_internal;
 
 	// now try all the formats in the selected list
-	for( format = sound.loadformats; format && format->ext; format++)
+	for( const loadwavfmt_t *format = sound.loadformats; format && format->ext; format++)
 	{
 		if( anyformat || !Q_stricmp( ext, format->ext ))
 		{
 			qboolean success = false;
 			fs_offset_t filesize = 0;
-			byte *f;
 			string path;
 
 			Q_snprintf( path, sizeof( path ), DEFAULT_SOUNDPATH "%s.%s", loadname, format->ext );
 
-			f = FS_LoadFile( path, &filesize, false );
+			byte *f = FS_LoadFile( path, &filesize, false );
 			if( f && filesize > 0 )
 			{
 				success = format->loadfunc( path, f, filesize );
@@ -119,7 +117,7 @@ wavdata_t *FS_LoadSound( const char *filename, const byte *buffer, size_t size )
 	}
 
 load_internal:
-	for( format = sound.loadformats; format && format->ext; format++ )
+	for( const loadwavfmt_t *format = sound.loadformats; format && format->ext; format++ )
 	{
 		if( anyformat || !Q_stricmp( ext, format->ext ))
 		{
@@ -162,7 +160,6 @@ stream_t *FS_OpenStream( const char *filename )
 	const char	*ext = COM_FileExtension( filename );
 	string		loadname;
 	qboolean		anyformat = true;
-	const streamfmt_t	*format;
 	stream_t		*stream = NULL;
 
 	Sound_Reset(); // clear old streaminfo
@@ -172,7 +169,7 @@ stream_t *FS_OpenStream( const char *filename )
 	{
 		// we needs to compare file extension with list of supported formats
 		// and be sure what is real extension, not a filename with dot
-		for( format = sound.streamformat; format && format->ext; format++ )
+		for( const streamfmt_t *format = sound.streamformat; format && format->ext; format++ )
 		{
 			if( !Q_stricmp( format->ext, ext ))
 			{
@@ -184,7 +181,7 @@ stream_t *FS_OpenStream( const char *filename )
 	}
 
 	// now try all the formats in the selected list
-	for( format = sound.streamformat; format && format->ext; format++)
+	for( const streamfmt_t *format = sound.streamformat; format && format->ext; format++)
 	{
 		if( anyformat || !Q_stricmp( ext, format->ext ))
 		{
@@ -277,7 +274,7 @@ void FS_FreeStream( stream_t *stream )
 	stream->format->freefunc( stream );
 }
 
-#if XASH_ENGINE_TESTS
+#if XASH_LLVM_LIBFUZZER
 #define IMPLEMENT_SOUNDLIB_FUZZ_TARGET( export, target ) \
 int EXPORT export( const uint8_t *Data, size_t Size ); \
 int EXPORT export( const uint8_t *Data, size_t Size ) \
@@ -297,4 +294,4 @@ int EXPORT export( const uint8_t *Data, size_t Size ) \
 
 IMPLEMENT_SOUNDLIB_FUZZ_TARGET( Fuzz_Sound_LoadMPG, Sound_LoadMPG )
 IMPLEMENT_SOUNDLIB_FUZZ_TARGET( Fuzz_Sound_LoadWAV, Sound_LoadWAV )
-#endif
+#endif // XASH_LLVM_LIBFUZZER

engine/client/soundlib/snd_mp3.c

@@ -185,7 +185,7 @@ static qboolean Sound_ParseID3Tag( const byte *buffer, fs_offset_t filesize )
 	return true;
 }
 
-#if XASH_ENGINE_TESTS
+#if XASH_LLVM_LIBFUZZER
 int EXPORT Fuzz_Sound_ParseID3Tag( const uint8_t *Data, size_t Size );
 int EXPORT Fuzz_Sound_ParseID3Tag( const uint8_t *Data, size_t Size )
 {
@@ -193,7 +193,7 @@ int EXPORT Fuzz_Sound_ParseID3Tag( const uint8_t *Data, size_t Size )
 	Sound_ParseID3Tag( Data, Size );
 	return 0;
 }
-#endif
+#endif // XASH_LLVM_LIBFUZZER
 
 /*
 =================================================================
@@ -362,9 +362,7 @@ int Stream_ReadMPG( stream_t *stream, int needBytes, void *buffer )
 {
 	// buffer handling
 	int	bytesWritten = 0;
-	void	*mpg;
-
-	mpg = stream->ptr;
+	void	*mpg = stream->ptr;
 
 	while( 1 )
 	{

engine/client/soundlib/snd_ogg_opus.c

@@ -258,13 +258,12 @@ int Stream_ReadOggOpus( stream_t *stream, int needBytes, void *buffer )
 
 	while( 1 )
 	{
-		int  ret;
 		byte *data;
 		int  outsize;
 
 		if( !stream->buffsize )
 		{
-			ret = op_read( ctx->of, (opus_int16 *)stream->temp, OUTBUF_SIZE / stream->width, NULL );
+			int ret = op_read( ctx->of, (opus_int16 *)stream->temp, OUTBUF_SIZE / stream->width, NULL );
 			if( ret == 0 )
 				break; // end of file
 			else if( ret < 0 )
@@ -298,9 +297,9 @@ int Stream_ReadOggOpus( stream_t *stream, int needBytes, void *buffer )
 
 int Stream_SetPosOggOpus( stream_t *stream, int newpos )
 {
-	int ret;
 	opus_streaming_ctx_t *ctx = (opus_streaming_ctx_t *)stream->ptr;
-	if(( ret = op_raw_seek( ctx->of, newpos )) == 0 )
+	int ret = op_raw_seek( ctx->of, newpos );
+	if( ret == 0 )
 	{
 		stream->buffsize = 0; // flush any previous data
 		return true;

engine/client/soundlib/snd_ogg_vorbis.c

@@ -268,9 +268,9 @@ int Stream_ReadOggVorbis( stream_t *stream, int needBytes, void *buffer )
 
 int Stream_SetPosOggVorbis( stream_t *stream, int newpos )
 {
-	int ret;
 	vorbis_streaming_ctx_t *ctx = (vorbis_streaming_ctx_t *)stream->ptr;
-	if(( ret = ov_raw_seek_lap( &ctx->vf, newpos )) == 0 )
+	int ret = ov_raw_seek_lap( &ctx->vf, newpos );
+	if( ret == 0 )
 	{
 		stream->buffsize = 0; // flush any previous data
 		return true;