Refactoring and cleanup project.

Removed project bzip2.
CZero: Fix crashing of HostageEscapeState.
This commit is contained in:
s1lentq 2016-02-04 06:18:26 +06:00
parent 4e3e9351fe
commit 25f425801a
267 changed files with 10401 additions and 22768 deletions

View File

@ -4,16 +4,16 @@ import org.gradle.api.Project
import org.gradle.nativeplatform.NativeBinarySpec import org.gradle.nativeplatform.NativeBinarySpec
class CppUnitTestExtension { class CppUnitTestExtension {
Project _project Project _project
CppUnitTestExtension(Project p) { CppUnitTestExtension(Project p) {
_project = p _project = p
} }
void eachTestExecutable(Closure action) { void eachTestExecutable(Closure action) {
_project.binaries.each { NativeBinarySpec bin -> _project.binaries.each { NativeBinarySpec bin ->
if (!bin.hasProperty('cppUnitTestsExecutable')) return if (!bin.hasProperty('cppUnitTestsExecutable')) return
action(bin) action(bin)
} }
} }
} }

View File

@ -1,75 +0,0 @@
import org.doomedsociety.gradlecpp.cfg.ToolchainConfigUtils
import org.doomedsociety.gradlecpp.msvc.MsvcToolchainConfig
import org.doomedsociety.gradlecpp.toolchain.icc.Icc
import org.doomedsociety.gradlecpp.toolchain.icc.IccCompilerPlugin
import org.gradle.nativeplatform.NativeBinarySpec
import org.gradle.nativeplatform.NativeLibrarySpec
import org.gradle.nativeplatform.toolchain.VisualCpp
apply plugin: 'c'
apply plugin: IccCompilerPlugin
void setupToolchain(NativeBinarySpec b) {
def cfg = rootProject.createToolchainConfig(b)
if (cfg instanceof MsvcToolchainConfig) {
cfg.compilerOptions.pchConfig = new MsvcToolchainConfig.PrecompiledHeadersConfig(
enabled: true,
pchHeader: 'bzlib_private.h',
pchSourceSet: 'bz2_pch'
)
}
ToolchainConfigUtils.apply(project, cfg, b)
}
model {
buildTypes {
debug
release
}
platforms {
x86 {
architecture "x86"
}
}
toolChains {
visualCpp(VisualCpp) {
}
icc(Icc) {
}
}
components {
bzip2(NativeLibrarySpec) {
targetPlatform 'x86'
sources {
bz2_main(CSourceSet) {
source {
srcDir "src"
include "**/*.c"
exclude "precompiled.c"
}
exportedHeaders {
srcDir "include"
}
}
bz2_pch(CSourceSet) {
source {
srcDir "src"
include "precompiled.c"
}
exportedHeaders {
srcDir "include"
}
}
}
binaries.all { NativeBinarySpec b -> project.setupToolchain(b) }
}
}
}

View File

@ -1,282 +0,0 @@
/*-------------------------------------------------------------*/
/*--- Public header file for the library. ---*/
/*--- bzlib.h ---*/
/*-------------------------------------------------------------*/
/* ------------------------------------------------------------------
This file is part of bzip2/libbzip2, a program and library for
lossless, block-sorting data compression.
bzip2/libbzip2 version 1.0.6 of 6 September 2010
Copyright (C) 1996-2010 Julian Seward <jseward@bzip.org>
Please read the WARNING, DISCLAIMER and PATENTS sections in the
README file.
This program is released under the terms of the license contained
in the file LICENSE.
------------------------------------------------------------------ */
#ifndef _BZLIB_H
#define _BZLIB_H
#ifdef __cplusplus
extern "C" {
#endif
#define BZ_RUN 0
#define BZ_FLUSH 1
#define BZ_FINISH 2
#define BZ_OK 0
#define BZ_RUN_OK 1
#define BZ_FLUSH_OK 2
#define BZ_FINISH_OK 3
#define BZ_STREAM_END 4
#define BZ_SEQUENCE_ERROR (-1)
#define BZ_PARAM_ERROR (-2)
#define BZ_MEM_ERROR (-3)
#define BZ_DATA_ERROR (-4)
#define BZ_DATA_ERROR_MAGIC (-5)
#define BZ_IO_ERROR (-6)
#define BZ_UNEXPECTED_EOF (-7)
#define BZ_OUTBUFF_FULL (-8)
#define BZ_CONFIG_ERROR (-9)
typedef
struct {
char *next_in;
unsigned int avail_in;
unsigned int total_in_lo32;
unsigned int total_in_hi32;
char *next_out;
unsigned int avail_out;
unsigned int total_out_lo32;
unsigned int total_out_hi32;
void *state;
void *(*bzalloc)(void *,int,int);
void (*bzfree)(void *,void *);
void *opaque;
}
bz_stream;
#ifndef BZ_IMPORT
#define BZ_EXPORT
#endif
#ifndef BZ_NO_STDIO
/* Need a definitition for FILE */
#include <stdio.h>
#endif
#ifdef _WIN32
# include <windows.h>
# ifdef small
/* windows.h define small to char */
# undef small
# endif
# ifdef BZ_EXPORT
# define BZ_API(func) WINAPI func
# define BZ_EXTERN extern
# else
/* import windows dll dynamically */
# define BZ_API(func) (WINAPI * func)
# define BZ_EXTERN
# endif
#else
# define BZ_API(func) func
# define BZ_EXTERN extern
#endif
/*-- Core (low-level) library functions --*/
BZ_EXTERN int BZ_API(BZ2_bzCompressInit) (
bz_stream* strm,
int blockSize100k,
int verbosity,
int workFactor
);
BZ_EXTERN int BZ_API(BZ2_bzCompress) (
bz_stream* strm,
int action
);
BZ_EXTERN int BZ_API(BZ2_bzCompressEnd) (
bz_stream* strm
);
BZ_EXTERN int BZ_API(BZ2_bzDecompressInit) (
bz_stream *strm,
int verbosity,
int small
);
BZ_EXTERN int BZ_API(BZ2_bzDecompress) (
bz_stream* strm
);
BZ_EXTERN int BZ_API(BZ2_bzDecompressEnd) (
bz_stream *strm
);
/*-- High(er) level library functions --*/
#ifndef BZ_NO_STDIO
#define BZ_MAX_UNUSED 5000
typedef void BZFILE;
BZ_EXTERN BZFILE* BZ_API(BZ2_bzReadOpen) (
int* bzerror,
FILE* f,
int verbosity,
int small,
void* unused,
int nUnused
);
BZ_EXTERN void BZ_API(BZ2_bzReadClose) (
int* bzerror,
BZFILE* b
);
BZ_EXTERN void BZ_API(BZ2_bzReadGetUnused) (
int* bzerror,
BZFILE* b,
void** unused,
int* nUnused
);
BZ_EXTERN int BZ_API(BZ2_bzRead) (
int* bzerror,
BZFILE* b,
void* buf,
int len
);
BZ_EXTERN BZFILE* BZ_API(BZ2_bzWriteOpen) (
int* bzerror,
FILE* f,
int blockSize100k,
int verbosity,
int workFactor
);
BZ_EXTERN void BZ_API(BZ2_bzWrite) (
int* bzerror,
BZFILE* b,
void* buf,
int len
);
BZ_EXTERN void BZ_API(BZ2_bzWriteClose) (
int* bzerror,
BZFILE* b,
int abandon,
unsigned int* nbytes_in,
unsigned int* nbytes_out
);
BZ_EXTERN void BZ_API(BZ2_bzWriteClose64) (
int* bzerror,
BZFILE* b,
int abandon,
unsigned int* nbytes_in_lo32,
unsigned int* nbytes_in_hi32,
unsigned int* nbytes_out_lo32,
unsigned int* nbytes_out_hi32
);
#endif
/*-- Utility functions --*/
BZ_EXTERN int BZ_API(BZ2_bzBuffToBuffCompress) (
char* dest,
unsigned int* destLen,
char* source,
unsigned int sourceLen,
int blockSize100k,
int verbosity,
int workFactor
);
BZ_EXTERN int BZ_API(BZ2_bzBuffToBuffDecompress) (
char* dest,
unsigned int* destLen,
char* source,
unsigned int sourceLen,
int small,
int verbosity
);
/*--
Code contributed by Yoshioka Tsuneo (tsuneo@rr.iij4u.or.jp)
to support better zlib compatibility.
This code is not _officially_ part of libbzip2 (yet);
I haven't tested it, documented it, or considered the
threading-safeness of it.
If this code breaks, please contact both Yoshioka and me.
--*/
BZ_EXTERN const char * BZ_API(BZ2_bzlibVersion) (
void
);
#ifndef BZ_NO_STDIO
BZ_EXTERN BZFILE * BZ_API(BZ2_bzopen) (
const char *path,
const char *mode
);
BZ_EXTERN BZFILE * BZ_API(BZ2_bzdopen) (
int fd,
const char *mode
);
BZ_EXTERN int BZ_API(BZ2_bzread) (
BZFILE* b,
void* buf,
int len
);
BZ_EXTERN int BZ_API(BZ2_bzwrite) (
BZFILE* b,
void* buf,
int len
);
BZ_EXTERN int BZ_API(BZ2_bzflush) (
BZFILE* b
);
BZ_EXTERN void BZ_API(BZ2_bzclose) (
BZFILE* b
);
BZ_EXTERN const char * BZ_API(BZ2_bzerror) (
BZFILE *b,
int *errnum
);
#endif
#ifdef __cplusplus
}
#endif
#endif
/*-------------------------------------------------------------*/
/*--- end bzlib.h ---*/
/*-------------------------------------------------------------*/

View File

@ -1,186 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup Label="ProjectConfigurations">
<ProjectConfiguration Include="Debug MP Play|Win32">
<Configuration>Debug MP Play</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Debug MP|Win32">
<Configuration>Debug MP</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Debug|Win32">
<Configuration>Debug</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release MP|Win32">
<Configuration>Release MP</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|Win32">
<Configuration>Release</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
</ItemGroup>
<PropertyGroup Label="Globals">
<ProjectGuid>{792DF067-9904-4579-99B9-46C17277ADE3}</ProjectGuid>
<Keyword>Win32Proj</Keyword>
<RootNamespace>bzip2</RootNamespace>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>v120</PlatformToolset>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug MP|Win32'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>v120</PlatformToolset>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release MP|Win32'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>v120</PlatformToolset>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug MP Play|Win32'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>v120</PlatformToolset>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>v120</PlatformToolset>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
<ImportGroup Label="ExtensionSettings">
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug MP|Win32'" Label="PropertySheets">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release MP|Win32'" Label="PropertySheets">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug MP Play|Win32'" Label="PropertySheets">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<PropertyGroup Label="UserMacros" />
<PropertyGroup />
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<ClCompile>
<PrecompiledHeader>Use</PrecompiledHeader>
<WarningLevel>Level3</WarningLevel>
<Optimization>Disabled</Optimization>
<PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<AdditionalIncludeDirectories>$(ProjectDir)..\include\</AdditionalIncludeDirectories>
<RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
<PrecompiledHeaderFile>bzlib_private.h</PrecompiledHeaderFile>
</ClCompile>
<Link>
<SubSystem>Windows</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug MP|Win32'">
<ClCompile>
<PrecompiledHeader>Use</PrecompiledHeader>
<WarningLevel>Level3</WarningLevel>
<Optimization>Disabled</Optimization>
<PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<AdditionalIncludeDirectories>$(ProjectDir)..\include\</AdditionalIncludeDirectories>
<RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
<PrecompiledHeaderFile>bzlib_private.h</PrecompiledHeaderFile>
</ClCompile>
<Link>
<SubSystem>Windows</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release MP|Win32'">
<ClCompile>
<PrecompiledHeader>Use</PrecompiledHeader>
<WarningLevel>Level3</WarningLevel>
<Optimization>Disabled</Optimization>
<PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<AdditionalIncludeDirectories>$(ProjectDir)..\include\</AdditionalIncludeDirectories>
<RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
<PrecompiledHeaderFile>bzlib_private.h</PrecompiledHeaderFile>
</ClCompile>
<Link>
<SubSystem>Windows</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug MP Play|Win32'">
<ClCompile>
<PrecompiledHeader>Use</PrecompiledHeader>
<WarningLevel>Level3</WarningLevel>
<Optimization>Disabled</Optimization>
<PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<AdditionalIncludeDirectories>$(ProjectDir)..\include\</AdditionalIncludeDirectories>
<RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
<PrecompiledHeaderFile>bzlib_private.h</PrecompiledHeaderFile>
</ClCompile>
<Link>
<SubSystem>Windows</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<PrecompiledHeader>Use</PrecompiledHeader>
<Optimization>MaxSpeed</Optimization>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<AdditionalIncludeDirectories>$(ProjectDir)..\include\</AdditionalIncludeDirectories>
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
<PrecompiledHeaderFile>bzlib_private.h</PrecompiledHeaderFile>
</ClCompile>
<Link>
<SubSystem>Windows</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
</Link>
</ItemDefinitionGroup>
<ItemGroup>
<Text Include="ReadMe.txt" />
</ItemGroup>
<ItemGroup>
<ClCompile Include="..\src\blocksort.c" />
<ClCompile Include="..\src\bzlib.c" />
<ClCompile Include="..\src\compress.c" />
<ClCompile Include="..\src\crctable.c" />
<ClCompile Include="..\src\decompress.c" />
<ClCompile Include="..\src\huffman.c" />
<ClCompile Include="..\src\precompiled.c">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Create</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug MP|Win32'">Create</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release MP|Win32'">Create</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug MP Play|Win32'">Create</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Create</PrecompiledHeader>
</ClCompile>
<ClCompile Include="..\src\randtable.c" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="..\src\bzlib_private.h" />
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>
</Project>

View File

@ -1,51 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup>
<Filter Include="Source Files">
<UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
<Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
</Filter>
<Filter Include="Header Files">
<UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
<Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
</Filter>
<Filter Include="Resource Files">
<UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
<Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
</Filter>
</ItemGroup>
<ItemGroup>
<Text Include="ReadMe.txt" />
</ItemGroup>
<ItemGroup>
<ClCompile Include="..\src\blocksort.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\bzlib.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\compress.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\crctable.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\decompress.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\huffman.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\randtable.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\src\precompiled.c">
<Filter>Source Files</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ClInclude Include="..\src\bzlib_private.h">
<Filter>Source Files</Filter>
</ClInclude>
</ItemGroup>
</Project>

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

@ -1,509 +0,0 @@
/*-------------------------------------------------------------*/
/*--- Private header file for the library. ---*/
/*--- bzlib_private.h ---*/
/*-------------------------------------------------------------*/
/* ------------------------------------------------------------------
This file is part of bzip2/libbzip2, a program and library for
lossless, block-sorting data compression.
bzip2/libbzip2 version 1.0.6 of 6 September 2010
Copyright (C) 1996-2010 Julian Seward <jseward@bzip.org>
Please read the WARNING, DISCLAIMER and PATENTS sections in the
README file.
This program is released under the terms of the license contained
in the file LICENSE.
------------------------------------------------------------------ */
#ifndef _BZLIB_PRIVATE_H
#define _BZLIB_PRIVATE_H
#include <stdlib.h>
#ifndef BZ_NO_STDIO
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#endif
#include "bzip2/bzlib.h"
/*-- General stuff. --*/
#define BZ_VERSION "1.0.6, 6-Sept-2010"
typedef char Char;
typedef unsigned char Bool;
typedef unsigned char UChar;
typedef int Int32;
typedef unsigned int UInt32;
typedef short Int16;
typedef unsigned short UInt16;
#define True ((Bool)1)
#define False ((Bool)0)
#ifndef __GNUC__
#define __inline__ /* */
#endif
#ifndef BZ_NO_STDIO
extern void BZ2_bz__AssertH__fail ( int errcode );
#define AssertH(cond,errcode) \
{ if (!(cond)) BZ2_bz__AssertH__fail ( errcode ); }
#if BZ_DEBUG
#define AssertD(cond,msg) \
{ if (!(cond)) { \
fprintf ( stderr, \
"\n\nlibbzip2(debug build): internal error\n\t%s\n", msg );\
exit(1); \
}}
#else
#define AssertD(cond,msg) /* */
#endif
#define VPrintf0(zf) \
fprintf(stderr,zf)
#define VPrintf1(zf,za1) \
fprintf(stderr,zf,za1)
#define VPrintf2(zf,za1,za2) \
fprintf(stderr,zf,za1,za2)
#define VPrintf3(zf,za1,za2,za3) \
fprintf(stderr,zf,za1,za2,za3)
#define VPrintf4(zf,za1,za2,za3,za4) \
fprintf(stderr,zf,za1,za2,za3,za4)
#define VPrintf5(zf,za1,za2,za3,za4,za5) \
fprintf(stderr,zf,za1,za2,za3,za4,za5)
#else
extern void bz_internal_error ( int errcode );
#define AssertH(cond,errcode) \
{ if (!(cond)) bz_internal_error ( errcode ); }
#define AssertD(cond,msg) do { } while (0)
#define VPrintf0(zf) do { } while (0)
#define VPrintf1(zf,za1) do { } while (0)
#define VPrintf2(zf,za1,za2) do { } while (0)
#define VPrintf3(zf,za1,za2,za3) do { } while (0)
#define VPrintf4(zf,za1,za2,za3,za4) do { } while (0)
#define VPrintf5(zf,za1,za2,za3,za4,za5) do { } while (0)
#endif
#define BZALLOC(nnn) (strm->bzalloc)(strm->opaque,(nnn),1)
#define BZFREE(ppp) (strm->bzfree)(strm->opaque,(ppp))
/*-- Header bytes. --*/
#define BZ_HDR_B 0x42 /* 'B' */
#define BZ_HDR_Z 0x5a /* 'Z' */
#define BZ_HDR_h 0x68 /* 'h' */
#define BZ_HDR_0 0x30 /* '0' */
/*-- Constants for the back end. --*/
#define BZ_MAX_ALPHA_SIZE 258
#define BZ_MAX_CODE_LEN 23
#define BZ_RUNA 0
#define BZ_RUNB 1
#define BZ_N_GROUPS 6
#define BZ_G_SIZE 50
#define BZ_N_ITERS 4
#define BZ_MAX_SELECTORS (2 + (900000 / BZ_G_SIZE))
/*-- Stuff for randomising repetitive blocks. --*/
extern Int32 BZ2_rNums[512];
#define BZ_RAND_DECLS \
Int32 rNToGo; \
Int32 rTPos \
#define BZ_RAND_INIT_MASK \
s->rNToGo = 0; \
s->rTPos = 0 \
#define BZ_RAND_MASK ((s->rNToGo == 1) ? 1 : 0)
#define BZ_RAND_UPD_MASK \
if (s->rNToGo == 0) { \
s->rNToGo = BZ2_rNums[s->rTPos]; \
s->rTPos++; \
if (s->rTPos == 512) s->rTPos = 0; \
} \
s->rNToGo--;
/*-- Stuff for doing CRCs. --*/
extern UInt32 BZ2_crc32Table[256];
#define BZ_INITIALISE_CRC(crcVar) \
{ \
crcVar = 0xffffffffL; \
}
#define BZ_FINALISE_CRC(crcVar) \
{ \
crcVar = ~(crcVar); \
}
#define BZ_UPDATE_CRC(crcVar,cha) \
{ \
crcVar = (crcVar << 8) ^ \
BZ2_crc32Table[(crcVar >> 24) ^ \
((UChar)cha)]; \
}
/*-- States and modes for compression. --*/
#define BZ_M_IDLE 1
#define BZ_M_RUNNING 2
#define BZ_M_FLUSHING 3
#define BZ_M_FINISHING 4
#define BZ_S_OUTPUT 1
#define BZ_S_INPUT 2
#define BZ_N_RADIX 2
#define BZ_N_QSORT 12
#define BZ_N_SHELL 18
#define BZ_N_OVERSHOOT (BZ_N_RADIX + BZ_N_QSORT + BZ_N_SHELL + 2)
/*-- Structure holding all the compression-side stuff. --*/
typedef
struct {
/* pointer back to the struct bz_stream */
bz_stream* strm;
/* mode this stream is in, and whether inputting */
/* or outputting data */
Int32 mode;
Int32 state;
/* remembers avail_in when flush/finish requested */
UInt32 avail_in_expect;
/* for doing the block sorting */
UInt32* arr1;
UInt32* arr2;
UInt32* ftab;
Int32 origPtr;
/* aliases for arr1 and arr2 */
UInt32* ptr;
UChar* block;
UInt16* mtfv;
UChar* zbits;
/* for deciding when to use the fallback sorting algorithm */
Int32 workFactor;
/* run-length-encoding of the input */
UInt32 state_in_ch;
Int32 state_in_len;
BZ_RAND_DECLS;
/* input and output limits and current posns */
Int32 nblock;
Int32 nblockMAX;
Int32 numZ;
Int32 state_out_pos;
/* map of bytes used in block */
Int32 nInUse;
Bool inUse[256];
UChar unseqToSeq[256];
/* the buffer for bit stream creation */
UInt32 bsBuff;
Int32 bsLive;
/* block and combined CRCs */
UInt32 blockCRC;
UInt32 combinedCRC;
/* misc administratium */
Int32 verbosity;
Int32 blockNo;
Int32 blockSize100k;
/* stuff for coding the MTF values */
Int32 nMTF;
Int32 mtfFreq [BZ_MAX_ALPHA_SIZE];
UChar selector [BZ_MAX_SELECTORS];
UChar selectorMtf[BZ_MAX_SELECTORS];
UChar len [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
Int32 code [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
Int32 rfreq [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
/* second dimension: only 3 needed; 4 makes index calculations faster */
UInt32 len_pack[BZ_MAX_ALPHA_SIZE][4];
}
EState;
/*-- externs for compression. --*/
extern void
BZ2_blockSort ( EState* );
extern void
BZ2_compressBlock ( EState*, Bool );
extern void
BZ2_bsInitWrite ( EState* );
extern void
BZ2_hbAssignCodes ( Int32*, UChar*, Int32, Int32, Int32 );
extern void
BZ2_hbMakeCodeLengths ( UChar*, Int32*, Int32, Int32 );
/*-- states for decompression. --*/
#define BZ_X_IDLE 1
#define BZ_X_OUTPUT 2
#define BZ_X_MAGIC_1 10
#define BZ_X_MAGIC_2 11
#define BZ_X_MAGIC_3 12
#define BZ_X_MAGIC_4 13
#define BZ_X_BLKHDR_1 14
#define BZ_X_BLKHDR_2 15
#define BZ_X_BLKHDR_3 16
#define BZ_X_BLKHDR_4 17
#define BZ_X_BLKHDR_5 18
#define BZ_X_BLKHDR_6 19
#define BZ_X_BCRC_1 20
#define BZ_X_BCRC_2 21
#define BZ_X_BCRC_3 22
#define BZ_X_BCRC_4 23
#define BZ_X_RANDBIT 24
#define BZ_X_ORIGPTR_1 25
#define BZ_X_ORIGPTR_2 26
#define BZ_X_ORIGPTR_3 27
#define BZ_X_MAPPING_1 28
#define BZ_X_MAPPING_2 29
#define BZ_X_SELECTOR_1 30
#define BZ_X_SELECTOR_2 31
#define BZ_X_SELECTOR_3 32
#define BZ_X_CODING_1 33
#define BZ_X_CODING_2 34
#define BZ_X_CODING_3 35
#define BZ_X_MTF_1 36
#define BZ_X_MTF_2 37
#define BZ_X_MTF_3 38
#define BZ_X_MTF_4 39
#define BZ_X_MTF_5 40
#define BZ_X_MTF_6 41
#define BZ_X_ENDHDR_2 42
#define BZ_X_ENDHDR_3 43
#define BZ_X_ENDHDR_4 44
#define BZ_X_ENDHDR_5 45
#define BZ_X_ENDHDR_6 46
#define BZ_X_CCRC_1 47
#define BZ_X_CCRC_2 48
#define BZ_X_CCRC_3 49
#define BZ_X_CCRC_4 50
/*-- Constants for the fast MTF decoder. --*/
#define MTFA_SIZE 4096
#define MTFL_SIZE 16
/*-- Structure holding all the decompression-side stuff. --*/
typedef
struct {
/* pointer back to the struct bz_stream */
bz_stream* strm;
/* state indicator for this stream */
Int32 state;
/* for doing the final run-length decoding */
UChar state_out_ch;
Int32 state_out_len;
Bool blockRandomised;
BZ_RAND_DECLS;
/* the buffer for bit stream reading */
UInt32 bsBuff;
Int32 bsLive;
/* misc administratium */
Int32 blockSize100k;
Bool smallDecompress;
Int32 currBlockNo;
Int32 verbosity;
/* for undoing the Burrows-Wheeler transform */
Int32 origPtr;
UInt32 tPos;
Int32 k0;
Int32 unzftab[256];
Int32 nblock_used;
Int32 cftab[257];
Int32 cftabCopy[257];
/* for undoing the Burrows-Wheeler transform (FAST) */
UInt32 *tt;
/* for undoing the Burrows-Wheeler transform (SMALL) */
UInt16 *ll16;
UChar *ll4;
/* stored and calculated CRCs */
UInt32 storedBlockCRC;
UInt32 storedCombinedCRC;
UInt32 calculatedBlockCRC;
UInt32 calculatedCombinedCRC;
/* map of bytes used in block */
Int32 nInUse;
Bool inUse[256];
Bool inUse16[16];
UChar seqToUnseq[256];
/* for decoding the MTF values */
UChar mtfa [MTFA_SIZE];
Int32 mtfbase[256 / MTFL_SIZE];
UChar selector [BZ_MAX_SELECTORS];
UChar selectorMtf[BZ_MAX_SELECTORS];
UChar len [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
Int32 limit [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
Int32 base [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
Int32 perm [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
Int32 minLens[BZ_N_GROUPS];
/* save area for scalars in the main decompress code */
Int32 save_i;
Int32 save_j;
Int32 save_t;
Int32 save_alphaSize;
Int32 save_nGroups;
Int32 save_nSelectors;
Int32 save_EOB;
Int32 save_groupNo;
Int32 save_groupPos;
Int32 save_nextSym;
Int32 save_nblockMAX;
Int32 save_nblock;
Int32 save_es;
Int32 save_N;
Int32 save_curr;
Int32 save_zt;
Int32 save_zn;
Int32 save_zvec;
Int32 save_zj;
Int32 save_gSel;
Int32 save_gMinlen;
Int32* save_gLimit;
Int32* save_gBase;
Int32* save_gPerm;
}
DState;
/*-- Macros for decompression. --*/
#define BZ_GET_FAST(cccc) \
/* c_tPos is unsigned, hence test < 0 is pointless. */ \
if (s->tPos >= (UInt32)100000 * (UInt32)s->blockSize100k) return True; \
s->tPos = s->tt[s->tPos]; \
cccc = (UChar)(s->tPos & 0xff); \
s->tPos >>= 8;
#define BZ_GET_FAST_C(cccc) \
/* c_tPos is unsigned, hence test < 0 is pointless. */ \
if (c_tPos >= (UInt32)100000 * (UInt32)ro_blockSize100k) return True; \
c_tPos = c_tt[c_tPos]; \
cccc = (UChar)(c_tPos & 0xff); \
c_tPos >>= 8;
#define SET_LL4(i,n) \
{ if (((i) & 0x1) == 0) \
s->ll4[(i) >> 1] = (s->ll4[(i) >> 1] & 0xf0) | (n); else \
s->ll4[(i) >> 1] = (s->ll4[(i) >> 1] & 0x0f) | ((n) << 4); \
}
#define GET_LL4(i) \
((((UInt32)(s->ll4[(i) >> 1])) >> (((i) << 2) & 0x4)) & 0xF)
#define SET_LL(i,n) \
{ s->ll16[i] = (UInt16)(n & 0x0000ffff); \
SET_LL4(i, n >> 16); \
}
#define GET_LL(i) \
(((UInt32)s->ll16[i]) | (GET_LL4(i) << 16))
#define BZ_GET_SMALL(cccc) \
/* c_tPos is unsigned, hence test < 0 is pointless. */ \
if (s->tPos >= (UInt32)100000 * (UInt32)s->blockSize100k) return True; \
cccc = BZ2_indexIntoF ( s->tPos, s->cftab ); \
s->tPos = GET_LL(s->tPos);
/*-- externs for decompression. --*/
extern Int32
BZ2_indexIntoF ( Int32, Int32* );
extern Int32
BZ2_decompress ( DState* );
extern void
BZ2_hbCreateDecodeTables ( Int32*, Int32*, Int32*, UChar*,
Int32, Int32, Int32 );
#endif
/*-- BZ_NO_STDIO seems to make NULL disappear on some platforms. --*/
#ifdef BZ_NO_STDIO
#ifndef NULL
#define NULL 0
#endif
#endif
/*-------------------------------------------------------------*/
/*--- end bzlib_private.h ---*/
/*-------------------------------------------------------------*/

View File

@ -1,672 +0,0 @@
/*-------------------------------------------------------------*/
/*--- Compression machinery (not incl block sorting) ---*/
/*--- compress.c ---*/
/*-------------------------------------------------------------*/
/* ------------------------------------------------------------------
This file is part of bzip2/libbzip2, a program and library for
lossless, block-sorting data compression.
bzip2/libbzip2 version 1.0.6 of 6 September 2010
Copyright (C) 1996-2010 Julian Seward <jseward@bzip.org>
Please read the WARNING, DISCLAIMER and PATENTS sections in the
README file.
This program is released under the terms of the license contained
in the file LICENSE.
------------------------------------------------------------------ */
/* CHANGES
0.9.0 -- original version.
0.9.0a/b -- no changes in this file.
0.9.0c -- changed setting of nGroups in sendMTFValues()
so as to do a bit better on small files
*/
#include "bzlib_private.h"
/*---------------------------------------------------*/
/*--- Bit stream I/O ---*/
/*---------------------------------------------------*/
/*---------------------------------------------------*/
void BZ2_bsInitWrite ( EState* s )
{
s->bsLive = 0;
s->bsBuff = 0;
}
/*---------------------------------------------------*/
static
void bsFinishWrite ( EState* s )
{
while (s->bsLive > 0) {
s->zbits[s->numZ] = (UChar)(s->bsBuff >> 24);
s->numZ++;
s->bsBuff <<= 8;
s->bsLive -= 8;
}
}
/*---------------------------------------------------*/
#define bsNEEDW(nz) \
{ \
while (s->bsLive >= 8) { \
s->zbits[s->numZ] \
= (UChar)(s->bsBuff >> 24); \
s->numZ++; \
s->bsBuff <<= 8; \
s->bsLive -= 8; \
} \
}
/*---------------------------------------------------*/
static
__inline__
void bsW ( EState* s, Int32 n, UInt32 v )
{
bsNEEDW ( n );
s->bsBuff |= (v << (32 - s->bsLive - n));
s->bsLive += n;
}
/*---------------------------------------------------*/
static
void bsPutUInt32 ( EState* s, UInt32 u )
{
bsW ( s, 8, (u >> 24) & 0xffL );
bsW ( s, 8, (u >> 16) & 0xffL );
bsW ( s, 8, (u >> 8) & 0xffL );
bsW ( s, 8, u & 0xffL );
}
/*---------------------------------------------------*/
static
void bsPutUChar ( EState* s, UChar c )
{
bsW( s, 8, (UInt32)c );
}
/*---------------------------------------------------*/
/*--- The back end proper ---*/
/*---------------------------------------------------*/
/*---------------------------------------------------*/
static
void makeMaps_e ( EState* s )
{
Int32 i;
s->nInUse = 0;
for (i = 0; i < 256; i++)
if (s->inUse[i]) {
s->unseqToSeq[i] = s->nInUse;
s->nInUse++;
}
}
/*---------------------------------------------------*/
static
void generateMTFValues ( EState* s )
{
UChar yy[256];
Int32 i, j;
Int32 zPend;
Int32 wr;
Int32 EOB;
/*
After sorting (eg, here),
s->arr1 [ 0 .. s->nblock-1 ] holds sorted order,
and
((UChar*)s->arr2) [ 0 .. s->nblock-1 ]
holds the original block data.
The first thing to do is generate the MTF values,
and put them in
((UInt16*)s->arr1) [ 0 .. s->nblock-1 ].
Because there are strictly fewer or equal MTF values
than block values, ptr values in this area are overwritten
with MTF values only when they are no longer needed.
The final compressed bitstream is generated into the
area starting at
(UChar*) (&((UChar*)s->arr2)[s->nblock])
These storage aliases are set up in bzCompressInit(),
except for the last one, which is arranged in
compressBlock().
*/
UInt32* ptr = s->ptr;
UChar* block = s->block;
UInt16* mtfv = s->mtfv;
makeMaps_e ( s );
EOB = s->nInUse+1;
for (i = 0; i <= EOB; i++) s->mtfFreq[i] = 0;
wr = 0;
zPend = 0;
for (i = 0; i < s->nInUse; i++) yy[i] = (UChar) i;
for (i = 0; i < s->nblock; i++) {
UChar ll_i;
AssertD ( wr <= i, "generateMTFValues(1)" );
j = ptr[i]-1; if (j < 0) j += s->nblock;
ll_i = s->unseqToSeq[block[j]];
AssertD ( ll_i < s->nInUse, "generateMTFValues(2a)" );
if (yy[0] == ll_i) {
zPend++;
} else {
if (zPend > 0) {
zPend--;
while (True) {
if (zPend & 1) {
mtfv[wr] = BZ_RUNB; wr++;
s->mtfFreq[BZ_RUNB]++;
} else {
mtfv[wr] = BZ_RUNA; wr++;
s->mtfFreq[BZ_RUNA]++;
}
if (zPend < 2) break;
zPend = (zPend - 2) / 2;
};
zPend = 0;
}
{
register UChar rtmp;
register UChar* ryy_j;
register UChar rll_i;
rtmp = yy[1];
yy[1] = yy[0];
ryy_j = &(yy[1]);
rll_i = ll_i;
while ( rll_i != rtmp ) {
register UChar rtmp2;
ryy_j++;
rtmp2 = rtmp;
rtmp = *ryy_j;
*ryy_j = rtmp2;
};
yy[0] = rtmp;
j = ryy_j - &(yy[0]);
mtfv[wr] = j+1; wr++; s->mtfFreq[j+1]++;
}
}
}
if (zPend > 0) {
zPend--;
while (True) {
if (zPend & 1) {
mtfv[wr] = BZ_RUNB; wr++;
s->mtfFreq[BZ_RUNB]++;
} else {
mtfv[wr] = BZ_RUNA; wr++;
s->mtfFreq[BZ_RUNA]++;
}
if (zPend < 2) break;
zPend = (zPend - 2) / 2;
};
zPend = 0;
}
mtfv[wr] = EOB; wr++; s->mtfFreq[EOB]++;
s->nMTF = wr;
}
/*---------------------------------------------------*/
#define BZ_LESSER_ICOST 0
#define BZ_GREATER_ICOST 15
static
void sendMTFValues ( EState* s )
{
Int32 v, t, i, j, gs, ge, totc, bt, bc, iter;
Int32 nSelectors, alphaSize, minLen, maxLen, selCtr;
Int32 nGroups, nBytes;
/*--
UChar len [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
is a global since the decoder also needs it.
Int32 code[BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
Int32 rfreq[BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
are also globals only used in this proc.
Made global to keep stack frame size small.
--*/
UInt16 cost[BZ_N_GROUPS];
Int32 fave[BZ_N_GROUPS];
UInt16* mtfv = s->mtfv;
if (s->verbosity >= 3)
VPrintf3( " %d in block, %d after MTF & 1-2 coding, "
"%d+2 syms in use\n",
s->nblock, s->nMTF, s->nInUse );
alphaSize = s->nInUse+2;
for (t = 0; t < BZ_N_GROUPS; t++)
for (v = 0; v < alphaSize; v++)
s->len[t][v] = BZ_GREATER_ICOST;
/*--- Decide how many coding tables to use ---*/
AssertH ( s->nMTF > 0, 3001 );
if (s->nMTF < 200) nGroups = 2; else
if (s->nMTF < 600) nGroups = 3; else
if (s->nMTF < 1200) nGroups = 4; else
if (s->nMTF < 2400) nGroups = 5; else
nGroups = 6;
/*--- Generate an initial set of coding tables ---*/
{
Int32 nPart, remF, tFreq, aFreq;
nPart = nGroups;
remF = s->nMTF;
gs = 0;
while (nPart > 0) {
tFreq = remF / nPart;
ge = gs-1;
aFreq = 0;
while (aFreq < tFreq && ge < alphaSize-1) {
ge++;
aFreq += s->mtfFreq[ge];
}
if (ge > gs
&& nPart != nGroups && nPart != 1
&& ((nGroups-nPart) % 2 == 1)) {
aFreq -= s->mtfFreq[ge];
ge--;
}
if (s->verbosity >= 3)
VPrintf5( " initial group %d, [%d .. %d], "
"has %d syms (%4.1f%%)\n",
nPart, gs, ge, aFreq,
(100.0 * (float)aFreq) / (float)(s->nMTF) );
for (v = 0; v < alphaSize; v++)
if (v >= gs && v <= ge)
s->len[nPart-1][v] = BZ_LESSER_ICOST; else
s->len[nPart-1][v] = BZ_GREATER_ICOST;
nPart--;
gs = ge+1;
remF -= aFreq;
}
}
/*---
Iterate up to BZ_N_ITERS times to improve the tables.
---*/
for (iter = 0; iter < BZ_N_ITERS; iter++) {
for (t = 0; t < nGroups; t++) fave[t] = 0;
for (t = 0; t < nGroups; t++)
for (v = 0; v < alphaSize; v++)
s->rfreq[t][v] = 0;
/*---
Set up an auxiliary length table which is used to fast-track
the common case (nGroups == 6).
---*/
if (nGroups == 6) {
for (v = 0; v < alphaSize; v++) {
s->len_pack[v][0] = (s->len[1][v] << 16) | s->len[0][v];
s->len_pack[v][1] = (s->len[3][v] << 16) | s->len[2][v];
s->len_pack[v][2] = (s->len[5][v] << 16) | s->len[4][v];
}
}
nSelectors = 0;
totc = 0;
gs = 0;
while (True) {
/*--- Set group start & end marks. --*/
if (gs >= s->nMTF) break;
ge = gs + BZ_G_SIZE - 1;
if (ge >= s->nMTF) ge = s->nMTF-1;
/*--
Calculate the cost of this group as coded
by each of the coding tables.
--*/
for (t = 0; t < nGroups; t++) cost[t] = 0;
if (nGroups == 6 && 50 == ge-gs+1) {
/*--- fast track the common case ---*/
register UInt32 cost01, cost23, cost45;
register UInt16 icv;
cost01 = cost23 = cost45 = 0;
# define BZ_ITER(nn) \
icv = mtfv[gs+(nn)]; \
cost01 += s->len_pack[icv][0]; \
cost23 += s->len_pack[icv][1]; \
cost45 += s->len_pack[icv][2]; \
BZ_ITER(0); BZ_ITER(1); BZ_ITER(2); BZ_ITER(3); BZ_ITER(4);
BZ_ITER(5); BZ_ITER(6); BZ_ITER(7); BZ_ITER(8); BZ_ITER(9);
BZ_ITER(10); BZ_ITER(11); BZ_ITER(12); BZ_ITER(13); BZ_ITER(14);
BZ_ITER(15); BZ_ITER(16); BZ_ITER(17); BZ_ITER(18); BZ_ITER(19);
BZ_ITER(20); BZ_ITER(21); BZ_ITER(22); BZ_ITER(23); BZ_ITER(24);
BZ_ITER(25); BZ_ITER(26); BZ_ITER(27); BZ_ITER(28); BZ_ITER(29);
BZ_ITER(30); BZ_ITER(31); BZ_ITER(32); BZ_ITER(33); BZ_ITER(34);
BZ_ITER(35); BZ_ITER(36); BZ_ITER(37); BZ_ITER(38); BZ_ITER(39);
BZ_ITER(40); BZ_ITER(41); BZ_ITER(42); BZ_ITER(43); BZ_ITER(44);
BZ_ITER(45); BZ_ITER(46); BZ_ITER(47); BZ_ITER(48); BZ_ITER(49);
# undef BZ_ITER
cost[0] = cost01 & 0xffff; cost[1] = cost01 >> 16;
cost[2] = cost23 & 0xffff; cost[3] = cost23 >> 16;
cost[4] = cost45 & 0xffff; cost[5] = cost45 >> 16;
} else {
/*--- slow version which correctly handles all situations ---*/
for (i = gs; i <= ge; i++) {
UInt16 icv = mtfv[i];
for (t = 0; t < nGroups; t++) cost[t] += s->len[t][icv];
}
}
/*--
Find the coding table which is best for this group,
and record its identity in the selector table.
--*/
bc = 999999999; bt = -1;
for (t = 0; t < nGroups; t++)
if (cost[t] < bc) { bc = cost[t]; bt = t; };
totc += bc;
fave[bt]++;
s->selector[nSelectors] = bt;
nSelectors++;
/*--
Increment the symbol frequencies for the selected table.
--*/
if (nGroups == 6 && 50 == ge-gs+1) {
/*--- fast track the common case ---*/
# define BZ_ITUR(nn) s->rfreq[bt][ mtfv[gs+(nn)] ]++
BZ_ITUR(0); BZ_ITUR(1); BZ_ITUR(2); BZ_ITUR(3); BZ_ITUR(4);
BZ_ITUR(5); BZ_ITUR(6); BZ_ITUR(7); BZ_ITUR(8); BZ_ITUR(9);
BZ_ITUR(10); BZ_ITUR(11); BZ_ITUR(12); BZ_ITUR(13); BZ_ITUR(14);
BZ_ITUR(15); BZ_ITUR(16); BZ_ITUR(17); BZ_ITUR(18); BZ_ITUR(19);
BZ_ITUR(20); BZ_ITUR(21); BZ_ITUR(22); BZ_ITUR(23); BZ_ITUR(24);
BZ_ITUR(25); BZ_ITUR(26); BZ_ITUR(27); BZ_ITUR(28); BZ_ITUR(29);
BZ_ITUR(30); BZ_ITUR(31); BZ_ITUR(32); BZ_ITUR(33); BZ_ITUR(34);
BZ_ITUR(35); BZ_ITUR(36); BZ_ITUR(37); BZ_ITUR(38); BZ_ITUR(39);
BZ_ITUR(40); BZ_ITUR(41); BZ_ITUR(42); BZ_ITUR(43); BZ_ITUR(44);
BZ_ITUR(45); BZ_ITUR(46); BZ_ITUR(47); BZ_ITUR(48); BZ_ITUR(49);
# undef BZ_ITUR
} else {
/*--- slow version which correctly handles all situations ---*/
for (i = gs; i <= ge; i++)
s->rfreq[bt][ mtfv[i] ]++;
}
gs = ge+1;
}
if (s->verbosity >= 3) {
VPrintf2 ( " pass %d: size is %d, grp uses are ",
iter+1, totc/8 );
for (t = 0; t < nGroups; t++)
VPrintf1 ( "%d ", fave[t] );
VPrintf0 ( "\n" );
}
/*--
Recompute the tables based on the accumulated frequencies.
--*/
/* maxLen was changed from 20 to 17 in bzip2-1.0.3. See
comment in huffman.c for details. */
for (t = 0; t < nGroups; t++)
BZ2_hbMakeCodeLengths ( &(s->len[t][0]), &(s->rfreq[t][0]),
alphaSize, 17 /*20*/ );
}
AssertH( nGroups < 8, 3002 );
AssertH( nSelectors < 32768 &&
nSelectors <= (2 + (900000 / BZ_G_SIZE)),
3003 );
/*--- Compute MTF values for the selectors. ---*/
{
UChar pos[BZ_N_GROUPS], ll_i, tmp2, tmp;
for (i = 0; i < nGroups; i++) pos[i] = i;
for (i = 0; i < nSelectors; i++) {
ll_i = s->selector[i];
j = 0;
tmp = pos[j];
while ( ll_i != tmp ) {
j++;
tmp2 = tmp;
tmp = pos[j];
pos[j] = tmp2;
};
pos[0] = tmp;
s->selectorMtf[i] = j;
}
};
/*--- Assign actual codes for the tables. --*/
for (t = 0; t < nGroups; t++) {
minLen = 32;
maxLen = 0;
for (i = 0; i < alphaSize; i++) {
if (s->len[t][i] > maxLen) maxLen = s->len[t][i];
if (s->len[t][i] < minLen) minLen = s->len[t][i];
}
AssertH ( !(maxLen > 17 /*20*/ ), 3004 );
AssertH ( !(minLen < 1), 3005 );
BZ2_hbAssignCodes ( &(s->code[t][0]), &(s->len[t][0]),
minLen, maxLen, alphaSize );
}
/*--- Transmit the mapping table. ---*/
{
Bool inUse16[16];
for (i = 0; i < 16; i++) {
inUse16[i] = False;
for (j = 0; j < 16; j++)
if (s->inUse[i * 16 + j]) inUse16[i] = True;
}
nBytes = s->numZ;
for (i = 0; i < 16; i++)
if (inUse16[i]) bsW(s,1,1); else bsW(s,1,0);
for (i = 0; i < 16; i++)
if (inUse16[i])
for (j = 0; j < 16; j++) {
if (s->inUse[i * 16 + j]) bsW(s,1,1); else bsW(s,1,0);
}
if (s->verbosity >= 3)
VPrintf1( " bytes: mapping %d, ", s->numZ-nBytes );
}
/*--- Now the selectors. ---*/
nBytes = s->numZ;
bsW ( s, 3, nGroups );
bsW ( s, 15, nSelectors );
for (i = 0; i < nSelectors; i++) {
for (j = 0; j < s->selectorMtf[i]; j++) bsW(s,1,1);
bsW(s,1,0);
}
if (s->verbosity >= 3)
VPrintf1( "selectors %d, ", s->numZ-nBytes );
/*--- Now the coding tables. ---*/
nBytes = s->numZ;
for (t = 0; t < nGroups; t++) {
Int32 curr = s->len[t][0];
bsW ( s, 5, curr );
for (i = 0; i < alphaSize; i++) {
while (curr < s->len[t][i]) { bsW(s,2,2); curr++; /* 10 */ };
while (curr > s->len[t][i]) { bsW(s,2,3); curr--; /* 11 */ };
bsW ( s, 1, 0 );
}
}
if (s->verbosity >= 3)
VPrintf1 ( "code lengths %d, ", s->numZ-nBytes );
/*--- And finally, the block data proper ---*/
nBytes = s->numZ;
selCtr = 0;
gs = 0;
while (True) {
if (gs >= s->nMTF) break;
ge = gs + BZ_G_SIZE - 1;
if (ge >= s->nMTF) ge = s->nMTF-1;
AssertH ( s->selector[selCtr] < nGroups, 3006 );
if (nGroups == 6 && 50 == ge-gs+1) {
/*--- fast track the common case ---*/
UInt16 mtfv_i;
UChar* s_len_sel_selCtr
= &(s->len[s->selector[selCtr]][0]);
Int32* s_code_sel_selCtr
= &(s->code[s->selector[selCtr]][0]);
# define BZ_ITAH(nn) \
mtfv_i = mtfv[gs+(nn)]; \
bsW ( s, \
s_len_sel_selCtr[mtfv_i], \
s_code_sel_selCtr[mtfv_i] )
BZ_ITAH(0); BZ_ITAH(1); BZ_ITAH(2); BZ_ITAH(3); BZ_ITAH(4);
BZ_ITAH(5); BZ_ITAH(6); BZ_ITAH(7); BZ_ITAH(8); BZ_ITAH(9);
BZ_ITAH(10); BZ_ITAH(11); BZ_ITAH(12); BZ_ITAH(13); BZ_ITAH(14);
BZ_ITAH(15); BZ_ITAH(16); BZ_ITAH(17); BZ_ITAH(18); BZ_ITAH(19);
BZ_ITAH(20); BZ_ITAH(21); BZ_ITAH(22); BZ_ITAH(23); BZ_ITAH(24);
BZ_ITAH(25); BZ_ITAH(26); BZ_ITAH(27); BZ_ITAH(28); BZ_ITAH(29);
BZ_ITAH(30); BZ_ITAH(31); BZ_ITAH(32); BZ_ITAH(33); BZ_ITAH(34);
BZ_ITAH(35); BZ_ITAH(36); BZ_ITAH(37); BZ_ITAH(38); BZ_ITAH(39);
BZ_ITAH(40); BZ_ITAH(41); BZ_ITAH(42); BZ_ITAH(43); BZ_ITAH(44);
BZ_ITAH(45); BZ_ITAH(46); BZ_ITAH(47); BZ_ITAH(48); BZ_ITAH(49);
# undef BZ_ITAH
} else {
/*--- slow version which correctly handles all situations ---*/
for (i = gs; i <= ge; i++) {
bsW ( s,
s->len [s->selector[selCtr]] [mtfv[i]],
s->code [s->selector[selCtr]] [mtfv[i]] );
}
}
gs = ge+1;
selCtr++;
}
AssertH( selCtr == nSelectors, 3007 );
if (s->verbosity >= 3)
VPrintf1( "codes %d\n", s->numZ-nBytes );
}
/*---------------------------------------------------*/
void BZ2_compressBlock ( EState* s, Bool is_last_block )
{
if (s->nblock > 0) {
BZ_FINALISE_CRC ( s->blockCRC );
s->combinedCRC = (s->combinedCRC << 1) | (s->combinedCRC >> 31);
s->combinedCRC ^= s->blockCRC;
if (s->blockNo > 1) s->numZ = 0;
if (s->verbosity >= 2)
VPrintf4( " block %d: crc = 0x%08x, "
"combined CRC = 0x%08x, size = %d\n",
s->blockNo, s->blockCRC, s->combinedCRC, s->nblock );
BZ2_blockSort ( s );
}
s->zbits = (UChar*) (&((UChar*)s->arr2)[s->nblock]);
/*-- If this is the first block, create the stream header. --*/
if (s->blockNo == 1) {
BZ2_bsInitWrite ( s );
bsPutUChar ( s, BZ_HDR_B );
bsPutUChar ( s, BZ_HDR_Z );
bsPutUChar ( s, BZ_HDR_h );
bsPutUChar ( s, (UChar)(BZ_HDR_0 + s->blockSize100k) );
}
if (s->nblock > 0) {
bsPutUChar ( s, 0x31 ); bsPutUChar ( s, 0x41 );
bsPutUChar ( s, 0x59 ); bsPutUChar ( s, 0x26 );
bsPutUChar ( s, 0x53 ); bsPutUChar ( s, 0x59 );
/*-- Now the block's CRC, so it is in a known place. --*/
bsPutUInt32 ( s, s->blockCRC );
/*--
Now a single bit indicating (non-)randomisation.
As of version 0.9.5, we use a better sorting algorithm
which makes randomisation unnecessary. So always set
the randomised bit to 'no'. Of course, the decoder
still needs to be able to handle randomised blocks
so as to maintain backwards compatibility with
older versions of bzip2.
--*/
bsW(s,1,0);
bsW ( s, 24, s->origPtr );
generateMTFValues ( s );
sendMTFValues ( s );
}
/*-- If this is the last block, add the stream trailer. --*/
if (is_last_block) {
bsPutUChar ( s, 0x17 ); bsPutUChar ( s, 0x72 );
bsPutUChar ( s, 0x45 ); bsPutUChar ( s, 0x38 );
bsPutUChar ( s, 0x50 ); bsPutUChar ( s, 0x90 );
bsPutUInt32 ( s, s->combinedCRC );
if (s->verbosity >= 2)
VPrintf1( " final combined CRC = 0x%08x\n ", s->combinedCRC );
bsFinishWrite ( s );
}
}
/*-------------------------------------------------------------*/
/*--- end compress.c ---*/
/*-------------------------------------------------------------*/

View File

@ -1,104 +0,0 @@
/*-------------------------------------------------------------*/
/*--- Table for doing CRCs ---*/
/*--- crctable.c ---*/
/*-------------------------------------------------------------*/
/* ------------------------------------------------------------------
This file is part of bzip2/libbzip2, a program and library for
lossless, block-sorting data compression.
bzip2/libbzip2 version 1.0.6 of 6 September 2010
Copyright (C) 1996-2010 Julian Seward <jseward@bzip.org>
Please read the WARNING, DISCLAIMER and PATENTS sections in the
README file.
This program is released under the terms of the license contained
in the file LICENSE.
------------------------------------------------------------------ */
#include "bzlib_private.h"
/*--
I think this is an implementation of the AUTODIN-II,
Ethernet & FDDI 32-bit CRC standard. Vaguely derived
from code by Rob Warnock, in Section 51 of the
comp.compression FAQ.
--*/
UInt32 BZ2_crc32Table[256] = {
/*-- Ugly, innit? --*/
0x00000000L, 0x04c11db7L, 0x09823b6eL, 0x0d4326d9L,
0x130476dcL, 0x17c56b6bL, 0x1a864db2L, 0x1e475005L,
0x2608edb8L, 0x22c9f00fL, 0x2f8ad6d6L, 0x2b4bcb61L,
0x350c9b64L, 0x31cd86d3L, 0x3c8ea00aL, 0x384fbdbdL,
0x4c11db70L, 0x48d0c6c7L, 0x4593e01eL, 0x4152fda9L,
0x5f15adacL, 0x5bd4b01bL, 0x569796c2L, 0x52568b75L,
0x6a1936c8L, 0x6ed82b7fL, 0x639b0da6L, 0x675a1011L,
0x791d4014L, 0x7ddc5da3L, 0x709f7b7aL, 0x745e66cdL,
0x9823b6e0L, 0x9ce2ab57L, 0x91a18d8eL, 0x95609039L,
0x8b27c03cL, 0x8fe6dd8bL, 0x82a5fb52L, 0x8664e6e5L,
0xbe2b5b58L, 0xbaea46efL, 0xb7a96036L, 0xb3687d81L,
0xad2f2d84L, 0xa9ee3033L, 0xa4ad16eaL, 0xa06c0b5dL,
0xd4326d90L, 0xd0f37027L, 0xddb056feL, 0xd9714b49L,
0xc7361b4cL, 0xc3f706fbL, 0xceb42022L, 0xca753d95L,
0xf23a8028L, 0xf6fb9d9fL, 0xfbb8bb46L, 0xff79a6f1L,
0xe13ef6f4L, 0xe5ffeb43L, 0xe8bccd9aL, 0xec7dd02dL,
0x34867077L, 0x30476dc0L, 0x3d044b19L, 0x39c556aeL,
0x278206abL, 0x23431b1cL, 0x2e003dc5L, 0x2ac12072L,
0x128e9dcfL, 0x164f8078L, 0x1b0ca6a1L, 0x1fcdbb16L,
0x018aeb13L, 0x054bf6a4L, 0x0808d07dL, 0x0cc9cdcaL,
0x7897ab07L, 0x7c56b6b0L, 0x71159069L, 0x75d48ddeL,
0x6b93dddbL, 0x6f52c06cL, 0x6211e6b5L, 0x66d0fb02L,
0x5e9f46bfL, 0x5a5e5b08L, 0x571d7dd1L, 0x53dc6066L,
0x4d9b3063L, 0x495a2dd4L, 0x44190b0dL, 0x40d816baL,
0xaca5c697L, 0xa864db20L, 0xa527fdf9L, 0xa1e6e04eL,
0xbfa1b04bL, 0xbb60adfcL, 0xb6238b25L, 0xb2e29692L,
0x8aad2b2fL, 0x8e6c3698L, 0x832f1041L, 0x87ee0df6L,
0x99a95df3L, 0x9d684044L, 0x902b669dL, 0x94ea7b2aL,
0xe0b41de7L, 0xe4750050L, 0xe9362689L, 0xedf73b3eL,
0xf3b06b3bL, 0xf771768cL, 0xfa325055L, 0xfef34de2L,
0xc6bcf05fL, 0xc27dede8L, 0xcf3ecb31L, 0xcbffd686L,
0xd5b88683L, 0xd1799b34L, 0xdc3abdedL, 0xd8fba05aL,
0x690ce0eeL, 0x6dcdfd59L, 0x608edb80L, 0x644fc637L,
0x7a089632L, 0x7ec98b85L, 0x738aad5cL, 0x774bb0ebL,
0x4f040d56L, 0x4bc510e1L, 0x46863638L, 0x42472b8fL,
0x5c007b8aL, 0x58c1663dL, 0x558240e4L, 0x51435d53L,
0x251d3b9eL, 0x21dc2629L, 0x2c9f00f0L, 0x285e1d47L,
0x36194d42L, 0x32d850f5L, 0x3f9b762cL, 0x3b5a6b9bL,
0x0315d626L, 0x07d4cb91L, 0x0a97ed48L, 0x0e56f0ffL,
0x1011a0faL, 0x14d0bd4dL, 0x19939b94L, 0x1d528623L,
0xf12f560eL, 0xf5ee4bb9L, 0xf8ad6d60L, 0xfc6c70d7L,
0xe22b20d2L, 0xe6ea3d65L, 0xeba91bbcL, 0xef68060bL,
0xd727bbb6L, 0xd3e6a601L, 0xdea580d8L, 0xda649d6fL,
0xc423cd6aL, 0xc0e2d0ddL, 0xcda1f604L, 0xc960ebb3L,
0xbd3e8d7eL, 0xb9ff90c9L, 0xb4bcb610L, 0xb07daba7L,
0xae3afba2L, 0xaafbe615L, 0xa7b8c0ccL, 0xa379dd7bL,
0x9b3660c6L, 0x9ff77d71L, 0x92b45ba8L, 0x9675461fL,
0x8832161aL, 0x8cf30badL, 0x81b02d74L, 0x857130c3L,
0x5d8a9099L, 0x594b8d2eL, 0x5408abf7L, 0x50c9b640L,
0x4e8ee645L, 0x4a4ffbf2L, 0x470cdd2bL, 0x43cdc09cL,
0x7b827d21L, 0x7f436096L, 0x7200464fL, 0x76c15bf8L,
0x68860bfdL, 0x6c47164aL, 0x61043093L, 0x65c52d24L,
0x119b4be9L, 0x155a565eL, 0x18197087L, 0x1cd86d30L,
0x029f3d35L, 0x065e2082L, 0x0b1d065bL, 0x0fdc1becL,
0x3793a651L, 0x3352bbe6L, 0x3e119d3fL, 0x3ad08088L,
0x2497d08dL, 0x2056cd3aL, 0x2d15ebe3L, 0x29d4f654L,
0xc5a92679L, 0xc1683bceL, 0xcc2b1d17L, 0xc8ea00a0L,
0xd6ad50a5L, 0xd26c4d12L, 0xdf2f6bcbL, 0xdbee767cL,
0xe3a1cbc1L, 0xe760d676L, 0xea23f0afL, 0xeee2ed18L,
0xf0a5bd1dL, 0xf464a0aaL, 0xf9278673L, 0xfde69bc4L,
0x89b8fd09L, 0x8d79e0beL, 0x803ac667L, 0x84fbdbd0L,
0x9abc8bd5L, 0x9e7d9662L, 0x933eb0bbL, 0x97ffad0cL,
0xafb010b1L, 0xab710d06L, 0xa6322bdfL, 0xa2f33668L,
0xbcb4666dL, 0xb8757bdaL, 0xb5365d03L, 0xb1f740b4L
};
/*-------------------------------------------------------------*/
/*--- end crctable.c ---*/
/*-------------------------------------------------------------*/

View File

@ -1,646 +0,0 @@
/*-------------------------------------------------------------*/
/*--- Decompression machinery ---*/
/*--- decompress.c ---*/
/*-------------------------------------------------------------*/
/* ------------------------------------------------------------------
This file is part of bzip2/libbzip2, a program and library for
lossless, block-sorting data compression.
bzip2/libbzip2 version 1.0.6 of 6 September 2010
Copyright (C) 1996-2010 Julian Seward <jseward@bzip.org>
Please read the WARNING, DISCLAIMER and PATENTS sections in the
README file.
This program is released under the terms of the license contained
in the file LICENSE.
------------------------------------------------------------------ */
#include "bzlib_private.h"
/*---------------------------------------------------*/
static
void makeMaps_d ( DState* s )
{
Int32 i;
s->nInUse = 0;
for (i = 0; i < 256; i++)
if (s->inUse[i]) {
s->seqToUnseq[s->nInUse] = i;
s->nInUse++;
}
}
/*---------------------------------------------------*/
#define RETURN(rrr) \
{ retVal = rrr; goto save_state_and_return; };
#define GET_BITS(lll,vvv,nnn) \
case lll: s->state = lll; \
while (True) { \
if (s->bsLive >= nnn) { \
UInt32 v; \
v = (s->bsBuff >> \
(s->bsLive-nnn)) & ((1 << nnn)-1); \
s->bsLive -= nnn; \
vvv = v; \
break; \
} \
if (s->strm->avail_in == 0) RETURN(BZ_OK); \
s->bsBuff \
= (s->bsBuff << 8) | \
((UInt32) \
(*((UChar*)(s->strm->next_in)))); \
s->bsLive += 8; \
s->strm->next_in++; \
s->strm->avail_in--; \
s->strm->total_in_lo32++; \
if (s->strm->total_in_lo32 == 0) \
s->strm->total_in_hi32++; \
}
#define GET_UCHAR(lll,uuu) \
GET_BITS(lll,uuu,8)
#define GET_BIT(lll,uuu) \
GET_BITS(lll,uuu,1)
/*---------------------------------------------------*/
#define GET_MTF_VAL(label1,label2,lval) \
{ \
if (groupPos == 0) { \
groupNo++; \
if (groupNo >= nSelectors) \
RETURN(BZ_DATA_ERROR); \
groupPos = BZ_G_SIZE; \
gSel = s->selector[groupNo]; \
gMinlen = s->minLens[gSel]; \
gLimit = &(s->limit[gSel][0]); \
gPerm = &(s->perm[gSel][0]); \
gBase = &(s->base[gSel][0]); \
} \
groupPos--; \
zn = gMinlen; \
GET_BITS(label1, zvec, zn); \
while (1) { \
if (zn > 20 /* the longest code */) \
RETURN(BZ_DATA_ERROR); \
if (zvec <= gLimit[zn]) break; \
zn++; \
GET_BIT(label2, zj); \
zvec = (zvec << 1) | zj; \
}; \
if (zvec - gBase[zn] < 0 \
|| zvec - gBase[zn] >= BZ_MAX_ALPHA_SIZE) \
RETURN(BZ_DATA_ERROR); \
lval = gPerm[zvec - gBase[zn]]; \
}
/*---------------------------------------------------*/
Int32 BZ2_decompress ( DState* s )
{
UChar uc;
Int32 retVal;
Int32 minLen, maxLen;
bz_stream* strm = s->strm;
/* stuff that needs to be saved/restored */
Int32 i;
Int32 j;
Int32 t;
Int32 alphaSize;
Int32 nGroups;
Int32 nSelectors;
Int32 EOB;
Int32 groupNo;
Int32 groupPos;
Int32 nextSym;
Int32 nblockMAX;
Int32 nblock;
Int32 es;
Int32 N;
Int32 curr;
Int32 zt;
Int32 zn;
Int32 zvec;
Int32 zj;
Int32 gSel;
Int32 gMinlen;
Int32* gLimit;
Int32* gBase;
Int32* gPerm;
if (s->state == BZ_X_MAGIC_1) {
/*initialise the save area*/
s->save_i = 0;
s->save_j = 0;
s->save_t = 0;
s->save_alphaSize = 0;
s->save_nGroups = 0;
s->save_nSelectors = 0;
s->save_EOB = 0;
s->save_groupNo = 0;
s->save_groupPos = 0;
s->save_nextSym = 0;
s->save_nblockMAX = 0;
s->save_nblock = 0;
s->save_es = 0;
s->save_N = 0;
s->save_curr = 0;
s->save_zt = 0;
s->save_zn = 0;
s->save_zvec = 0;
s->save_zj = 0;
s->save_gSel = 0;
s->save_gMinlen = 0;
s->save_gLimit = NULL;
s->save_gBase = NULL;
s->save_gPerm = NULL;
}
/*restore from the save area*/
i = s->save_i;
j = s->save_j;
t = s->save_t;
alphaSize = s->save_alphaSize;
nGroups = s->save_nGroups;
nSelectors = s->save_nSelectors;
EOB = s->save_EOB;
groupNo = s->save_groupNo;
groupPos = s->save_groupPos;
nextSym = s->save_nextSym;
nblockMAX = s->save_nblockMAX;
nblock = s->save_nblock;
es = s->save_es;
N = s->save_N;
curr = s->save_curr;
zt = s->save_zt;
zn = s->save_zn;
zvec = s->save_zvec;
zj = s->save_zj;
gSel = s->save_gSel;
gMinlen = s->save_gMinlen;
gLimit = s->save_gLimit;
gBase = s->save_gBase;
gPerm = s->save_gPerm;
retVal = BZ_OK;
switch (s->state) {
GET_UCHAR(BZ_X_MAGIC_1, uc);
if (uc != BZ_HDR_B) RETURN(BZ_DATA_ERROR_MAGIC);
GET_UCHAR(BZ_X_MAGIC_2, uc);
if (uc != BZ_HDR_Z) RETURN(BZ_DATA_ERROR_MAGIC);
GET_UCHAR(BZ_X_MAGIC_3, uc)
if (uc != BZ_HDR_h) RETURN(BZ_DATA_ERROR_MAGIC);
GET_BITS(BZ_X_MAGIC_4, s->blockSize100k, 8)
if (s->blockSize100k < (BZ_HDR_0 + 1) ||
s->blockSize100k > (BZ_HDR_0 + 9)) RETURN(BZ_DATA_ERROR_MAGIC);
s->blockSize100k -= BZ_HDR_0;
if (s->smallDecompress) {
s->ll16 = BZALLOC( s->blockSize100k * 100000 * sizeof(UInt16) );
s->ll4 = BZALLOC(
((1 + s->blockSize100k * 100000) >> 1) * sizeof(UChar)
);
if (s->ll16 == NULL || s->ll4 == NULL) RETURN(BZ_MEM_ERROR);
} else {
s->tt = BZALLOC( s->blockSize100k * 100000 * sizeof(Int32) );
if (s->tt == NULL) RETURN(BZ_MEM_ERROR);
}
GET_UCHAR(BZ_X_BLKHDR_1, uc);
if (uc == 0x17) goto endhdr_2;
if (uc != 0x31) RETURN(BZ_DATA_ERROR);
GET_UCHAR(BZ_X_BLKHDR_2, uc);
if (uc != 0x41) RETURN(BZ_DATA_ERROR);
GET_UCHAR(BZ_X_BLKHDR_3, uc);
if (uc != 0x59) RETURN(BZ_DATA_ERROR);
GET_UCHAR(BZ_X_BLKHDR_4, uc);
if (uc != 0x26) RETURN(BZ_DATA_ERROR);
GET_UCHAR(BZ_X_BLKHDR_5, uc);
if (uc != 0x53) RETURN(BZ_DATA_ERROR);
GET_UCHAR(BZ_X_BLKHDR_6, uc);
if (uc != 0x59) RETURN(BZ_DATA_ERROR);
s->currBlockNo++;
if (s->verbosity >= 2)
VPrintf1 ( "\n [%d: huff+mtf ", s->currBlockNo );
s->storedBlockCRC = 0;
GET_UCHAR(BZ_X_BCRC_1, uc);
s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc);
GET_UCHAR(BZ_X_BCRC_2, uc);
s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc);
GET_UCHAR(BZ_X_BCRC_3, uc);
s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc);
GET_UCHAR(BZ_X_BCRC_4, uc);
s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc);
GET_BITS(BZ_X_RANDBIT, s->blockRandomised, 1);
s->origPtr = 0;
GET_UCHAR(BZ_X_ORIGPTR_1, uc);
s->origPtr = (s->origPtr << 8) | ((Int32)uc);
GET_UCHAR(BZ_X_ORIGPTR_2, uc);
s->origPtr = (s->origPtr << 8) | ((Int32)uc);
GET_UCHAR(BZ_X_ORIGPTR_3, uc);
s->origPtr = (s->origPtr << 8) | ((Int32)uc);
if (s->origPtr < 0)
RETURN(BZ_DATA_ERROR);
if (s->origPtr > 10 + 100000*s->blockSize100k)
RETURN(BZ_DATA_ERROR);
/*--- Receive the mapping table ---*/
for (i = 0; i < 16; i++) {
GET_BIT(BZ_X_MAPPING_1, uc);
if (uc == 1)
s->inUse16[i] = True; else
s->inUse16[i] = False;
}
for (i = 0; i < 256; i++) s->inUse[i] = False;
for (i = 0; i < 16; i++)
if (s->inUse16[i])
for (j = 0; j < 16; j++) {
GET_BIT(BZ_X_MAPPING_2, uc);
if (uc == 1) s->inUse[i * 16 + j] = True;
}
makeMaps_d ( s );
if (s->nInUse == 0) RETURN(BZ_DATA_ERROR);
alphaSize = s->nInUse+2;
/*--- Now the selectors ---*/
GET_BITS(BZ_X_SELECTOR_1, nGroups, 3);
if (nGroups < 2 || nGroups > 6) RETURN(BZ_DATA_ERROR);
GET_BITS(BZ_X_SELECTOR_2, nSelectors, 15);
if (nSelectors < 1) RETURN(BZ_DATA_ERROR);
for (i = 0; i < nSelectors; i++) {
j = 0;
while (True) {
GET_BIT(BZ_X_SELECTOR_3, uc);
if (uc == 0) break;
j++;
if (j >= nGroups) RETURN(BZ_DATA_ERROR);
}
s->selectorMtf[i] = j;
}
/*--- Undo the MTF values for the selectors. ---*/
{
UChar pos[BZ_N_GROUPS], tmp, v;
for (v = 0; v < nGroups; v++) pos[v] = v;
for (i = 0; i < nSelectors; i++) {
v = s->selectorMtf[i];
tmp = pos[v];
while (v > 0) { pos[v] = pos[v-1]; v--; }
pos[0] = tmp;
s->selector[i] = tmp;
}
}
/*--- Now the coding tables ---*/
for (t = 0; t < nGroups; t++) {
GET_BITS(BZ_X_CODING_1, curr, 5);
for (i = 0; i < alphaSize; i++) {
while (True) {
if (curr < 1 || curr > 20) RETURN(BZ_DATA_ERROR);
GET_BIT(BZ_X_CODING_2, uc);
if (uc == 0) break;
GET_BIT(BZ_X_CODING_3, uc);
if (uc == 0) curr++; else curr--;
}
s->len[t][i] = curr;
}
}
/*--- Create the Huffman decoding tables ---*/
for (t = 0; t < nGroups; t++) {
minLen = 32;
maxLen = 0;
for (i = 0; i < alphaSize; i++) {
if (s->len[t][i] > maxLen) maxLen = s->len[t][i];
if (s->len[t][i] < minLen) minLen = s->len[t][i];
}
BZ2_hbCreateDecodeTables (
&(s->limit[t][0]),
&(s->base[t][0]),
&(s->perm[t][0]),
&(s->len[t][0]),
minLen, maxLen, alphaSize
);
s->minLens[t] = minLen;
}
/*--- Now the MTF values ---*/
EOB = s->nInUse+1;
nblockMAX = 100000 * s->blockSize100k;
groupNo = -1;
groupPos = 0;
for (i = 0; i <= 255; i++) s->unzftab[i] = 0;
/*-- MTF init --*/
{
Int32 ii, jj, kk;
kk = MTFA_SIZE-1;
for (ii = 256 / MTFL_SIZE - 1; ii >= 0; ii--) {
for (jj = MTFL_SIZE-1; jj >= 0; jj--) {
s->mtfa[kk] = (UChar)(ii * MTFL_SIZE + jj);
kk--;
}
s->mtfbase[ii] = kk + 1;
}
}
/*-- end MTF init --*/
nblock = 0;
GET_MTF_VAL(BZ_X_MTF_1, BZ_X_MTF_2, nextSym);
while (True) {
if (nextSym == EOB) break;
if (nextSym == BZ_RUNA || nextSym == BZ_RUNB) {
es = -1;
N = 1;
do {
/* Check that N doesn't get too big, so that es doesn't
go negative. The maximum value that can be
RUNA/RUNB encoded is equal to the block size (post
the initial RLE), viz, 900k, so bounding N at 2
million should guard against overflow without
rejecting any legitimate inputs. */
if (N >= 2*1024*1024) RETURN(BZ_DATA_ERROR);
if (nextSym == BZ_RUNA) es = es + (0+1) * N; else
if (nextSym == BZ_RUNB) es = es + (1+1) * N;
N = N * 2;
GET_MTF_VAL(BZ_X_MTF_3, BZ_X_MTF_4, nextSym);
}
while (nextSym == BZ_RUNA || nextSym == BZ_RUNB);
es++;
uc = s->seqToUnseq[ s->mtfa[s->mtfbase[0]] ];
s->unzftab[uc] += es;
if (s->smallDecompress)
while (es > 0) {
if (nblock >= nblockMAX) RETURN(BZ_DATA_ERROR);
s->ll16[nblock] = (UInt16)uc;
nblock++;
es--;
}
else
while (es > 0) {
if (nblock >= nblockMAX) RETURN(BZ_DATA_ERROR);
s->tt[nblock] = (UInt32)uc;
nblock++;
es--;
};
continue;
} else {
if (nblock >= nblockMAX) RETURN(BZ_DATA_ERROR);
/*-- uc = MTF ( nextSym-1 ) --*/
{
Int32 ii, jj, kk, pp, lno, off;
UInt32 nn;
nn = (UInt32)(nextSym - 1);
if (nn < MTFL_SIZE) {
/* avoid general-case expense */
pp = s->mtfbase[0];
uc = s->mtfa[pp+nn];
while (nn > 3) {
Int32 z = pp+nn;
s->mtfa[(z) ] = s->mtfa[(z)-1];
s->mtfa[(z)-1] = s->mtfa[(z)-2];
s->mtfa[(z)-2] = s->mtfa[(z)-3];
s->mtfa[(z)-3] = s->mtfa[(z)-4];
nn -= 4;
}
while (nn > 0) {
s->mtfa[(pp+nn)] = s->mtfa[(pp+nn)-1]; nn--;
};
s->mtfa[pp] = uc;
} else {
/* general case */
lno = nn / MTFL_SIZE;
off = nn % MTFL_SIZE;
pp = s->mtfbase[lno] + off;
uc = s->mtfa[pp];
while (pp > s->mtfbase[lno]) {
s->mtfa[pp] = s->mtfa[pp-1]; pp--;
};
s->mtfbase[lno]++;
while (lno > 0) {
s->mtfbase[lno]--;
s->mtfa[s->mtfbase[lno]]
= s->mtfa[s->mtfbase[lno-1] + MTFL_SIZE - 1];
lno--;
}
s->mtfbase[0]--;
s->mtfa[s->mtfbase[0]] = uc;
if (s->mtfbase[0] == 0) {
kk = MTFA_SIZE-1;
for (ii = 256 / MTFL_SIZE-1; ii >= 0; ii--) {
for (jj = MTFL_SIZE-1; jj >= 0; jj--) {
s->mtfa[kk] = s->mtfa[s->mtfbase[ii] + jj];
kk--;
}
s->mtfbase[ii] = kk + 1;
}
}
}
}
/*-- end uc = MTF ( nextSym-1 ) --*/
s->unzftab[s->seqToUnseq[uc]]++;
if (s->smallDecompress)
s->ll16[nblock] = (UInt16)(s->seqToUnseq[uc]); else
s->tt[nblock] = (UInt32)(s->seqToUnseq[uc]);
nblock++;
GET_MTF_VAL(BZ_X_MTF_5, BZ_X_MTF_6, nextSym);
continue;
}
}
/* Now we know what nblock is, we can do a better sanity
check on s->origPtr.
*/
if (s->origPtr < 0 || s->origPtr >= nblock)
RETURN(BZ_DATA_ERROR);
/*-- Set up cftab to facilitate generation of T^(-1) --*/
/* Check: unzftab entries in range. */
for (i = 0; i <= 255; i++) {
if (s->unzftab[i] < 0 || s->unzftab[i] > nblock)
RETURN(BZ_DATA_ERROR);
}
/* Actually generate cftab. */
s->cftab[0] = 0;
for (i = 1; i <= 256; i++) s->cftab[i] = s->unzftab[i-1];
for (i = 1; i <= 256; i++) s->cftab[i] += s->cftab[i-1];
/* Check: cftab entries in range. */
for (i = 0; i <= 256; i++) {
if (s->cftab[i] < 0 || s->cftab[i] > nblock) {
/* s->cftab[i] can legitimately be == nblock */
RETURN(BZ_DATA_ERROR);
}
}
/* Check: cftab entries non-descending. */
for (i = 1; i <= 256; i++) {
if (s->cftab[i-1] > s->cftab[i]) {
RETURN(BZ_DATA_ERROR);
}
}
s->state_out_len = 0;
s->state_out_ch = 0;
BZ_INITIALISE_CRC ( s->calculatedBlockCRC );
s->state = BZ_X_OUTPUT;
if (s->verbosity >= 2) VPrintf0 ( "rt+rld" );
if (s->smallDecompress) {
/*-- Make a copy of cftab, used in generation of T --*/
for (i = 0; i <= 256; i++) s->cftabCopy[i] = s->cftab[i];
/*-- compute the T vector --*/
for (i = 0; i < nblock; i++) {
uc = (UChar)(s->ll16[i]);
SET_LL(i, s->cftabCopy[uc]);
s->cftabCopy[uc]++;
}
/*-- Compute T^(-1) by pointer reversal on T --*/
i = s->origPtr;
j = GET_LL(i);
do {
Int32 tmp = GET_LL(j);
SET_LL(j, i);
i = j;
j = tmp;
}
while (i != s->origPtr);
s->tPos = s->origPtr;
s->nblock_used = 0;
if (s->blockRandomised) {
BZ_RAND_INIT_MASK;
BZ_GET_SMALL(s->k0); s->nblock_used++;
BZ_RAND_UPD_MASK; s->k0 ^= BZ_RAND_MASK;
} else {
BZ_GET_SMALL(s->k0); s->nblock_used++;
}
} else {
/*-- compute the T^(-1) vector --*/
for (i = 0; i < nblock; i++) {
uc = (UChar)(s->tt[i] & 0xff);
s->tt[s->cftab[uc]] |= (i << 8);
s->cftab[uc]++;
}
s->tPos = s->tt[s->origPtr] >> 8;
s->nblock_used = 0;
if (s->blockRandomised) {
BZ_RAND_INIT_MASK;
BZ_GET_FAST(s->k0); s->nblock_used++;
BZ_RAND_UPD_MASK; s->k0 ^= BZ_RAND_MASK;
} else {
BZ_GET_FAST(s->k0); s->nblock_used++;
}
}
RETURN(BZ_OK);
endhdr_2:
GET_UCHAR(BZ_X_ENDHDR_2, uc);
if (uc != 0x72) RETURN(BZ_DATA_ERROR);
GET_UCHAR(BZ_X_ENDHDR_3, uc);
if (uc != 0x45) RETURN(BZ_DATA_ERROR);
GET_UCHAR(BZ_X_ENDHDR_4, uc);
if (uc != 0x38) RETURN(BZ_DATA_ERROR);
GET_UCHAR(BZ_X_ENDHDR_5, uc);
if (uc != 0x50) RETURN(BZ_DATA_ERROR);
GET_UCHAR(BZ_X_ENDHDR_6, uc);
if (uc != 0x90) RETURN(BZ_DATA_ERROR);
s->storedCombinedCRC = 0;
GET_UCHAR(BZ_X_CCRC_1, uc);
s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc);
GET_UCHAR(BZ_X_CCRC_2, uc);
s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc);
GET_UCHAR(BZ_X_CCRC_3, uc);
s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc);
GET_UCHAR(BZ_X_CCRC_4, uc);
s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc);
s->state = BZ_X_IDLE;
RETURN(BZ_STREAM_END);
default: AssertH ( False, 4001 );
}
AssertH ( False, 4002 );
save_state_and_return:
s->save_i = i;
s->save_j = j;
s->save_t = t;
s->save_alphaSize = alphaSize;
s->save_nGroups = nGroups;
s->save_nSelectors = nSelectors;
s->save_EOB = EOB;
s->save_groupNo = groupNo;
s->save_groupPos = groupPos;
s->save_nextSym = nextSym;
s->save_nblockMAX = nblockMAX;
s->save_nblock = nblock;
s->save_es = es;
s->save_N = N;
s->save_curr = curr;
s->save_zt = zt;
s->save_zn = zn;
s->save_zvec = zvec;
s->save_zj = zj;
s->save_gSel = gSel;
s->save_gMinlen = gMinlen;
s->save_gLimit = gLimit;
s->save_gBase = gBase;
s->save_gPerm = gPerm;
return retVal;
}
/*-------------------------------------------------------------*/
/*--- end decompress.c ---*/
/*-------------------------------------------------------------*/

View File

@ -1,205 +0,0 @@
/*-------------------------------------------------------------*/
/*--- Huffman coding low-level stuff ---*/
/*--- huffman.c ---*/
/*-------------------------------------------------------------*/
/* ------------------------------------------------------------------
This file is part of bzip2/libbzip2, a program and library for
lossless, block-sorting data compression.
bzip2/libbzip2 version 1.0.6 of 6 September 2010
Copyright (C) 1996-2010 Julian Seward <jseward@bzip.org>
Please read the WARNING, DISCLAIMER and PATENTS sections in the
README file.
This program is released under the terms of the license contained
in the file LICENSE.
------------------------------------------------------------------ */
#include "bzlib_private.h"
/*---------------------------------------------------*/
#define WEIGHTOF(zz0) ((zz0) & 0xffffff00)
#define DEPTHOF(zz1) ((zz1) & 0x000000ff)
#define MYMAX(zz2,zz3) ((zz2) > (zz3) ? (zz2) : (zz3))
#define ADDWEIGHTS(zw1,zw2) \
(WEIGHTOF(zw1)+WEIGHTOF(zw2)) | \
(1 + MYMAX(DEPTHOF(zw1),DEPTHOF(zw2)))
#define UPHEAP(z) \
{ \
Int32 zz, tmp; \
zz = z; tmp = heap[zz]; \
while (weight[tmp] < weight[heap[zz >> 1]]) { \
heap[zz] = heap[zz >> 1]; \
zz >>= 1; \
} \
heap[zz] = tmp; \
}
#define DOWNHEAP(z) \
{ \
Int32 zz, yy, tmp; \
zz = z; tmp = heap[zz]; \
while (True) { \
yy = zz << 1; \
if (yy > nHeap) break; \
if (yy < nHeap && \
weight[heap[yy+1]] < weight[heap[yy]]) \
yy++; \
if (weight[tmp] < weight[heap[yy]]) break; \
heap[zz] = heap[yy]; \
zz = yy; \
} \
heap[zz] = tmp; \
}
/*---------------------------------------------------*/
void BZ2_hbMakeCodeLengths ( UChar *len,
Int32 *freq,
Int32 alphaSize,
Int32 maxLen )
{
/*--
Nodes and heap entries run from 1. Entry 0
for both the heap and nodes is a sentinel.
--*/
Int32 nNodes, nHeap, n1, n2, i, j, k;
Bool tooLong;
Int32 heap [ BZ_MAX_ALPHA_SIZE + 2 ];
Int32 weight [ BZ_MAX_ALPHA_SIZE * 2 ];
Int32 parent [ BZ_MAX_ALPHA_SIZE * 2 ];
for (i = 0; i < alphaSize; i++)
weight[i+1] = (freq[i] == 0 ? 1 : freq[i]) << 8;
while (True) {
nNodes = alphaSize;
nHeap = 0;
heap[0] = 0;
weight[0] = 0;
parent[0] = -2;
for (i = 1; i <= alphaSize; i++) {
parent[i] = -1;
nHeap++;
heap[nHeap] = i;
UPHEAP(nHeap);
}
AssertH( nHeap < (BZ_MAX_ALPHA_SIZE+2), 2001 );
while (nHeap > 1) {
n1 = heap[1]; heap[1] = heap[nHeap]; nHeap--; DOWNHEAP(1);
n2 = heap[1]; heap[1] = heap[nHeap]; nHeap--; DOWNHEAP(1);
nNodes++;
parent[n1] = parent[n2] = nNodes;
weight[nNodes] = ADDWEIGHTS(weight[n1], weight[n2]);
parent[nNodes] = -1;
nHeap++;
heap[nHeap] = nNodes;
UPHEAP(nHeap);
}
AssertH( nNodes < (BZ_MAX_ALPHA_SIZE * 2), 2002 );
tooLong = False;
for (i = 1; i <= alphaSize; i++) {
j = 0;
k = i;
while (parent[k] >= 0) { k = parent[k]; j++; }
len[i-1] = j;
if (j > maxLen) tooLong = True;
}
if (! tooLong) break;
/* 17 Oct 04: keep-going condition for the following loop used
to be 'i < alphaSize', which missed the last element,
theoretically leading to the possibility of the compressor
looping. However, this count-scaling step is only needed if
one of the generated Huffman code words is longer than
maxLen, which up to and including version 1.0.2 was 20 bits,
which is extremely unlikely. In version 1.0.3 maxLen was
changed to 17 bits, which has minimal effect on compression
ratio, but does mean this scaling step is used from time to
time, enough to verify that it works.
This means that bzip2-1.0.3 and later will only produce
Huffman codes with a maximum length of 17 bits. However, in
order to preserve backwards compatibility with bitstreams
produced by versions pre-1.0.3, the decompressor must still
handle lengths of up to 20. */
for (i = 1; i <= alphaSize; i++) {
j = weight[i] >> 8;
j = 1 + (j / 2);
weight[i] = j << 8;
}
}
}
/*---------------------------------------------------*/
void BZ2_hbAssignCodes ( Int32 *code,
UChar *length,
Int32 minLen,
Int32 maxLen,
Int32 alphaSize )
{
Int32 n, vec, i;
vec = 0;
for (n = minLen; n <= maxLen; n++) {
for (i = 0; i < alphaSize; i++)
if (length[i] == n) { code[i] = vec; vec++; };
vec <<= 1;
}
}
/*---------------------------------------------------*/
void BZ2_hbCreateDecodeTables ( Int32 *limit,
Int32 *base,
Int32 *perm,
UChar *length,
Int32 minLen,
Int32 maxLen,
Int32 alphaSize )
{
Int32 pp, i, j, vec;
pp = 0;
for (i = minLen; i <= maxLen; i++)
for (j = 0; j < alphaSize; j++)
if (length[j] == i) { perm[pp] = j; pp++; };
for (i = 0; i < BZ_MAX_CODE_LEN; i++) base[i] = 0;
for (i = 0; i < alphaSize; i++) base[length[i]+1]++;
for (i = 1; i < BZ_MAX_CODE_LEN; i++) base[i] += base[i-1];
for (i = 0; i < BZ_MAX_CODE_LEN; i++) limit[i] = 0;
vec = 0;
for (i = minLen; i <= maxLen; i++) {
vec += (base[i+1] - base[i]);
limit[i] = vec-1;
vec <<= 1;
}
for (i = minLen + 1; i <= maxLen; i++)
base[i] = ((limit[i-1] + 1) << 1) - base[i];
}
/*-------------------------------------------------------------*/
/*--- end huffman.c ---*/
/*-------------------------------------------------------------*/

View File

@ -1 +0,0 @@
#include "bzlib_private.h"

View File

@ -1,84 +0,0 @@
/*-------------------------------------------------------------*/
/*--- Table for randomising repetitive blocks ---*/
/*--- randtable.c ---*/
/*-------------------------------------------------------------*/
/* ------------------------------------------------------------------
This file is part of bzip2/libbzip2, a program and library for
lossless, block-sorting data compression.
bzip2/libbzip2 version 1.0.6 of 6 September 2010
Copyright (C) 1996-2010 Julian Seward <jseward@bzip.org>
Please read the WARNING, DISCLAIMER and PATENTS sections in the
README file.
This program is released under the terms of the license contained
in the file LICENSE.
------------------------------------------------------------------ */
#include "bzlib_private.h"
/*---------------------------------------------*/
Int32 BZ2_rNums[512] = {
619, 720, 127, 481, 931, 816, 813, 233, 566, 247,
985, 724, 205, 454, 863, 491, 741, 242, 949, 214,
733, 859, 335, 708, 621, 574, 73, 654, 730, 472,
419, 436, 278, 496, 867, 210, 399, 680, 480, 51,
878, 465, 811, 169, 869, 675, 611, 697, 867, 561,
862, 687, 507, 283, 482, 129, 807, 591, 733, 623,
150, 238, 59, 379, 684, 877, 625, 169, 643, 105,
170, 607, 520, 932, 727, 476, 693, 425, 174, 647,
73, 122, 335, 530, 442, 853, 695, 249, 445, 515,
909, 545, 703, 919, 874, 474, 882, 500, 594, 612,
641, 801, 220, 162, 819, 984, 589, 513, 495, 799,
161, 604, 958, 533, 221, 400, 386, 867, 600, 782,
382, 596, 414, 171, 516, 375, 682, 485, 911, 276,
98, 553, 163, 354, 666, 933, 424, 341, 533, 870,
227, 730, 475, 186, 263, 647, 537, 686, 600, 224,
469, 68, 770, 919, 190, 373, 294, 822, 808, 206,
184, 943, 795, 384, 383, 461, 404, 758, 839, 887,
715, 67, 618, 276, 204, 918, 873, 777, 604, 560,
951, 160, 578, 722, 79, 804, 96, 409, 713, 940,
652, 934, 970, 447, 318, 353, 859, 672, 112, 785,
645, 863, 803, 350, 139, 93, 354, 99, 820, 908,
609, 772, 154, 274, 580, 184, 79, 626, 630, 742,
653, 282, 762, 623, 680, 81, 927, 626, 789, 125,
411, 521, 938, 300, 821, 78, 343, 175, 128, 250,
170, 774, 972, 275, 999, 639, 495, 78, 352, 126,
857, 956, 358, 619, 580, 124, 737, 594, 701, 612,
669, 112, 134, 694, 363, 992, 809, 743, 168, 974,
944, 375, 748, 52, 600, 747, 642, 182, 862, 81,
344, 805, 988, 739, 511, 655, 814, 334, 249, 515,
897, 955, 664, 981, 649, 113, 974, 459, 893, 228,
433, 837, 553, 268, 926, 240, 102, 654, 459, 51,
686, 754, 806, 760, 493, 403, 415, 394, 687, 700,
946, 670, 656, 610, 738, 392, 760, 799, 887, 653,
978, 321, 576, 617, 626, 502, 894, 679, 243, 440,
680, 879, 194, 572, 640, 724, 926, 56, 204, 700,
707, 151, 457, 449, 797, 195, 791, 558, 945, 679,
297, 59, 87, 824, 713, 663, 412, 693, 342, 606,
134, 108, 571, 364, 631, 212, 174, 643, 304, 329,
343, 97, 430, 751, 497, 314, 983, 374, 822, 928,
140, 206, 73, 263, 980, 736, 876, 478, 430, 305,
170, 514, 364, 692, 829, 82, 855, 953, 676, 246,
369, 970, 294, 750, 807, 827, 150, 790, 288, 923,
804, 378, 215, 828, 592, 281, 565, 555, 710, 82,
896, 831, 547, 261, 524, 462, 293, 465, 502, 56,
661, 821, 976, 991, 658, 869, 905, 758, 745, 193,
768, 550, 608, 933, 378, 286, 215, 979, 792, 961,
61, 688, 793, 644, 986, 403, 106, 366, 905, 644,
372, 567, 466, 434, 645, 210, 389, 550, 919, 135,
780, 773, 635, 389, 707, 100, 626, 958, 165, 504,
920, 176, 193, 713, 857, 265, 203, 50, 668, 108,
645, 990, 626, 197, 510, 357, 358, 850, 858, 364,
936, 638
};
/*-------------------------------------------------------------*/
/*--- end randtable.c ---*/
/*-------------------------------------------------------------*/

View File

@ -13,6 +13,10 @@
<Configuration>Debug</Configuration> <Configuration>Debug</Configuration>
<Platform>Win32</Platform> <Platform>Win32</Platform>
</ProjectConfiguration> </ProjectConfiguration>
<ProjectConfiguration Include="Release MP Play|Win32">
<Configuration>Release MP Play</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release MP|Win32"> <ProjectConfiguration Include="Release MP|Win32">
<Configuration>Release MP</Configuration> <Configuration>Release MP</Configuration>
<Platform>Win32</Platform> <Platform>Win32</Platform>
@ -62,6 +66,12 @@
<PlatformToolset>v120</PlatformToolset> <PlatformToolset>v120</PlatformToolset>
<CharacterSet>MultiByte</CharacterSet> <CharacterSet>MultiByte</CharacterSet>
</PropertyGroup> </PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release MP Play|Win32'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>v120</PlatformToolset>
<CharacterSet>MultiByte</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug MP Play|Win32'" Label="Configuration"> <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug MP Play|Win32'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType> <ConfigurationType>StaticLibrary</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries> <UseDebugLibraries>true</UseDebugLibraries>
@ -93,6 +103,9 @@
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release MP|Win32'" Label="PropertySheets"> <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release MP|Win32'" Label="PropertySheets">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" /> <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup> </ImportGroup>
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release MP Play|Win32'" Label="PropertySheets">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug MP Play|Win32'" Label="PropertySheets"> <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug MP Play|Win32'" Label="PropertySheets">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" /> <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup> </ImportGroup>
@ -149,6 +162,22 @@
<GenerateDebugInformation>true</GenerateDebugInformation> <GenerateDebugInformation>true</GenerateDebugInformation>
</Link> </Link>
</ItemDefinitionGroup> </ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release MP Play|Win32'">
<ClCompile>
<PrecompiledHeader>
</PrecompiledHeader>
<WarningLevel>Level3</WarningLevel>
<Optimization>Disabled</Optimization>
<PreprocessorDefinitions>WIN32;_CRT_SECURE_NO_WARNINGS;_DEBUG;_LIB;_ITERATOR_DEBUG_LEVEL=0;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
<AdditionalIncludeDirectories>$(ProjectDir)..\include\</AdditionalIncludeDirectories>
<CompileAs>CompileAsCpp</CompileAs>
</ClCompile>
<Link>
<SubSystem>Windows</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug MP Play|Win32'"> <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug MP Play|Win32'">
<ClCompile> <ClCompile>
<PrecompiledHeader> <PrecompiledHeader>

View File

@ -5,14 +5,11 @@ VisualStudioVersion = 12.0.21005.1
MinimumVisualStudioVersion = 10.0.40219.1 MinimumVisualStudioVersion = 10.0.40219.1
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ReGameDLL", "..\regamedll\msvc\ReGameDLL.vcxproj", "{70A2B904-B7DB-4C48-8DE0-AF567360D572}" Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ReGameDLL", "..\regamedll\msvc\ReGameDLL.vcxproj", "{70A2B904-B7DB-4C48-8DE0-AF567360D572}"
ProjectSection(ProjectDependencies) = postProject ProjectSection(ProjectDependencies) = postProject
{792DF067-9904-4579-99B9-46C17277ADE3} = {792DF067-9904-4579-99B9-46C17277ADE3}
{CEB94F7C-E459-4673-AABB-36E2074396C0} = {CEB94F7C-E459-4673-AABB-36E2074396C0} {CEB94F7C-E459-4673-AABB-36E2074396C0} = {CEB94F7C-E459-4673-AABB-36E2074396C0}
EndProjectSection EndProjectSection
EndProject EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "cppunitlite", "..\dep\cppunitlite\msvc\cppunitlite.vcxproj", "{CEB94F7C-E459-4673-AABB-36E2074396C0}" Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "cppunitlite", "..\dep\cppunitlite\msvc\cppunitlite.vcxproj", "{CEB94F7C-E459-4673-AABB-36E2074396C0}"
EndProject EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "bzip2", "..\dep\bzip2\msvc\bzip2.vcxproj", "{792DF067-9904-4579-99B9-46C17277ADE3}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "gradle", "gradle", "{DB570330-2FEE-4C39-971B-340019B6E661}" Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "gradle", "gradle", "{DB570330-2FEE-4C39-971B-340019B6E661}"
ProjectSection(SolutionItems) = preProject ProjectSection(SolutionItems) = preProject
..\build.gradle = ..\build.gradle ..\build.gradle = ..\build.gradle
@ -27,6 +24,7 @@ Global
Debug MP|Win32 = Debug MP|Win32 Debug MP|Win32 = Debug MP|Win32
Debug Play|Win32 = Debug Play|Win32 Debug Play|Win32 = Debug Play|Win32
Debug|Win32 = Debug|Win32 Debug|Win32 = Debug|Win32
Release MP Play|Win32 = Release MP Play|Win32
Release MP|Win32 = Release MP|Win32 Release MP|Win32 = Release MP|Win32
Release Play|Win32 = Release Play|Win32 Release Play|Win32 = Release Play|Win32
Release|Win32 = Release|Win32 Release|Win32 = Release|Win32
@ -41,6 +39,8 @@ Global
{70A2B904-B7DB-4C48-8DE0-AF567360D572}.Debug Play|Win32.Build.0 = Debug Play|Win32 {70A2B904-B7DB-4C48-8DE0-AF567360D572}.Debug Play|Win32.Build.0 = Debug Play|Win32
{70A2B904-B7DB-4C48-8DE0-AF567360D572}.Debug|Win32.ActiveCfg = Debug|Win32 {70A2B904-B7DB-4C48-8DE0-AF567360D572}.Debug|Win32.ActiveCfg = Debug|Win32
{70A2B904-B7DB-4C48-8DE0-AF567360D572}.Debug|Win32.Build.0 = Debug|Win32 {70A2B904-B7DB-4C48-8DE0-AF567360D572}.Debug|Win32.Build.0 = Debug|Win32
{70A2B904-B7DB-4C48-8DE0-AF567360D572}.Release MP Play|Win32.ActiveCfg = Release MP Play|Win32
{70A2B904-B7DB-4C48-8DE0-AF567360D572}.Release MP Play|Win32.Build.0 = Release MP Play|Win32
{70A2B904-B7DB-4C48-8DE0-AF567360D572}.Release MP|Win32.ActiveCfg = Release MP|Win32 {70A2B904-B7DB-4C48-8DE0-AF567360D572}.Release MP|Win32.ActiveCfg = Release MP|Win32
{70A2B904-B7DB-4C48-8DE0-AF567360D572}.Release MP|Win32.Build.0 = Release MP|Win32 {70A2B904-B7DB-4C48-8DE0-AF567360D572}.Release MP|Win32.Build.0 = Release MP|Win32
{70A2B904-B7DB-4C48-8DE0-AF567360D572}.Release Play|Win32.ActiveCfg = Release Play|Win32 {70A2B904-B7DB-4C48-8DE0-AF567360D572}.Release Play|Win32.ActiveCfg = Release Play|Win32
@ -57,6 +57,8 @@ Global
{CEB94F7C-E459-4673-AABB-36E2074396C0}.Debug Play|Win32.Build.0 = Debug|Win32 {CEB94F7C-E459-4673-AABB-36E2074396C0}.Debug Play|Win32.Build.0 = Debug|Win32
{CEB94F7C-E459-4673-AABB-36E2074396C0}.Debug|Win32.ActiveCfg = Debug|Win32 {CEB94F7C-E459-4673-AABB-36E2074396C0}.Debug|Win32.ActiveCfg = Debug|Win32
{CEB94F7C-E459-4673-AABB-36E2074396C0}.Debug|Win32.Build.0 = Debug|Win32 {CEB94F7C-E459-4673-AABB-36E2074396C0}.Debug|Win32.Build.0 = Debug|Win32
{CEB94F7C-E459-4673-AABB-36E2074396C0}.Release MP Play|Win32.ActiveCfg = Release MP Play|Win32
{CEB94F7C-E459-4673-AABB-36E2074396C0}.Release MP Play|Win32.Build.0 = Release MP Play|Win32
{CEB94F7C-E459-4673-AABB-36E2074396C0}.Release MP|Win32.ActiveCfg = Release MP|Win32 {CEB94F7C-E459-4673-AABB-36E2074396C0}.Release MP|Win32.ActiveCfg = Release MP|Win32
{CEB94F7C-E459-4673-AABB-36E2074396C0}.Release MP|Win32.Build.0 = Release MP|Win32 {CEB94F7C-E459-4673-AABB-36E2074396C0}.Release MP|Win32.Build.0 = Release MP|Win32
{CEB94F7C-E459-4673-AABB-36E2074396C0}.Release Play|Win32.ActiveCfg = Release|Win32 {CEB94F7C-E459-4673-AABB-36E2074396C0}.Release Play|Win32.ActiveCfg = Release|Win32
@ -65,22 +67,6 @@ Global
{CEB94F7C-E459-4673-AABB-36E2074396C0}.Release|Win32.Build.0 = Release|Win32 {CEB94F7C-E459-4673-AABB-36E2074396C0}.Release|Win32.Build.0 = Release|Win32
{CEB94F7C-E459-4673-AABB-36E2074396C0}.Tests|Win32.ActiveCfg = Debug|Win32 {CEB94F7C-E459-4673-AABB-36E2074396C0}.Tests|Win32.ActiveCfg = Debug|Win32
{CEB94F7C-E459-4673-AABB-36E2074396C0}.Tests|Win32.Build.0 = Debug|Win32 {CEB94F7C-E459-4673-AABB-36E2074396C0}.Tests|Win32.Build.0 = Debug|Win32
{792DF067-9904-4579-99B9-46C17277ADE3}.Debug MP Play|Win32.ActiveCfg = Debug MP Play|Win32
{792DF067-9904-4579-99B9-46C17277ADE3}.Debug MP Play|Win32.Build.0 = Debug MP Play|Win32
{792DF067-9904-4579-99B9-46C17277ADE3}.Debug MP|Win32.ActiveCfg = Debug MP|Win32
{792DF067-9904-4579-99B9-46C17277ADE3}.Debug MP|Win32.Build.0 = Debug MP|Win32
{792DF067-9904-4579-99B9-46C17277ADE3}.Debug Play|Win32.ActiveCfg = Debug|Win32
{792DF067-9904-4579-99B9-46C17277ADE3}.Debug Play|Win32.Build.0 = Debug|Win32
{792DF067-9904-4579-99B9-46C17277ADE3}.Debug|Win32.ActiveCfg = Debug|Win32
{792DF067-9904-4579-99B9-46C17277ADE3}.Debug|Win32.Build.0 = Debug|Win32
{792DF067-9904-4579-99B9-46C17277ADE3}.Release MP|Win32.ActiveCfg = Release MP|Win32
{792DF067-9904-4579-99B9-46C17277ADE3}.Release MP|Win32.Build.0 = Release MP|Win32
{792DF067-9904-4579-99B9-46C17277ADE3}.Release Play|Win32.ActiveCfg = Release|Win32
{792DF067-9904-4579-99B9-46C17277ADE3}.Release Play|Win32.Build.0 = Release|Win32
{792DF067-9904-4579-99B9-46C17277ADE3}.Release|Win32.ActiveCfg = Release|Win32
{792DF067-9904-4579-99B9-46C17277ADE3}.Release|Win32.Build.0 = Release|Win32
{792DF067-9904-4579-99B9-46C17277ADE3}.Tests|Win32.ActiveCfg = Debug|Win32
{792DF067-9904-4579-99B9-46C17277ADE3}.Tests|Win32.Build.0 = Debug|Win32
EndGlobalSection EndGlobalSection
GlobalSection(SolutionProperties) = preSolution GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE HideSolutionNode = FALSE

View File

@ -46,7 +46,6 @@ dependencies {
} }
project.ext.dep_bzip2 = project(':dep/bzip2')
project.ext.dep_cppunitlite = project(':dep/cppunitlite') project.ext.dep_cppunitlite = project(':dep/cppunitlite')
void createIntergrationTestTask(NativeBinarySpec b) { void createIntergrationTestTask(NativeBinarySpec b) {
@ -118,16 +117,13 @@ void setupToolchain(NativeBinarySpec b)
boolean regamedllFixes = b.flavor.name.contains('regamedllFixes') boolean regamedllFixes = b.flavor.name.contains('regamedllFixes')
ToolchainConfig cfg = rootProject.createToolchainConfig(b) ToolchainConfig cfg = rootProject.createToolchainConfig(b)
cfg.projectInclude(project, '', '/engine', '/common', '/dlls', '/game_shared', '/pm_shared', '/regamedll', '/testsuite', '/hookers', '/public', '/public/regamedll') cfg.projectInclude(project, '', '/engine', '/common', '/dlls', '/game_shared', '/pm_shared', '/regamedll', '/testsuite', '/hookers', '/public', '/public/regamedll')
cfg.projectInclude(dep_bzip2, '/include')
if (unitTestExecutable) if (unitTestExecutable)
{ {
cfg.projectInclude(dep_cppunitlite, '/include') cfg.projectInclude(dep_cppunitlite, '/include')
b.lib LazyNativeDepSet.create(dep_cppunitlite, 'cppunitlite', b.buildType.name, true) b.lib LazyNativeDepSet.create(dep_cppunitlite, 'cppunitlite', b.buildType.name, true)
} }
b.lib LazyNativeDepSet.create(dep_bzip2, 'bzip2', b.buildType.name, true)
cfg.singleDefines 'USE_BREAKPAD_HANDLER', 'DEDICATED', 'REGAMEDLL_SELF', 'CLIENT_WEAPONS' cfg.singleDefines 'USE_BREAKPAD_HANDLER', 'DEDICATED', 'REGAMEDLL_SELF', 'CLIENT_WEAPONS'
@ -155,7 +151,8 @@ void setupToolchain(NativeBinarySpec b)
cfg.projectLibpath(project, '/lib') cfg.projectLibpath(project, '/lib')
cfg.extraLibs 'steam_api.lib', 'psapi.lib', 'ws2_32.lib', 'kernel32.lib', 'user32.lib', 'advapi32.lib' cfg.extraLibs 'steam_api.lib', 'psapi.lib', 'ws2_32.lib', 'kernel32.lib', 'user32.lib', 'advapi32.lib'
} }
else if (cfg instanceof GccToolchainConfig) { else if (cfg instanceof GccToolchainConfig)
{
cfg.compilerOptions.pchConfig = new GccToolchainConfig.PrecompilerHeaderOptions( cfg.compilerOptions.pchConfig = new GccToolchainConfig.PrecompilerHeaderOptions(
enabled: true, enabled: true,
pchSourceSet: 'regamedll_pch' pchSourceSet: 'regamedll_pch'
@ -179,7 +176,8 @@ void setupToolchain(NativeBinarySpec b)
cfg.extraLibs 'dl', 'm', 'stdc++', 'steam_api' cfg.extraLibs 'dl', 'm', 'stdc++', 'steam_api'
} }
if (mpLib && GradleCppUtils.windows && !unitTestExecutable) { if (mpLib && GradleCppUtils.windows && !unitTestExecutable)
{
cfg.linkerOptions.definitionFile = "${projectDir}\\msvc\\mp.def"; cfg.linkerOptions.definitionFile = "${projectDir}\\msvc\\mp.def";
} }
@ -221,6 +219,7 @@ class RegamedllSrc {
include "**/*.cpp" include "**/*.cpp"
exclude "precompiled.cpp" exclude "precompiled.cpp"
exclude "tier0/dbg.cpp", "utlsymbol.cpp", "utlbuffer.cpp"
if (GradleCppUtils.windows) { if (GradleCppUtils.windows) {
exclude "tier0/platform_linux.cpp" exclude "tier0/platform_linux.cpp"
@ -228,16 +227,12 @@ class RegamedllSrc {
exclude "tier0/platform_win32.cpp" exclude "tier0/platform_win32.cpp"
exclude "classes_dummy.cpp" exclude "classes_dummy.cpp"
} }
//exclude "interface.cpp"
} }
source { source {
srcDirs "hookers" srcDirs "hookers"
include "**/*.cpp" include "**/*.cpp"
exclude "6153_hooker.cpp", "hooker.cpp", "main.cpp", "main_mp.cpp" exclude "6153_hooker.cpp", "hooker.cpp", "main.cpp", "main_mp.cpp", "hooker_impl.cpp"
// if (!GradleCppUtils.windows)
// exclude "regamedll_debug.cpp"
} }
} }
} }
@ -255,7 +250,7 @@ class RegamedllSrc {
h.regamedll_hooker_src(CppSourceSet) { h.regamedll_hooker_src(CppSourceSet) {
source { source {
srcDirs "hookers" srcDirs "hookers"
include "6153_hooker.cpp", "hooker.cpp" include "6153_hooker.cpp", "hooker.cpp", "hooker_impl.cpp"
} }
} }
} }

View File

@ -50,7 +50,7 @@ typedef struct cvar_s
int flags; int flags;
float value; float value;
struct cvar_s *next; struct cvar_s *next;
} cvar_t; } cvar_t;
/* size: 20, cachelines: 1, members: 5 */
#endif // CVARDEF_H #endif // CVARDEF_H

View File

@ -107,8 +107,7 @@ struct entity_state_s
vec3_t vuser2; vec3_t vuser2;
vec3_t vuser3; vec3_t vuser3;
vec3_t vuser4; vec3_t vuser4;
};
};/* size: 340, cachelines: 6, members: 62 */
typedef struct clientdata_s typedef struct clientdata_s
{ {
@ -154,6 +153,5 @@ typedef struct clientdata_s
Vector vuser4; Vector vuser4;
} clientdata_t; } clientdata_t;
/* size: 476, cachelines: 8, members: 40 */
#endif // ENTITY_STATE_H #endif // ENTITY_STATE_H

View File

@ -55,7 +55,7 @@ typedef vec_t vec3_t[3];
typedef vec_t vec4_t[4]; typedef vec_t vec4_t[4];
/* <42bac> ../common/mathlib.h:18 */ /* <42bac> ../common/mathlib.h:18 */
typedef int fixed16_t; /* size: 4 */ typedef int fixed16_t;
/* <42bb7> ../common/mathlib.h:60 */ /* <42bb7> ../common/mathlib.h:60 */
typedef union DLONG_u typedef union DLONG_u

View File

@ -36,8 +36,8 @@ typedef struct
{ {
vec3_t normal; vec3_t normal;
float dist; float dist;
} pmplane_t; } pmplane_t;
/* size: 16, cachelines: 1, members: 2 */
typedef struct pmtrace_s typedef struct pmtrace_s
{ {
@ -51,7 +51,7 @@ typedef struct pmtrace_s
vec3_t deltavelocity; // Change in player's velocity caused by impact. vec3_t deltavelocity; // Change in player's velocity caused by impact.
// Only run on server. // Only run on server.
int hitgroup; int hitgroup;
} pmtrace_t; } pmtrace_t;
/* size: 68, cachelines: 2, members: 10 */
#endif // PMTRACE_H #endif // PMTRACE_H

View File

@ -38,7 +38,7 @@ typedef struct mstudioevent_s
int event; int event;
int type; int type;
char options[64]; char options[64];
} mstudioevent_t; } mstudioevent_t;
/* size: 76, cachelines: 2, members: 4 */
#endif // STUDIO_EVENT_H #endif // STUDIO_EVENT_H

View File

@ -52,6 +52,5 @@ typedef struct usercmd_s
vec3_t impact_position; vec3_t impact_position;
} usercmd_t; } usercmd_t;
/* size: 52, cachelines: 1, members: 12 */
#endif // USERCMD_H #endif // USERCMD_H

View File

@ -59,6 +59,5 @@ typedef struct weapon_data_s
float fuser4; float fuser4;
} weapon_data_t; } weapon_data_t;
/* size: 88, cachelines: 2, members: 22 */
#endif // WEAPONINFO_H #endif // WEAPONINFO_H

View File

@ -36,106 +36,106 @@ typedef enum
{ {
ACT_INVALID = -1, ACT_INVALID = -1,
ACT_RESET = 0, // Set m_Activity to this invalid value to force a reset to m_IdealActivity ACT_RESET = 0, // Set m_Activity to this invalid value to force a reset to m_IdealActivity
ACT_IDLE, ACT_IDLE,
ACT_GUARD, ACT_GUARD,
ACT_WALK, ACT_WALK,
ACT_RUN, ACT_RUN,
ACT_FLY, ACT_FLY,
ACT_SWIM, ACT_SWIM,
ACT_HOP, ACT_HOP,
ACT_LEAP, ACT_LEAP,
ACT_FALL, ACT_FALL,
ACT_LAND, ACT_LAND,
ACT_STRAFE_LEFT, ACT_STRAFE_LEFT,
ACT_STRAFE_RIGHT, ACT_STRAFE_RIGHT,
ACT_ROLL_LEFT, ACT_ROLL_LEFT,
ACT_ROLL_RIGHT, ACT_ROLL_RIGHT,
ACT_TURN_LEFT, ACT_TURN_LEFT,
ACT_TURN_RIGHT, ACT_TURN_RIGHT,
ACT_CROUCH, ACT_CROUCH,
ACT_CROUCHIDLE, ACT_CROUCHIDLE,
ACT_STAND, ACT_STAND,
ACT_USE, ACT_USE,
ACT_SIGNAL1, ACT_SIGNAL1,
ACT_SIGNAL2, ACT_SIGNAL2,
ACT_SIGNAL3, ACT_SIGNAL3,
ACT_TWITCH, ACT_TWITCH,
ACT_COWER, ACT_COWER,
ACT_SMALL_FLINCH, ACT_SMALL_FLINCH,
ACT_BIG_FLINCH, ACT_BIG_FLINCH,
ACT_RANGE_ATTACK1, ACT_RANGE_ATTACK1,
ACT_RANGE_ATTACK2, ACT_RANGE_ATTACK2,
ACT_MELEE_ATTACK1, ACT_MELEE_ATTACK1,
ACT_MELEE_ATTACK2, ACT_MELEE_ATTACK2,
ACT_RELOAD, ACT_RELOAD,
ACT_ARM, ACT_ARM,
ACT_DISARM, ACT_DISARM,
ACT_EAT, ACT_EAT,
ACT_DIESIMPLE, ACT_DIESIMPLE,
ACT_DIEBACKWARD, ACT_DIEBACKWARD,
ACT_DIEFORWARD, ACT_DIEFORWARD,
ACT_DIEVIOLENT, ACT_DIEVIOLENT,
ACT_BARNACLE_HIT, ACT_BARNACLE_HIT,
ACT_BARNACLE_PULL, ACT_BARNACLE_PULL,
ACT_BARNACLE_CHOMP, ACT_BARNACLE_CHOMP,
ACT_BARNACLE_CHEW, ACT_BARNACLE_CHEW,
ACT_SLEEP, ACT_SLEEP,
ACT_INSPECT_FLOOR, ACT_INSPECT_FLOOR,
ACT_INSPECT_WALL, ACT_INSPECT_WALL,
ACT_IDLE_ANGRY, ACT_IDLE_ANGRY,
ACT_WALK_HURT, ACT_WALK_HURT,
ACT_RUN_HURT, ACT_RUN_HURT,
ACT_HOVER, ACT_HOVER,
ACT_GLIDE, ACT_GLIDE,
ACT_FLY_LEFT, ACT_FLY_LEFT,
ACT_FLY_RIGHT, ACT_FLY_RIGHT,
ACT_DETECT_SCENT, ACT_DETECT_SCENT,
ACT_SNIFF, ACT_SNIFF,
ACT_BITE, ACT_BITE,
ACT_THREAT_DISPLAY, ACT_THREAT_DISPLAY,
ACT_FEAR_DISPLAY, ACT_FEAR_DISPLAY,
ACT_EXCITED, ACT_EXCITED,
ACT_SPECIAL_ATTACK1, ACT_SPECIAL_ATTACK1,
ACT_SPECIAL_ATTACK2, ACT_SPECIAL_ATTACK2,
ACT_COMBAT_IDLE, ACT_COMBAT_IDLE,
ACT_WALK_SCARED, ACT_WALK_SCARED,
ACT_RUN_SCARED, ACT_RUN_SCARED,
ACT_VICTORY_DANCE, ACT_VICTORY_DANCE,
ACT_DIE_HEADSHOT, ACT_DIE_HEADSHOT,
ACT_DIE_CHESTSHOT, ACT_DIE_CHESTSHOT,
ACT_DIE_GUTSHOT, ACT_DIE_GUTSHOT,
ACT_DIE_BACKSHOT, ACT_DIE_BACKSHOT,
ACT_FLINCH_HEAD, ACT_FLINCH_HEAD,
ACT_FLINCH_CHEST, ACT_FLINCH_CHEST,
ACT_FLINCH_STOMACH, ACT_FLINCH_STOMACH,
ACT_FLINCH_LEFTARM, ACT_FLINCH_LEFTARM,
ACT_FLINCH_RIGHTARM, ACT_FLINCH_RIGHTARM,
ACT_FLINCH_LEFTLEG, ACT_FLINCH_LEFTLEG,
ACT_FLINCH_RIGHTLEG, ACT_FLINCH_RIGHTLEG,
ACT_FLINCH, ACT_FLINCH,
ACT_LARGE_FLINCH, ACT_LARGE_FLINCH,
ACT_HOLDBOMB, ACT_HOLDBOMB,
ACT_IDLE_FIDGET, ACT_IDLE_FIDGET,
ACT_IDLE_SCARED, ACT_IDLE_SCARED,
ACT_IDLE_SCARED_FIDGET, ACT_IDLE_SCARED_FIDGET,
ACT_FOLLOW_IDLE, ACT_FOLLOW_IDLE,
ACT_FOLLOW_IDLE_FIDGET, ACT_FOLLOW_IDLE_FIDGET,
ACT_FOLLOW_IDLE_SCARED, ACT_FOLLOW_IDLE_SCARED,
ACT_FOLLOW_IDLE_SCARED_FIDGET, ACT_FOLLOW_IDLE_SCARED_FIDGET,
ACT_CROUCH_IDLE, ACT_CROUCH_IDLE,
ACT_CROUCH_IDLE_FIDGET, ACT_CROUCH_IDLE_FIDGET,
ACT_CROUCH_IDLE_SCARED, ACT_CROUCH_IDLE_SCARED,
ACT_CROUCH_IDLE_SCARED_FIDGET, ACT_CROUCH_IDLE_SCARED_FIDGET,
ACT_CROUCH_WALK, ACT_CROUCH_WALK,
ACT_CROUCH_WALK_SCARED, ACT_CROUCH_WALK_SCARED,
ACT_CROUCH_DIE, ACT_CROUCH_DIE,
ACT_WALK_BACK, ACT_WALK_BACK,
ACT_IDLE_SNEAKY, ACT_IDLE_SNEAKY,
ACT_IDLE_SNEAKY_FIDGET, ACT_IDLE_SNEAKY_FIDGET,
ACT_WALK_SNEAKY, ACT_WALK_SNEAKY,
ACT_WAVE, ACT_WAVE,
ACT_YES, ACT_YES,
ACT_NO, ACT_NO,
} Activity; } Activity;
@ -146,7 +146,6 @@ typedef struct
char *name; char *name;
} activity_map_t; } activity_map_t;
/* size: 8, cachelines: 1, members: 2 */
extern activity_map_t activity_map[]; extern activity_map_t activity_map[];

View File

@ -10,10 +10,6 @@ TYPEDESCRIPTION CAirtank::m_SaveData[] =
DEFINE_FIELD(CAirtank, m_state, FIELD_INTEGER) DEFINE_FIELD(CAirtank, m_state, FIELD_INTEGER)
}; };
#else
TYPEDESCRIPTION IMPL_CLASS(CAirtank, m_SaveData)[1];
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
/* <5329> ../cstrike/dlls/airtank.cpp:41 */ /* <5329> ../cstrike/dlls/airtank.cpp:41 */
@ -23,7 +19,7 @@ LINK_ENTITY_TO_CLASS(item_airtank, CAirtank);
IMPLEMENT_SAVERESTORE(CAirtank, CGrenade); IMPLEMENT_SAVERESTORE(CAirtank, CGrenade);
/* <50dd> ../cstrike/dlls/airtank.cpp:50 */ /* <50dd> ../cstrike/dlls/airtank.cpp:50 */
void CAirtank::__MAKE_VHOOK(Spawn)(void) void CAirtank::__MAKE_VHOOK(Spawn)()
{ {
Precache(); Precache();
@ -46,7 +42,7 @@ void CAirtank::__MAKE_VHOOK(Spawn)(void)
} }
/* <4fef> ../cstrike/dlls/airtank.cpp:71 */ /* <4fef> ../cstrike/dlls/airtank.cpp:71 */
void CAirtank::__MAKE_VHOOK(Precache)(void) void CAirtank::__MAKE_VHOOK(Precache)()
{ {
PRECACHE_MODEL("models/w_oxygen.mdl"); PRECACHE_MODEL("models/w_oxygen.mdl");
PRECACHE_SOUND("doors/aliendoor3.wav"); PRECACHE_SOUND("doors/aliendoor3.wav");
@ -62,7 +58,7 @@ void CAirtank::__MAKE_VHOOK(Killed)(entvars_t *pevAttacker, int iGib)
} }
/* <5016> ../cstrike/dlls/airtank.cpp:88 */ /* <5016> ../cstrike/dlls/airtank.cpp:88 */
void CAirtank::TankThink(void) void CAirtank::TankThink()
{ {
// Fire trigger // Fire trigger
m_state = 1; m_state = 1;
@ -85,42 +81,13 @@ void CAirtank::TankTouch(CBaseEntity *pOther)
} }
// give player 12 more seconds of air // give player 12 more seconds of air
pOther->pev->air_finished = gpGlobals->time + 12; pOther->pev->air_finished = gpGlobals->time + 12.0f;
// suit recharge sound // suit recharge sound
EMIT_SOUND(ENT(pev), CHAN_VOICE, "doors/aliendoor3.wav", VOL_NORM, ATTN_NORM); EMIT_SOUND(ENT(pev), CHAN_VOICE, "doors/aliendoor3.wav", VOL_NORM, ATTN_NORM);
// recharge airtank in 30 seconds // recharge airtank in 30 seconds
pev->nextthink = gpGlobals->time + 30; pev->nextthink = gpGlobals->time + 30.0f;
m_state = 0; m_state = 0;
SUB_UseTargets(this, USE_TOGGLE, 1); SUB_UseTargets(this, USE_TOGGLE, 1);
} }
#ifdef HOOK_GAMEDLL
void CAirtank::Spawn(void)
{
Spawn_();
}
void CAirtank::Precache(void)
{
Precache_();
}
int CAirtank::Save(CSave &save)
{
return Save_(save);
}
int CAirtank::Restore(CRestore &restore)
{
return Restore_(restore);
}
void CAirtank::Killed(entvars_t *pevAttacker, int iGib)
{
Killed_(pevAttacker, iGib);
}
#endif // HOOK_GAMEDLL

View File

@ -37,23 +37,21 @@ class CAirtank: public CGrenade
{ {
public: public:
virtual void Spawn(void); virtual void Spawn();
virtual void Precache(void); virtual void Precache();
virtual int Save(CSave &save); virtual int Save(CSave &save);
virtual int Restore(CRestore &restore); virtual int Restore(CRestore &restore);
virtual void Killed(entvars_t *pevAttacker, int iGib); virtual void Killed(entvars_t *pevAttacker, int iGib);
virtual int BloodColor(void) virtual int BloodColor() { return DONT_BLEED; }
{
return DONT_BLEED;
}
public: public:
void EXPORT TankThink(void); void EXPORT TankThink();
void EXPORT TankTouch(CBaseEntity *pOther); void EXPORT TankTouch(CBaseEntity *pOther);
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Spawn_(void); void Spawn_();
void Precache_(void); void Precache_();
int Save_(CSave &save); int Save_(CSave &save);
int Restore_(CRestore &restore); int Restore_(CRestore &restore);
void Killed_(entvars_t *pevAttacker, int iGib); void Killed_(entvars_t *pevAttacker, int iGib);
@ -65,14 +63,6 @@ public:
private: private:
int m_state; int m_state;
}; };
#ifdef HOOK_GAMEDLL
// linked objects
C_DLLEXPORT void item_airtank(entvars_t *pev);
#endif // HOOK_GAMEDLL
#endif // AIRTANK_H #endif // AIRTANK_H

View File

@ -1,7 +1,7 @@
#include "precompiled.h" #include "precompiled.h"
/* <a6c7> ../cstrike/dlls/ammo.cpp:16 */ /* <a6c7> ../cstrike/dlls/ammo.cpp:16 */
void C9MMAmmo::__MAKE_VHOOK(Spawn)(void) void C9MMAmmo::__MAKE_VHOOK(Spawn)()
{ {
Precache(); Precache();
SET_MODEL(ENT(pev), "models/w_9mmclip.mdl"); SET_MODEL(ENT(pev), "models/w_9mmclip.mdl");
@ -9,7 +9,7 @@ void C9MMAmmo::__MAKE_VHOOK(Spawn)(void)
} }
/* <a3e2> ../cstrike/dlls/ammo.cpp:22 */ /* <a3e2> ../cstrike/dlls/ammo.cpp:22 */
void C9MMAmmo::__MAKE_VHOOK(Precache)(void) void C9MMAmmo::__MAKE_VHOOK(Precache)()
{ {
PRECACHE_MODEL("models/w_9mmclip.mdl"); PRECACHE_MODEL("models/w_9mmclip.mdl");
PRECACHE_SOUND("items/9mmclip1.wav"); PRECACHE_SOUND("items/9mmclip1.wav");
@ -31,7 +31,7 @@ BOOL C9MMAmmo::__MAKE_VHOOK(AddAmmo)(CBaseEntity *pOther)
LINK_ENTITY_TO_CLASS(ammo_9mm, C9MMAmmo); LINK_ENTITY_TO_CLASS(ammo_9mm, C9MMAmmo);
/* <a6a0> ../cstrike/dlls/ammo.cpp:42 */ /* <a6a0> ../cstrike/dlls/ammo.cpp:42 */
void CBuckShotAmmo::__MAKE_VHOOK(Spawn)(void) void CBuckShotAmmo::__MAKE_VHOOK(Spawn)()
{ {
Precache(); Precache();
SET_MODEL(ENT(pev), "models/w_shotbox.mdl"); SET_MODEL(ENT(pev), "models/w_shotbox.mdl");
@ -39,7 +39,7 @@ void CBuckShotAmmo::__MAKE_VHOOK(Spawn)(void)
} }
/* <a409> ../cstrike/dlls/ammo.cpp:48 */ /* <a409> ../cstrike/dlls/ammo.cpp:48 */
void CBuckShotAmmo::__MAKE_VHOOK(Precache)(void) void CBuckShotAmmo::__MAKE_VHOOK(Precache)()
{ {
PRECACHE_MODEL("models/w_shotbox.mdl"); PRECACHE_MODEL("models/w_shotbox.mdl");
PRECACHE_SOUND("items/9mmclip1.wav"); PRECACHE_SOUND("items/9mmclip1.wav");
@ -61,7 +61,7 @@ BOOL CBuckShotAmmo::__MAKE_VHOOK(AddAmmo)(CBaseEntity *pOther)
LINK_ENTITY_TO_CLASS(ammo_buckshot, CBuckShotAmmo); LINK_ENTITY_TO_CLASS(ammo_buckshot, CBuckShotAmmo);
/* <a679> ../cstrike/dlls/ammo.cpp:69 */ /* <a679> ../cstrike/dlls/ammo.cpp:69 */
void C556NatoAmmo::__MAKE_VHOOK(Spawn)(void) void C556NatoAmmo::__MAKE_VHOOK(Spawn)()
{ {
Precache(); Precache();
SET_MODEL(ENT(pev), "models/w_9mmclip.mdl"); SET_MODEL(ENT(pev), "models/w_9mmclip.mdl");
@ -69,7 +69,7 @@ void C556NatoAmmo::__MAKE_VHOOK(Spawn)(void)
} }
/* <a430> ../cstrike/dlls/ammo.cpp:75 */ /* <a430> ../cstrike/dlls/ammo.cpp:75 */
void C556NatoAmmo::__MAKE_VHOOK(Precache)(void) void C556NatoAmmo::__MAKE_VHOOK(Precache)()
{ {
PRECACHE_MODEL("models/w_9mmclip.mdl"); PRECACHE_MODEL("models/w_9mmclip.mdl");
PRECACHE_SOUND("items/9mmclip1.wav"); PRECACHE_SOUND("items/9mmclip1.wav");
@ -91,7 +91,7 @@ BOOL C556NatoAmmo::__MAKE_VHOOK(AddAmmo)(CBaseEntity *pOther)
LINK_ENTITY_TO_CLASS(ammo_556nato, C556NatoAmmo); LINK_ENTITY_TO_CLASS(ammo_556nato, C556NatoAmmo);
/* <a652> ../cstrike/dlls/ammo.cpp:95 */ /* <a652> ../cstrike/dlls/ammo.cpp:95 */
void C556NatoBoxAmmo::__MAKE_VHOOK(Spawn)(void) void C556NatoBoxAmmo::__MAKE_VHOOK(Spawn)()
{ {
Precache(); Precache();
SET_MODEL(ENT(pev), "models/w_9mmclip.mdl"); SET_MODEL(ENT(pev), "models/w_9mmclip.mdl");
@ -99,7 +99,7 @@ void C556NatoBoxAmmo::__MAKE_VHOOK(Spawn)(void)
} }
/* <a457> ../cstrike/dlls/ammo.cpp:101 */ /* <a457> ../cstrike/dlls/ammo.cpp:101 */
void C556NatoBoxAmmo::__MAKE_VHOOK(Precache)(void) void C556NatoBoxAmmo::__MAKE_VHOOK(Precache)()
{ {
PRECACHE_MODEL("models/w_9mmclip.mdl"); PRECACHE_MODEL("models/w_9mmclip.mdl");
PRECACHE_SOUND("items/9mmclip1.wav"); PRECACHE_SOUND("items/9mmclip1.wav");
@ -121,7 +121,7 @@ BOOL C556NatoBoxAmmo::__MAKE_VHOOK(AddAmmo)(CBaseEntity *pOther)
LINK_ENTITY_TO_CLASS(ammo_556natobox, C556NatoBoxAmmo); LINK_ENTITY_TO_CLASS(ammo_556natobox, C556NatoBoxAmmo);
/* <a62b> ../cstrike/dlls/ammo.cpp:121 */ /* <a62b> ../cstrike/dlls/ammo.cpp:121 */
void C762NatoAmmo::__MAKE_VHOOK(Spawn)(void) void C762NatoAmmo::__MAKE_VHOOK(Spawn)()
{ {
Precache(); Precache();
SET_MODEL(ENT(pev), "models/w_9mmclip.mdl"); SET_MODEL(ENT(pev), "models/w_9mmclip.mdl");
@ -129,7 +129,7 @@ void C762NatoAmmo::__MAKE_VHOOK(Spawn)(void)
} }
/* <a47e> ../cstrike/dlls/ammo.cpp:127 */ /* <a47e> ../cstrike/dlls/ammo.cpp:127 */
void C762NatoAmmo::__MAKE_VHOOK(Precache)(void) void C762NatoAmmo::__MAKE_VHOOK(Precache)()
{ {
PRECACHE_MODEL("models/w_9mmclip.mdl"); PRECACHE_MODEL("models/w_9mmclip.mdl");
PRECACHE_SOUND("items/9mmclip1.wav"); PRECACHE_SOUND("items/9mmclip1.wav");
@ -151,7 +151,7 @@ BOOL C762NatoAmmo::__MAKE_VHOOK(AddAmmo)(CBaseEntity *pOther)
LINK_ENTITY_TO_CLASS(ammo_762nato, C762NatoAmmo); LINK_ENTITY_TO_CLASS(ammo_762nato, C762NatoAmmo);
/* <a604> ../cstrike/dlls/ammo.cpp:147 */ /* <a604> ../cstrike/dlls/ammo.cpp:147 */
void C45ACPAmmo::__MAKE_VHOOK(Spawn)(void) void C45ACPAmmo::__MAKE_VHOOK(Spawn)()
{ {
Precache(); Precache();
SET_MODEL(ENT(pev), "models/w_9mmclip.mdl"); SET_MODEL(ENT(pev), "models/w_9mmclip.mdl");
@ -159,7 +159,7 @@ void C45ACPAmmo::__MAKE_VHOOK(Spawn)(void)
} }
/* <a4a5> ../cstrike/dlls/ammo.cpp:153 */ /* <a4a5> ../cstrike/dlls/ammo.cpp:153 */
void C45ACPAmmo::__MAKE_VHOOK(Precache)(void) void C45ACPAmmo::__MAKE_VHOOK(Precache)()
{ {
PRECACHE_MODEL("models/w_9mmclip.mdl"); PRECACHE_MODEL("models/w_9mmclip.mdl");
PRECACHE_SOUND("items/9mmclip1.wav"); PRECACHE_SOUND("items/9mmclip1.wav");
@ -181,7 +181,7 @@ BOOL C45ACPAmmo::__MAKE_VHOOK(AddAmmo)(CBaseEntity *pOther)
LINK_ENTITY_TO_CLASS(ammo_45acp, C45ACPAmmo); LINK_ENTITY_TO_CLASS(ammo_45acp, C45ACPAmmo);
/* <a5dd> ../cstrike/dlls/ammo.cpp:173 */ /* <a5dd> ../cstrike/dlls/ammo.cpp:173 */
void C50AEAmmo::__MAKE_VHOOK(Spawn)(void) void C50AEAmmo::__MAKE_VHOOK(Spawn)()
{ {
Precache(); Precache();
SET_MODEL(ENT(pev), "models/w_9mmclip.mdl"); SET_MODEL(ENT(pev), "models/w_9mmclip.mdl");
@ -189,7 +189,7 @@ void C50AEAmmo::__MAKE_VHOOK(Spawn)(void)
} }
/* <a4cc> ../cstrike/dlls/ammo.cpp:179 */ /* <a4cc> ../cstrike/dlls/ammo.cpp:179 */
void C50AEAmmo::__MAKE_VHOOK(Precache)(void) void C50AEAmmo::__MAKE_VHOOK(Precache)()
{ {
PRECACHE_MODEL("models/w_9mmclip.mdl"); PRECACHE_MODEL("models/w_9mmclip.mdl");
PRECACHE_SOUND("items/9mmclip1.wav"); PRECACHE_SOUND("items/9mmclip1.wav");
@ -211,7 +211,7 @@ BOOL C50AEAmmo::__MAKE_VHOOK(AddAmmo)(CBaseEntity *pOther)
LINK_ENTITY_TO_CLASS(ammo_50ae, C50AEAmmo); LINK_ENTITY_TO_CLASS(ammo_50ae, C50AEAmmo);
/* <a5b6> ../cstrike/dlls/ammo.cpp:199 */ /* <a5b6> ../cstrike/dlls/ammo.cpp:199 */
void C338MagnumAmmo::__MAKE_VHOOK(Spawn)(void) void C338MagnumAmmo::__MAKE_VHOOK(Spawn)()
{ {
Precache(); Precache();
SET_MODEL(ENT(pev), "models/w_9mmclip.mdl"); SET_MODEL(ENT(pev), "models/w_9mmclip.mdl");
@ -219,7 +219,7 @@ void C338MagnumAmmo::__MAKE_VHOOK(Spawn)(void)
} }
/* <a4f3> ../cstrike/dlls/ammo.cpp:205 */ /* <a4f3> ../cstrike/dlls/ammo.cpp:205 */
void C338MagnumAmmo::__MAKE_VHOOK(Precache)(void) void C338MagnumAmmo::__MAKE_VHOOK(Precache)()
{ {
PRECACHE_MODEL("models/w_9mmclip.mdl"); PRECACHE_MODEL("models/w_9mmclip.mdl");
PRECACHE_SOUND("items/9mmclip1.wav"); PRECACHE_SOUND("items/9mmclip1.wav");
@ -241,7 +241,7 @@ BOOL C338MagnumAmmo::__MAKE_VHOOK(AddAmmo)(CBaseEntity *pOther)
LINK_ENTITY_TO_CLASS(ammo_338magnum, C338MagnumAmmo); LINK_ENTITY_TO_CLASS(ammo_338magnum, C338MagnumAmmo);
/* <a58f> ../cstrike/dlls/ammo.cpp:226 */ /* <a58f> ../cstrike/dlls/ammo.cpp:226 */
void C57MMAmmo::__MAKE_VHOOK(Spawn)(void) void C57MMAmmo::__MAKE_VHOOK(Spawn)()
{ {
Precache(); Precache();
SET_MODEL(ENT(pev), "models/w_9mmclip.mdl"); SET_MODEL(ENT(pev), "models/w_9mmclip.mdl");
@ -249,7 +249,7 @@ void C57MMAmmo::__MAKE_VHOOK(Spawn)(void)
} }
/* <a51a> ../cstrike/dlls/ammo.cpp:232 */ /* <a51a> ../cstrike/dlls/ammo.cpp:232 */
void C57MMAmmo::__MAKE_VHOOK(Precache)(void) void C57MMAmmo::__MAKE_VHOOK(Precache)()
{ {
PRECACHE_MODEL("models/w_9mmclip.mdl"); PRECACHE_MODEL("models/w_9mmclip.mdl");
PRECACHE_SOUND("items/9mmclip1.wav"); PRECACHE_SOUND("items/9mmclip1.wav");
@ -271,7 +271,7 @@ BOOL C57MMAmmo::__MAKE_VHOOK(AddAmmo)(CBaseEntity *pOther)
LINK_ENTITY_TO_CLASS(ammo_57mm, C57MMAmmo); LINK_ENTITY_TO_CLASS(ammo_57mm, C57MMAmmo);
/* <a568> ../cstrike/dlls/ammo.cpp:251 */ /* <a568> ../cstrike/dlls/ammo.cpp:251 */
void C357SIGAmmo::__MAKE_VHOOK(Spawn)(void) void C357SIGAmmo::__MAKE_VHOOK(Spawn)()
{ {
Precache(); Precache();
SET_MODEL(ENT(pev), "models/w_9mmclip.mdl"); SET_MODEL(ENT(pev), "models/w_9mmclip.mdl");
@ -279,7 +279,7 @@ void C357SIGAmmo::__MAKE_VHOOK(Spawn)(void)
} }
/* <a541> ../cstrike/dlls/ammo.cpp:257 */ /* <a541> ../cstrike/dlls/ammo.cpp:257 */
void C357SIGAmmo::__MAKE_VHOOK(Precache)(void) void C357SIGAmmo::__MAKE_VHOOK(Precache)()
{ {
PRECACHE_MODEL("models/w_9mmclip.mdl"); PRECACHE_MODEL("models/w_9mmclip.mdl");
PRECACHE_SOUND("items/9mmclip1.wav"); PRECACHE_SOUND("items/9mmclip1.wav");
@ -299,157 +299,3 @@ BOOL C357SIGAmmo::__MAKE_VHOOK(AddAmmo)(CBaseEntity *pOther)
/* <b403> ../cstrike/dlls/ammo.cpp:272 */ /* <b403> ../cstrike/dlls/ammo.cpp:272 */
LINK_ENTITY_TO_CLASS(ammo_357sig, C357SIGAmmo); LINK_ENTITY_TO_CLASS(ammo_357sig, C357SIGAmmo);
#ifdef HOOK_GAMEDLL
void C9MMAmmo::Spawn(void)
{
Spawn_();
}
void C9MMAmmo::Precache(void)
{
Precache_();
}
BOOL C9MMAmmo::AddAmmo(CBaseEntity *pOther)
{
return AddAmmo_(pOther);
}
void CBuckShotAmmo::Spawn(void)
{
Spawn_();
}
void CBuckShotAmmo::Precache(void)
{
Precache_();
}
BOOL CBuckShotAmmo::AddAmmo(CBaseEntity *pOther)
{
return AddAmmo_(pOther);
}
void C556NatoAmmo::Spawn(void)
{
Spawn_();
}
void C556NatoAmmo::Precache(void)
{
Precache_();
}
BOOL C556NatoAmmo::AddAmmo(CBaseEntity *pOther)
{
return AddAmmo_(pOther);
}
void C556NatoBoxAmmo::Spawn(void)
{
Spawn_();
}
void C556NatoBoxAmmo::Precache(void)
{
Precache_();
}
BOOL C556NatoBoxAmmo::AddAmmo(CBaseEntity *pOther)
{
return AddAmmo_(pOther);
}
void C762NatoAmmo::Spawn(void)
{
Spawn_();
}
void C762NatoAmmo::Precache(void)
{
Precache_();
}
BOOL C762NatoAmmo::AddAmmo(CBaseEntity *pOther)
{
return AddAmmo_(pOther);
}
void C45ACPAmmo::Spawn(void)
{
Spawn_();
}
void C45ACPAmmo::Precache(void)
{
Precache_();
}
BOOL C45ACPAmmo::AddAmmo(CBaseEntity *pOther)
{
return AddAmmo_(pOther);
}
void C50AEAmmo::Spawn(void)
{
Spawn_();
}
void C50AEAmmo::Precache(void)
{
Precache_();
}
BOOL C50AEAmmo::AddAmmo(CBaseEntity *pOther)
{
return AddAmmo_(pOther);
}
void C338MagnumAmmo::Spawn(void)
{
Spawn_();
}
void C338MagnumAmmo::Precache(void)
{
Precache_();
}
BOOL C338MagnumAmmo::AddAmmo(CBaseEntity *pOther)
{
return AddAmmo_(pOther);
}
void C57MMAmmo::Spawn(void)
{
Spawn_();
}
void C57MMAmmo::Precache(void)
{
Precache_();
}
BOOL C57MMAmmo::AddAmmo(CBaseEntity *pOther)
{
return AddAmmo_(pOther);
}
void C357SIGAmmo::Spawn(void)
{
Spawn_();
}
void C357SIGAmmo::Precache(void)
{
Precache_();
}
BOOL C357SIGAmmo::AddAmmo(CBaseEntity *pOther)
{
return AddAmmo_(pOther);
}
#endif // HOOK_GAMEDLL

View File

@ -36,196 +36,180 @@
class C9MMAmmo: public CBasePlayerAmmo class C9MMAmmo: public CBasePlayerAmmo
{ {
public: public:
virtual void Spawn(void); virtual void Spawn();
virtual void Precache(void); virtual void Precache();
virtual BOOL AddAmmo(CBaseEntity *pOther); virtual BOOL AddAmmo(CBaseEntity *pOther);
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Spawn_(void); void Spawn_();
void Precache_(void); void Precache_();
BOOL AddAmmo_(CBaseEntity *pOther); BOOL AddAmmo_(CBaseEntity *pOther);
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
};/* size: 152, cachelines: 3, members: 1 */ };
/* <97df> ../cstrike/dlls/ammo.cpp:40 */ /* <97df> ../cstrike/dlls/ammo.cpp:40 */
class CBuckShotAmmo: public CBasePlayerAmmo class CBuckShotAmmo: public CBasePlayerAmmo
{ {
public: public:
virtual void Spawn(void); virtual void Spawn();
virtual void Precache(void); virtual void Precache();
virtual BOOL AddAmmo(CBaseEntity *pOther); virtual BOOL AddAmmo(CBaseEntity *pOther);
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Spawn_(void); void Spawn_();
void Precache_(void); void Precache_();
BOOL AddAmmo_(CBaseEntity *pOther); BOOL AddAmmo_(CBaseEntity *pOther);
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
};/* size: 152, cachelines: 3, members: 1 */ };
/* <982c> ../cstrike/dlls/ammo.cpp:67 */ /* <982c> ../cstrike/dlls/ammo.cpp:67 */
class C556NatoAmmo: public CBasePlayerAmmo class C556NatoAmmo: public CBasePlayerAmmo
{ {
public: public:
virtual void Spawn(void); virtual void Spawn();
virtual void Precache(void); virtual void Precache();
virtual BOOL AddAmmo(CBaseEntity *pOther); virtual BOOL AddAmmo(CBaseEntity *pOther);
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Spawn_(void); void Spawn_();
void Precache_(void); void Precache_();
BOOL AddAmmo_(CBaseEntity *pOther); BOOL AddAmmo_(CBaseEntity *pOther);
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
};/* size: 152, cachelines: 3, members: 1 */ };
/* <9879> ../cstrike/dlls/ammo.cpp:93 */ /* <9879> ../cstrike/dlls/ammo.cpp:93 */
class C556NatoBoxAmmo: public CBasePlayerAmmo class C556NatoBoxAmmo: public CBasePlayerAmmo
{ {
public: public:
virtual void Spawn(void); virtual void Spawn();
virtual void Precache(void); virtual void Precache();
virtual BOOL AddAmmo(CBaseEntity *pOther); virtual BOOL AddAmmo(CBaseEntity *pOther);
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Spawn_(void); void Spawn_();
void Precache_(void); void Precache_();
BOOL AddAmmo_(CBaseEntity *pOther); BOOL AddAmmo_(CBaseEntity *pOther);
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
};/* size: 152, cachelines: 3, members: 1 */ };
/* <98c6> ../cstrike/dlls/ammo.cpp:119 */ /* <98c6> ../cstrike/dlls/ammo.cpp:119 */
class C762NatoAmmo: public CBasePlayerAmmo class C762NatoAmmo: public CBasePlayerAmmo
{ {
public: public:
virtual void Spawn(void); virtual void Spawn();
virtual void Precache(void); virtual void Precache();
virtual BOOL AddAmmo(CBaseEntity *pOther); virtual BOOL AddAmmo(CBaseEntity *pOther);
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Spawn_(void); void Spawn_();
void Precache_(void); void Precache_();
BOOL AddAmmo_(CBaseEntity *pOther); BOOL AddAmmo_(CBaseEntity *pOther);
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
};/* size: 152, cachelines: 3, members: 1 */ };
/* <9913> ../cstrike/dlls/ammo.cpp:145 */ /* <9913> ../cstrike/dlls/ammo.cpp:145 */
class C45ACPAmmo: public CBasePlayerAmmo class C45ACPAmmo: public CBasePlayerAmmo
{ {
public: public:
virtual void Spawn(void); virtual void Spawn();
virtual void Precache(void); virtual void Precache();
virtual BOOL AddAmmo(CBaseEntity *pOther); virtual BOOL AddAmmo(CBaseEntity *pOther);
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Spawn_(void); void Spawn_();
void Precache_(void); void Precache_();
BOOL AddAmmo_(CBaseEntity *pOther); BOOL AddAmmo_(CBaseEntity *pOther);
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
};/* size: 152, cachelines: 3, members: 1 */ };
/* <9960> ../cstrike/dlls/ammo.cpp:171 */ /* <9960> ../cstrike/dlls/ammo.cpp:171 */
class C50AEAmmo: public CBasePlayerAmmo class C50AEAmmo: public CBasePlayerAmmo
{ {
public: public:
virtual void Spawn(void); virtual void Spawn();
virtual void Precache(void); virtual void Precache();
virtual BOOL AddAmmo(CBaseEntity *pOther); virtual BOOL AddAmmo(CBaseEntity *pOther);
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Spawn_(void); void Spawn_();
void Precache_(void); void Precache_();
BOOL AddAmmo_(CBaseEntity *pOther); BOOL AddAmmo_(CBaseEntity *pOther);
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
};/* size: 152, cachelines: 3, members: 1 */ };
/* <99ad> ../cstrike/dlls/ammo.cpp:197 */ /* <99ad> ../cstrike/dlls/ammo.cpp:197 */
class C338MagnumAmmo: public CBasePlayerAmmo class C338MagnumAmmo: public CBasePlayerAmmo
{ {
public: public:
virtual void Spawn(void); virtual void Spawn();
virtual void Precache(void); virtual void Precache();
virtual BOOL AddAmmo(CBaseEntity *pOther); virtual BOOL AddAmmo(CBaseEntity *pOther);
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Spawn_(void); void Spawn_();
void Precache_(void); void Precache_();
BOOL AddAmmo_(CBaseEntity *pOther); BOOL AddAmmo_(CBaseEntity *pOther);
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
};/* size: 152, cachelines: 3, members: 1 */ };
/* <99fa> ../cstrike/dlls/ammo.cpp:224 */ /* <99fa> ../cstrike/dlls/ammo.cpp:224 */
class C57MMAmmo: public CBasePlayerAmmo class C57MMAmmo: public CBasePlayerAmmo
{ {
public: public:
virtual void Spawn(void); virtual void Spawn();
virtual void Precache(void); virtual void Precache();
virtual BOOL AddAmmo(CBaseEntity *pOther); virtual BOOL AddAmmo(CBaseEntity *pOther);
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Spawn_(void); void Spawn_();
void Precache_(void); void Precache_();
BOOL AddAmmo_(CBaseEntity *pOther); BOOL AddAmmo_(CBaseEntity *pOther);
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
};/* size: 152, cachelines: 3, members: 1 */ };
/* <9a47> ../cstrike/dlls/ammo.cpp:249 */ /* <9a47> ../cstrike/dlls/ammo.cpp:249 */
class C357SIGAmmo: public CBasePlayerAmmo class C357SIGAmmo: public CBasePlayerAmmo
{ {
public: public:
virtual void Spawn(void); virtual void Spawn();
virtual void Precache(void); virtual void Precache();
virtual BOOL AddAmmo(CBaseEntity *pOther); virtual BOOL AddAmmo(CBaseEntity *pOther);
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Spawn_(void); void Spawn_();
void Precache_(void); void Precache_();
BOOL AddAmmo_(CBaseEntity *pOther); BOOL AddAmmo_(CBaseEntity *pOther);
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
};/* size: 152, cachelines: 3, members: 1 */ };
#ifdef HOOK_GAMEDLL
// linked objects
C_DLLEXPORT void ammo_9mm(entvars_t *pev);
C_DLLEXPORT void ammo_buckshot(entvars_t *pev);
C_DLLEXPORT void ammo_556nato(entvars_t *pev);
C_DLLEXPORT void ammo_556natobox(entvars_t *pev);
C_DLLEXPORT void ammo_762nato(entvars_t *pev);
C_DLLEXPORT void ammo_45acp(entvars_t *pev);
C_DLLEXPORT void ammo_50ae(entvars_t *pev);
C_DLLEXPORT void ammo_338magnum(entvars_t *pev);
C_DLLEXPORT void ammo_57mm(entvars_t *pev);
C_DLLEXPORT void ammo_357sig(entvars_t *pev);
#endif // HOOK_GAMEDLL
#endif // AMMO_H #endif // AMMO_H

View File

@ -14,10 +14,6 @@ TYPEDESCRIPTION CBaseAnimating::m_SaveData[] =
DEFINE_FIELD(CBaseMonster, m_fSequenceLoops, FIELD_BOOLEAN), DEFINE_FIELD(CBaseMonster, m_fSequenceLoops, FIELD_BOOLEAN),
}; };
#else
TYPEDESCRIPTION IMPL_CLASS(CBaseAnimating, m_SaveData)[5];
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
/* <10583> ../cstrike/dlls/animating.cpp:38 */ /* <10583> ../cstrike/dlls/animating.cpp:38 */
@ -112,7 +108,7 @@ int CBaseAnimating::LookupSequence(const char *label)
} }
/* <10711> ../cstrike/dlls/animating.cpp:110 */ /* <10711> ../cstrike/dlls/animating.cpp:110 */
void CBaseAnimating::ResetSequenceInfo(void) void CBaseAnimating::ResetSequenceInfo()
{ {
void *pmodel = GET_MODEL_PTR(ENT(pev)); void *pmodel = GET_MODEL_PTR(ENT(pev));
@ -126,7 +122,7 @@ void CBaseAnimating::ResetSequenceInfo(void)
} }
/* <1077c> ../cstrike/dlls/animating.cpp:126 */ /* <1077c> ../cstrike/dlls/animating.cpp:126 */
BOOL CBaseAnimating::GetSequenceFlags(void) BOOL CBaseAnimating::GetSequenceFlags()
{ {
void *pmodel = GET_MODEL_PTR(ENT(pev)); void *pmodel = GET_MODEL_PTR(ENT(pev));
return ::GetSequenceFlags(pmodel, pev); return ::GetSequenceFlags(pmodel, pev);
@ -141,7 +137,7 @@ float CBaseAnimating::SetBoneController(int iController, float flValue)
} }
/* <10893> ../cstrike/dlls/animating.cpp:180 */ /* <10893> ../cstrike/dlls/animating.cpp:180 */
void CBaseAnimating::InitBoneControllers(void) void CBaseAnimating::InitBoneControllers()
{ {
void *pmodel = GET_MODEL_PTR(ENT(pev)); void *pmodel = GET_MODEL_PTR(ENT(pev));
@ -214,7 +210,7 @@ int CBaseAnimating::ExtractBbox(int sequence, float *mins, float *maxs)
} }
/* <10b99> ../cstrike/dlls/animating.cpp:258 */ /* <10b99> ../cstrike/dlls/animating.cpp:258 */
void CBaseAnimating::SetSequenceBox(void) void CBaseAnimating::SetSequenceBox()
{ {
Vector mins, maxs; Vector mins, maxs;
@ -280,17 +276,3 @@ void CBaseAnimating::SetSequenceBox(void)
UTIL_SetSize(pev, rmin, rmax); UTIL_SetSize(pev, rmin, rmax);
} }
} }
#ifdef HOOK_GAMEDLL
int CBaseAnimating::Save(CSave &save)
{
return Save_(save);
}
int CBaseAnimating::Restore(CRestore &restore)
{
return Restore_(restore);
}
#endif // HOOK_GAMEDLL

View File

@ -11,10 +11,6 @@ sv_blending_interface_t svBlending =
SV_StudioSetupBones SV_StudioSetupBones
}; };
#else
sv_blending_interface_t svBlending;
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
server_studio_api_t IEngineStudio; server_studio_api_t IEngineStudio;
@ -23,12 +19,6 @@ studiohdr_t *g_pstudiohdr;
float (*g_pRotationMatrix)[3][4]; float (*g_pRotationMatrix)[3][4];
float (*g_pBoneTransform)[128][3][4]; float (*g_pBoneTransform)[128][3][4];
float omega;
float cosom;
float sinom;
float sclp;
float sclq;
/* <1523e> ../cstrike/dlls/animation.cpp:57 */ /* <1523e> ../cstrike/dlls/animation.cpp:57 */
int ExtractBbox(void *pmodel, int sequence, float *mins, float *maxs) int ExtractBbox(void *pmodel, int sequence, float *mins, float *maxs)
{ {
@ -657,7 +647,8 @@ void QuaternionSlerp(vec_t *p, vec_t *q, float t, vec_t *qt)
q[i] = -q[i]; q[i] = -q[i];
} }
cosom = (p[0] * q[0] + p[1] * q[1] + p[2] * q[2] + p[3] * q[3]); float sclp, sclq;
float cosom = (p[0] * q[0] + p[1] * q[1] + p[2] * q[2] + p[3] * q[3]);
if ((1.0 + cosom) > 0.00000001) if ((1.0 + cosom) > 0.00000001)
{ {
@ -665,8 +656,8 @@ void QuaternionSlerp(vec_t *p, vec_t *q, float t, vec_t *qt)
{ {
float_precision cosomega = acos((float_precision)cosom); float_precision cosomega = acos((float_precision)cosom);
omega = cosomega; float omega = cosomega;
sinom = sin(cosomega); float sinom = sin(cosomega);
sclp = sin((1.0 - t) * omega) / sinom; sclp = sin((1.0 - t) * omega) / sinom;
sclq = sin((float_precision)(omega * t)) / sinom; sclq = sin((float_precision)(omega * t)) / sinom;
@ -1040,8 +1031,8 @@ void SV_StudioSetupBones(model_t *pModel, float frame, int sequence, const vec_t
int chainlength; int chainlength;
vec3_t temp_angles; vec3_t temp_angles;
static float pos[MAXSTUDIOBONES][3], pos2[MAXSTUDIOBONES][3]; /*static */float pos[MAXSTUDIOBONES][3], pos2[MAXSTUDIOBONES][3];
static float q[MAXSTUDIOBONES][4], q2[MAXSTUDIOBONES][4]; /*static */float q[MAXSTUDIOBONES][4], q2[MAXSTUDIOBONES][4];
g_pstudiohdr = (studiohdr_t *)IEngineStudio.Mod_Extradata(pModel); g_pstudiohdr = (studiohdr_t *)IEngineStudio.Mod_Extradata(pModel);
@ -1074,7 +1065,7 @@ void SV_StudioSetupBones(model_t *pModel, float frame, int sequence, const vec_t
f = StudioEstimateFrame(frame, pseqdesc); f = StudioEstimateFrame(frame, pseqdesc);
subframe = (int)f; subframe = (int)f;
f -= subframe; f -= subframe;
StudioCalcBoneAdj(0, adj, pcontroller, pcontroller, 0); StudioCalcBoneAdj(0, adj, pcontroller, pcontroller, 0);
StudioCalcRotations(pbones, chain, chainlength, adj, pos, q, pseqdesc, panim, subframe, f); StudioCalcRotations(pbones, chain, chainlength, adj, pos, q, pseqdesc, panim, subframe, f);
@ -1095,8 +1086,8 @@ void SV_StudioSetupBones(model_t *pModel, float frame, int sequence, const vec_t
// This game knows how to do nine way blending // This game knows how to do nine way blending
else else
{ {
static float pos3[MAXSTUDIOBONES][3], pos4[MAXSTUDIOBONES][3]; /*static */float pos3[MAXSTUDIOBONES][3], pos4[MAXSTUDIOBONES][3];
static float q3[MAXSTUDIOBONES][4], q4[MAXSTUDIOBONES][4]; /*static */float q3[MAXSTUDIOBONES][4], q4[MAXSTUDIOBONES][4];
float_precision s, t; float_precision s, t;

View File

@ -69,30 +69,4 @@ void StudioCalcRotations(mstudiobone_t *pbones, int *chain, int chainlength, flo
void ConcatTransforms(float in1[3][4], float in2[3][4], float out[3][4]); void ConcatTransforms(float in1[3][4], float in2[3][4], float out[3][4]);
void SV_StudioSetupBones(model_t *pModel, float frame, int sequence, const vec_t *angles, const vec_t *origin, const byte *pcontroller, const byte *pblending, int iBone, const edict_t *pEdict); void SV_StudioSetupBones(model_t *pModel, float frame, int sequence, const vec_t *angles, const vec_t *origin, const byte *pcontroller, const byte *pblending, int iBone, const edict_t *pEdict);
#ifdef HOOK_GAMEDLL
#define svBlending (*psvBlending)
#define IEngineStudio (*pIEngineStudio)
#define g_pstudiohdr (*pg_pstudiohdr)
#define g_pRotationMatrix (*pg_pRotationMatrix)
#define g_pBoneTransform (*pg_pBoneTransform)
#define omega (*pomega)
#define cosom (*pcosom)
#define sinom (*psinom)
#define sclp (*psclp)
#define sclq (*psclq)
#endif // HOOK_GAMEDLL
extern struct sv_blending_interface_s svBlending;
extern server_studio_api_t IEngineStudio;
extern studiohdr_t *g_pstudiohdr;
extern float (*g_pRotationMatrix)[3][4];
extern float (*g_pBoneTransform)[128][3][4];
extern float omega;
extern float cosom;
extern float sinom;
extern float sclp;
extern float sclq;
#endif // ANIMATION_H #endif // ANIMATION_H

View File

@ -47,29 +47,23 @@ public:
virtual int TakeDamage(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType); virtual int TakeDamage(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType);
virtual int TakeHealth(float flHealth, int bitsDamageType); virtual int TakeHealth(float flHealth, int bitsDamageType);
virtual void Killed(entvars_t *pevAttacker, int iGib); virtual void Killed(entvars_t *pevAttacker, int iGib);
virtual int BloodColor(void) virtual int BloodColor() { return m_bloodColor; }
{ virtual BOOL IsAlive() { return (pev->deadflag != DEAD_DEAD); }
return m_bloodColor;
}
virtual BOOL IsAlive(void)
{
return (pev->deadflag != DEAD_DEAD);
}
virtual float ChangeYaw(int speed); virtual float ChangeYaw(int speed);
virtual BOOL HasHumanGibs(void); virtual BOOL HasHumanGibs();
virtual BOOL HasAlienGibs(void); virtual BOOL HasAlienGibs();
virtual void FadeMonster(void); virtual void FadeMonster();
virtual void GibMonster(void); virtual void GibMonster();
NOXREF virtual Activity GetDeathActivity(void); NOXREF virtual Activity GetDeathActivity();
virtual void BecomeDead(void); virtual void BecomeDead();
virtual BOOL ShouldFadeOnDeath(void); virtual BOOL ShouldFadeOnDeath();
virtual int IRelationship(CBaseEntity *pTarget); virtual int IRelationship(CBaseEntity *pTarget);
virtual void PainSound(void) {} virtual void PainSound() {}
virtual void ResetMaxSpeed(void) {} virtual void ResetMaxSpeed() {}
virtual void ReportAIState(void) {} virtual void ReportAIState() {}
virtual void MonsterInitDead(void); virtual void MonsterInitDead();
virtual void Look(int iDistance); virtual void Look(int iDistance);
virtual CBaseEntity *BestVisibleEnemy(void); virtual CBaseEntity *BestVisibleEnemy();
virtual BOOL FInViewCone(CBaseEntity *pEntity); virtual BOOL FInViewCone(CBaseEntity *pEntity);
virtual BOOL FInViewCone(const Vector *pOrigin); virtual BOOL FInViewCone(const Vector *pOrigin);
@ -81,17 +75,17 @@ public:
int TakeHealth_(float flHealth, int bitsDamageType); int TakeHealth_(float flHealth, int bitsDamageType);
void Killed_(entvars_t *pevAttacker, int iGib); void Killed_(entvars_t *pevAttacker, int iGib);
float ChangeYaw_(int speed); float ChangeYaw_(int speed);
BOOL HasHumanGibs_(void); BOOL HasHumanGibs_();
BOOL HasAlienGibs_(void); BOOL HasAlienGibs_();
void FadeMonster_(void); void FadeMonster_();
void GibMonster_(void); void GibMonster_();
Activity GetDeathActivity_(void); Activity GetDeathActivity_();
void BecomeDead_(void); void BecomeDead_();
BOOL ShouldFadeOnDeath_(void); BOOL ShouldFadeOnDeath_();
int IRelationship_(CBaseEntity *pTarget); int IRelationship_(CBaseEntity *pTarget);
void MonsterInitDead_(void); void MonsterInitDead_();
void Look_(int iDistance); void Look_(int iDistance);
CBaseEntity *BestVisibleEnemy_(void); CBaseEntity *BestVisibleEnemy_();
BOOL FInViewCone_(CBaseEntity *pEntity); BOOL FInViewCone_(CBaseEntity *pEntity);
BOOL FInViewCone_(const Vector *pOrigin); BOOL FInViewCone_(const Vector *pOrigin);
@ -99,10 +93,10 @@ public:
public: public:
void MakeIdealYaw(Vector vecTarget); void MakeIdealYaw(Vector vecTarget);
NOXREF Activity GetSmallFlinchActivity(void); NOXREF Activity GetSmallFlinchActivity();
BOOL ShouldGibMonster(int iGib); BOOL ShouldGibMonster(int iGib);
void CallGibMonster(void); void CallGibMonster();
BOOL FCheckAITrigger(void); BOOL FCheckAITrigger();
int DeadTakeDamage(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType); int DeadTakeDamage(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType);
float DamageForce(float damage); float DamageForce(float damage);
void RadiusDamage(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int iClassIgnore, int bitsDamageType); void RadiusDamage(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int iClassIgnore, int bitsDamageType);
@ -111,65 +105,22 @@ public:
{ {
::RadiusDamage2(vecSrc, pevInflictor, pevAttacker, flDamage, flDamage * (RANDOM_FLOAT(0.5, 1.5) + 3), iClassIgnore, bitsDamageType); ::RadiusDamage2(vecSrc, pevInflictor, pevAttacker, flDamage, flDamage * (RANDOM_FLOAT(0.5, 1.5) + 3), iClassIgnore, bitsDamageType);
} }
void SetConditions(int iConditions) void SetConditions(int iConditions) { m_afConditions |= iConditions; }
{ void ClearConditions(int iConditions) { m_afConditions &= ~iConditions; }
m_afConditions |= iConditions; BOOL HasConditions(int iConditions) { return (m_afConditions & iConditions) ? TRUE : FALSE; }
} BOOL HasAllConditions(int iConditions) { return ((m_afConditions & iConditions) == iConditions) ? TRUE : FALSE; }
void ClearConditions(int iConditions)
{ void Remember(int iMemory) { m_afMemory |= iMemory; }
m_afConditions &= ~iConditions; void Forget(int iMemory) { m_afMemory &= ~iMemory; }
} BOOL HasMemory(int iMemory) { return (m_afMemory & iMemory) ? TRUE : FALSE; }
BOOL HasConditions(int iConditions) BOOL HasAllMemories(int iMemory) { return ((m_afMemory & iMemory) == iMemory) ? TRUE : FALSE; }
{
if (m_afConditions & iConditions) void StopAnimation() { pev->framerate = 0.0f; }
{
return TRUE; NOXREF void CorpseFallThink();
}
return FALSE;
}
BOOL HasAllConditions(int iConditions)
{
if ((m_afConditions & iConditions) == iConditions)
{
return TRUE;
}
return FALSE;
}
void Remember(int iMemory)
{
m_afMemory |= iMemory;
}
void Forget(int iMemory)
{
m_afMemory &= ~iMemory;
}
BOOL HasMemory(int iMemory)
{
if (m_afMemory & iMemory)
{
return TRUE;
}
return FALSE;
}
BOOL HasAllMemories(int iMemory)
{
if ((m_afMemory & iMemory) == iMemory)
{
return TRUE;
}
return FALSE;
}
void StopAnimation(void)
{
pev->framerate = 0.0;
}
NOXREF void CorpseFallThink(void);
NOXREF CBaseEntity *CheckTraceHullAttack(float flDist, int iDamage, int iDmgType); NOXREF CBaseEntity *CheckTraceHullAttack(float flDist, int iDamage, int iDmgType);
NOXREF void MakeDamageBloodDecal(int cCount, float flNoise, TraceResult *ptr, Vector &vecDir); NOXREF void MakeDamageBloodDecal(int cCount, float flNoise, TraceResult *ptr, Vector &vecDir);
void MonsterUse(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value) void MonsterUse(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value) { m_IdealMonsterState = MONSTERSTATE_ALERT; }
{
m_IdealMonsterState = MONSTERSTATE_ALERT;
}
void BloodSplat(const Vector &vecSrc, const Vector &vecDir, int HitLocation, int iVelocity); void BloodSplat(const Vector &vecSrc, const Vector &vecDir, int HitLocation, int iVelocity);
public: public:
@ -178,10 +129,12 @@ public:
int m_LastHitGroup; // the last body region that took damage int m_LastHitGroup; // the last body region that took damage
int m_bitsDamageType; // what types of damage has monster (player) taken int m_bitsDamageType; // what types of damage has monster (player) taken
BYTE m_rgbTimeBasedDamage[8]; BYTE m_rgbTimeBasedDamage[8];
MONSTERSTATE m_MonsterState; // monster's current state MONSTERSTATE m_MonsterState; // monster's current state
MONSTERSTATE m_IdealMonsterState; // monster should change to this state MONSTERSTATE m_IdealMonsterState; // monster should change to this state
int m_afConditions; int m_afConditions;
int m_afMemory; int m_afMemory;
float m_flNextAttack; // cannot attack again until this time float m_flNextAttack; // cannot attack again until this time
EHANDLE m_hEnemy; // the entity that the monster is fighting. EHANDLE m_hEnemy; // the entity that the monster is fighting.
EHANDLE m_hTargetEnt; // the entity that the monster is trying to reach EHANDLE m_hTargetEnt; // the entity that the monster is trying to reach
@ -189,17 +142,6 @@ public:
int m_bloodColor; // color of blood particless int m_bloodColor; // color of blood particless
Vector m_HackedGunPos; // HACK until we can query end of gun Vector m_HackedGunPos; // HACK until we can query end of gun
Vector m_vecEnemyLKP; // last known position of enemy. (enemy's origin) Vector m_vecEnemyLKP; // last known position of enemy. (enemy's origin)
};
};/* size: 404, cachelines: 7, members: 17 */
#ifdef HOOK_GAMEDLL
typedef void (CBaseMonster::*RADIUSDAMAGE_ENTVARS)(entvars_t *, entvars_t *, float, int, int);
typedef void (CBaseMonster::*RADIUSDAMAGE_VECTOR)(Vector, entvars_t *, entvars_t *, float, int, int);
typedef BOOL (CBaseMonster::*FINVIEWCONE_ENTITY)(CBaseEntity *);
typedef BOOL (CBaseMonster::*FINVIEWCONE_VECTOR)(const Vector *);
#endif // HOOK_GAMEDLL
#endif // BASEMONSTER_H #endif // BASEMONSTER_H

View File

@ -26,11 +26,6 @@ TYPEDESCRIPTION CPendulum::m_SaveData[] =
DEFINE_FIELD(CPendulum, m_start, FIELD_VECTOR), DEFINE_FIELD(CPendulum, m_start, FIELD_VECTOR),
}; };
#else
TYPEDESCRIPTION IMPL_CLASS(CFuncRotating, m_SaveData)[5];
TYPEDESCRIPTION IMPL_CLASS(CPendulum, m_SaveData)[8];
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
// BModelOrigin - calculates origin of a bmodel from absmin/size because all bmodel origins are 0 0 0 // BModelOrigin - calculates origin of a bmodel from absmin/size because all bmodel origins are 0 0 0
@ -45,7 +40,7 @@ Vector VecBModelOrigin(entvars_t *pevBModel)
LINK_ENTITY_TO_CLASS(func_wall, CFuncWall); LINK_ENTITY_TO_CLASS(func_wall, CFuncWall);
/* <1d193> ../cstrike/dlls/bmodels.cpp:65 */ /* <1d193> ../cstrike/dlls/bmodels.cpp:65 */
void CFuncWall::__MAKE_VHOOK(Spawn)(void) void CFuncWall::__MAKE_VHOOK(Spawn)()
{ {
pev->angles = g_vecZero; pev->angles = g_vecZero;
@ -72,7 +67,7 @@ void CFuncWall::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCaller,
LINK_ENTITY_TO_CLASS(func_wall_toggle, CFuncWallToggle); LINK_ENTITY_TO_CLASS(func_wall_toggle, CFuncWallToggle);
/* <1e28f> ../cstrike/dlls/bmodels.cpp:98 */ /* <1e28f> ../cstrike/dlls/bmodels.cpp:98 */
void CFuncWallToggle::__MAKE_VHOOK(Spawn)(void) void CFuncWallToggle::__MAKE_VHOOK(Spawn)()
{ {
CFuncWall::Spawn(); CFuncWall::Spawn();
@ -83,7 +78,7 @@ void CFuncWallToggle::__MAKE_VHOOK(Spawn)(void)
} }
/* <1e518> ../cstrike/dlls/bmodels.cpp:106 */ /* <1e518> ../cstrike/dlls/bmodels.cpp:106 */
void CFuncWallToggle::TurnOff(void) void CFuncWallToggle::TurnOff()
{ {
pev->solid = SOLID_NOT; pev->solid = SOLID_NOT;
pev->effects |= EF_NODRAW; pev->effects |= EF_NODRAW;
@ -91,7 +86,7 @@ void CFuncWallToggle::TurnOff(void)
} }
/* <1e53a> ../cstrike/dlls/bmodels.cpp:114 */ /* <1e53a> ../cstrike/dlls/bmodels.cpp:114 */
void CFuncWallToggle::TurnOn(void) void CFuncWallToggle::TurnOn()
{ {
pev->solid = SOLID_BSP; pev->solid = SOLID_BSP;
pev->effects &= ~EF_NODRAW; pev->effects &= ~EF_NODRAW;
@ -99,7 +94,7 @@ void CFuncWallToggle::TurnOn(void)
} }
/* <1e55c> ../cstrike/dlls/bmodels.cpp:122 */ /* <1e55c> ../cstrike/dlls/bmodels.cpp:122 */
BOOL CFuncWallToggle::IsOn(void) BOOL CFuncWallToggle::IsOn()
{ {
if (pev->solid == SOLID_NOT) if (pev->solid == SOLID_NOT)
{ {
@ -127,7 +122,7 @@ void CFuncWallToggle::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pC
LINK_ENTITY_TO_CLASS(func_conveyor, CFuncConveyor); LINK_ENTITY_TO_CLASS(func_conveyor, CFuncConveyor);
/* <1e1c3> ../cstrike/dlls/bmodels.cpp:156 */ /* <1e1c3> ../cstrike/dlls/bmodels.cpp:156 */
void CFuncConveyor::__MAKE_VHOOK(Spawn)(void) void CFuncConveyor::__MAKE_VHOOK(Spawn)()
{ {
SetMovedir(pev); SetMovedir(pev);
CFuncWall::Spawn(); CFuncWall::Spawn();
@ -192,7 +187,7 @@ void CFuncIllusionary::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
} }
/* <1d1db> ../cstrike/dlls/bmodels.cpp:230 */ /* <1d1db> ../cstrike/dlls/bmodels.cpp:230 */
void CFuncIllusionary::__MAKE_VHOOK(Spawn)(void) void CFuncIllusionary::__MAKE_VHOOK(Spawn)()
{ {
pev->angles = g_vecZero; pev->angles = g_vecZero;
pev->movetype = MOVETYPE_NONE; pev->movetype = MOVETYPE_NONE;
@ -212,7 +207,7 @@ void CFuncIllusionary::__MAKE_VHOOK(Spawn)(void)
LINK_ENTITY_TO_CLASS(func_monsterclip, CFuncMonsterClip); LINK_ENTITY_TO_CLASS(func_monsterclip, CFuncMonsterClip);
/* <1e24f> ../cstrike/dlls/bmodels.cpp:264 */ /* <1e24f> ../cstrike/dlls/bmodels.cpp:264 */
void CFuncMonsterClip::__MAKE_VHOOK(Spawn)(void) void CFuncMonsterClip::__MAKE_VHOOK(Spawn)()
{ {
CFuncWall::Spawn(); CFuncWall::Spawn();
@ -282,7 +277,7 @@ void CFuncRotating::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
// REVERSE will cause the it to rotate in the opposite direction. // REVERSE will cause the it to rotate in the opposite direction.
/* <1d5c4> ../cstrike/dlls/bmodels.cpp:362 */ /* <1d5c4> ../cstrike/dlls/bmodels.cpp:362 */
void CFuncRotating::__MAKE_VHOOK(Spawn)(void) void CFuncRotating::__MAKE_VHOOK(Spawn)()
{ {
// set final pitch. Must not be PITCH_NORM, since we // set final pitch. Must not be PITCH_NORM, since we
// plan on pitch shifting later. // plan on pitch shifting later.
@ -381,7 +376,7 @@ void CFuncRotating::__MAKE_VHOOK(Spawn)(void)
} }
/* <1d28a> ../cstrike/dlls/bmodels.cpp:447 */ /* <1d28a> ../cstrike/dlls/bmodels.cpp:447 */
void CFuncRotating::__MAKE_VHOOK(Precache)(void) void CFuncRotating::__MAKE_VHOOK(Precache)()
{ {
char *szSoundFile = (char *)STRING(pev->message); char *szSoundFile = (char *)STRING(pev->message);
@ -513,7 +508,7 @@ void CFuncRotating::RampPitchVol(int fUp)
// SpinUp - accelerates a non-moving func_rotating up to it's speed // SpinUp - accelerates a non-moving func_rotating up to it's speed
/* <1ea74> ../cstrike/dlls/bmodels.cpp:585 */ /* <1ea74> ../cstrike/dlls/bmodels.cpp:585 */
void CFuncRotating::SpinUp(void) void CFuncRotating::SpinUp()
{ {
//rotational velocity //rotational velocity
Vector vecAVel; Vector vecAVel;
@ -543,7 +538,7 @@ void CFuncRotating::SpinUp(void)
} }
/* <1e9c3> ../cstrike/dlls/bmodels.cpp:615 */ /* <1e9c3> ../cstrike/dlls/bmodels.cpp:615 */
void CFuncRotating::SpinDown(void) void CFuncRotating::SpinDown()
{ {
//rotational velocity //rotational velocity
Vector vecAVel; Vector vecAVel;
@ -585,7 +580,7 @@ void CFuncRotating::SpinDown(void)
} }
/* <1d304> ../cstrike/dlls/bmodels.cpp:653 */ /* <1d304> ../cstrike/dlls/bmodels.cpp:653 */
void CFuncRotating::Rotate(void) void CFuncRotating::Rotate()
{ {
pev->nextthink = pev->ltime + 10; pev->nextthink = pev->ltime + 10;
} }
@ -669,7 +664,7 @@ void CPendulum::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
} }
/* <1d9c7> ../cstrike/dlls/bmodels.cpp:782 */ /* <1d9c7> ../cstrike/dlls/bmodels.cpp:782 */
void CPendulum::__MAKE_VHOOK(Spawn)(void) void CPendulum::__MAKE_VHOOK(Spawn)()
{ {
// set the axis of rotation // set the axis of rotation
CBaseToggle::AxisDir(pev); CBaseToggle::AxisDir(pev);
@ -747,7 +742,7 @@ void CPendulum::PendulumUse(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_T
} }
/* <1d381> ../cstrike/dlls/bmodels.cpp:852 */ /* <1d381> ../cstrike/dlls/bmodels.cpp:852 */
void CPendulum::Stop(void) void CPendulum::Stop()
{ {
pev->angles = m_start; pev->angles = m_start;
pev->speed = 0; pev->speed = 0;
@ -762,7 +757,7 @@ void CPendulum::__MAKE_VHOOK(Blocked)(CBaseEntity *pOther)
} }
/* <1d533> ../cstrike/dlls/bmodels.cpp:867 */ /* <1d533> ../cstrike/dlls/bmodels.cpp:867 */
void CPendulum::Swing(void) void CPendulum::Swing()
{ {
float delta, dt; float delta, dt;
@ -859,112 +854,3 @@ void CPendulum::RopeTouch(CBaseEntity *pOther)
pevOther->velocity = g_vecZero; pevOther->velocity = g_vecZero;
pevOther->movetype = MOVETYPE_NONE; pevOther->movetype = MOVETYPE_NONE;
} }
#ifdef HOOK_GAMEDLL
void CFuncWall::Spawn(void)
{
Spawn_();
}
void CFuncWall::Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
{
Use_(pActivator, pCaller, useType, value);
}
void CFuncWallToggle::Spawn(void)
{
Spawn_();
}
void CFuncWallToggle::Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
{
Use_(pActivator, pCaller, useType, value);
}
void CFuncConveyor::Spawn(void)
{
Spawn_();
}
void CFuncConveyor::Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
{
Use_(pActivator, pCaller, useType, value);
}
void CFuncIllusionary::Spawn(void)
{
Spawn_();
}
void CFuncIllusionary::KeyValue(KeyValueData *pkvd)
{
KeyValue_(pkvd);
}
void CFuncMonsterClip::Spawn(void)
{
Spawn_();
}
void CFuncRotating::Spawn(void)
{
Spawn_();
}
void CFuncRotating::Precache(void)
{
Precache_();
}
void CFuncRotating::KeyValue(KeyValueData *pkvd)
{
KeyValue_(pkvd);
}
int CFuncRotating::Save(CSave &save)
{
return Save_(save);
}
int CFuncRotating::Restore(CRestore &restore)
{
return Restore_(restore);
}
void CFuncRotating::Blocked(CBaseEntity *pOther)
{
Blocked_(pOther);
}
void CPendulum::Spawn(void)
{
Spawn_();
}
void CPendulum::KeyValue(KeyValueData *pkvd)
{
KeyValue_(pkvd);
}
int CPendulum::Save(CSave &save)
{
return Save_(save);
}
int CPendulum::Restore(CRestore &restore)
{
return Restore_(restore);
}
void CPendulum::Touch(CBaseEntity *pOther)
{
Touch_(pOther);
}
void CPendulum::Blocked(CBaseEntity *pOther)
{
Blocked_(pOther);
}
#endif // HOOK_GAMEDLL

View File

@ -61,55 +61,52 @@
class CFuncWall: public CBaseEntity class CFuncWall: public CBaseEntity
{ {
public: public:
virtual void Spawn(void); virtual void Spawn();
// Bmodels don't go across transitions // Bmodels don't go across transitions
virtual int ObjectCaps(void) virtual int ObjectCaps() { return CBaseEntity::ObjectCaps() & ~FCAP_ACROSS_TRANSITION; }
{
return CBaseEntity::ObjectCaps() & ~FCAP_ACROSS_TRANSITION;
}
virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value); virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Spawn_(void); void Spawn_();
void Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value); void Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
};/* size: 152, cachelines: 3, members: 1 */ };
/* <1c4e1> ../cstrike/dlls/bmodels.cpp:86 */ /* <1c4e1> ../cstrike/dlls/bmodels.cpp:86 */
class CFuncWallToggle: public CFuncWall class CFuncWallToggle: public CFuncWall
{ {
public: public:
virtual void Spawn(void); virtual void Spawn();
virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value); virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Spawn_(void); void Spawn_();
void Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value); void Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
public: public:
void TurnOff(void); void TurnOff();
void TurnOn(void); void TurnOn();
BOOL IsOn(void); BOOL IsOn();
};/* size: 152, cachelines: 3, members: 1 */ };
/* <1c52e> ../cstrike/dlls/bmodels.cpp:147 */ /* <1c52e> ../cstrike/dlls/bmodels.cpp:147 */
class CFuncConveyor: public CFuncWall class CFuncConveyor: public CFuncWall
{ {
public: public:
virtual void Spawn(void); virtual void Spawn();
virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value); virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Spawn_(void); void Spawn_();
void Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value); void Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
@ -117,7 +114,7 @@ public:
public: public:
void UpdateSpeed(float speed); void UpdateSpeed(float speed);
};/* size: 152, cachelines: 3, members: 1 */ };
// A simple entity that looks solid but lets you walk through it. // A simple entity that looks solid but lets you walk through it.
@ -125,16 +122,13 @@ public:
class CFuncIllusionary: public CBaseToggle class CFuncIllusionary: public CBaseToggle
{ {
public: public:
virtual void Spawn(void); virtual void Spawn();
virtual void KeyValue(KeyValueData *pkvd); virtual void KeyValue(KeyValueData *pkvd);
virtual int ObjectCaps(void) virtual int ObjectCaps() { return CBaseEntity::ObjectCaps() & ~FCAP_ACROSS_TRANSITION; }
{
return CBaseEntity::ObjectCaps() & ~FCAP_ACROSS_TRANSITION;
}
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Spawn_(void); void Spawn_();
void KeyValue_(KeyValueData *pkvd); void KeyValue_(KeyValueData *pkvd);
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
@ -142,7 +136,7 @@ public:
public: public:
void EXPORT SloshTouch(CBaseEntity *pOther); void EXPORT SloshTouch(CBaseEntity *pOther);
};/* size: 312, cachelines: 5, members: 1 */ };
// Monster only clip brush // Monster only clip brush
// //
@ -156,43 +150,37 @@ public:
class CFuncMonsterClip: public CFuncWall class CFuncMonsterClip: public CFuncWall
{ {
public: public:
virtual void Spawn(void); virtual void Spawn();
// Clear out func_wall's use function // Clear out func_wall's use function
virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value) virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value) {}
{
;
}
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Spawn_(void); void Spawn_();
void Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value); void Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
};/* size: 152, cachelines: 3, members: 1 */ };
/* <1c6fa> ../cstrike/dlls/bmodels.cpp:274 */ /* <1c6fa> ../cstrike/dlls/bmodels.cpp:274 */
class CFuncRotating: public CBaseEntity class CFuncRotating: public CBaseEntity
{ {
public: public:
// basic functions // basic functions
virtual void Spawn(void); virtual void Spawn();
virtual void Precache(void); virtual void Precache();
virtual void KeyValue(KeyValueData *pkvd); virtual void KeyValue(KeyValueData *pkvd);
virtual int Save(CSave &save); virtual int Save(CSave &save);
virtual int Restore(CRestore &restore); virtual int Restore(CRestore &restore);
virtual int ObjectCaps(void) virtual int ObjectCaps() { return CBaseEntity::ObjectCaps() & ~FCAP_ACROSS_TRANSITION; }
{
return CBaseEntity::ObjectCaps() & ~FCAP_ACROSS_TRANSITION;
}
virtual void Blocked(CBaseEntity *pOther); virtual void Blocked(CBaseEntity *pOther);
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Spawn_(void); void Spawn_();
void Precache_(void); void Precache_();
void KeyValue_(KeyValueData *pkvd); void KeyValue_(KeyValueData *pkvd);
int Save_(CSave &save); int Save_(CSave &save);
int Restore_(CRestore &restore); int Restore_(CRestore &restore);
@ -201,11 +189,11 @@ public:
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
public: public:
void EXPORT SpinUp(void); void EXPORT SpinUp();
void EXPORT SpinDown(void); void EXPORT SpinDown();
void EXPORT HurtTouch(CBaseEntity *pOther); void EXPORT HurtTouch(CBaseEntity *pOther);
void EXPORT RotatingUse(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value); void EXPORT RotatingUse(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
void EXPORT Rotate(void); void EXPORT Rotate();
void RampPitchVol(int fUp); void RampPitchVol(int fUp);
public: public:
@ -217,27 +205,23 @@ public:
float m_flVolume; float m_flVolume;
float m_pitch; float m_pitch;
int m_sounds; int m_sounds;
};
};/* size: 172, cachelines: 3, members: 7 */
/* <1c748> ../cstrike/dlls/bmodels.cpp:720 */ /* <1c748> ../cstrike/dlls/bmodels.cpp:720 */
class CPendulum: public CBaseEntity class CPendulum: public CBaseEntity
{ {
public: public:
virtual void Spawn(void); virtual void Spawn();
virtual void KeyValue(KeyValueData *pkvd); virtual void KeyValue(KeyValueData *pkvd);
virtual int Save(CSave &save); virtual int Save(CSave &save);
virtual int Restore(CRestore &restore); virtual int Restore(CRestore &restore);
virtual int ObjectCaps(void) virtual int ObjectCaps() { return CBaseEntity::ObjectCaps() & ~FCAP_ACROSS_TRANSITION; }
{
return CBaseEntity::ObjectCaps() & ~FCAP_ACROSS_TRANSITION;
}
virtual void Touch(CBaseEntity *pOther); virtual void Touch(CBaseEntity *pOther);
virtual void Blocked(CBaseEntity *pOther); virtual void Blocked(CBaseEntity *pOther);
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Spawn_(void); void Spawn_();
void KeyValue_(KeyValueData *pkvd); void KeyValue_(KeyValueData *pkvd);
int Save_(CSave &save); int Save_(CSave &save);
int Restore_(CRestore &restore); int Restore_(CRestore &restore);
@ -247,9 +231,9 @@ public:
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
public: public:
void EXPORT Swing(void); void EXPORT Swing();
void EXPORT PendulumUse(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value); void EXPORT PendulumUse(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
void EXPORT Stop(void); void EXPORT Stop();
// this touch func makes the pendulum a rope // this touch func makes the pendulum a rope
void EXPORT RopeTouch(CBaseEntity *pOther); void EXPORT RopeTouch(CBaseEntity *pOther);
@ -266,22 +250,8 @@ public:
Vector m_center; Vector m_center;
Vector m_start; Vector m_start;
};
};/* size: 200, cachelines: 4, members: 10 */
Vector VecBModelOrigin(entvars_t *pevBModel); Vector VecBModelOrigin(entvars_t *pevBModel);
#ifdef HOOK_GAMEDLL
// linked objects
C_DLLEXPORT void func_wall(entvars_t *pev);
C_DLLEXPORT void func_wall_toggle(entvars_t *pev);
C_DLLEXPORT void func_conveyor(entvars_t *pev);
C_DLLEXPORT void func_illusionary(entvars_t *pev);
C_DLLEXPORT void func_monsterclip(entvars_t *pev);
C_DLLEXPORT void func_rotating(entvars_t *pev);
C_DLLEXPORT void func_pendulum(entvars_t *pev);
#endif // HOOK_GAMEDLL
#endif // BMODELS_H #endif // BMODELS_H

View File

@ -29,7 +29,7 @@ int GetBotFollowCount(CBasePlayer *leader)
continue; continue;
CCSBot *bot = dynamic_cast<CCSBot *>(player); CCSBot *bot = dynamic_cast<CCSBot *>(player);
if (bot && bot->GetFollowLeader() == leader) if (bot != NULL && bot->GetFollowLeader() == leader)
++count; ++count;
} }
@ -39,7 +39,7 @@ int GetBotFollowCount(CBasePlayer *leader)
// Change movement speed to walking // Change movement speed to walking
/* <2e86df> ../cstrike/dlls/bot/cs_bot.cpp:62 */ /* <2e86df> ../cstrike/dlls/bot/cs_bot.cpp:62 */
void CCSBot::__MAKE_VHOOK(Walk)(void) void CCSBot::__MAKE_VHOOK(Walk)()
{ {
if (m_mustRunTimer.IsElapsed()) if (m_mustRunTimer.IsElapsed())
{ {
@ -96,7 +96,7 @@ int CCSBot::__MAKE_VHOOK(TakeDamage)(entvars_t *pevInflictor, entvars_t *pevAtta
float lastAttackedTimestamp = m_attackedTimestamp; float lastAttackedTimestamp = m_attackedTimestamp;
// keep track of our last attacker // keep track of our last attacker
m_attacker = reinterpret_cast<CBasePlayer *>(attacker); m_attacker = static_cast<CBasePlayer *>(attacker);
m_attackedTimestamp = gpGlobals->time; m_attackedTimestamp = gpGlobals->time;
// no longer safe // no longer safe
@ -297,7 +297,7 @@ void CCSBot::BotTouch(CBaseEntity *other)
} }
/* <2e89e3> ../cstrike/dlls/bot/cs_bot.cpp:335 */ /* <2e89e3> ../cstrike/dlls/bot/cs_bot.cpp:335 */
bool CCSBot::IsBusy(void) const bool CCSBot::IsBusy() const
{ {
if (IsAttacking() || if (IsAttacking() ||
IsBuying() || IsBuying() ||
@ -313,13 +313,13 @@ bool CCSBot::IsBusy(void) const
} }
/* <2e8a0c> ../cstrike/dlls/bot/cs_bot.cpp:351 */ /* <2e8a0c> ../cstrike/dlls/bot/cs_bot.cpp:351 */
void CCSBot::BotDeathThink(void) void CCSBot::BotDeathThink()
{ {
; ;
} }
/* <2e8a34> ../cstrike/dlls/bot/cs_bot.cpp:358 */ /* <2e8a34> ../cstrike/dlls/bot/cs_bot.cpp:358 */
CBasePlayer *CCSBot::FindNearbyPlayer(void) CBasePlayer *CCSBot::FindNearbyPlayer()
{ {
CBaseEntity *pEntity = NULL; CBaseEntity *pEntity = NULL;
Vector vecSrc = pev->origin; Vector vecSrc = pev->origin;
@ -356,7 +356,7 @@ void CCSBot::SetEnemy(CBasePlayer *enemy)
// Return false if off mesh. // Return false if off mesh.
/* <2e8af6> ../cstrike/dlls/bot/cs_bot.cpp:400 */ /* <2e8af6> ../cstrike/dlls/bot/cs_bot.cpp:400 */
bool CCSBot::StayOnNavMesh(void) bool CCSBot::StayOnNavMesh()
{ {
if (m_currentArea != NULL) if (m_currentArea != NULL)
return true; return true;
@ -466,7 +466,7 @@ void CCSBot::Panic(CBasePlayer *enemy)
} }
/* <2e9047> ../cstrike/dlls/bot/cs_bot.cpp:527 */ /* <2e9047> ../cstrike/dlls/bot/cs_bot.cpp:527 */
bool CCSBot::IsDoingScenario(void) const bool CCSBot::IsDoingScenario() const
{ {
if (cv_bot_defer_to_human.value <= 0.0f) if (cv_bot_defer_to_human.value <= 0.0f)
return true; return true;
@ -477,7 +477,7 @@ bool CCSBot::IsDoingScenario(void) const
// Return true if we noticed the bomb on the ground or on the radar (for T's only) // Return true if we noticed the bomb on the ground or on the radar (for T's only)
/* <2e9070> ../cstrike/dlls/bot/cs_bot.cpp:544 */ /* <2e9070> ../cstrike/dlls/bot/cs_bot.cpp:544 */
bool CCSBot::NoticeLooseBomb(void) const bool CCSBot::NoticeLooseBomb() const
{ {
CCSBotManager *ctrl = TheCSBots(); CCSBotManager *ctrl = TheCSBots();
@ -498,7 +498,7 @@ bool CCSBot::NoticeLooseBomb(void) const
// Return true if can see the bomb lying on the ground // Return true if can see the bomb lying on the ground
/* <2e90d4> ../cstrike/dlls/bot/cs_bot.cpp:566 */ /* <2e90d4> ../cstrike/dlls/bot/cs_bot.cpp:566 */
bool CCSBot::CanSeeLooseBomb(void) const bool CCSBot::CanSeeLooseBomb() const
{ {
CCSBotManager *ctrl = TheCSBots(); CCSBotManager *ctrl = TheCSBots();
@ -519,7 +519,7 @@ bool CCSBot::CanSeeLooseBomb(void) const
// Return true if can see the planted bomb // Return true if can see the planted bomb
/* <2e9140> ../cstrike/dlls/bot/cs_bot.cpp:588 */ /* <2e9140> ../cstrike/dlls/bot/cs_bot.cpp:588 */
bool CCSBot::CanSeePlantedBomb(void) const bool CCSBot::CanSeePlantedBomb() const
{ {
CCSBotManager *ctrl = TheCSBots(); CCSBotManager *ctrl = TheCSBots();
@ -540,7 +540,7 @@ bool CCSBot::CanSeePlantedBomb(void) const
// Return last enemy that hurt us // Return last enemy that hurt us
/* <2e918e> ../cstrike/dlls/bot/cs_bot.cpp:610 */ /* <2e918e> ../cstrike/dlls/bot/cs_bot.cpp:610 */
CBasePlayer *CCSBot::GetAttacker(void) const CBasePlayer *CCSBot::GetAttacker() const
{ {
if (m_attacker != NULL && m_attacker->IsAlive()) if (m_attacker != NULL && m_attacker->IsAlive())
return m_attacker; return m_attacker;
@ -551,7 +551,7 @@ CBasePlayer *CCSBot::GetAttacker(void) const
// Immediately jump off of our ladder, if we're on one // Immediately jump off of our ladder, if we're on one
/* <2e91b7> ../cstrike/dlls/bot/cs_bot.cpp:622 */ /* <2e91b7> ../cstrike/dlls/bot/cs_bot.cpp:622 */
void CCSBot::GetOffLadder(void) void CCSBot::GetOffLadder()
{ {
if (IsUsingLadder()) if (IsUsingLadder())
{ {
@ -618,7 +618,7 @@ void CCSBot::SetHidingSpotCheckTimestamp(HidingSpot *spot)
// Periodic check of hostage count in case we lost some // Periodic check of hostage count in case we lost some
/* <2e92b8> ../cstrike/dlls/bot/cs_bot.cpp:693 */ /* <2e92b8> ../cstrike/dlls/bot/cs_bot.cpp:693 */
void CCSBot::UpdateHostageEscortCount(void) void CCSBot::UpdateHostageEscortCount()
{ {
const float updateInterval = 1.0f; const float updateInterval = 1.0f;
if (m_hostageEscortCount == 0 || gpGlobals->time - m_hostageEscortCountTimestamp < updateInterval) if (m_hostageEscortCount == 0 || gpGlobals->time - m_hostageEscortCountTimestamp < updateInterval)
@ -648,7 +648,7 @@ void CCSBot::UpdateHostageEscortCount(void)
// Return true if we are outnumbered by enemies // Return true if we are outnumbered by enemies
/* <2e940d> ../cstrike/dlls/bot/cs_bot.cpp:722 */ /* <2e940d> ../cstrike/dlls/bot/cs_bot.cpp:722 */
bool CCSBot::IsOutnumbered(void) const bool CCSBot::IsOutnumbered() const
{ {
return (GetNearbyFriendCount() < GetNearbyEnemyCount() - 1) ? true : false; return (GetNearbyFriendCount() < GetNearbyEnemyCount() - 1) ? true : false;
} }
@ -656,7 +656,7 @@ bool CCSBot::IsOutnumbered(void) const
// Return number of enemies we are outnumbered by // Return number of enemies we are outnumbered by
/* <2e94a0> ../cstrike/dlls/bot/cs_bot.cpp:731 */ /* <2e94a0> ../cstrike/dlls/bot/cs_bot.cpp:731 */
int CCSBot::OutnumberedCount(void) const int CCSBot::OutnumberedCount() const
{ {
if (IsOutnumbered()) if (IsOutnumbered())
{ {
@ -739,7 +739,7 @@ void CCSBot::SetDisposition(DispositionType disposition)
// Return our current disposition // Return our current disposition
/* <2e9762> ../cstrike/dlls/bot/cs_bot.cpp:814 */ /* <2e9762> ../cstrike/dlls/bot/cs_bot.cpp:814 */
CCSBot::DispositionType CCSBot::GetDisposition(void) const CCSBot::DispositionType CCSBot::GetDisposition() const
{ {
if (!m_ignoreEnemiesTimer.IsElapsed()) if (!m_ignoreEnemiesTimer.IsElapsed())
return IGNORE_ENEMIES; return IGNORE_ENEMIES;
@ -758,7 +758,7 @@ void CCSBot::IgnoreEnemies(float duration)
// Increase morale one step // Increase morale one step
/* <2e97fc> ../cstrike/dlls/bot/cs_bot.cpp:835 */ /* <2e97fc> ../cstrike/dlls/bot/cs_bot.cpp:835 */
void CCSBot::IncreaseMorale(void) void CCSBot::IncreaseMorale()
{ {
if (m_morale < EXCELLENT) if (m_morale < EXCELLENT)
{ {
@ -769,7 +769,7 @@ void CCSBot::IncreaseMorale(void)
// Decrease morale one step // Decrease morale one step
/* <2e9824> ../cstrike/dlls/bot/cs_bot.cpp:845 */ /* <2e9824> ../cstrike/dlls/bot/cs_bot.cpp:845 */
void CCSBot::DecreaseMorale(void) void CCSBot::DecreaseMorale()
{ {
if (m_morale > TERRIBLE) if (m_morale > TERRIBLE)
{ {
@ -781,7 +781,7 @@ void CCSBot::DecreaseMorale(void)
// TODO: Account for morale // TODO: Account for morale
/* <2e984c> ../cstrike/dlls/bot/cs_bot.cpp:857 */ /* <2e984c> ../cstrike/dlls/bot/cs_bot.cpp:857 */
bool CCSBot::IsRogue(void) const bool CCSBot::IsRogue() const
{ {
CCSBotManager *ctrl = TheCSBots(); CCSBotManager *ctrl = TheCSBots();
@ -805,7 +805,7 @@ bool CCSBot::IsRogue(void) const
// Return true if we are in a hurry // Return true if we are in a hurry
/* <2e98f1> ../cstrike/dlls/bot/cs_bot.cpp:882 */ /* <2e98f1> ../cstrike/dlls/bot/cs_bot.cpp:882 */
bool CCSBot::IsHurrying(void) const bool CCSBot::IsHurrying() const
{ {
if (!m_hurryTimer.IsElapsed()) if (!m_hurryTimer.IsElapsed())
return true; return true;
@ -828,7 +828,7 @@ bool CCSBot::IsHurrying(void) const
// Return true if it is the early, "safe", part of the round // Return true if it is the early, "safe", part of the round
/* <2e9942> ../cstrike/dlls/bot/cs_bot.cpp:906 */ /* <2e9942> ../cstrike/dlls/bot/cs_bot.cpp:906 */
bool CCSBot::IsSafe(void) const bool CCSBot::IsSafe() const
{ {
CCSBotManager *ctrl = TheCSBots(); CCSBotManager *ctrl = TheCSBots();
@ -841,7 +841,7 @@ bool CCSBot::IsSafe(void) const
// Return true if it is well past the early, "safe", part of the round // Return true if it is well past the early, "safe", part of the round
/* <2e9987> ../cstrike/dlls/bot/cs_bot.cpp:920 */ /* <2e9987> ../cstrike/dlls/bot/cs_bot.cpp:920 */
bool CCSBot::IsWellPastSafe(void) const bool CCSBot::IsWellPastSafe() const
{ {
CCSBotManager *ctrl = TheCSBots(); CCSBotManager *ctrl = TheCSBots();
@ -854,7 +854,7 @@ bool CCSBot::IsWellPastSafe(void) const
// Return true if we were in the safe time last update, but not now // Return true if we were in the safe time last update, but not now
/* <2e99d8> ../cstrike/dlls/bot/cs_bot.cpp:934 */ /* <2e99d8> ../cstrike/dlls/bot/cs_bot.cpp:934 */
bool CCSBot::IsEndOfSafeTime(void) const bool CCSBot::IsEndOfSafeTime() const
{ {
return m_wasSafe && !IsSafe(); return m_wasSafe && !IsSafe();
} }
@ -862,7 +862,7 @@ bool CCSBot::IsEndOfSafeTime(void) const
// Return the amount of "safe time" we have left // Return the amount of "safe time" we have left
/* <2e9a3e> ../cstrike/dlls/bot/cs_bot.cpp:943 */ /* <2e9a3e> ../cstrike/dlls/bot/cs_bot.cpp:943 */
float CCSBot::GetSafeTimeRemaining(void) const float CCSBot::GetSafeTimeRemaining() const
{ {
CCSBotManager *ctrl = TheCSBots(); CCSBotManager *ctrl = TheCSBots();
@ -872,7 +872,7 @@ float CCSBot::GetSafeTimeRemaining(void) const
// Called when enemy seen to adjust safe time for this round // Called when enemy seen to adjust safe time for this round
/* <2e9a8f> ../cstrike/dlls/bot/cs_bot.cpp:954 */ /* <2e9a8f> ../cstrike/dlls/bot/cs_bot.cpp:954 */
void CCSBot::AdjustSafeTime(void) void CCSBot::AdjustSafeTime()
{ {
CCSBotManager *ctrl = TheCSBots(); CCSBotManager *ctrl = TheCSBots();
@ -887,7 +887,7 @@ void CCSBot::AdjustSafeTime(void)
// Return true if we haven't seen an enemy for "a long time" // Return true if we haven't seen an enemy for "a long time"
/* <2e9ad0> ../cstrike/dlls/bot/cs_bot.cpp:970 */ /* <2e9ad0> ../cstrike/dlls/bot/cs_bot.cpp:970 */
bool CCSBot::HasNotSeenEnemyForLongTime(void) const bool CCSBot::HasNotSeenEnemyForLongTime() const
{ {
const float longTime = 30.0f; const float longTime = 30.0f;
return (GetTimeSinceLastSawEnemy() > longTime); return (GetTimeSinceLastSawEnemy() > longTime);
@ -940,7 +940,7 @@ const Vector *FindNearbyRetreatSpot(CCSBot *me, float maxRange)
// Return -1 if no hostage is following us. // Return -1 if no hostage is following us.
/* <2eaa1d> ../cstrike/dlls/bot/cs_bot.cpp:1116 */ /* <2eaa1d> ../cstrike/dlls/bot/cs_bot.cpp:1116 */
float CCSBot::GetRangeToFarthestEscortedHostage(void) const float CCSBot::GetRangeToFarthestEscortedHostage() const
{ {
FarthestHostage away(this); FarthestHostage away(this);
@ -948,27 +948,3 @@ float CCSBot::GetRangeToFarthestEscortedHostage(void) const
return away.m_farRange; return away.m_farRange;
} }
#ifdef HOOK_GAMEDLL
void CCSBot::Walk(void)
{
Walk_();
}
bool CCSBot::Jump(bool mustJump)
{
return Jump_(mustJump);
}
int CCSBot::TakeDamage(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType)
{
return TakeDamage_(pevInflictor, pevAttacker, flDamage, bitsDamageType);
}
void CCSBot::Killed(entvars_t *pevAttacker, int iGib)
{
Killed_(pevAttacker, iGib);
}
#endif // HOOK_GAMEDLL

File diff suppressed because it is too large Load Diff

View File

@ -11,14 +11,6 @@ CBaseEntity *g_pSelectedZombieSpawn = NULL;
CountdownTimer BotChatterInterface::m_encourageTimer; CountdownTimer BotChatterInterface::m_encourageTimer;
IntervalTimer BotChatterInterface::m_radioSilenceInterval[ 2 ]; IntervalTimer BotChatterInterface::m_radioSilenceInterval[ 2 ];
#else // HOOK_GAMEDLL
BotPhraseManager *TheBotPhrases;
CBaseEntity *g_pSelectedZombieSpawn;
CountdownTimer IMPL_CLASS(BotChatterInterface, m_encourageTimer);
IntervalTimer IMPL_CLASS(BotChatterInterface, m_radioSilenceInterval)[ 2 ];
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
/* <303469> ../cstrike/dlls/bot/cs_bot_chatter.cpp:32 */ /* <303469> ../cstrike/dlls/bot/cs_bot_chatter.cpp:32 */
@ -268,13 +260,13 @@ void BotHostageBeingTakenMeme::__MAKE_VHOOK(Interpret)(CCSBot *sender, CCSBot *r
} }
/* <303609> ../cstrike/dlls/bot/cs_bot_chatter.cpp:285 */ /* <303609> ../cstrike/dlls/bot/cs_bot_chatter.cpp:285 */
BotSpeakable::BotSpeakable(void) BotSpeakable::BotSpeakable()
{ {
m_phrase = NULL; m_phrase = NULL;
} }
/* <303655> ../cstrike/dlls/bot/cs_bot_chatter.cpp:291 */ /* <303655> ../cstrike/dlls/bot/cs_bot_chatter.cpp:291 */
BotSpeakable::~BotSpeakable(void) BotSpeakable::~BotSpeakable()
{ {
if (m_phrase != NULL) if (m_phrase != NULL)
{ {
@ -299,7 +291,7 @@ BotPhrase::BotPhrase(unsigned int id, bool isPlace)
} }
/* <3036c2> ../cstrike/dlls/bot/cs_bot_chatter.cpp:314 */ /* <3036c2> ../cstrike/dlls/bot/cs_bot_chatter.cpp:314 */
BotPhrase::~BotPhrase(void) BotPhrase::~BotPhrase()
{ {
for (uint32 bank = 0; bank < m_voiceBank.size(); ++bank) for (uint32 bank = 0; bank < m_voiceBank.size(); ++bank)
{ {
@ -387,7 +379,7 @@ char *BotPhrase::GetSpeakable(int bankIndex, float *duration) const
/* <30395a> ../cstrike/dlls/bot/cs_bot_chatter.cpp:395 */ /* <30395a> ../cstrike/dlls/bot/cs_bot_chatter.cpp:395 */
#ifndef HOOK_GAMEDLL #ifndef HOOK_GAMEDLL
void BotPhrase::Randomize(void) void BotPhrase::Randomize()
{ {
for (uint32 i = 0; i < m_voiceBank.size(); ++i) for (uint32 i = 0; i < m_voiceBank.size(); ++i)
{ {
@ -397,7 +389,7 @@ void BotPhrase::Randomize(void)
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
/* <303b3f> ../cstrike/dlls/bot/cs_bot_chatter.cpp:409 */ /* <303b3f> ../cstrike/dlls/bot/cs_bot_chatter.cpp:409 */
BotPhraseManager::BotPhraseManager(void) BotPhraseManager::BotPhraseManager()
{ {
for (int i = 0; i < MAX_PLACES_PER_MAP; ++i) for (int i = 0; i < MAX_PLACES_PER_MAP; ++i)
m_placeStatementHistory[i].timer.Invalidate(); m_placeStatementHistory[i].timer.Invalidate();
@ -408,7 +400,7 @@ BotPhraseManager::BotPhraseManager(void)
// Invoked when map changes // Invoked when map changes
/* <303c45> ../cstrike/dlls/bot/cs_bot_chatter.cpp:417 */ /* <303c45> ../cstrike/dlls/bot/cs_bot_chatter.cpp:417 */
void BotPhraseManager::OnMapChange(void) void BotPhraseManager::OnMapChange()
{ {
m_placeCount = 0; m_placeCount = 0;
} }
@ -416,7 +408,7 @@ void BotPhraseManager::OnMapChange(void)
// Invoked when the round resets // Invoked when the round resets
/* <303c70> ../cstrike/dlls/bot/cs_bot_chatter.cpp:425 */ /* <303c70> ../cstrike/dlls/bot/cs_bot_chatter.cpp:425 */
void BotPhraseManager::OnRoundRestart(void) void BotPhraseManager::OnRoundRestart()
{ {
// effectively reset all interval timers // effectively reset all interval timers
m_placeCount = 0; m_placeCount = 0;
@ -445,7 +437,7 @@ bool BotPhraseManager::Initialize(const char *filename, int bankIndex)
if (phraseDataFile == NULL) if (phraseDataFile == NULL)
{ {
if (UTIL_IsGame("czero")) if (g_bIsCzeroGame)
{ {
CONSOLE_ECHO("WARNING: Cannot access bot phrase database '%s'\n", filename); CONSOLE_ECHO("WARNING: Cannot access bot phrase database '%s'\n", filename);
} }
@ -652,7 +644,7 @@ bool BotPhraseManager::Initialize(const char *filename, int bankIndex)
Q_snprintf(compositeFilename, RadioPathLen, "sound\\%s", speak->m_phrase); Q_snprintf(compositeFilename, RadioPathLen, "sound\\%s", speak->m_phrase);
speak->m_duration = (double)GET_APPROX_WAVE_PLAY_LEN(compositeFilename) / 1000.0f; speak->m_duration = (double)GET_APPROX_WAVE_PLAY_LEN(compositeFilename) / 1000.0f;
if (speak->m_duration <= 0.0f) if (speak->m_duration <= 0.0f)
{ {
CONSOLE_ECHO("Warning: Couldn't get duration of phrase '%s'\n", compositeFilename); CONSOLE_ECHO("Warning: Couldn't get duration of phrase '%s'\n", compositeFilename);
@ -685,7 +677,7 @@ bool BotPhraseManager::Initialize(const char *filename, int bankIndex)
} }
/* <30409e> ../cstrike/dlls/bot/cs_bot_chatter.cpp:682 */ /* <30409e> ../cstrike/dlls/bot/cs_bot_chatter.cpp:682 */
BotPhraseManager::~BotPhraseManager(void) BotPhraseManager::~BotPhraseManager()
{ {
BotPhraseList::iterator iter; BotPhraseList::iterator iter;
for (iter = m_list.begin(); iter != m_list.end(); ++iter) for (iter = m_list.begin(); iter != m_list.end(); ++iter)
@ -707,7 +699,7 @@ BotPhraseManager::~BotPhraseManager(void)
delete phrase; delete phrase;
} }
} }
m_list.clear(); m_list.clear();
m_placeList.clear(); m_placeList.clear();
} }
@ -856,7 +848,7 @@ BotStatement::BotStatement(BotChatterInterface *chatter, BotStatementType type,
} }
/* <3047bd> ../cstrike/dlls/bot/cs_bot_chatter.cpp:855 */ /* <3047bd> ../cstrike/dlls/bot/cs_bot_chatter.cpp:855 */
BotStatement::~BotStatement(void) BotStatement::~BotStatement()
{ {
if (m_meme != NULL) if (m_meme != NULL)
{ {
@ -865,7 +857,7 @@ BotStatement::~BotStatement(void)
} }
/* <3047e0> ../cstrike/dlls/bot/cs_bot_chatter.cpp:863 */ /* <3047e0> ../cstrike/dlls/bot/cs_bot_chatter.cpp:863 */
CCSBot *BotStatement::GetOwner(void) const CCSBot *BotStatement::GetOwner() const
{ {
return m_chatter->GetOwner(); return m_chatter->GetOwner();
} }
@ -890,7 +882,7 @@ void BotStatement::AddCondition(ConditionType condition)
// Return true if this statement is "important" and not personality chatter // Return true if this statement is "important" and not personality chatter
/* <30485b> ../cstrike/dlls/bot/cs_bot_chatter.cpp:891 */ /* <30485b> ../cstrike/dlls/bot/cs_bot_chatter.cpp:891 */
bool BotStatement::IsImportant(void) const bool BotStatement::IsImportant() const
{ {
// if a statement contains any important phrases, it is important // if a statement contains any important phrases, it is important
for (int i = 0; i < m_count; ++i) for (int i = 0; i < m_count; ++i)
@ -909,7 +901,7 @@ bool BotStatement::IsImportant(void) const
// Verify all attached conditions // Verify all attached conditions
/* <3048bc> ../cstrike/dlls/bot/cs_bot_chatter.cpp:911 */ /* <3048bc> ../cstrike/dlls/bot/cs_bot_chatter.cpp:911 */
bool BotStatement::IsValid(void) const bool BotStatement::IsValid() const
{ {
for (int i = 0; i < m_conditionCount; ++i) for (int i = 0; i < m_conditionCount; ++i)
{ {
@ -980,7 +972,7 @@ bool BotStatement::IsRedundant(const BotStatement *say) const
// Return true if this statement is no longer appropriate to say // Return true if this statement is no longer appropriate to say
/* <304977> ../cstrike/dlls/bot/cs_bot_chatter.cpp:990 */ /* <304977> ../cstrike/dlls/bot/cs_bot_chatter.cpp:990 */
bool BotStatement::IsObsolete(void) const bool BotStatement::IsObsolete() const
{ {
// if the round is over, the only things we should say are emotes // if the round is over, the only things we should say are emotes
if (GetOwner()->GetGameState()->IsRoundOver()) if (GetOwner()->GetGameState()->IsRoundOver())
@ -1062,7 +1054,7 @@ void BotStatement::AppendPhrase(ContextType contextPhrase)
// m_index refers to the phrase currently being spoken, or -1 if we havent started yet // m_index refers to the phrase currently being spoken, or -1 if we havent started yet
/* <304b22> ../cstrike/dlls/bot/cs_bot_chatter.cpp:1065 */ /* <304b22> ../cstrike/dlls/bot/cs_bot_chatter.cpp:1065 */
bool BotStatement::Update(void) bool BotStatement::Update()
{ {
CCSBot *me = GetOwner(); CCSBot *me = GetOwner();
@ -1259,7 +1251,7 @@ bool BotStatement::Update(void)
// Places can be implicit in the statement, or explicitly defined // Places can be implicit in the statement, or explicitly defined
/* <2fee36> ../cstrike/dlls/bot/cs_bot_chatter.cpp:1266 */ /* <2fee36> ../cstrike/dlls/bot/cs_bot_chatter.cpp:1266 */
Place BotStatement::GetPlace(void) const Place BotStatement::GetPlace() const
{ {
// return any explicitly set place if we have one // return any explicitly set place if we have one
if (m_place != UNDEFINED_PLACE) if (m_place != UNDEFINED_PLACE)
@ -1278,7 +1270,7 @@ Place BotStatement::GetPlace(void) const
// Return true if this statement has an associated count // Return true if this statement has an associated count
/* <305289> ../cstrike/dlls/bot/cs_bot_chatter.cpp:1283 */ /* <305289> ../cstrike/dlls/bot/cs_bot_chatter.cpp:1283 */
bool BotStatement::HasCount(void) const bool BotStatement::HasCount() const
{ {
for (int i = 0; i < m_count; ++i) for (int i = 0; i < m_count; ++i)
{ {
@ -1317,7 +1309,7 @@ BotChatterInterface::BotChatterInterface(CCSBot *me)
} }
/* <305307> ../cstrike/dlls/bot/cs_bot_chatter.cpp:1334 */ /* <305307> ../cstrike/dlls/bot/cs_bot_chatter.cpp:1334 */
BotChatterInterface::~BotChatterInterface(void) BotChatterInterface::~BotChatterInterface()
{ {
// free pending statements // free pending statements
BotStatement *next; BotStatement *next;
@ -1331,7 +1323,7 @@ BotChatterInterface::~BotChatterInterface(void)
// Reset to initial state // Reset to initial state
/* <305386> ../cstrike/dlls/bot/cs_bot_chatter.cpp:1347 */ /* <305386> ../cstrike/dlls/bot/cs_bot_chatter.cpp:1347 */
void BotChatterInterface::Reset(void) void BotChatterInterface::Reset()
{ {
BotStatement *msg, *nextMsg; BotStatement *msg, *nextMsg;
@ -1343,7 +1335,7 @@ void BotChatterInterface::Reset(void)
if (msg->GetType() != REPORT_ROUND_END) if (msg->GetType() != REPORT_ROUND_END)
RemoveStatement(msg); RemoveStatement(msg);
} }
m_seeAtLeastOneEnemy = false; m_seeAtLeastOneEnemy = false;
m_timeWhenSawFirstEnemy = 0.0f; m_timeWhenSawFirstEnemy = 0.0f;
m_reportedEnemies = false; m_reportedEnemies = false;
@ -1469,7 +1461,7 @@ void BotChatterInterface::RemoveStatement(BotStatement *statement)
// Track nearby enemy count and report enemy activity // Track nearby enemy count and report enemy activity
/* <3087ee> ../cstrike/dlls/bot/cs_bot_chatter.cpp:1479 */ /* <3087ee> ../cstrike/dlls/bot/cs_bot_chatter.cpp:1479 */
void BotChatterInterface::ReportEnemies(void) void BotChatterInterface::ReportEnemies()
{ {
if (!m_me->IsAlive()) if (!m_me->IsAlive())
return; return;
@ -1509,7 +1501,7 @@ void BotChatterInterface::OnEvent(GameEventType event, CBaseEntity *entity, CBas
// Invoked when we die // Invoked when we die
/* <30579e> ../cstrike/dlls/bot/cs_bot_chatter.cpp:1524 */ /* <30579e> ../cstrike/dlls/bot/cs_bot_chatter.cpp:1524 */
void BotChatterInterface::OnDeath(void) void BotChatterInterface::OnDeath()
{ {
if (IsTalking()) if (IsTalking())
{ {
@ -1534,7 +1526,7 @@ void BotChatterInterface::OnDeath(void)
// Process ongoing chatter for this bot // Process ongoing chatter for this bot
/* <308852> ../cstrike/dlls/bot/cs_bot_chatter.cpp:1549 */ /* <308852> ../cstrike/dlls/bot/cs_bot_chatter.cpp:1549 */
void BotChatterInterface::Update(void) void BotChatterInterface::Update()
{ {
// report enemy activity // report enemy activity
ReportEnemies(); ReportEnemies();
@ -1615,7 +1607,7 @@ void BotChatterInterface::Update(void)
// Returns the statement that is being spoken, or is next to be spoken if no-one is speaking now // Returns the statement that is being spoken, or is next to be spoken if no-one is speaking now
/* <305915> ../cstrike/dlls/bot/cs_bot_chatter.cpp:1635 */ /* <305915> ../cstrike/dlls/bot/cs_bot_chatter.cpp:1635 */
BotStatement *BotChatterInterface::GetActiveStatement(void) BotStatement *BotChatterInterface::GetActiveStatement()
{ {
// keep track of statement waiting longest to be spoken - it is next // keep track of statement waiting longest to be spoken - it is next
BotStatement *earliest = NULL; BotStatement *earliest = NULL;
@ -1674,7 +1666,7 @@ BotStatement *BotChatterInterface::GetActiveStatement(void)
// Return true if we speaking makes sense now // Return true if we speaking makes sense now
/* <305a35> ../cstrike/dlls/bot/cs_bot_chatter.cpp:1694 */ /* <305a35> ../cstrike/dlls/bot/cs_bot_chatter.cpp:1694 */
bool BotChatterInterface::ShouldSpeak(void) const bool BotChatterInterface::ShouldSpeak() const
{ {
// don't talk to non-existent friends // don't talk to non-existent friends
if (m_me->GetFriendsRemaining() == 0) if (m_me->GetFriendsRemaining() == 0)
@ -1688,13 +1680,13 @@ bool BotChatterInterface::ShouldSpeak(void) const
} }
/* <305a8f> ../cstrike/dlls/bot/cs_bot_chatter.cpp:1708 */ /* <305a8f> ../cstrike/dlls/bot/cs_bot_chatter.cpp:1708 */
float BotChatterInterface::GetRadioSilenceDuration(void) float BotChatterInterface::GetRadioSilenceDuration()
{ {
return IMPL(m_radioSilenceInterval)[ m_me->m_iTeam - 1 ].GetElapsedTime(); return IMPL(m_radioSilenceInterval)[ m_me->m_iTeam - 1 ].GetElapsedTime();
} }
/* <305b15> ../cstrike/dlls/bot/cs_bot_chatter.cpp:1714 */ /* <305b15> ../cstrike/dlls/bot/cs_bot_chatter.cpp:1714 */
void BotChatterInterface::ResetRadioSilenceDuration(void) void BotChatterInterface::ResetRadioSilenceDuration()
{ {
IMPL(m_radioSilenceInterval)[m_me->m_iTeam - 1].Reset(); IMPL(m_radioSilenceInterval)[m_me->m_iTeam - 1].Reset();
} }
@ -1708,7 +1700,7 @@ inline void SayWhere(BotStatement *say, Place place)
// Report enemy sightings // Report enemy sightings
/* <305b50> ../cstrike/dlls/bot/cs_bot_chatter.cpp:1740 */ /* <305b50> ../cstrike/dlls/bot/cs_bot_chatter.cpp:1740 */
void BotChatterInterface::EnemySpotted(void) void BotChatterInterface::EnemySpotted()
{ {
// NOTE: This could be a few seconds out of date (enemy is in an adjacent place) // NOTE: This could be a few seconds out of date (enemy is in an adjacent place)
Place place = m_me->GetEnemyPlace(); Place place = m_me->GetEnemyPlace();
@ -1733,28 +1725,26 @@ NOXREF void BotChatterInterface::Clear(Place place)
SayWhere(say, place); SayWhere(say, place);
say->AppendPhrase(TheBotPhrases->GetPhrase("Clear")); say->AppendPhrase(TheBotPhrases->GetPhrase("Clear"));
AddStatement(say); AddStatement(say);
} }
// Request enemy activity report // Request enemy activity report
/* <305ffa> ../cstrike/dlls/bot/cs_bot_chatter.cpp:1773 */ /* <305ffa> ../cstrike/dlls/bot/cs_bot_chatter.cpp:1773 */
void BotChatterInterface::ReportIn(void) void BotChatterInterface::ReportIn()
{ {
BotStatement *say = new BotStatement(this, REPORT_REQUEST_INFORMATION, 10.0f); BotStatement *say = new BotStatement(this, REPORT_REQUEST_INFORMATION, 10.0f);
say->AppendPhrase(TheBotPhrases->GetPhrase("RequestReport")); say->AppendPhrase(TheBotPhrases->GetPhrase("RequestReport"));
say->AddCondition(BotStatement::RADIO_SILENCE); say->AddCondition(BotStatement::RADIO_SILENCE);
say->AttachMeme(new BotRequestReportMeme()); say->AttachMeme(new BotRequestReportMeme());
AddStatement(say); AddStatement(say);
} }
// Report our situtation // Report our situtation
/* <309851> ../cstrike/dlls/bot/cs_bot_chatter.cpp:1788 */ /* <309851> ../cstrike/dlls/bot/cs_bot_chatter.cpp:1788 */
void BotChatterInterface::ReportingIn(void) void BotChatterInterface::ReportingIn()
{ {
CCSBotManager *ctrl = TheCSBots(); CCSBotManager *ctrl = TheCSBots();
BotStatement *say = new BotStatement(this, REPORT_INFORMATION, 10.0f); BotStatement *say = new BotStatement(this, REPORT_INFORMATION, 10.0f);
@ -1852,7 +1842,7 @@ void BotChatterInterface::ReportingIn(void)
} }
/* <3084cf> ../cstrike/dlls/bot/cs_bot_chatter.cpp:1896 */ /* <3084cf> ../cstrike/dlls/bot/cs_bot_chatter.cpp:1896 */
bool BotChatterInterface::NeedBackup(void) bool BotChatterInterface::NeedBackup()
{ {
const float minRequestInterval = 10.0f; const float minRequestInterval = 10.0f;
if (m_needBackupInterval.IsLessThen(minRequestInterval)) if (m_needBackupInterval.IsLessThen(minRequestInterval))
@ -1877,7 +1867,6 @@ bool BotChatterInterface::NeedBackup(void)
say->AppendPhrase(TheBotPhrases->GetPhrase("Help")); say->AppendPhrase(TheBotPhrases->GetPhrase("Help"));
say->AttachMeme(new BotHelpMeme(place)); say->AttachMeme(new BotHelpMeme(place));
AddStatement(say); AddStatement(say);
} }
@ -1885,7 +1874,7 @@ bool BotChatterInterface::NeedBackup(void)
} }
/* <3061a8> ../cstrike/dlls/bot/cs_bot_chatter.cpp:1929 */ /* <3061a8> ../cstrike/dlls/bot/cs_bot_chatter.cpp:1929 */
void BotChatterInterface::PinnedDown(void) void BotChatterInterface::PinnedDown()
{ {
// this is a form of "need backup" // this is a form of "need backup"
const float minRequestInterval = 10.0f; const float minRequestInterval = 10.0f;
@ -1939,15 +1928,13 @@ void BotChatterInterface::KilledMyEnemy(int victimID)
return; return;
BotStatement *say = new BotStatement(this, REPORT_ENEMY_ACTION, 3.0f); BotStatement *say = new BotStatement(this, REPORT_ENEMY_ACTION, 3.0f);
say->AppendPhrase(TheBotPhrases->GetPhrase("KilledMyEnemy")); say->AppendPhrase(TheBotPhrases->GetPhrase("KilledMyEnemy"));
say->SetSubject(victimID); say->SetSubject(victimID);
AddStatement(say); AddStatement(say);
} }
/* <306853> ../cstrike/dlls/bot/cs_bot_chatter.cpp:1993 */ /* <306853> ../cstrike/dlls/bot/cs_bot_chatter.cpp:1993 */
void BotChatterInterface::EnemiesRemaining(void) void BotChatterInterface::EnemiesRemaining()
{ {
// only report if we killed the last enemy in the area // only report if we killed the last enemy in the area
if (m_me->GetNearbyEnemyCount() > 1) if (m_me->GetNearbyEnemyCount() > 1)
@ -1956,27 +1943,22 @@ void BotChatterInterface::EnemiesRemaining(void)
BotStatement *say = new BotStatement(this, REPORT_ENEMIES_REMAINING, 5.0f); BotStatement *say = new BotStatement(this, REPORT_ENEMIES_REMAINING, 5.0f);
say->AppendPhrase(BotStatement::REMAINING_ENEMY_COUNT); say->AppendPhrase(BotStatement::REMAINING_ENEMY_COUNT);
say->SetStartTime(gpGlobals->time + RANDOM_FLOAT(2.0f, 4.0f)); say->SetStartTime(gpGlobals->time + RANDOM_FLOAT(2.0f, 4.0f));
AddStatement(say); AddStatement(say);
} }
/* <306974> ../cstrike/dlls/bot/cs_bot_chatter.cpp:2008 */ /* <306974> ../cstrike/dlls/bot/cs_bot_chatter.cpp:2008 */
void BotChatterInterface::Affirmative(void) void BotChatterInterface::Affirmative()
{ {
BotStatement *say = new BotStatement(this, REPORT_ACKNOWLEDGE, 3.0f); BotStatement *say = new BotStatement(this, REPORT_ACKNOWLEDGE, 3.0f);
say->AppendPhrase(TheBotPhrases->GetPhrase("Affirmative")); say->AppendPhrase(TheBotPhrases->GetPhrase("Affirmative"));
AddStatement(say); AddStatement(say);
} }
/* <306bb2> ../cstrike/dlls/bot/cs_bot_chatter.cpp:2018 */ /* <306bb2> ../cstrike/dlls/bot/cs_bot_chatter.cpp:2018 */
void BotChatterInterface::Negative(void) void BotChatterInterface::Negative()
{ {
BotStatement *say = new BotStatement(this, REPORT_ACKNOWLEDGE, 3.0f); BotStatement *say = new BotStatement(this, REPORT_ACKNOWLEDGE, 3.0f);
say->AppendPhrase(TheBotPhrases->GetPhrase("Negative")); say->AppendPhrase(TheBotPhrases->GetPhrase("Negative"));
AddStatement(say); AddStatement(say);
} }
@ -1993,11 +1975,9 @@ void BotChatterInterface::GoingToPlantTheBomb(Place place)
m_planInterval.Reset(); m_planInterval.Reset();
BotStatement *say = new BotStatement(this, REPORT_CRITICAL_EVENT, 10.0f); BotStatement *say = new BotStatement(this, REPORT_CRITICAL_EVENT, 10.0f);
say->AppendPhrase(TheBotPhrases->GetPhrase("GoingToPlantBomb")); say->AppendPhrase(TheBotPhrases->GetPhrase("GoingToPlantBomb"));
say->SetPlace(place); say->SetPlace(place);
say->AttachMeme(new BotFollowMeme()); say->AttachMeme(new BotFollowMeme());
AddStatement(say); AddStatement(say);
} }
@ -2008,17 +1988,14 @@ void BotChatterInterface::PlantingTheBomb(Place place)
return; return;
BotStatement *say = new BotStatement(this, REPORT_CRITICAL_EVENT, 10.0f); BotStatement *say = new BotStatement(this, REPORT_CRITICAL_EVENT, 10.0f);
say->AppendPhrase(TheBotPhrases->GetPhrase("PlantingBomb")); say->AppendPhrase(TheBotPhrases->GetPhrase("PlantingBomb"));
say->SetPlace(place); say->SetPlace(place);
say->AttachMeme(new BotDefendHereMeme(m_me->pev->origin)); say->AttachMeme(new BotDefendHereMeme(m_me->pev->origin));
AddStatement(say); AddStatement(say);
} }
/* <3070c8> ../cstrike/dlls/bot/cs_bot_chatter.cpp:2066 */ /* <3070c8> ../cstrike/dlls/bot/cs_bot_chatter.cpp:2066 */
void BotChatterInterface::TheyPickedUpTheBomb(void) void BotChatterInterface::TheyPickedUpTheBomb()
{ {
if (TheCSBots()->IsRoundOver()) if (TheCSBots()->IsRoundOver())
return; return;
@ -2032,10 +2009,8 @@ void BotChatterInterface::TheyPickedUpTheBomb(void)
// tell our teammates // tell our teammates
BotStatement *say = new BotStatement(this, REPORT_INFORMATION, 10.0f); BotStatement *say = new BotStatement(this, REPORT_INFORMATION, 10.0f);
say->AppendPhrase(TheBotPhrases->GetPhrase("TheyPickedUpTheBomb")); say->AppendPhrase(TheBotPhrases->GetPhrase("TheyPickedUpTheBomb"));
say->AttachMeme(new BotBombStatusMeme(CSGameState::MOVING, m_me->pev->origin)); say->AttachMeme(new BotBombStatusMeme(CSGameState::MOVING, m_me->pev->origin));
AddStatement(say); AddStatement(say);
} }
@ -2066,7 +2041,6 @@ void BotChatterInterface::SpottedBomber(CBasePlayer *bomber)
//say->AttachMeme(new BotHelpMeme(place)); //say->AttachMeme(new BotHelpMeme(place));
say->AttachMeme(new BotBombStatusMeme(CSGameState::MOVING, bomber->pev->origin)); say->AttachMeme(new BotBombStatusMeme(CSGameState::MOVING, bomber->pev->origin));
AddStatement(say); AddStatement(say);
} }
@ -2137,7 +2111,7 @@ NOXREF void BotChatterInterface::GuardingLooseBomb(CBaseEntity *bomb)
} }
/* <307c56> ../cstrike/dlls/bot/cs_bot_chatter.cpp:2186 */ /* <307c56> ../cstrike/dlls/bot/cs_bot_chatter.cpp:2186 */
void BotChatterInterface::RequestBombLocation(void) void BotChatterInterface::RequestBombLocation()
{ {
// only ask once per round // only ask once per round
if (m_requestedBombLocation) if (m_requestedBombLocation)
@ -2147,11 +2121,8 @@ void BotChatterInterface::RequestBombLocation(void)
// tell our teammates // tell our teammates
BotStatement *say = new BotStatement(this, REPORT_REQUEST_INFORMATION, 10.0f); BotStatement *say = new BotStatement(this, REPORT_REQUEST_INFORMATION, 10.0f);
say->AppendPhrase(TheBotPhrases->GetPhrase("WhereIsTheBomb")); say->AppendPhrase(TheBotPhrases->GetPhrase("WhereIsTheBomb"));
say->AttachMeme(new BotWhereBombMeme()); say->AttachMeme(new BotWhereBombMeme());
AddStatement(say); AddStatement(say);
} }
@ -2166,9 +2137,7 @@ void BotChatterInterface::BombsiteClear(int zoneIndex)
SayWhere(say, TheNavAreaGrid.GetPlace(&zone->m_center)); SayWhere(say, TheNavAreaGrid.GetPlace(&zone->m_center));
say->AppendPhrase(TheBotPhrases->GetPhrase("BombsiteClear")); say->AppendPhrase(TheBotPhrases->GetPhrase("BombsiteClear"));
say->AttachMeme(new BotBombsiteStatusMeme(zoneIndex, BotBombsiteStatusMeme::CLEAR)); say->AttachMeme(new BotBombsiteStatusMeme(zoneIndex, BotBombsiteStatusMeme::CLEAR));
AddStatement(say); AddStatement(say);
} }
@ -2180,17 +2149,14 @@ void BotChatterInterface::FoundPlantedBomb(int zoneIndex)
return; return;
BotStatement *say = new BotStatement(this, REPORT_INFORMATION, 3.0f); BotStatement *say = new BotStatement(this, REPORT_INFORMATION, 3.0f);
say->AppendPhrase(TheBotPhrases->GetPhrase("PlantedBombPlace")); say->AppendPhrase(TheBotPhrases->GetPhrase("PlantedBombPlace"));
say->SetPlace(TheNavAreaGrid.GetPlace(&zone->m_center)); say->SetPlace(TheNavAreaGrid.GetPlace(&zone->m_center));
say->AttachMeme(new BotBombsiteStatusMeme(zoneIndex, BotBombsiteStatusMeme::PLANTED)); say->AttachMeme(new BotBombsiteStatusMeme(zoneIndex, BotBombsiteStatusMeme::PLANTED));
AddStatement(say); AddStatement(say);
} }
/* <308308> ../cstrike/dlls/bot/cs_bot_chatter.cpp:2242 */ /* <308308> ../cstrike/dlls/bot/cs_bot_chatter.cpp:2242 */
void BotChatterInterface::Scared(void) void BotChatterInterface::Scared()
{ {
const float minInterval = 10.0f; const float minInterval = 10.0f;
if (m_scaredInterval.IsLessThen(minInterval)) if (m_scaredInterval.IsLessThen(minInterval))
@ -2199,15 +2165,13 @@ void BotChatterInterface::Scared(void)
m_scaredInterval.Reset(); m_scaredInterval.Reset();
BotStatement *say = new BotStatement(this, REPORT_EMOTE, 1.0f); BotStatement *say = new BotStatement(this, REPORT_EMOTE, 1.0f);
say->AppendPhrase(TheBotPhrases->GetPhrase("ScaredEmote")); say->AppendPhrase(TheBotPhrases->GetPhrase("ScaredEmote"));
say->AddCondition(BotStatement::IS_IN_COMBAT); say->AddCondition(BotStatement::IS_IN_COMBAT);
AddStatement(say); AddStatement(say);
} }
/* <308b60> ../cstrike/dlls/bot/cs_bot_chatter.cpp:2259 */ /* <308b60> ../cstrike/dlls/bot/cs_bot_chatter.cpp:2259 */
void BotChatterInterface::CelebrateWin(void) void BotChatterInterface::CelebrateWin()
{ {
BotStatement *say = new BotStatement(this, REPORT_EMOTE, 15.0f); BotStatement *say = new BotStatement(this, REPORT_EMOTE, 15.0f);
@ -2249,13 +2213,11 @@ void BotChatterInterface::AnnouncePlan(const char *phraseName, Place place)
return; return;
BotStatement *say = new BotStatement(this, REPORT_MY_PLAN, 10.0f); BotStatement *say = new BotStatement(this, REPORT_MY_PLAN, 10.0f);
say->AppendPhrase(TheBotPhrases->GetPhrase(phraseName)); say->AppendPhrase(TheBotPhrases->GetPhrase(phraseName));
say->SetPlace(place); say->SetPlace(place);
// wait at least a short time after round start // wait at least a short time after round start
say->SetStartTime(ctrl->GetRoundStartTime() + RANDOM_FLOAT(2.0, 3.0f)); say->SetStartTime(ctrl->GetRoundStartTime() + RANDOM_FLOAT(2.0, 3.0f));
AddStatement(say); AddStatement(say);
} }
@ -2300,40 +2262,36 @@ void BotChatterInterface::GuardingHostageEscapeZone(bool isPlan)
} }
/* <3093a9> ../cstrike/dlls/bot/cs_bot_chatter.cpp:2346 */ /* <3093a9> ../cstrike/dlls/bot/cs_bot_chatter.cpp:2346 */
void BotChatterInterface::HostagesBeingTaken(void) void BotChatterInterface::HostagesBeingTaken()
{ {
if (TheCSBots()->IsRoundOver()) if (TheCSBots()->IsRoundOver())
return; return;
BotStatement *say = new BotStatement(this, REPORT_INFORMATION, 3.0f); BotStatement *say = new BotStatement(this, REPORT_INFORMATION, 3.0f);
say->AppendPhrase(TheBotPhrases->GetPhrase("HostagesBeingTaken")); say->AppendPhrase(TheBotPhrases->GetPhrase("HostagesBeingTaken"));
say->AttachMeme(new BotHostageBeingTakenMeme()); say->AttachMeme(new BotHostageBeingTakenMeme());
AddStatement(say); AddStatement(say);
} }
/* <309542> ../cstrike/dlls/bot/cs_bot_chatter.cpp:2361 */ /* <309542> ../cstrike/dlls/bot/cs_bot_chatter.cpp:2361 */
void BotChatterInterface::HostagesTaken(void) void BotChatterInterface::HostagesTaken()
{ {
if (TheCSBots()->IsRoundOver()) if (TheCSBots()->IsRoundOver())
return; return;
BotStatement *say = new BotStatement(this, REPORT_INFORMATION, 3.0f); BotStatement *say = new BotStatement(this, REPORT_INFORMATION, 3.0f);
say->AppendPhrase(TheBotPhrases->GetPhrase("HostagesTaken")); say->AppendPhrase(TheBotPhrases->GetPhrase("HostagesTaken"));
AddStatement(say); AddStatement(say);
} }
/* <309691> ../cstrike/dlls/bot/cs_bot_chatter.cpp:2375 */ /* <309691> ../cstrike/dlls/bot/cs_bot_chatter.cpp:2375 */
void BotChatterInterface::TalkingToHostages(void) void BotChatterInterface::TalkingToHostages()
{ {
; ;
} }
/* <3096bc> ../cstrike/dlls/bot/cs_bot_chatter.cpp:2380 */ /* <3096bc> ../cstrike/dlls/bot/cs_bot_chatter.cpp:2380 */
void BotChatterInterface::EscortingHostages(void) void BotChatterInterface::EscortingHostages()
{ {
if (TheCSBots()->IsRoundOver()) if (TheCSBots()->IsRoundOver())
return; return;
@ -2344,23 +2302,19 @@ void BotChatterInterface::EscortingHostages(void)
m_escortingHostageTimer.Start(10.0f); m_escortingHostageTimer.Start(10.0f);
BotStatement *say = new BotStatement(this, REPORT_MY_PLAN, 5.0f); BotStatement *say = new BotStatement(this, REPORT_MY_PLAN, 5.0f);
say->AppendPhrase(TheBotPhrases->GetPhrase("EscortingHostages")); say->AppendPhrase(TheBotPhrases->GetPhrase("EscortingHostages"));
AddStatement(say); AddStatement(say);
} }
} }
/* <30a5b9> ../cstrike/dlls/bot/cs_bot_chatter.cpp:2400 */ /* <30a5b9> ../cstrike/dlls/bot/cs_bot_chatter.cpp:2400 */
NOXREF void BotChatterInterface::HostageDown(void) NOXREF void BotChatterInterface::HostageDown()
{ {
if (TheCSBots()->IsRoundOver()) if (TheCSBots()->IsRoundOver())
return; return;
BotStatement *say = new BotStatement(this, REPORT_INFORMATION, 3.0f); BotStatement *say = new BotStatement(this, REPORT_INFORMATION, 3.0f);
say->AppendPhrase(TheBotPhrases->GetPhrase("HostageDown")); say->AppendPhrase(TheBotPhrases->GetPhrase("HostageDown"));
AddStatement(say); AddStatement(say);
} }
@ -2375,84 +2329,23 @@ void BotChatterInterface::Encourage(const char *phraseName, float repeatInterval
} }
/* <30a905> ../cstrike/dlls/bot/cs_bot_chatter.cpp:2427 */ /* <30a905> ../cstrike/dlls/bot/cs_bot_chatter.cpp:2427 */
void BotChatterInterface::KilledFriend(void) void BotChatterInterface::KilledFriend()
{ {
BotStatement *say = new BotStatement(this, REPORT_KILLED_FRIEND, 2.0f); BotStatement *say = new BotStatement(this, REPORT_KILLED_FRIEND, 2.0f);
say->AppendPhrase(TheBotPhrases->GetPhrase("KilledFriend")); say->AppendPhrase(TheBotPhrases->GetPhrase("KilledFriend"));
// give them time to react // give them time to react
say->SetStartTime(gpGlobals->time + RANDOM_FLOAT(0.5f, 1.0f)); say->SetStartTime(gpGlobals->time + RANDOM_FLOAT(0.5f, 1.0f));
AddStatement(say); AddStatement(say);
} }
/* <30aa67> ../cstrike/dlls/bot/cs_bot_chatter.cpp:2440 */ /* <30aa67> ../cstrike/dlls/bot/cs_bot_chatter.cpp:2440 */
void BotChatterInterface::FriendlyFire(void) void BotChatterInterface::FriendlyFire()
{ {
BotStatement *say = new BotStatement(this, REPORT_FRIENDLY_FIRE, 1.0f); BotStatement *say = new BotStatement(this, REPORT_FRIENDLY_FIRE, 1.0f);
say->AppendPhrase(TheBotPhrases->GetPhrase("FriendlyFire")); say->AppendPhrase(TheBotPhrases->GetPhrase("FriendlyFire"));
// give them time to react // give them time to react
say->SetStartTime(gpGlobals->time + RANDOM_FLOAT(0.3f, 0.5f)); say->SetStartTime(gpGlobals->time + RANDOM_FLOAT(0.3f, 0.5f));
AddStatement(say); AddStatement(say);
} }
#ifdef HOOK_GAMEDLL
void (*pBotPhrase__Randomize)(void);
void __declspec(naked) BotPhrase::Randomize(void)
{
// you can not hook this function, because it uses the rand() function
// which does not allow us to carry out tests because different results at the output.
__asm { jmp pBotPhrase__Randomize }
}
void BotAllHostagesGoneMeme::Interpret(CCSBot *sender, CCSBot *receiver) const
{
Interpret_(sender, receiver);
}
void BotHostageBeingTakenMeme::Interpret(CCSBot *sender, CCSBot *receiver) const
{
Interpret_(sender, receiver);
}
void BotHelpMeme::Interpret(CCSBot *sender, CCSBot *receiver) const
{
Interpret_(sender, receiver);
}
void BotBombsiteStatusMeme::Interpret(CCSBot *sender, CCSBot *receiver) const
{
Interpret_(sender, receiver);
}
void BotBombStatusMeme::Interpret(CCSBot *sender, CCSBot *receiver) const
{
Interpret_(sender, receiver);
}
void BotFollowMeme::Interpret(CCSBot *sender, CCSBot *receiver) const
{
Interpret_(sender, receiver);
}
void BotDefendHereMeme::Interpret(CCSBot *sender, CCSBot *receiver) const
{
Interpret_(sender, receiver);
}
void BotWhereBombMeme::Interpret(CCSBot *sender, CCSBot *receiver) const
{
Interpret_(sender, receiver);
}
void BotRequestReportMeme::Interpret(CCSBot *sender, CCSBot *receiver) const
{
Interpret_(sender, receiver);
}
#endif // HOOK_GAMEDLL

View File

@ -43,17 +43,16 @@ class BotChatterInterface;
typedef unsigned int PlaceCriteria; typedef unsigned int PlaceCriteria;
typedef unsigned int CountCriteria; typedef unsigned int CountCriteria;
// A meme is a unit information that bots use to // A meme is a unit information that bots use to
// transmit information to each other via the radio // transmit information to each other via the radio
/* <2fe97b> ../cstrike/dlls/bot/cs_bot_chatter.h:42 */ /* <2fe97b> ../cstrike/dlls/bot/cs_bot_chatter.h:42 */
class BotMeme class BotMeme
{ {
public: public:
void Transmit(CCSBot *sender) const; // transmit meme to other bots void Transmit(CCSBot *sender) const; // transmit meme to other bots
virtual void Interpret(CCSBot *sender, CCSBot *receiver) const = 0; // cause the given bot to act on this meme virtual void Interpret(CCSBot *sender, CCSBot *receiver) const = 0; // cause the given bot to act on this meme
};
};/* size: 4, cachelines: 1, members: 1 */
class BotAllHostagesGoneMeme: public BotMeme class BotAllHostagesGoneMeme: public BotMeme
{ {
@ -61,12 +60,12 @@ public:
virtual void Interpret(CCSBot *sender, CCSBot *receiver) const; // cause the given bot to act on this meme virtual void Interpret(CCSBot *sender, CCSBot *receiver) const; // cause the given bot to act on this meme
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Interpret_(CCSBot *sender, CCSBot *receiver) const; void Interpret_(CCSBot *sender, CCSBot *receiver) const;
#endif //HOOK_GAMEDLL #endif // HOOK_GAMEDLL
};/* size: 4, cachelines: 1, members: 1 */ };
class BotHostageBeingTakenMeme: public BotMeme class BotHostageBeingTakenMeme: public BotMeme
{ {
@ -74,12 +73,12 @@ public:
virtual void Interpret(CCSBot *sender, CCSBot *receiver) const; // cause the given bot to act on this meme virtual void Interpret(CCSBot *sender, CCSBot *receiver) const; // cause the given bot to act on this meme
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Interpret_(CCSBot *sender, CCSBot *receiver) const; void Interpret_(CCSBot *sender, CCSBot *receiver) const;
#endif //HOOK_GAMEDLL #endif // HOOK_GAMEDLL
};/* size: 4, cachelines: 1, members: 1 */ };
/* <2ff7ef> ../cstrike/dlls/bot/cs_bot_chatter.h:53 */ /* <2ff7ef> ../cstrike/dlls/bot/cs_bot_chatter.h:53 */
class BotHelpMeme: public BotMeme class BotHelpMeme: public BotMeme
@ -92,15 +91,14 @@ public:
virtual void Interpret(CCSBot *sender, CCSBot *receiver) const; // cause the given bot to act on this meme virtual void Interpret(CCSBot *sender, CCSBot *receiver) const; // cause the given bot to act on this meme
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Interpret_(CCSBot *sender, CCSBot *receiver) const; void Interpret_(CCSBot *sender, CCSBot *receiver) const;
#endif //HOOK_GAMEDLL #endif // HOOK_GAMEDLL
private: private:
Place m_place; Place m_place;
};
};/* size: 8, cachelines: 1, members: 2 */
/* <2ff65e> ../cstrike/dlls/bot/cs_bot_chatter.h:70 */ /* <2ff65e> ../cstrike/dlls/bot/cs_bot_chatter.h:70 */
class BotBombsiteStatusMeme: public BotMeme class BotBombsiteStatusMeme: public BotMeme
@ -116,16 +114,15 @@ public:
virtual void Interpret(CCSBot *sender, CCSBot *receiver) const; // cause the given bot to act on this meme virtual void Interpret(CCSBot *sender, CCSBot *receiver) const; // cause the given bot to act on this meme
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Interpret_(CCSBot *sender, CCSBot *receiver) const; void Interpret_(CCSBot *sender, CCSBot *receiver) const;
#endif //HOOK_GAMEDLL #endif // HOOK_GAMEDLL
private: private:
int m_zoneIndex; // the bombsite int m_zoneIndex; // the bombsite
StatusType m_status; // whether it is cleared or the bomb is there (planted) StatusType m_status; // whether it is cleared or the bomb is there (planted)
};
};/* size: 12, cachelines: 1, members: 3 */
/* <2ff6de> ../cstrike/dlls/bot/cs_bot_chatter.h:87 */ /* <2ff6de> ../cstrike/dlls/bot/cs_bot_chatter.h:87 */
class BotBombStatusMeme: public BotMeme class BotBombStatusMeme: public BotMeme
@ -141,16 +138,15 @@ public:
virtual void Interpret(CCSBot *sender, CCSBot *receiver) const; // cause the given bot to act on this meme virtual void Interpret(CCSBot *sender, CCSBot *receiver) const; // cause the given bot to act on this meme
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Interpret_(CCSBot *sender, CCSBot *receiver) const; void Interpret_(CCSBot *sender, CCSBot *receiver) const;
#endif //HOOK_GAMEDLL #endif // HOOK_GAMEDLL
private: private:
CSGameState::BombState m_state; CSGameState::BombState m_state;
Vector m_pos; Vector m_pos;
};
};/* size: 20, cachelines: 1, members: 3 */
/* <2ff75d> ../cstrike/dlls/bot/cs_bot_chatter.h:101 */ /* <2ff75d> ../cstrike/dlls/bot/cs_bot_chatter.h:101 */
class BotFollowMeme: public BotMeme class BotFollowMeme: public BotMeme
@ -159,12 +155,11 @@ public:
virtual void Interpret(CCSBot *sender, CCSBot *receiver) const; // cause the given bot to act on this meme virtual void Interpret(CCSBot *sender, CCSBot *receiver) const; // cause the given bot to act on this meme
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Interpret_(CCSBot *sender, CCSBot *receiver) const; void Interpret_(CCSBot *sender, CCSBot *receiver) const;
#endif //HOOK_GAMEDLL #endif // HOOK_GAMEDLL
};
};/* size: 4, cachelines: 1, members: 1 */
/* <2ff731> ../cstrike/dlls/bot/cs_bot_chatter.h:111 */ /* <2ff731> ../cstrike/dlls/bot/cs_bot_chatter.h:111 */
class BotDefendHereMeme: public BotMeme class BotDefendHereMeme: public BotMeme
@ -177,15 +172,14 @@ public:
virtual void Interpret(CCSBot *sender, CCSBot *receiver) const; // cause the given bot to act on this meme virtual void Interpret(CCSBot *sender, CCSBot *receiver) const; // cause the given bot to act on this meme
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Interpret_(CCSBot *sender, CCSBot *receiver) const; void Interpret_(CCSBot *sender, CCSBot *receiver) const;
#endif //HOOK_GAMEDLL #endif // HOOK_GAMEDLL
private: private:
Vector m_pos; Vector m_pos;
};
};/* size: 16, cachelines: 1, members: 2 */
/* <2ff696> ../cstrike/dlls/bot/cs_bot_chatter.h:123 */ /* <2ff696> ../cstrike/dlls/bot/cs_bot_chatter.h:123 */
class BotWhereBombMeme: public BotMeme class BotWhereBombMeme: public BotMeme
@ -194,12 +188,11 @@ public:
virtual void Interpret(CCSBot *sender, CCSBot *receiver) const; // cause the given bot to act on this meme virtual void Interpret(CCSBot *sender, CCSBot *receiver) const; // cause the given bot to act on this meme
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Interpret_(CCSBot *sender, CCSBot *receiver) const; void Interpret_(CCSBot *sender, CCSBot *receiver) const;
#endif //HOOK_GAMEDLL #endif // HOOK_GAMEDLL
};
};/* size: 4, cachelines: 1, members: 1 */
/* <2ff81b> ../cstrike/dlls/bot/cs_bot_chatter.h:130 */ /* <2ff81b> ../cstrike/dlls/bot/cs_bot_chatter.h:130 */
class BotRequestReportMeme: public BotMeme class BotRequestReportMeme: public BotMeme
@ -208,12 +201,12 @@ public:
virtual void Interpret(CCSBot *sender, CCSBot *receiver) const; // cause the given bot to act on this meme virtual void Interpret(CCSBot *sender, CCSBot *receiver) const; // cause the given bot to act on this meme
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Interpret_(CCSBot *sender, CCSBot *receiver) const; void Interpret_(CCSBot *sender, CCSBot *receiver) const;
#endif //HOOK_GAMEDLL #endif // HOOK_GAMEDLL
};/* size: 4, cachelines: 1, members: 1 */ };
enum BotStatementType enum BotStatementType
{ {
@ -242,15 +235,14 @@ enum BotStatementType
class BotSpeakable class BotSpeakable
{ {
public: public:
BotSpeakable(void); BotSpeakable();
~BotSpeakable(void); ~BotSpeakable();
char *m_phrase; char *m_phrase;
float m_duration; float m_duration;
PlaceCriteria m_place; PlaceCriteria m_place;
CountCriteria m_count; CountCriteria m_count;
};
};/* size: 16, cachelines: 1, members: 4 */
typedef std::STD_VECTOR<BotSpeakable *> BotSpeakableVector; typedef std::STD_VECTOR<BotSpeakable *> BotSpeakableVector;
typedef std::STD_VECTOR<BotSpeakableVector *> BotVoiceBankVector; typedef std::STD_VECTOR<BotSpeakableVector *> BotVoiceBankVector;
@ -262,17 +254,17 @@ public:
char *GetSpeakable(int bankIndex, float *duration = NULL) const; // return a random speakable and its duration in seconds that meets the current criteria char *GetSpeakable(int bankIndex, float *duration = NULL) const; // return a random speakable and its duration in seconds that meets the current criteria
// NOTE: Criteria must be set just before the GetSpeakable() call, since they are shared among all bots // NOTE: Criteria must be set just before the GetSpeakable() call, since they are shared among all bots
void ClearCriteria(void) const; void ClearCriteria() const;
void SetPlaceCriteria(PlaceCriteria place) const; // all returned phrases must have this place criteria void SetPlaceCriteria(PlaceCriteria place) const; // all returned phrases must have this place criteria
void SetCountCriteria(CountCriteria count) const; // all returned phrases must have this count criteria void SetCountCriteria(CountCriteria count) const; // all returned phrases must have this count criteria
const char *GetName(void) const { return m_name; } const char *GetName() const { return m_name; }
Place GetID(void) const { return m_id; } Place GetID() const { return m_id; }
GameEventType GetRadioEquivalent(void) const { return m_radioEvent; } GameEventType GetRadioEquivalent() const { return m_radioEvent; }
bool IsImportant(void) const { return m_isImportant; } // return true if this phrase is part of an important statement bool IsImportant() const { return m_isImportant; } // return true if this phrase is part of an important statement
bool IsPlace(void) const { return m_isPlace; } bool IsPlace() const { return m_isPlace; }
void Randomize(void); // randomly shuffle the speakable order void Randomize(); // randomly shuffle the speakable order
#ifndef HOOK_GAMEDLL #ifndef HOOK_GAMEDLL
private: private:
@ -280,7 +272,7 @@ private:
friend class BotPhraseManager; friend class BotPhraseManager;
BotPhrase(unsigned int id, bool isPlace); BotPhrase(unsigned int id, bool isPlace);
~BotPhrase(void); ~BotPhrase();
char *m_name; char *m_name;
Place m_id; Place m_id;
@ -296,13 +288,12 @@ private:
mutable PlaceCriteria m_placeCriteria; mutable PlaceCriteria m_placeCriteria;
mutable CountCriteria m_countCriteria; mutable CountCriteria m_countCriteria;
};
};/* size: 68, cachelines: 2, members: 11 */
typedef std::STD_LIST<BotPhrase *> BotPhraseList; typedef std::STD_LIST<BotPhrase *> BotPhraseList;
/* <2fea0e> ../cstrike/dlls/bot/cs_bot_chatter.h:239 */ /* <2fea0e> ../cstrike/dlls/bot/cs_bot_chatter.h:239 */
inline void BotPhrase::ClearCriteria(void) const inline void BotPhrase::ClearCriteria() const
{ {
m_placeCriteria = ANY_PLACE; m_placeCriteria = ANY_PLACE;
m_countCriteria = UNDEFINED_COUNT; m_countCriteria = UNDEFINED_COUNT;
@ -324,17 +315,17 @@ inline void BotPhrase::SetCountCriteria(CountCriteria count) const
class BotPhraseManager class BotPhraseManager
{ {
public: public:
BotPhraseManager(void); BotPhraseManager();
~BotPhraseManager(void); ~BotPhraseManager();
// initialize phrase system from database file for a specific voice bank (0 is the default voice bank) // initialize phrase system from database file for a specific voice bank (0 is the default voice bank)
bool Initialize(const char *filename, int bankIndex); bool Initialize(const char *filename, int bankIndex);
// invoked when round resets // invoked when round resets
void OnRoundRestart(void); void OnRoundRestart();
// invoked when map changes // invoked when map changes
void OnMapChange(void); void OnMapChange();
Place NameToID(const char *name) const; Place NameToID(const char *name) const;
const char *IDToName(Place id) const; const char *IDToName(Place id) const;
@ -347,7 +338,7 @@ public:
// given an id, return the associated Place phrase collection // given an id, return the associated Place phrase collection
const BotPhrase *GetPlace(PlaceCriteria place) const; const BotPhrase *GetPlace(PlaceCriteria place) const;
const BotPhraseList *GetPlaceList(void) const { return &m_placeList; } const BotPhraseList *GetPlaceList() const { return &m_placeList; }
// return time last statement of given type was emitted by a teammate for the given place // return time last statement of given type was emitted by a teammate for the given place
float GetPlaceStatementInterval(Place place) const; float GetPlaceStatementInterval(Place place) const;
@ -375,8 +366,7 @@ private:
mutable PlaceTimeInfo m_placeStatementHistory[ MAX_PLACES_PER_MAP ]; mutable PlaceTimeInfo m_placeStatementHistory[ MAX_PLACES_PER_MAP ];
mutable int m_placeCount; mutable int m_placeCount;
};
};/* size: 532, cachelines: 9, members: 4 */
/* <2fea95> ../cstrike/dlls/bot/cs_bot_chatter.h:298 */ /* <2fea95> ../cstrike/dlls/bot/cs_bot_chatter.h:298 */
inline int BotPhraseManager::FindPlaceIndex(Place where) const inline int BotPhraseManager::FindPlaceIndex(Place where) const
@ -430,33 +420,33 @@ class BotStatement
{ {
public: public:
BotStatement(BotChatterInterface *chatter, BotStatementType type, float expireDuration); BotStatement(BotChatterInterface *chatter, BotStatementType type, float expireDuration);
~BotStatement(void); ~BotStatement();
public: public:
BotChatterInterface *GetChatter(void) const { return m_chatter; } BotChatterInterface *GetChatter() const { return m_chatter; }
CCSBot *GetOwner(void) const; CCSBot *GetOwner() const;
BotStatementType GetType(void) const { return m_type; } // return the type of statement this is BotStatementType GetType() const { return m_type; } // return the type of statement this is
bool IsImportant(void) const; // return true if this statement is "important" and not personality chatter bool IsImportant() const; // return true if this statement is "important" and not personality chatter
bool HasSubject(void) const { return (m_subject != UNDEFINED_SUBJECT); } bool HasSubject() const { return (m_subject != UNDEFINED_SUBJECT); }
void SetSubject(int playerID) { m_subject = playerID; } // who this statement is about void SetSubject(int playerID) { m_subject = playerID; } // who this statement is about
int GetSubject(void) const { return m_subject; } // who this statement is about int GetSubject() const { return m_subject; } // who this statement is about
bool HasPlace(void) const { return (GetPlace()) ? true : false; } bool HasPlace() const { return (GetPlace()) ? true : false; }
Place GetPlace(void) const; // if this statement refers to a specific place, return that place Place GetPlace() const; // if this statement refers to a specific place, return that place
void SetPlace(Place where) { m_place = where; } // explicitly set place void SetPlace(Place where) { m_place = where; } // explicitly set place
bool HasCount(void) const; // return true if this statement has an associated count bool HasCount() const; // return true if this statement has an associated count
bool IsRedundant(const BotStatement *say) const; // return true if this statement is the same as the given one bool IsRedundant(const BotStatement *say) const; // return true if this statement is the same as the given one
bool IsObsolete(void) const; // return true if this statement is no longer appropriate to say bool IsObsolete() const; // return true if this statement is no longer appropriate to say
void Convert(const BotStatement *say); // possibly change what were going to say base on what teammate is saying void Convert(const BotStatement *say); // possibly change what were going to say base on what teammate is saying
void AppendPhrase(const BotPhrase *phrase); void AppendPhrase(const BotPhrase *phrase);
void SetStartTime(float timestamp) { m_startTime = timestamp; } // define the earliest time this statement can be spoken void SetStartTime(float timestamp) { m_startTime = timestamp; } // define the earliest time this statement can be spoken
float GetStartTime(void) const { return m_startTime; } float GetStartTime() const { return m_startTime; }
enum ConditionType enum ConditionType
{ {
@ -467,7 +457,7 @@ public:
}; };
void AddCondition(ConditionType condition); // conditions must be true for the statement to be spoken void AddCondition(ConditionType condition); // conditions must be true for the statement to be spoken
bool IsValid(void) const; // verify all attached conditions bool IsValid() const; // verify all attached conditions
enum ContextType enum ContextType
{ {
@ -477,13 +467,13 @@ public:
LONG_DELAY, LONG_DELAY,
ACCUMULATE_ENEMIES_DELAY, ACCUMULATE_ENEMIES_DELAY,
}; };
void AppendPhrase(ContextType contextPhrase); // special phrases that depend on the context void AppendPhrase(ContextType contextPhrase); // special phrases that depend on the context
bool Update(void); // emit statement over time, return false if statement is done bool Update(); // emit statement over time, return false if statement is done
bool IsSpeaking(void) const { return m_isSpeaking; } // return true if this statement is currently being spoken bool IsSpeaking() const { return m_isSpeaking; } // return true if this statement is currently being spoken
float GetTimestamp(void) const { return m_timestamp; } // get time statement was created (but not necessarily started talking) float GetTimestamp() const { return m_timestamp; } // get time statement was created (but not necessarily started talking)
void AttachMeme(BotMeme *meme); // attach a meme to this statement, to be transmitted to other friendly bots when spoken void AttachMeme(BotMeme *meme); // attach a meme to this statement, to be transmitted to other friendly bots when spoken
public: public:
friend class BotChatterInterface; friend class BotChatterInterface;
@ -524,23 +514,22 @@ public:
int m_index; // m_index refers to the phrase currently being spoken, or -1 if we havent started yet int m_index; // m_index refers to the phrase currently being spoken, or -1 if we havent started yet
int m_count; int m_count;
};
};/* size: 112, cachelines: 2, members: 18 */
// This class defines the interface to the bot radio chatter system // This class defines the interface to the bot radio chatter system
class BotChatterInterface class BotChatterInterface
{ {
public: public:
BotChatterInterface(void) {}; BotChatterInterface() {};
BotChatterInterface(CCSBot *me); BotChatterInterface(CCSBot *me);
~BotChatterInterface(); ~BotChatterInterface();
void Reset(void); // reset to initial state void Reset(); // reset to initial state
void Update(void); // process ongoing chatter void Update(); // process ongoing chatter
void OnEvent(GameEventType event, CBaseEntity *entity, CBaseEntity *other); // invoked when event occurs in the game (some events have NULL entities) void OnEvent(GameEventType event, CBaseEntity *entity, CBaseEntity *other); // invoked when event occurs in the game (some events have NULL entities)
void OnDeath(void); // invoked when we die void OnDeath(); // invoked when we die
enum VerbosityType enum VerbosityType
{ {
@ -549,44 +538,44 @@ public:
RADIO, // use the standard radio instead RADIO, // use the standard radio instead
OFF // no chatter at all OFF // no chatter at all
}; };
VerbosityType GetVerbosity(void) const; // return our current level of verbosity VerbosityType GetVerbosity() const; // return our current level of verbosity
CCSBot *GetOwner(void) const { return m_me; } CCSBot *GetOwner() const { return m_me; }
bool IsTalking(void) const; // return true if we are currently talking bool IsTalking() const; // return true if we are currently talking
float GetRadioSilenceDuration(void); // return time since any teammate said anything float GetRadioSilenceDuration(); // return time since any teammate said anything
void ResetRadioSilenceDuration(void); void ResetRadioSilenceDuration();
enum { MUST_ADD = 1 }; enum { MUST_ADD = 1 };
void AddStatement(BotStatement *statement, bool mustAdd = false); // register a statement for speaking void AddStatement(BotStatement *statement, bool mustAdd = false); // register a statement for speaking
void RemoveStatement(BotStatement *statement); // remove a statement void RemoveStatement(BotStatement *statement); // remove a statement
BotStatement *GetActiveStatement(void); // returns the statement that is being spoken, or is next to be spoken if no-one is speaking now BotStatement *GetActiveStatement(); // returns the statement that is being spoken, or is next to be spoken if no-one is speaking now
BotStatement *GetStatement(void) const; // returns our current statement, or NULL if we aren't speaking BotStatement *GetStatement() const; // returns our current statement, or NULL if we aren't speaking
int GetPitch(void) const { return m_pitch; } int GetPitch() const { return m_pitch; }
// things the bots can say // things the bots can say
void Say(const char *phraseName, float lifetime = 3.0f, float delay = 0.0f); void Say(const char *phraseName, float lifetime = 3.0f, float delay = 0.0f);
void AnnouncePlan(const char *phraseName, Place place); void AnnouncePlan(const char *phraseName, Place place);
void Affirmative(void); void Affirmative();
void Negative(void); void Negative();
void EnemySpotted(void); // report enemy sightings void EnemySpotted(); // report enemy sightings
void KilledMyEnemy(int victimID); void KilledMyEnemy(int victimID);
void EnemiesRemaining(void); void EnemiesRemaining();
NOXREF void Clear(Place place); NOXREF void Clear(Place place);
void ReportIn(void); // ask for current situation void ReportIn(); // ask for current situation
void ReportingIn(void); // report current situation void ReportingIn(); // report current situation
bool NeedBackup(void); bool NeedBackup();
void PinnedDown(void); void PinnedDown();
void Scared(void); void Scared();
void HeardNoise(const Vector *pos); void HeardNoise(const Vector *pos);
void TheyPickedUpTheBomb(void); void TheyPickedUpTheBomb();
void GoingToPlantTheBomb(Place place); void GoingToPlantTheBomb(Place place);
void BombsiteClear(int zoneIndex); void BombsiteClear(int zoneIndex);
void FoundPlantedBomb(int zoneIndex); void FoundPlantedBomb(int zoneIndex);
@ -594,33 +583,33 @@ public:
void SpottedBomber(CBasePlayer *bomber); void SpottedBomber(CBasePlayer *bomber);
void SpottedLooseBomb(CBaseEntity *bomb); void SpottedLooseBomb(CBaseEntity *bomb);
NOXREF void GuardingLooseBomb(CBaseEntity *bomb); NOXREF void GuardingLooseBomb(CBaseEntity *bomb);
void RequestBombLocation(void); void RequestBombLocation();
#define IS_PLAN true #define IS_PLAN true
void GuardingHostages(Place place, bool isPlan = false); void GuardingHostages(Place place, bool isPlan = false);
void GuardingHostageEscapeZone(bool isPlan = false); void GuardingHostageEscapeZone(bool isPlan = false);
void HostagesBeingTaken(void); void HostagesBeingTaken();
void HostagesTaken(void); void HostagesTaken();
void TalkingToHostages(void); void TalkingToHostages();
void EscortingHostages(void); void EscortingHostages();
NOXREF void HostageDown(void); NOXREF void HostageDown();
void CelebrateWin(void); void CelebrateWin();
void Encourage(const char *phraseName, float repeatInterval = 10.0f, float lifetime = 3.0f); // "encourage" the player to do the scenario void Encourage(const char *phraseName, float repeatInterval = 10.0f, float lifetime = 3.0f); // "encourage" the player to do the scenario
void KilledFriend(void); void KilledFriend();
void FriendlyFire(void); void FriendlyFire();
bool SeesAtLeastOneEnemy(void) const { return m_seeAtLeastOneEnemy; } bool SeesAtLeastOneEnemy() const { return m_seeAtLeastOneEnemy; }
#ifndef HOOK_GAMEDLL #ifndef HOOK_GAMEDLL
private: private:
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
BotStatement *m_statementList; // list of all active/pending messages for this bot BotStatement *m_statementList; // list of all active/pending messages for this bot
void ReportEnemies(void); // track nearby enemy count and generate enemy activity statements void ReportEnemies(); // track nearby enemy count and generate enemy activity statements
bool ShouldSpeak(void) const; // return true if we speaking makes sense now bool ShouldSpeak() const; // return true if we speaking makes sense now
CCSBot *m_me; // the bot this chatter is for CCSBot *m_me; // the bot this chatter is for
@ -641,11 +630,10 @@ private:
CountdownTimer m_heardNoiseTimer; CountdownTimer m_heardNoiseTimer;
CountdownTimer m_escortingHostageTimer; CountdownTimer m_escortingHostageTimer;
static CountdownTimer IMPL(m_encourageTimer); // timer to know when we can "encourage" the human player again - shared by all bots static CountdownTimer IMPL(m_encourageTimer); // timer to know when we can "encourage" the human player again - shared by all bots
};
};/* size: 64, cachelines: 1, members: 16 */
/* <2fec2d> ../cstrike/dlls/bot/cs_bot_chatter.h:572 */ /* <2fec2d> ../cstrike/dlls/bot/cs_bot_chatter.h:572 */
inline BotChatterInterface::VerbosityType BotChatterInterface::GetVerbosity(void) const inline BotChatterInterface::VerbosityType BotChatterInterface::GetVerbosity() const
{ {
const char *string = cv_bot_chatter.string; const char *string = cv_bot_chatter.string;
@ -665,7 +653,7 @@ inline BotChatterInterface::VerbosityType BotChatterInterface::GetVerbosity(void
} }
/* <2fec4a> ../cstrike/dlls/bot/cs_bot_chatter.h:590 */ /* <2fec4a> ../cstrike/dlls/bot/cs_bot_chatter.h:590 */
inline bool BotChatterInterface::IsTalking(void) const inline bool BotChatterInterface::IsTalking() const
{ {
if (m_statementList != NULL) if (m_statementList != NULL)
{ {
@ -676,18 +664,11 @@ inline bool BotChatterInterface::IsTalking(void) const
} }
/* <3f2bad> ../cstrike/dlls/bot/cs_bot_chatter.h:596 */ /* <3f2bad> ../cstrike/dlls/bot/cs_bot_chatter.h:596 */
inline BotStatement *BotChatterInterface::GetStatement(void) const inline BotStatement *BotChatterInterface::GetStatement() const
{ {
return m_statementList; return m_statementList;
} }
#ifdef HOOK_GAMEDLL
#define TheBotPhrases (*pTheBotPhrases)
#define g_pSelectedZombieSpawn (*pg_pSelectedZombieSpawn)
#endif // HOOK_GAMEDLL
extern BotPhraseManager *TheBotPhrases; extern BotPhraseManager *TheBotPhrases;
extern CBaseEntity *g_pSelectedZombieSpawn; extern CBaseEntity *g_pSelectedZombieSpawn;
@ -706,17 +687,4 @@ inline void BotChatterInterface::Say(const char *phraseName, float lifetime, flo
const Vector *GetRandomSpotAtPlace(Place place); const Vector *GetRandomSpotAtPlace(Place place);
#ifdef HOOK_GAMEDLL
typedef void (BotStatement::*APPEND_PHRASE_CONTEXT)(BotStatement::ContextType);
typedef void (BotStatement::*APPEND_PHRASE_BOTPHRASE)(const BotPhrase *);
typedef const BotPhrase *(BotPhraseManager::*GET_PLACE_NAME)(const char *name) const;
typedef const BotPhrase *(BotPhraseManager::*GET_PLACE_PLACE)(PlaceCriteria place) const;
// refs
extern void (*pBotPhrase__Randomize)(void);
#endif // HOOK_GAMEDLL
#endif // CS_BOT_CHATTER_H #endif // CS_BOT_CHATTER_H

View File

@ -3,56 +3,56 @@
/* <31d087> ../cstrike/dlls/bot/cs_bot_event.cpp:22 */ /* <31d087> ../cstrike/dlls/bot/cs_bot_event.cpp:22 */
void CCSBot::__MAKE_VHOOK(OnEvent)(GameEventType event, CBaseEntity *entity, CBaseEntity *other) void CCSBot::__MAKE_VHOOK(OnEvent)(GameEventType event, CBaseEntity *entity, CBaseEntity *other)
{ {
GetGameState()->OnEvent(event, entity, other); GetGameState()->OnEvent(event, entity, other);
GetChatter()->OnEvent(event, entity, other); GetChatter()->OnEvent(event, entity, other);
// Morale adjustments happen even for dead players // Morale adjustments happen even for dead players
switch (event) switch (event)
{ {
case EVENT_TERRORISTS_WIN: case EVENT_TERRORISTS_WIN:
if (m_iTeam == CT) if (m_iTeam == CT)
{ {
DecreaseMorale(); DecreaseMorale();
} }
else else
{ {
IncreaseMorale(); IncreaseMorale();
} }
break; break;
case EVENT_CTS_WIN: case EVENT_CTS_WIN:
if (m_iTeam == CT) if (m_iTeam == CT)
{ {
IncreaseMorale(); IncreaseMorale();
} }
else else
{ {
DecreaseMorale(); DecreaseMorale();
} }
break; break;
} }
if (!IsAlive()) if (!IsAlive())
return; return;
CBasePlayer *player = static_cast<CBasePlayer *>(entity); CBasePlayer *player = static_cast<CBasePlayer *>(entity);
// If we just saw a nearby friend die, and we haven't yet acquired an enemy // If we just saw a nearby friend die, and we haven't yet acquired an enemy
// automatically acquire our dead friend's killer // automatically acquire our dead friend's killer
if (!IsAttacking() && (GetDisposition() == ENGAGE_AND_INVESTIGATE || GetDisposition() == OPPORTUNITY_FIRE)) if (!IsAttacking() && (GetDisposition() == ENGAGE_AND_INVESTIGATE || GetDisposition() == OPPORTUNITY_FIRE))
{ {
if (event == EVENT_PLAYER_DIED) if (event == EVENT_PLAYER_DIED)
{ {
if (player->m_iTeam == m_iTeam) if (player->m_iTeam == m_iTeam)
{ {
CBasePlayer *killer = static_cast<CBasePlayer *>(other); CBasePlayer *killer = static_cast<CBasePlayer *>(other);
// check that attacker is an enemy (for friendly fire, etc) // check that attacker is an enemy (for friendly fire, etc)
if (killer && killer->IsPlayer()) if (killer && killer->IsPlayer())
{ {
// check if we saw our friend die - dont check FOV - assume we're aware of our surroundings in combat // check if we saw our friend die - dont check FOV - assume we're aware of our surroundings in combat
// snipers stay put // snipers stay put
if (!IsSniper() && IsVisible(&player->pev->origin)) if (!IsSniper() && IsVisible(&player->pev->origin))
{ {
// people are dying - we should hurry // people are dying - we should hurry
Hurry(RANDOM_FLOAT(10.0f, 15.0f)); Hurry(RANDOM_FLOAT(10.0f, 15.0f));
@ -63,11 +63,11 @@ void CCSBot::__MAKE_VHOOK(OnEvent)(GameEventType event, CBaseEntity *entity, CBa
PrintIfWatched("Attacking our friend's killer!\n"); PrintIfWatched("Attacking our friend's killer!\n");
Attack(killer); Attack(killer);
return; return;
} }
} }
} }
} }
} }
} }
switch (event) switch (event)
@ -382,12 +382,3 @@ void CCSBot::__MAKE_VHOOK(OnEvent)(GameEventType event, CBaseEntity *entity, CBa
m_noiseTimestamp = gpGlobals->time; m_noiseTimestamp = gpGlobals->time;
} }
} }
#ifdef HOOK_GAMEDLL
void CCSBot::OnEvent(GameEventType event, CBaseEntity *entity, CBaseEntity *other)
{
OnEvent_(event, entity, other);
}
#endif // HOOK_GAMEDLL

View File

@ -35,42 +35,10 @@ cvar_t cv_bot_defer_to_human = { "bot_defer_to_human", "0", FCVAR_SERVER, 0.0f,
cvar_t cv_bot_chatter = { "bot_chatter", "normal", FCVAR_SERVER, 0.0f, NULL }; cvar_t cv_bot_chatter = { "bot_chatter", "normal", FCVAR_SERVER, 0.0f, NULL };
cvar_t cv_bot_profile_db = { "bot_profile_db", "BotProfile.db", FCVAR_SERVER, 0.0f, NULL }; cvar_t cv_bot_profile_db = { "bot_profile_db", "BotProfile.db", FCVAR_SERVER, 0.0f, NULL };
#else // HOOK_GAMEDLL
cvar_t cv_bot_traceview;
cvar_t cv_bot_stop;
cvar_t cv_bot_show_nav;
cvar_t cv_bot_show_danger;
cvar_t cv_bot_nav_edit;
cvar_t cv_bot_nav_zdraw;
cvar_t cv_bot_walk;
cvar_t cv_bot_difficulty;
cvar_t cv_bot_debug;
cvar_t cv_bot_quicksave;
cvar_t cv_bot_quota;
cvar_t cv_bot_quota_match;
cvar_t cv_bot_prefix;
cvar_t cv_bot_allow_rogues;
cvar_t cv_bot_allow_pistols;
cvar_t cv_bot_allow_shotguns;
cvar_t cv_bot_allow_sub_machine_guns;
cvar_t cv_bot_allow_rifles;
cvar_t cv_bot_allow_machine_guns;
cvar_t cv_bot_allow_grenades;
cvar_t cv_bot_allow_snipers;
cvar_t cv_bot_allow_shield;
cvar_t cv_bot_join_team;
cvar_t cv_bot_join_after_player;
cvar_t cv_bot_auto_vacate;
cvar_t cv_bot_zombie;
cvar_t cv_bot_defer_to_human;
cvar_t cv_bot_chatter;
cvar_t cv_bot_profile_db;
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
/* <333bca> ../cstrike/dlls/bot/cs_bot_init.cpp:57 */ /* <333bca> ../cstrike/dlls/bot/cs_bot_init.cpp:57 */
void InstallBotControl(void) void InstallBotControl()
{ {
if (TheBots != NULL) if (TheBots != NULL)
{ {
@ -83,7 +51,7 @@ void InstallBotControl(void)
// Engine callback for custom server commands // Engine callback for custom server commands
/* <333cb3> ../cstrike/dlls/bot/cs_bot_init.cpp:68 */ /* <333cb3> ../cstrike/dlls/bot/cs_bot_init.cpp:68 */
void Bot_ServerCommand(void) void Bot_ServerCommand()
{ {
if (TheBots != NULL) if (TheBots != NULL)
{ {
@ -93,46 +61,46 @@ void Bot_ServerCommand(void)
} }
/* <333cec> ../cstrike/dlls/bot/cs_bot_init.cpp:81 */ /* <333cec> ../cstrike/dlls/bot/cs_bot_init.cpp:81 */
void Bot_RegisterCvars(void) void Bot_RegisterCvars()
{ {
if (UTIL_IsGame("czero")) if (!g_bIsCzeroGame)
{ return;
CVAR_REGISTER(&cv_bot_traceview);
CVAR_REGISTER(&cv_bot_stop); CVAR_REGISTER(&cv_bot_traceview);
CVAR_REGISTER(&cv_bot_show_nav); CVAR_REGISTER(&cv_bot_stop);
CVAR_REGISTER(&cv_bot_show_danger); CVAR_REGISTER(&cv_bot_show_nav);
CVAR_REGISTER(&cv_bot_nav_edit); CVAR_REGISTER(&cv_bot_show_danger);
CVAR_REGISTER(&cv_bot_nav_zdraw); CVAR_REGISTER(&cv_bot_nav_edit);
CVAR_REGISTER(&cv_bot_walk); CVAR_REGISTER(&cv_bot_nav_zdraw);
CVAR_REGISTER(&cv_bot_difficulty); CVAR_REGISTER(&cv_bot_walk);
CVAR_REGISTER(&cv_bot_debug); CVAR_REGISTER(&cv_bot_difficulty);
CVAR_REGISTER(&cv_bot_quicksave); CVAR_REGISTER(&cv_bot_debug);
CVAR_REGISTER(&cv_bot_quota); CVAR_REGISTER(&cv_bot_quicksave);
CVAR_REGISTER(&cv_bot_quota_match); CVAR_REGISTER(&cv_bot_quota);
CVAR_REGISTER(&cv_bot_prefix); CVAR_REGISTER(&cv_bot_quota_match);
CVAR_REGISTER(&cv_bot_allow_rogues); CVAR_REGISTER(&cv_bot_prefix);
CVAR_REGISTER(&cv_bot_allow_pistols); CVAR_REGISTER(&cv_bot_allow_rogues);
CVAR_REGISTER(&cv_bot_allow_shotguns); CVAR_REGISTER(&cv_bot_allow_pistols);
CVAR_REGISTER(&cv_bot_allow_sub_machine_guns); CVAR_REGISTER(&cv_bot_allow_shotguns);
CVAR_REGISTER(&cv_bot_allow_rifles); CVAR_REGISTER(&cv_bot_allow_sub_machine_guns);
CVAR_REGISTER(&cv_bot_allow_machine_guns); CVAR_REGISTER(&cv_bot_allow_rifles);
CVAR_REGISTER(&cv_bot_allow_grenades); CVAR_REGISTER(&cv_bot_allow_machine_guns);
CVAR_REGISTER(&cv_bot_allow_snipers); CVAR_REGISTER(&cv_bot_allow_grenades);
CVAR_REGISTER(&cv_bot_allow_shield); CVAR_REGISTER(&cv_bot_allow_snipers);
CVAR_REGISTER(&cv_bot_join_team); CVAR_REGISTER(&cv_bot_allow_shield);
CVAR_REGISTER(&cv_bot_join_after_player); CVAR_REGISTER(&cv_bot_join_team);
CVAR_REGISTER(&cv_bot_auto_vacate); CVAR_REGISTER(&cv_bot_join_after_player);
CVAR_REGISTER(&cv_bot_zombie); CVAR_REGISTER(&cv_bot_auto_vacate);
CVAR_REGISTER(&cv_bot_defer_to_human); CVAR_REGISTER(&cv_bot_zombie);
CVAR_REGISTER(&cv_bot_chatter); CVAR_REGISTER(&cv_bot_defer_to_human);
CVAR_REGISTER(&cv_bot_profile_db); CVAR_REGISTER(&cv_bot_chatter);
} CVAR_REGISTER(&cv_bot_profile_db);
} }
// Constructor // Constructor
/* <333d1e> ../cstrike/dlls/bot/cs_bot_init.cpp:129 */ /* <333d1e> ../cstrike/dlls/bot/cs_bot_init.cpp:129 */
CCSBot::CCSBot(void) : m_chatter(this), m_gameState(this) CCSBot::CCSBot() : m_chatter(this), m_gameState(this)
{ {
; ;
} }
@ -148,7 +116,7 @@ bool CCSBot::__MAKE_VHOOK(Initialize)(const BotProfile *profile)
// CS bot initialization // CS bot initialization
m_diedLastRound = false; m_diedLastRound = false;
m_morale = POSITIVE; // starting a new round makes everyone a little happy m_morale = POSITIVE; // starting a new round makes everyone a little happy
m_combatRange = RANDOM_FLOAT(325, 425); m_combatRange = RANDOM_FLOAT(325, 425);
m_navNodeList = NULL; m_navNodeList = NULL;
@ -157,7 +125,7 @@ bool CCSBot::__MAKE_VHOOK(Initialize)(const BotProfile *profile)
// set initial safe time guess for this map // set initial safe time guess for this map
m_safeTime = 15.0f + 5.0f * GetProfile()->GetAggression(); m_safeTime = 15.0f + 5.0f * GetProfile()->GetAggression();
m_name[0] = '\000'; m_name[0] = '\0';
ResetValues(); ResetValues();
StartNormalProcess(); StartNormalProcess();
@ -168,7 +136,7 @@ bool CCSBot::__MAKE_VHOOK(Initialize)(const BotProfile *profile)
// Reset internal data to initial state // Reset internal data to initial state
/* <3341dc> ../cstrike/dlls/bot/cs_bot_init.cpp:167 */ /* <3341dc> ../cstrike/dlls/bot/cs_bot_init.cpp:167 */
void CCSBot::ResetValues(void) void CCSBot::ResetValues()
{ {
m_chatter.Reset(); m_chatter.Reset();
m_gameState.Reset(); m_gameState.Reset();
@ -325,7 +293,7 @@ void CCSBot::ResetValues(void)
// NOTE: For some reason, this can be called twice when a bot is added. // NOTE: For some reason, this can be called twice when a bot is added.
/* <3342e4> ../cstrike/dlls/bot/cs_bot_init.cpp:336 */ /* <3342e4> ../cstrike/dlls/bot/cs_bot_init.cpp:336 */
void CCSBot::__MAKE_VHOOK(SpawnBot)(void) void CCSBot::__MAKE_VHOOK(SpawnBot)()
{ {
CCSBotManager *ctrl = TheCSBots(); CCSBotManager *ctrl = TheCSBots();
@ -345,7 +313,7 @@ void CCSBot::__MAKE_VHOOK(SpawnBot)(void)
} }
/* <3338f7> ../cstrike/dlls/bot/cs_bot_init.cpp:366 */ /* <3338f7> ../cstrike/dlls/bot/cs_bot_init.cpp:366 */
void CCSBot::__MAKE_VHOOK(RoundRespawn)(void) void CCSBot::__MAKE_VHOOK(RoundRespawn)()
{ {
// do the normal player spawn process // do the normal player spawn process
CBasePlayer::RoundRespawn(); CBasePlayer::RoundRespawn();
@ -353,7 +321,7 @@ void CCSBot::__MAKE_VHOOK(RoundRespawn)(void)
} }
/* <334332> ../cstrike/dlls/bot/cs_bot_init.cpp:378 */ /* <334332> ../cstrike/dlls/bot/cs_bot_init.cpp:378 */
void CCSBot::Disconnect(void) void CCSBot::Disconnect()
{ {
EndVoiceFeedback(); EndVoiceFeedback();
@ -362,22 +330,3 @@ void CCSBot::Disconnect(void)
hideProgressMeter(); hideProgressMeter();
} }
} }
#ifdef HOOK_GAMEDLL
bool CCSBot::Initialize(const BotProfile *profile)
{
return Initialize_(profile);
}
void CCSBot::SpawnBot(void)
{
SpawnBot_();
}
void CCSBot::RoundRespawn(void)
{
RoundRespawn_();
}
#endif // HOOK_GAMEDLL

View File

@ -98,7 +98,7 @@ CNavNode *CCSBot::AddNode(const Vector *destPos, const Vector *normal, NavDirTyp
{ {
floor = *destPos + Vector(x, y, 5.0f); floor = *destPos + Vector(x, y, 5.0f);
ceiling = *destPos + Vector(x, y, 72.0f - epsilon); ceiling = *destPos + Vector(x, y, 72.0f - epsilon);
UTIL_TraceLine(floor, ceiling, ignore_monsters, dont_ignore_glass, ENT(pev), &result); UTIL_TraceLine(floor, ceiling, ignore_monsters, dont_ignore_glass, ENT(pev), &result);
if (result.flFraction != 1.0f) if (result.flFraction != 1.0f)
@ -139,7 +139,7 @@ void startProgressMeter(const char *title)
} }
/* <3435a8> ../cstrike/dlls/bot/cs_bot_learn.cpp:167 */ /* <3435a8> ../cstrike/dlls/bot/cs_bot_learn.cpp:167 */
void hideProgressMeter(void) void hideProgressMeter()
{ {
MESSAGE_BEGIN(MSG_ALL, gmsgBotProgress); MESSAGE_BEGIN(MSG_ALL, gmsgBotProgress);
WRITE_BYTE(FLAG_PROGRESS_HIDE); WRITE_BYTE(FLAG_PROGRESS_HIDE);
@ -147,7 +147,7 @@ void hideProgressMeter(void)
} }
/* <343b63> ../cstrike/dlls/bot/cs_bot_learn.cpp:182 */ /* <343b63> ../cstrike/dlls/bot/cs_bot_learn.cpp:182 */
void CCSBot::StartLearnProcess(void) void CCSBot::StartLearnProcess()
{ {
startProgressMeter("#CZero_LearningMap"); startProgressMeter("#CZero_LearningMap");
drawProgressMeter(0, "#CZero_LearningMap"); drawProgressMeter(0, "#CZero_LearningMap");
@ -155,7 +155,7 @@ void CCSBot::StartLearnProcess(void)
Vector normal; Vector normal;
Vector pos = pev->origin; Vector pos = pev->origin;
SnapToGrid(&pos.x); SnapToGrid(&pos.x);
SnapToGrid(&pos.y); SnapToGrid(&pos.y);
@ -178,185 +178,185 @@ void CCSBot::StartLearnProcess(void)
// Returns true if sampling needs to continue, or false if done. // Returns true if sampling needs to continue, or false if done.
/* <343d37> ../cstrike/dlls/bot/cs_bot_learn.cpp:217 */ /* <343d37> ../cstrike/dlls/bot/cs_bot_learn.cpp:217 */
bool CCSBot::LearnStep(void) bool CCSBot::LearnStep()
{ {
// take a step // take a step
while (true) while (true)
{ {
if (m_currentNode == NULL) if (m_currentNode == NULL)
{ {
// search is exhausted - continue search from ends of ladders // search is exhausted - continue search from ends of ladders
NavLadderList::iterator iter; NavLadderList::iterator iter;
for (iter = TheNavLadderList.begin(); iter != TheNavLadderList.end(); ++iter) for (iter = TheNavLadderList.begin(); iter != TheNavLadderList.end(); ++iter)
{ {
CNavLadder *ladder = (*iter); CNavLadder *ladder = (*iter);
// check ladder bottom // check ladder bottom
if ((m_currentNode = LadderEndSearch(ladder->m_entity, &ladder->m_bottom, ladder->m_dir)) != 0) if ((m_currentNode = LadderEndSearch(ladder->m_entity, &ladder->m_bottom, ladder->m_dir)) != 0)
break; break;
// check ladder top // check ladder top
if ((m_currentNode = LadderEndSearch(ladder->m_entity, &ladder->m_top, ladder->m_dir)) != 0) if ((m_currentNode = LadderEndSearch(ladder->m_entity, &ladder->m_top, ladder->m_dir)) != 0)
break; break;
} }
if (m_currentNode == NULL) if (m_currentNode == NULL)
{ {
// all seeds exhausted, sampling complete // all seeds exhausted, sampling complete
GenerateNavigationAreaMesh(); GenerateNavigationAreaMesh();
return false; return false;
} }
} }
// Take a step from this node // Take a step from this node
for (int dir = NORTH; dir < NUM_DIRECTIONS; dir++) for (int dir = NORTH; dir < NUM_DIRECTIONS; dir++)
{ {
if (!m_currentNode->HasVisited((NavDirType)dir)) if (!m_currentNode->HasVisited((NavDirType)dir))
{ {
float feetOffset = pev->origin.z - GetFeetZ(); float feetOffset = pev->origin.z - GetFeetZ();
// start at current node position // start at current node position
Vector pos = *m_currentNode->GetPosition(); Vector pos = *m_currentNode->GetPosition();
// snap to grid // snap to grid
int cx = SnapToGrid(pos.x); int cx = SnapToGrid(pos.x);
int cy = SnapToGrid(pos.y); int cy = SnapToGrid(pos.y);
// attempt to move to adjacent node // attempt to move to adjacent node
switch (dir) switch (dir)
{ {
case NORTH: cy -= GenerationStepSize; break; case NORTH: cy -= GenerationStepSize; break;
case SOUTH: cy += GenerationStepSize; break; case SOUTH: cy += GenerationStepSize; break;
case EAST: cx += GenerationStepSize; break; case EAST: cx += GenerationStepSize; break;
case WEST: cx -= GenerationStepSize; break; case WEST: cx -= GenerationStepSize; break;
} }
pos.x = cx; pos.x = cx;
pos.y = cy; pos.y = cy;
m_generationDir = (NavDirType)dir; m_generationDir = (NavDirType)dir;
// mark direction as visited // mark direction as visited
m_currentNode->MarkAsVisited(m_generationDir); m_currentNode->MarkAsVisited(m_generationDir);
// test if we can move to new position // test if we can move to new position
TraceResult result; TraceResult result;
Vector from, to; Vector from, to;
// modify position to account for change in ground level during step // modify position to account for change in ground level during step
to.x = pos.x; to.x = pos.x;
to.y = pos.y; to.y = pos.y;
Vector toNormal; Vector toNormal;
if (GetGroundHeight(&pos, &to.z, &toNormal) == false) if (GetGroundHeight(&pos, &to.z, &toNormal) == false)
{ {
return true; return true;
} }
from = *m_currentNode->GetPosition(); from = *m_currentNode->GetPosition();
Vector fromOrigin = from + Vector(0, 0, feetOffset); Vector fromOrigin = from + Vector(0, 0, feetOffset);
Vector toOrigin = to + Vector(0, 0, feetOffset); Vector toOrigin = to + Vector(0, 0, feetOffset);
UTIL_SetOrigin(pev, toOrigin); UTIL_SetOrigin(pev, toOrigin);
UTIL_TraceLine(fromOrigin, toOrigin, ignore_monsters, dont_ignore_glass, ENT(pev), &result); UTIL_TraceLine(fromOrigin, toOrigin, ignore_monsters, dont_ignore_glass, ENT(pev), &result);
bool walkable; bool walkable;
if (result.flFraction == 1.0f && !result.fStartSolid) if (result.flFraction == 1.0f && !result.fStartSolid)
{ {
// the trace didnt hit anything - clear // the trace didnt hit anything - clear
float toGround = to.z; float toGround = to.z;
float fromGround = from.z; float fromGround = from.z;
float epsilon = 0.1f; float epsilon = 0.1f;
// check if ledge is too high to reach or will cause us to fall to our death // check if ledge is too high to reach or will cause us to fall to our death
if (toGround - fromGround > JumpCrouchHeight + epsilon || fromGround - toGround > DeathDrop) if (toGround - fromGround > JumpCrouchHeight + epsilon || fromGround - toGround > DeathDrop)
{ {
walkable = false; walkable = false;
} }
else else
{ {
// check surface normals along this step to see if we would cross any impassable slopes // check surface normals along this step to see if we would cross any impassable slopes
Vector delta = to - from; Vector delta = to - from;
const float inc = 2.0f; const float inc = 2.0f;
float along = inc; float along = inc;
bool done = false; bool done = false;
float ground; float ground;
Vector normal; Vector normal;
walkable = true; walkable = true;
while (!done) while (!done)
{ {
Vector p; Vector p;
// need to guarantee that we test the exact edges // need to guarantee that we test the exact edges
if (along >= GenerationStepSize) if (along >= GenerationStepSize)
{ {
p = to; p = to;
done = true; done = true;
} }
else else
{ {
p = from + delta * (along / GenerationStepSize); p = from + delta * (along / GenerationStepSize);
} }
if (GetGroundHeight(&p, &ground, &normal) == false) if (GetGroundHeight(&p, &ground, &normal) == false)
{ {
walkable = false; walkable = false;
break; break;
} }
// check for maximum allowed slope // check for maximum allowed slope
if (normal.z < 0.7f) if (normal.z < 0.7f)
{ {
walkable = false; walkable = false;
break; break;
} }
along += inc; along += inc;
} }
} }
} }
// TraceLine hit something... // TraceLine hit something...
else else
{ {
if (IsEntityWalkable(VARS(result.pHit), WALK_THRU_EVERYTHING)) if (IsEntityWalkable(VARS(result.pHit), WALK_THRU_EVERYTHING))
{ {
walkable = true; walkable = true;
} }
else else
{ {
walkable = false; walkable = false;
} }
} }
#ifdef REGAMEDLL_FIXES #ifdef REGAMEDLL_FIXES
// if we're incrementally generating, don't overlap existing nav areas // if we're incrementally generating, don't overlap existing nav areas
CNavArea *overlap = TheNavAreaGrid.GetNavArea(&to, HumanHeight); CNavArea *overlap = TheNavAreaGrid.GetNavArea(&to, HumanHeight);
if (overlap != NULL) if (overlap != NULL)
{ {
walkable = false; walkable = false;
} }
#endif // REGAMEDLL_FIXES #endif // REGAMEDLL_FIXES
if (walkable) if (walkable)
{ {
// we can move here // we can move here
// create a new navigation node, and update current node pointer // create a new navigation node, and update current node pointer
CNavNode *newNode = AddNode(&to, &toNormal, m_generationDir, m_currentNode); CNavNode *newNode = AddNode(&to, &toNormal, m_generationDir, m_currentNode);
} }
return true; return true;
} }
} }
// all directions have been searched from this node - pop back to its parent and continue // all directions have been searched from this node - pop back to its parent and continue
m_currentNode = m_currentNode->GetParent(); m_currentNode = m_currentNode->GetParent();
} }
} }
/* <34489e> ../cstrike/dlls/bot/cs_bot_learn.cpp:392 */ /* <34489e> ../cstrike/dlls/bot/cs_bot_learn.cpp:392 */
void CCSBot::UpdateLearnProcess(void) void CCSBot::UpdateLearnProcess()
{ {
float startTime = g_engfuncs.pfnTime(); float startTime = g_engfuncs.pfnTime();
while (g_engfuncs.pfnTime() - startTime < updateTimesliceDuration) while (g_engfuncs.pfnTime() - startTime < updateTimesliceDuration)
@ -370,7 +370,7 @@ void CCSBot::UpdateLearnProcess(void)
} }
/* <344750> ../cstrike/dlls/bot/cs_bot_learn.cpp:409 */ /* <344750> ../cstrike/dlls/bot/cs_bot_learn.cpp:409 */
void CCSBot::StartAnalyzeAlphaProcess(void) void CCSBot::StartAnalyzeAlphaProcess()
{ {
m_processMode = PROCESS_ANALYZE_ALPHA; m_processMode = PROCESS_ANALYZE_ALPHA;
m_analyzeIter = TheNavAreaList.begin(); m_analyzeIter = TheNavAreaList.begin();
@ -386,7 +386,7 @@ void CCSBot::StartAnalyzeAlphaProcess(void)
} }
/* <34396c> ../cstrike/dlls/bot/cs_bot_learn.cpp:427 */ /* <34396c> ../cstrike/dlls/bot/cs_bot_learn.cpp:427 */
bool CCSBot::AnalyzeAlphaStep(void) bool CCSBot::AnalyzeAlphaStep()
{ {
++_currentIndex; ++_currentIndex;
if (m_analyzeIter == TheNavAreaList.end()) if (m_analyzeIter == TheNavAreaList.end())
@ -401,7 +401,7 @@ bool CCSBot::AnalyzeAlphaStep(void)
} }
/* <3448de> ../cstrike/dlls/bot/cs_bot_learn.cpp:443 */ /* <3448de> ../cstrike/dlls/bot/cs_bot_learn.cpp:443 */
void CCSBot::UpdateAnalyzeAlphaProcess(void) void CCSBot::UpdateAnalyzeAlphaProcess()
{ {
float startTime = g_engfuncs.pfnTime(); float startTime = g_engfuncs.pfnTime();
while (g_engfuncs.pfnTime() - startTime < updateTimesliceDuration) while (g_engfuncs.pfnTime() - startTime < updateTimesliceDuration)
@ -420,7 +420,7 @@ void CCSBot::UpdateAnalyzeAlphaProcess(void)
} }
/* <344aed> ../cstrike/dlls/bot/cs_bot_learn.cpp:467 */ /* <344aed> ../cstrike/dlls/bot/cs_bot_learn.cpp:467 */
void CCSBot::StartAnalyzeBetaProcess(void) void CCSBot::StartAnalyzeBetaProcess()
{ {
m_processMode = PROCESS_ANALYZE_BETA; m_processMode = PROCESS_ANALYZE_BETA;
m_analyzeIter = TheNavAreaList.begin(); m_analyzeIter = TheNavAreaList.begin();
@ -430,7 +430,7 @@ void CCSBot::StartAnalyzeBetaProcess(void)
} }
/* <3437c8> ../cstrike/dlls/bot/cs_bot_learn.cpp:479 */ /* <3437c8> ../cstrike/dlls/bot/cs_bot_learn.cpp:479 */
bool CCSBot::AnalyzeBetaStep(void) bool CCSBot::AnalyzeBetaStep()
{ {
++_currentIndex; ++_currentIndex;
if (m_analyzeIter == TheNavAreaList.end()) if (m_analyzeIter == TheNavAreaList.end())
@ -445,7 +445,7 @@ bool CCSBot::AnalyzeBetaStep(void)
} }
/* <344b8d> ../cstrike/dlls/bot/cs_bot_learn.cpp:495 */ /* <344b8d> ../cstrike/dlls/bot/cs_bot_learn.cpp:495 */
void CCSBot::UpdateAnalyzeBetaProcess(void) void CCSBot::UpdateAnalyzeBetaProcess()
{ {
float startTime = g_engfuncs.pfnTime(); float startTime = g_engfuncs.pfnTime();
while (g_engfuncs.pfnTime() - startTime < updateTimesliceDuration) while (g_engfuncs.pfnTime() - startTime < updateTimesliceDuration)
@ -463,13 +463,13 @@ void CCSBot::UpdateAnalyzeBetaProcess(void)
} }
/* <344d1f> ../cstrike/dlls/bot/cs_bot_learn.cpp:517 */ /* <344d1f> ../cstrike/dlls/bot/cs_bot_learn.cpp:517 */
void CCSBot::StartSaveProcess(void) void CCSBot::StartSaveProcess()
{ {
m_processMode = PROCESS_SAVE; m_processMode = PROCESS_SAVE;
} }
/* <344d41> ../cstrike/dlls/bot/cs_bot_learn.cpp:527 */ /* <344d41> ../cstrike/dlls/bot/cs_bot_learn.cpp:527 */
void CCSBot::UpdateSaveProcess(void) void CCSBot::UpdateSaveProcess()
{ {
char filename[256]; char filename[256];
char msg[256]; char msg[256];
@ -494,7 +494,7 @@ void CCSBot::UpdateSaveProcess(void)
} }
/* <344e24> ../cstrike/dlls/bot/cs_bot_learn.cpp:554 */ /* <344e24> ../cstrike/dlls/bot/cs_bot_learn.cpp:554 */
void CCSBot::StartNormalProcess(void) void CCSBot::StartNormalProcess()
{ {
m_processMode = PROCESS_NORMAL; m_processMode = PROCESS_NORMAL;
} }

View File

@ -110,7 +110,7 @@ bool CCSBot::CanHearNearbyEnemyGunfire(float range) const
// NOTE: Dont use IsVisible(), because smoke shouldnt cause us to not look toward noises // NOTE: Dont use IsVisible(), because smoke shouldnt cause us to not look toward noises
/* <354e7b> ../cstrike/dlls/bot/cs_bot_listen.cpp:141 */ /* <354e7b> ../cstrike/dlls/bot/cs_bot_listen.cpp:141 */
bool CCSBot::CanSeeNoisePosition(void) const bool CCSBot::CanSeeNoisePosition() const
{ {
TraceResult result; TraceResult result;
UTIL_TraceLine(GetEyePosition(), m_noisePosition + Vector(0, 0, HalfHumanHeight), ignore_monsters, ignore_glass, ENT(pev), &result); UTIL_TraceLine(GetEyePosition(), m_noisePosition + Vector(0, 0, HalfHumanHeight), ignore_monsters, ignore_glass, ENT(pev), &result);
@ -128,7 +128,7 @@ bool CCSBot::CanSeeNoisePosition(void) const
// Assumes m_noisePosition is valid. // Assumes m_noisePosition is valid.
/* <354f48> ../cstrike/dlls/bot/cs_bot_listen.cpp:160 */ /* <354f48> ../cstrike/dlls/bot/cs_bot_listen.cpp:160 */
bool CCSBot::UpdateLookAtNoise(void) bool CCSBot::UpdateLookAtNoise()
{ {
// make sure a noise exists // make sure a noise exists
if (!IsNoiseHeard() || gpGlobals->time - m_noiseTimestamp > 0.5f) if (!IsNoiseHeard() || gpGlobals->time - m_noiseTimestamp > 0.5f)
@ -162,7 +162,7 @@ bool CCSBot::UpdateLookAtNoise(void)
int nearIdx = -1; int nearIdx = -1;
float nearRangeSq = 9.9999998e10f; float nearRangeSq = 9.9999998e10f;
for (int i = 0; i < m_approachPointCount; ++i) for (int i = 0; i < m_approachPointCount; ++i)
{ {
float distanceSq = (m_approachPoint[i] - m_noisePosition).LengthSquared(); float distanceSq = (m_approachPoint[i] - m_noisePosition).LengthSquared();

View File

@ -13,16 +13,6 @@ bool CCSBotManager::m_isLearningMap = false;
bool CCSBotManager::m_isAnalysisRequested = false; bool CCSBotManager::m_isAnalysisRequested = false;
NavEditCmdType CCSBotManager::m_editCmd = EDIT_NONE; NavEditCmdType CCSBotManager::m_editCmd = EDIT_NONE;
#else // HOOK_GAMEDLL
CBotManager *TheBots;
float IMPL_CLASS(CCSBotManager, m_flNextCVarCheck);
bool IMPL_CLASS(CCSBotManager, m_isMapDataLoaded);
bool IMPL_CLASS(CCSBotManager, m_isLearningMap);
bool IMPL_CLASS(CCSBotManager, m_isAnalysisRequested);
NavEditCmdType IMPL_CLASS(CCSBotManager, m_editCmd);
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
// Determine whether bots can be used or not // Determine whether bots can be used or not
@ -40,7 +30,7 @@ inline bool AreBotsAllowed()
} }
/* <36b3b4> ../cstrike/dlls/bot/cs_bot_manager.cpp:45 */ /* <36b3b4> ../cstrike/dlls/bot/cs_bot_manager.cpp:45 */
CCSBotManager::CCSBotManager(void) CCSBotManager::CCSBotManager()
{ {
IMPL(m_flNextCVarCheck) = 0.0f; IMPL(m_flNextCVarCheck) = 0.0f;
@ -49,7 +39,7 @@ CCSBotManager::CCSBotManager(void)
m_isBombPlanted = false; m_isBombPlanted = false;
m_bombDefuser = NULL; m_bombDefuser = NULL;
IMPL(m_isLearningMap) = false; IMPL(m_isLearningMap) = false;
IMPL(m_isAnalysisRequested) = false; IMPL(m_isAnalysisRequested) = false;
IMPL(m_editCmd) = EDIT_NONE; IMPL(m_editCmd) = EDIT_NONE;
@ -114,7 +104,7 @@ CCSBotManager::CCSBotManager(void)
// Invoked when a new round begins // Invoked when a new round begins
/* <36b22a> ../cstrike/dlls/bot/cs_bot_manager.cpp:111 */ /* <36b22a> ../cstrike/dlls/bot/cs_bot_manager.cpp:111 */
void CCSBotManager::__MAKE_VHOOK(RestartRound)(void) void CCSBotManager::__MAKE_VHOOK(RestartRound)()
{ {
// extend // extend
CBotManager::RestartRound(); CBotManager::RestartRound();
@ -198,7 +188,7 @@ void UTIL_DrawBox(Extent *extent, int lifetime, int red, int green, int blue)
// Called each frame // Called each frame
/* <36b13d> ../cstrike/dlls/bot/cs_bot_manager.cpp:195 */ /* <36b13d> ../cstrike/dlls/bot/cs_bot_manager.cpp:195 */
void CCSBotManager::__MAKE_VHOOK(StartFrame)(void) void CCSBotManager::__MAKE_VHOOK(StartFrame)()
{ {
// EXTEND // EXTEND
CBotManager::StartFrame(); CBotManager::StartFrame();
@ -280,7 +270,7 @@ bool CCSBotManager::IsOnOffense(CBasePlayer *player) const
// Invoked when a map has just been loaded // Invoked when a map has just been loaded
/* <36a3b6> ../cstrike/dlls/bot/cs_bot_manager.cpp:331 */ /* <36a3b6> ../cstrike/dlls/bot/cs_bot_manager.cpp:331 */
void CCSBotManager::__MAKE_VHOOK(ServerActivate)(void) void CCSBotManager::__MAKE_VHOOK(ServerActivate)()
{ {
DestroyNavigationMap(); DestroyNavigationMap();
IMPL(m_isMapDataLoaded) = false; IMPL(m_isMapDataLoaded) = false;
@ -311,7 +301,7 @@ void CCSBotManager::__MAKE_VHOOK(AddServerCommand)(const char *cmd)
} }
/* <36b0e0> ../cstrike/dlls/bot/cs_bot_manager.cpp:375 */ /* <36b0e0> ../cstrike/dlls/bot/cs_bot_manager.cpp:375 */
void CCSBotManager::__MAKE_VHOOK(AddServerCommands)(void) void CCSBotManager::__MAKE_VHOOK(AddServerCommands)()
{ {
static bool fFirstTime = true; static bool fFirstTime = true;
@ -320,7 +310,7 @@ void CCSBotManager::__MAKE_VHOOK(AddServerCommands)(void)
fFirstTime = false; fFirstTime = false;
if (UTIL_IsGame("czero")) if (g_bIsCzeroGame)
{ {
AddServerCommand("bot_about"); AddServerCommand("bot_about");
AddServerCommand("bot_add"); AddServerCommand("bot_add");
@ -367,7 +357,7 @@ void CCSBotManager::__MAKE_VHOOK(AddServerCommands)(void)
} }
/* <36b2ac> ../cstrike/dlls/bot/cs_bot_manager.cpp:413 */ /* <36b2ac> ../cstrike/dlls/bot/cs_bot_manager.cpp:413 */
void CCSBotManager::__MAKE_VHOOK(ServerDeactivate)(void) void CCSBotManager::__MAKE_VHOOK(ServerDeactivate)()
{ {
m_bServerActive = false; m_bServerActive = false;
} }
@ -399,7 +389,7 @@ void CCSBotManager::__MAKE_VHOOK(ClientDisconnect)(CBasePlayer *pPlayer)
} }
/* <36b714> ../cstrike/dlls/bot/cs_bot_manager.cpp:464 */ /* <36b714> ../cstrike/dlls/bot/cs_bot_manager.cpp:464 */
void PrintAllEntities(void) void PrintAllEntities()
{ {
for (int i = 1; i < gpGlobals->maxEntities; ++i) for (int i = 1; i < gpGlobals->maxEntities; ++i)
{ {
@ -415,7 +405,7 @@ void PrintAllEntities(void)
/* <36ace2> ../cstrike/dlls/bot/cs_bot_manager.cpp:484 */ /* <36ace2> ../cstrike/dlls/bot/cs_bot_manager.cpp:484 */
void CCSBotManager::__MAKE_VHOOK(ServerCommand)(const char *pcmd) void CCSBotManager::__MAKE_VHOOK(ServerCommand)(const char *pcmd)
{ {
if (!m_bServerActive || !UTIL_IsGame("czero")) if (!m_bServerActive || !g_bIsCzeroGame)
return; return;
char buffer[400]; char buffer[400];
@ -897,7 +887,7 @@ bool CCSBotManager::BotAddCommand(BotProfileTeamType team, bool isFromConsole)
// Keep a minimum quota of bots in the game // Keep a minimum quota of bots in the game
/* <36d10f> ../cstrike/dlls/bot/cs_bot_manager.cpp:979 */ /* <36d10f> ../cstrike/dlls/bot/cs_bot_manager.cpp:979 */
void CCSBotManager::MaintainBotQuota(void) void CCSBotManager::MaintainBotQuota()
{ {
if (IMPL(m_isLearningMap)) if (IMPL(m_isLearningMap))
return; return;
@ -1009,7 +999,7 @@ void CCSBotManager::MaintainBotQuota(void)
} }
/* <36d1dd> ../cstrike/dlls/bot/cs_bot_manager.cpp:1086 */ /* <36d1dd> ../cstrike/dlls/bot/cs_bot_manager.cpp:1086 */
void CCSBotManager::MonitorBotCVars(void) void CCSBotManager::MonitorBotCVars()
{ {
if (cv_bot_nav_edit.value != 0.0f) if (cv_bot_nav_edit.value != 0.0f)
{ {
@ -1062,9 +1052,9 @@ private:
// Search the map entities to determine the game scenario and define important zones. // Search the map entities to determine the game scenario and define important zones.
/* <36b780> ../cstrike/dlls/bot/cs_bot_manager.cpp:1109 */ /* <36b780> ../cstrike/dlls/bot/cs_bot_manager.cpp:1109 */
void CCSBotManager::ValidateMapData(void) void CCSBotManager::ValidateMapData()
{ {
if (IMPL(m_isMapDataLoaded) || !UTIL_IsGame("czero")) if (IMPL(m_isMapDataLoaded) || !g_bIsCzeroGame)
return; return;
IMPL(m_isMapDataLoaded) = true; IMPL(m_isMapDataLoaded) = true;
@ -1206,13 +1196,13 @@ void CCSBotManager::ValidateMapData(void)
#ifndef HOOK_GAMEDLL #ifndef HOOK_GAMEDLL
bool CCSBotManager::AddBot(const BotProfile *profile, BotProfileTeamType team) bool CCSBotManager::AddBot(const BotProfile *profile, BotProfileTeamType team)
{ {
if (!UTIL_IsGame("czero")) if (!g_bIsCzeroGame)
return false; return false;
CHalfLifeMultiplay *mp = g_pGameRules; CHalfLifeMultiplay *mp = g_pGameRules;
int nTeamSlot = UNASSIGNED; int nTeamSlot = UNASSIGNED;
if (team == BOT_TEAM_ANY) if (team == BOT_TEAM_ANY)
{ {
// if team not specified, check cv_bot_join_team cvar for preference // if team not specified, check cv_bot_join_team cvar for preference
@ -1416,7 +1406,7 @@ void CCSBotManager::__MAKE_VHOOK(OnEvent)(GameEventType event, CBaseEntity *enti
// Get the time remaining before the planted bomb explodes // Get the time remaining before the planted bomb explodes
/* <36bdb3> ../cstrike/dlls/bot/cs_bot_manager.cpp:1541 */ /* <36bdb3> ../cstrike/dlls/bot/cs_bot_manager.cpp:1541 */
float CCSBotManager::GetBombTimeLeft(void) const float CCSBotManager::GetBombTimeLeft() const
{ {
return (g_pGameRules->m_iC4Timer - (gpGlobals->time - m_bombPlantTimestamp)); return (g_pGameRules->m_iC4Timer - (gpGlobals->time - m_bombPlantTimestamp));
} }
@ -1562,84 +1552,13 @@ void CCSBotManager::SetRadioMessageTimestamp(GameEventType event, int teamID)
// Reset all radio message timestamps // Reset all radio message timestamps
/* <36bf06> ../cstrike/dlls/bot/cs_bot_manager.cpp:1690 */ /* <36bf06> ../cstrike/dlls/bot/cs_bot_manager.cpp:1690 */
void CCSBotManager::ResetRadioMessageTimestamps(void) void CCSBotManager::ResetRadioMessageTimestamps()
{ {
for (int t = 0; t < ARRAYSIZE(m_radioMsgTimestamp[0]); t++) for (int t = 0; t < ARRAYSIZE(m_radioMsgTimestamp[0]); ++t)
{ {
for (int m = 0; m < ARRAYSIZE(m_radioMsgTimestamp); m++) for (int m = 0; m < ARRAYSIZE(m_radioMsgTimestamp); ++m)
{ {
m_radioMsgTimestamp[m][t] = 0.0f; m_radioMsgTimestamp[m][t] = 0.0f;
} }
} }
} }
#ifdef HOOK_GAMEDLL
void (*pCCSBotManager__AddBot)(void);
bool __declspec(naked) CCSBotManager::AddBot(const BotProfile *profile, BotProfileTeamType team)
{
__asm { jmp pCCSBotManager__AddBot }
}
void CCSBotManager::ClientDisconnect(CBasePlayer *pPlayer)
{
ClientDisconnect_(pPlayer);
}
BOOL CCSBotManager::ClientCommand(CBasePlayer *pPlayer, const char *pcmd)
{
return ClientCommand_(pPlayer, pcmd);
}
void CCSBotManager::ServerActivate(void)
{
ServerActivate_();
}
void CCSBotManager::ServerDeactivate(void)
{
ServerDeactivate_();
}
void CCSBotManager::ServerCommand(const char *pcmd)
{
ServerCommand_(pcmd);
}
void CCSBotManager::AddServerCommand(const char *cmd)
{
AddServerCommand_(cmd);
}
void CCSBotManager::AddServerCommands(void)
{
AddServerCommands_();
}
void CCSBotManager::RestartRound(void)
{
RestartRound_();
}
void CCSBotManager::StartFrame(void)
{
StartFrame_();
}
void CCSBotManager::OnEvent(GameEventType event, CBaseEntity *entity, CBaseEntity *other)
{
OnEvent_(event, entity, other);
}
unsigned int CCSBotManager::GetPlayerPriority(CBasePlayer *player) const
{
return GetPlayerPriority_(player);
}
bool CCSBotManager::IsImportantPlayer(CBasePlayer *player) const
{
return IsImportantPlayer_(player);
}
#endif // HOOK_GAMEDLL

View File

@ -32,12 +32,6 @@
#pragma once #pragma once
#endif #endif
#ifdef HOOK_GAMEDLL
#define TheBots (*pTheBots)
#endif // HOOK_GAMEDLL
extern CBotManager *TheBots; extern CBotManager *TheBots;
// The manager for Counter-Strike specific bots // The manager for Counter-Strike specific bots
@ -49,15 +43,15 @@ public:
virtual void ClientDisconnect(CBasePlayer *pPlayer); virtual void ClientDisconnect(CBasePlayer *pPlayer);
virtual BOOL ClientCommand(CBasePlayer *pPlayer, const char *pcmd); virtual BOOL ClientCommand(CBasePlayer *pPlayer, const char *pcmd);
virtual void ServerActivate(void); virtual void ServerActivate();
virtual void ServerDeactivate(void); virtual void ServerDeactivate();
virtual void ServerCommand(const char *pcmd); virtual void ServerCommand(const char *pcmd);
virtual void AddServerCommand(const char *cmd); virtual void AddServerCommand(const char *cmd);
virtual void AddServerCommands(void); virtual void AddServerCommands();
virtual void RestartRound(void); // (EXTEND) invoked when a new round begins virtual void RestartRound(); // (EXTEND) invoked when a new round begins
virtual void StartFrame(void); // (EXTEND) called each frame virtual void StartFrame(); // (EXTEND) called each frame
virtual void OnEvent(GameEventType event, CBaseEntity *entity = NULL, CBaseEntity *other = NULL); virtual void OnEvent(GameEventType event, CBaseEntity *entity = NULL, CBaseEntity *other = NULL);
virtual unsigned int GetPlayerPriority(CBasePlayer *player) const; // return priority of player (0 = max pri) virtual unsigned int GetPlayerPriority(CBasePlayer *player) const; // return priority of player (0 = max pri)
@ -67,13 +61,13 @@ public:
void ClientDisconnect_(CBasePlayer *pPlayer); void ClientDisconnect_(CBasePlayer *pPlayer);
BOOL ClientCommand_(CBasePlayer *pPlayer, const char *pcmd); BOOL ClientCommand_(CBasePlayer *pPlayer, const char *pcmd);
void ServerActivate_(void); void ServerActivate_();
void ServerDeactivate_(void); void ServerDeactivate_();
void ServerCommand_(const char *pcmd); void ServerCommand_(const char *pcmd);
void AddServerCommand_(const char *cmd); void AddServerCommand_(const char *cmd);
void AddServerCommands_(void); void AddServerCommands_();
void RestartRound_(void); void RestartRound_();
void StartFrame_(void); void StartFrame_();
void OnEvent_(GameEventType event, CBaseEntity *entity, CBaseEntity *other); void OnEvent_(GameEventType event, CBaseEntity *entity, CBaseEntity *other);
unsigned int GetPlayerPriority_(CBasePlayer *player) const; unsigned int GetPlayerPriority_(CBasePlayer *player) const;
bool IsImportantPlayer_(CBasePlayer *player) const; bool IsImportantPlayer_(CBasePlayer *player) const;
@ -81,15 +75,15 @@ public:
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
public: public:
void ValidateMapData(void); void ValidateMapData();
bool IsLearningMap(void) const { return IMPL(m_isLearningMap); } bool IsLearningMap() const { return IMPL(m_isLearningMap); }
void SetLearningMapFlag(void) { IMPL(m_isLearningMap) = true;} void SetLearningMapFlag() { IMPL(m_isLearningMap) = true;}
bool IsAnalysisRequested(void) const { return IMPL(m_isAnalysisRequested); } bool IsAnalysisRequested() const { return IMPL(m_isAnalysisRequested); }
void RequestAnalysis(void) { IMPL(m_isAnalysisRequested) = true; } void RequestAnalysis() { IMPL(m_isAnalysisRequested) = true; }
void AckAnalysisRequest(void) { IMPL(m_isAnalysisRequested) = false; } void AckAnalysisRequest() { IMPL(m_isAnalysisRequested) = false; }
// difficulty levels // difficulty levels
static BotDifficultyType GetDifficultyLevel(void) static BotDifficultyType GetDifficultyLevel()
{ {
if (cv_bot_difficulty.value < 0.9f) if (cv_bot_difficulty.value < 0.9f)
return BOT_EASY; return BOT_EASY;
@ -111,7 +105,7 @@ public:
SCENARIO_RESCUE_HOSTAGES, SCENARIO_RESCUE_HOSTAGES,
SCENARIO_ESCORT_VIP SCENARIO_ESCORT_VIP
}; };
GameScenarioType GetScenario(void) const { return m_gameScenario; } GameScenarioType GetScenario() const { return m_gameScenario; }
// "zones" // "zones"
// depending on the game mode, these are bomb zones, rescue zones, etc. // depending on the game mode, these are bomb zones, rescue zones, etc.
@ -132,7 +126,7 @@ public:
const Zone *GetZone(const Vector *pos) const; // return the zone that contains the given position const Zone *GetZone(const Vector *pos) const; // return the zone that contains the given position
const Zone *GetClosestZone(const Vector *pos) const; // return the closest zone to the given position const Zone *GetClosestZone(const Vector *pos) const; // return the closest zone to the given position
const Zone *GetClosestZone(const CBaseEntity *entity) const { return GetClosestZone(&entity->pev->origin); } // return the closest zone to the given entity const Zone *GetClosestZone(const CBaseEntity *entity) const { return GetClosestZone(&entity->pev->origin); } // return the closest zone to the given entity
int GetZoneCount(void) const { return m_zoneCount; } int GetZoneCount() const { return m_zoneCount; }
const Vector *GetRandomPositionInZone(const Zone *zone) const; const Vector *GetRandomPositionInZone(const Zone *zone) const;
CNavArea *GetRandomAreaInZone(const Zone *zone) const; CNavArea *GetRandomAreaInZone(const Zone *zone) const;
@ -169,61 +163,61 @@ public:
} }
// pick a zone at random and return it // pick a zone at random and return it
const Zone *GetRandomZone(void) const const Zone *GetRandomZone() const
{ {
if (!m_zoneCount) if (!m_zoneCount)
return NULL; return NULL;
return &m_zone[ RANDOM_LONG(0, m_zoneCount - 1) ]; return &m_zone[ RANDOM_LONG(0, m_zoneCount - 1) ];
} }
bool IsBombPlanted(void) const { return m_isBombPlanted; } // returns true if bomb has been planted bool IsBombPlanted() const { return m_isBombPlanted; } // returns true if bomb has been planted
float GetBombPlantTimestamp(void) const { return m_bombPlantTimestamp; } // return time bomb was planted float GetBombPlantTimestamp() const { return m_bombPlantTimestamp; } // return time bomb was planted
bool IsTimeToPlantBomb(void) const { return (gpGlobals->time >= m_earliestBombPlantTimestamp); } // return true if it's ok to try to plant bomb bool IsTimeToPlantBomb() const { return (gpGlobals->time >= m_earliestBombPlantTimestamp); } // return true if it's ok to try to plant bomb
CBasePlayer *GetBombDefuser(void) const { return m_bombDefuser; } // return the player currently defusing the bomb, or NULL CBasePlayer *GetBombDefuser() const { return m_bombDefuser; } // return the player currently defusing the bomb, or NULL
float GetBombTimeLeft(void) const; // get the time remaining before the planted bomb explodes float GetBombTimeLeft() const; // get the time remaining before the planted bomb explodes
CBaseEntity *GetLooseBomb(void) { return m_looseBomb; } // return the bomb if it is loose on the ground CBaseEntity *GetLooseBomb() { return m_looseBomb; } // return the bomb if it is loose on the ground
CNavArea *GetLooseBombArea(void) const { return m_looseBombArea; } // return area that bomb is in/near CNavArea *GetLooseBombArea() const { return m_looseBombArea; } // return area that bomb is in/near
void SetLooseBomb(CBaseEntity *bomb); void SetLooseBomb(CBaseEntity *bomb);
float GetRadioMessageTimestamp(GameEventType event, int teamID) const; // return the last time the given radio message was sent for given team float GetRadioMessageTimestamp(GameEventType event, int teamID) const; // return the last time the given radio message was sent for given team
float GetRadioMessageInterval(GameEventType event, int teamID) const; // return the interval since the last time this message was sent float GetRadioMessageInterval(GameEventType event, int teamID) const; // return the interval since the last time this message was sent
void SetRadioMessageTimestamp(GameEventType event, int teamID); void SetRadioMessageTimestamp(GameEventType event, int teamID);
void ResetRadioMessageTimestamps(void); void ResetRadioMessageTimestamps();
float GetLastSeenEnemyTimestamp(void) const { return m_lastSeenEnemyTimestamp; } // return the last time anyone has seen an enemy float GetLastSeenEnemyTimestamp() const { return m_lastSeenEnemyTimestamp; } // return the last time anyone has seen an enemy
void SetLastSeenEnemyTimestamp(void) { m_lastSeenEnemyTimestamp = gpGlobals->time; } void SetLastSeenEnemyTimestamp() { m_lastSeenEnemyTimestamp = gpGlobals->time; }
float GetRoundStartTime(void) const { return m_roundStartTimestamp; } float GetRoundStartTime() const { return m_roundStartTimestamp; }
float GetElapsedRoundTime(void) const { return gpGlobals->time - m_roundStartTimestamp; } // return the elapsed time since the current round began float GetElapsedRoundTime() const { return gpGlobals->time - m_roundStartTimestamp; } // return the elapsed time since the current round began
bool AllowRogues(void) const { return cv_bot_allow_rogues.value != 0.0f; } bool AllowRogues() const { return cv_bot_allow_rogues.value != 0.0f; }
bool AllowPistols(void) const { return cv_bot_allow_pistols.value != 0.0f; } bool AllowPistols() const { return cv_bot_allow_pistols.value != 0.0f; }
bool AllowShotguns(void) const { return cv_bot_allow_shotguns.value != 0.0f; } bool AllowShotguns() const { return cv_bot_allow_shotguns.value != 0.0f; }
bool AllowSubMachineGuns(void) const { return cv_bot_allow_sub_machine_guns.value != 0.0f; } bool AllowSubMachineGuns() const { return cv_bot_allow_sub_machine_guns.value != 0.0f; }
bool AllowRifles(void) const { return cv_bot_allow_rifles.value != 0.0f; } bool AllowRifles() const { return cv_bot_allow_rifles.value != 0.0f; }
bool AllowMachineGuns(void) const { return cv_bot_allow_machine_guns.value != 0.0f; } bool AllowMachineGuns() const { return cv_bot_allow_machine_guns.value != 0.0f; }
bool AllowGrenades(void) const { return cv_bot_allow_grenades.value != 0.0f; } bool AllowGrenades() const { return cv_bot_allow_grenades.value != 0.0f; }
bool AllowSnipers(void) const { return cv_bot_allow_snipers.value != 0.0f; } bool AllowSnipers() const { return cv_bot_allow_snipers.value != 0.0f; }
bool AllowTacticalShield(void) const { return cv_bot_allow_shield.value != 0.0f; } bool AllowTacticalShield() const { return cv_bot_allow_shield.value != 0.0f; }
bool AllowFriendlyFireDamage(void) const { return friendlyfire.value != 0.0f; } bool AllowFriendlyFireDamage() const { return friendlyfire.value != 0.0f; }
bool IsWeaponUseable(CBasePlayerItem *item) const; // return true if the bot can use this weapon bool IsWeaponUseable(CBasePlayerItem *item) const; // return true if the bot can use this weapon
bool IsDefenseRushing(void) const { return m_isDefenseRushing; } // returns true if defense team has "decided" to rush this round bool IsDefenseRushing() const { return m_isDefenseRushing; } // returns true if defense team has "decided" to rush this round
bool IsOnDefense(CBasePlayer *player) const; // return true if this player is on "defense" bool IsOnDefense(CBasePlayer *player) const; // return true if this player is on "defense"
bool IsOnOffense(CBasePlayer *player) const; // return true if this player is on "offense" bool IsOnOffense(CBasePlayer *player) const; // return true if this player is on "offense"
bool IsRoundOver(void) const { return m_isRoundOver; } // return true if the round has ended bool IsRoundOver() const { return m_isRoundOver; } // return true if the round has ended
unsigned int GetNavPlace(void) const { return m_navPlace; } unsigned int GetNavPlace() const { return m_navPlace; }
void SetNavPlace(unsigned int place) { m_navPlace = place; } void SetNavPlace(unsigned int place) { m_navPlace = place; }
enum SkillType { LOW, AVERAGE, HIGH, RANDOM }; enum SkillType { LOW, AVERAGE, HIGH, RANDOM };
NOXREF const char *GetRandomBotName(SkillType skill); NOXREF const char *GetRandomBotName(SkillType skill);
static void MonitorBotCVars(void); static void MonitorBotCVars();
static void MaintainBotQuota(void); static void MaintainBotQuota();
static bool AddBot(const BotProfile *profile, BotProfileTeamType team); static bool AddBot(const BotProfile *profile, BotProfileTeamType team);
#define FROM_CONSOLE true #define FROM_CONSOLE true
@ -264,8 +258,7 @@ private:
bool m_isRespawnStarted; bool m_isRespawnStarted;
bool m_canRespawn; bool m_canRespawn;
bool m_bServerActive; bool m_bServerActive;
};
};/* size: 736, cachelines: 12, members: 25 */
/* <2e81a8> ../cstrike/dlls/bot/cs_bot_manager.h:24 */ /* <2e81a8> ../cstrike/dlls/bot/cs_bot_manager.h:24 */
NOXREF inline int OtherTeam(int team) NOXREF inline int OtherTeam(int team)
@ -274,25 +267,12 @@ NOXREF inline int OtherTeam(int team)
} }
/* <111bd2> ../cstrike/dlls/bot/cs_bot_manager.h:266 */ /* <111bd2> ../cstrike/dlls/bot/cs_bot_manager.h:266 */
inline CCSBotManager *TheCSBots(void) inline CCSBotManager *TheCSBots()
{ {
return reinterpret_cast<CCSBotManager *>(TheBots); return reinterpret_cast<CCSBotManager *>(TheBots);
} }
void PrintAllEntities(void); void PrintAllEntities();
void UTIL_DrawBox(Extent *extent, int lifetime, int red, int green, int blue); void UTIL_DrawBox(Extent *extent, int lifetime, int red, int green, int blue);
#ifdef HOOK_GAMEDLL
typedef const CCSBotManager::Zone *(CCSBotManager::*GET_ZONE_INT)(int) const;
typedef const CCSBotManager::Zone *(CCSBotManager::*GET_ZONE_VECTOR)(const Vector *pos) const;
typedef const CCSBotManager::Zone *(CCSBotManager::*GET_CLOSEST_ZONE_ENT)(const CBaseEntity *entity) const;
typedef const CCSBotManager::Zone *(CCSBotManager::*GET_CLOSEST_ZONE_VECTOR)(const Vector *pos) const;
#endif // HOOK_GAMEDLL
// refs
extern void (*pCCSBotManager__AddBot)(void);
#endif // CS_BOT_MANAGER_H #endif // CS_BOT_MANAGER_H

View File

@ -3,7 +3,7 @@
// Reset the stuck-checker. // Reset the stuck-checker.
/* <37c284> ../cstrike/dlls/bot/cs_bot_nav.cpp:16 */ /* <37c284> ../cstrike/dlls/bot/cs_bot_nav.cpp:16 */
void CCSBot::ResetStuckMonitor(void) void CCSBot::ResetStuckMonitor()
{ {
if (m_isStuck) if (m_isStuck)
{ {
@ -26,7 +26,7 @@ void CCSBot::ResetStuckMonitor(void)
// Test if we have become stuck // Test if we have become stuck
/* <37c2a6> ../cstrike/dlls/bot/cs_bot_nav.cpp:37 */ /* <37c2a6> ../cstrike/dlls/bot/cs_bot_nav.cpp:37 */
void CCSBot::StuckCheck(void) void CCSBot::StuckCheck()
{ {
if (m_isStuck) if (m_isStuck)
{ {
@ -160,7 +160,7 @@ bool CCSBot::GetSimpleGroundHeightWithFloor(const Vector *pos, float *height, Ve
} }
/* <37c4b8> ../cstrike/dlls/bot/cs_bot_nav.cpp:172 */ /* <37c4b8> ../cstrike/dlls/bot/cs_bot_nav.cpp:172 */
Place CCSBot::GetPlace(void) const Place CCSBot::GetPlace() const
{ {
if (m_lastKnownArea != NULL) if (m_lastKnownArea != NULL)
return m_lastKnownArea->GetPlace(); return m_lastKnownArea->GetPlace();
@ -319,7 +319,7 @@ void CCSBot::StrafeAwayFromPosition(const Vector *pos)
// For getting un-stuck // For getting un-stuck
/* <37cc52> ../cstrike/dlls/bot/cs_bot_nav.cpp:338 */ /* <37cc52> ../cstrike/dlls/bot/cs_bot_nav.cpp:338 */
void CCSBot::Wiggle(void) void CCSBot::Wiggle()
{ {
if (IsCrouching()) if (IsCrouching())
{ {
@ -363,7 +363,7 @@ void CCSBot::Wiggle(void)
// Determine approach points from eye position and approach areas of current area // Determine approach points from eye position and approach areas of current area
/* <37cc94> ../cstrike/dlls/bot/cs_bot_nav.cpp:383 */ /* <37cc94> ../cstrike/dlls/bot/cs_bot_nav.cpp:383 */
void CCSBot::ComputeApproachPoints(void) void CCSBot::ComputeApproachPoints()
{ {
m_approachPointCount = 0; m_approachPointCount = 0;
@ -408,7 +408,7 @@ void CCSBot::ComputeApproachPoints(void)
} }
/* <37cd67> ../cstrike/dlls/bot/cs_bot_nav.cpp:422 */ /* <37cd67> ../cstrike/dlls/bot/cs_bot_nav.cpp:422 */
void CCSBot::DrawApproachPoints(void) void CCSBot::DrawApproachPoints()
{ {
for (int i = 0; i < m_approachPointCount; ++i) for (int i = 0; i < m_approachPointCount; ++i)
{ {

View File

@ -3,7 +3,7 @@
// Determine actual path positions bot will move between along the path // Determine actual path positions bot will move between along the path
/* <38db02> ../cstrike/dlls/bot/cs_bot_pathfind.cpp:30 */ /* <38db02> ../cstrike/dlls/bot/cs_bot_pathfind.cpp:30 */
bool CCSBot::ComputePathPositions(void) bool CCSBot::ComputePathPositions()
{ {
if (m_pathLength == 0) if (m_pathLength == 0)
return false; return false;
@ -127,7 +127,7 @@ bool CCSBot::ComputePathPositions(void)
// If next step of path uses a ladder, prepare to traverse it // If next step of path uses a ladder, prepare to traverse it
/* <38d424> ../cstrike/dlls/bot/cs_bot_pathfind.cpp:155 */ /* <38d424> ../cstrike/dlls/bot/cs_bot_pathfind.cpp:155 */
void CCSBot::SetupLadderMovement(void) void CCSBot::SetupLadderMovement()
{ {
if (m_pathIndex < 1 || m_pathLength == 0) if (m_pathIndex < 1 || m_pathLength == 0)
return; return;
@ -149,7 +149,7 @@ void CCSBot::SetupLadderMovement(void)
m_pathLadderFaceIn = true; m_pathLadderFaceIn = true;
PrintIfWatched("APPROACH_ASCENDING_LADDER\n"); PrintIfWatched("APPROACH_ASCENDING_LADDER\n");
m_goalPosition = m_pathLadder->m_bottom; m_goalPosition = m_pathLadder->m_bottom;
AddDirectionVector(&m_goalPosition, m_pathLadder->m_dir, HalfHumanWidth * 2.0f); AddDirectionVector(&m_goalPosition, m_pathLadder->m_dir, HalfHumanWidth * 2.0f);
m_lookAheadAngle = DirectionToAngle(OppositeDirection(m_pathLadder->m_dir)); m_lookAheadAngle = DirectionToAngle(OppositeDirection(m_pathLadder->m_dir));
} }
@ -223,7 +223,7 @@ void CCSBot::ComputeLadderEndpoint(bool isAscending)
// TODO: Need Push() and Pop() for run/walk context to keep ladder speed contained. // TODO: Need Push() and Pop() for run/walk context to keep ladder speed contained.
/* <38de76> ../cstrike/dlls/bot/cs_bot_pathfind.cpp:248 */ /* <38de76> ../cstrike/dlls/bot/cs_bot_pathfind.cpp:248 */
bool CCSBot::UpdateLadderMovement(void) bool CCSBot::UpdateLadderMovement()
{ {
if (m_pathLadder == NULL) if (m_pathLadder == NULL)
return false; return false;
@ -1047,7 +1047,7 @@ void CCSBot::SetPathIndex(int newIndex)
// Return true if nearing a jump in the path // Return true if nearing a jump in the path
/* <38cafc> ../cstrike/dlls/bot/cs_bot_pathfind.cpp:1077 */ /* <38cafc> ../cstrike/dlls/bot/cs_bot_pathfind.cpp:1077 */
bool CCSBot::IsNearJump(void) const bool CCSBot::IsNearJump() const
{ {
if (m_pathIndex == 0 || m_pathIndex >= m_pathLength) if (m_pathIndex == 0 || m_pathIndex >= m_pathLength)
return false; return false;
@ -1614,7 +1614,7 @@ bool CCSBot::ComputePath(CNavArea *goalArea, const Vector *goal, RouteType route
m_repathTimer.Start(RANDOM_FLOAT(0.4f, 0.6f)); m_repathTimer.Start(RANDOM_FLOAT(0.4f, 0.6f));
DestroyPath(); DestroyPath();
CNavArea *startArea = m_lastKnownArea; CNavArea *startArea = m_lastKnownArea;
if (startArea == NULL) if (startArea == NULL)
return false; return false;
@ -1733,7 +1733,7 @@ bool CCSBot::ComputePath(CNavArea *goalArea, const Vector *goal, RouteType route
// Return estimated distance left to travel along path // Return estimated distance left to travel along path
/* <390ef6> ../cstrike/dlls/bot/cs_bot_pathfind.cpp:1798 */ /* <390ef6> ../cstrike/dlls/bot/cs_bot_pathfind.cpp:1798 */
float CCSBot::GetPathDistanceRemaining(void) const float CCSBot::GetPathDistanceRemaining() const
{ {
if (!HasPath()) if (!HasPath())
return -1.0f; return -1.0f;
@ -1755,7 +1755,7 @@ float CCSBot::GetPathDistanceRemaining(void) const
// Draw a portion of our current path for debugging. // Draw a portion of our current path for debugging.
/* <390fb1> ../cstrike/dlls/bot/cs_bot_pathfind.cpp:1821 */ /* <390fb1> ../cstrike/dlls/bot/cs_bot_pathfind.cpp:1821 */
void CCSBot::DrawPath(void) void CCSBot::DrawPath()
{ {
if (!HasPath()) if (!HasPath())
return; return;

View File

@ -20,7 +20,7 @@ bool CCSBot::IsRadioCommand(GameEventType event) const
// Respond to radio commands from HUMAN players // Respond to radio commands from HUMAN players
/* <3a36e0> ../cstrike/dlls/bot/cs_bot_radio.cpp:37 */ /* <3a36e0> ../cstrike/dlls/bot/cs_bot_radio.cpp:37 */
void CCSBot::RespondToRadioCommands(void) void CCSBot::RespondToRadioCommands()
{ {
// bots use the chatter system to respond to each other // bots use the chatter system to respond to each other
if (m_radioSubject != NULL && m_radioSubject->IsPlayer()) if (m_radioSubject != NULL && m_radioSubject->IsPlayer())
@ -309,7 +309,7 @@ void CCSBot::SendRadioMessage(GameEventType event)
m_lastRadioSentTimestamp = gpGlobals->time; m_lastRadioSentTimestamp = gpGlobals->time;
char slot[2]; char slot[2];
slot[1] = '\000'; slot[1] = '\0';
if (event > EVENT_START_RADIO_1 && event < EVENT_START_RADIO_2) if (event > EVENT_START_RADIO_1 && event < EVENT_START_RADIO_2)
{ {
@ -329,7 +329,7 @@ void CCSBot::SendRadioMessage(GameEventType event)
ClientCommand("radio3"); ClientCommand("radio3");
//Radio3(this, event - EVENT_START_RADIO_3); //Radio3(this, event - EVENT_START_RADIO_3);
} }
ClientCommand("menuselect", slot); ClientCommand("menuselect", slot);
ClientCommand("menuselect", "10"); ClientCommand("menuselect", "10");
} }

View File

@ -21,14 +21,14 @@ void CCSBot::SetState(BotState *state)
} }
/* <3b3ab4> ../cstrike/dlls/bot/cs_bot_statemachine.cpp:34 */ /* <3b3ab4> ../cstrike/dlls/bot/cs_bot_statemachine.cpp:34 */
void CCSBot::Idle(void) void CCSBot::Idle()
{ {
SetTask(SEEK_AND_DESTROY); SetTask(SEEK_AND_DESTROY);
SetState(&m_idleState); SetState(&m_idleState);
} }
/* <3b3afa> ../cstrike/dlls/bot/cs_bot_statemachine.cpp:41 */ /* <3b3afa> ../cstrike/dlls/bot/cs_bot_statemachine.cpp:41 */
void CCSBot::EscapeFromBomb(void) void CCSBot::EscapeFromBomb()
{ {
SetTask(ESCAPE_FROM_BOMB); SetTask(ESCAPE_FROM_BOMB);
SetState(&m_escapeFromBombState); SetState(&m_escapeFromBombState);
@ -55,7 +55,7 @@ void CCSBot::Follow(CBasePlayer *player)
// Continue following our leader after finishing what we were doing // Continue following our leader after finishing what we were doing
/* <3b3bd1> ../cstrike/dlls/bot/cs_bot_statemachine.cpp:69 */ /* <3b3bd1> ../cstrike/dlls/bot/cs_bot_statemachine.cpp:69 */
void CCSBot::ContinueFollowing(void) void CCSBot::ContinueFollowing()
{ {
SetTask(FOLLOW); SetTask(FOLLOW);
m_followState.SetLeader(m_leader); m_followState.SetLeader(m_leader);
@ -65,7 +65,7 @@ void CCSBot::ContinueFollowing(void)
// Stop following // Stop following
/* <3b3c57> ../cstrike/dlls/bot/cs_bot_statemachine.cpp:83 */ /* <3b3c57> ../cstrike/dlls/bot/cs_bot_statemachine.cpp:83 */
void CCSBot::StopFollowing(void) void CCSBot::StopFollowing()
{ {
m_isFollowing = false; m_isFollowing = false;
m_leader = NULL; m_leader = NULL;
@ -75,7 +75,7 @@ void CCSBot::StopFollowing(void)
// Begin process of rescuing hostages // Begin process of rescuing hostages
/* <3b3c7e> ../cstrike/dlls/bot/cs_bot_statemachine.cpp:94 */ /* <3b3c7e> ../cstrike/dlls/bot/cs_bot_statemachine.cpp:94 */
void CCSBot::RescueHostages(void) void CCSBot::RescueHostages()
{ {
SetTask(RESCUE_HOSTAGES); SetTask(RESCUE_HOSTAGES);
} }
@ -237,7 +237,7 @@ bool CCSBot::TryToHide(CNavArea *searchFromArea, float duration, float hideRange
// Retreat to a nearby hiding spot, away from enemies // Retreat to a nearby hiding spot, away from enemies
/* <3b40ed> ../cstrike/dlls/bot/cs_bot_statemachine.cpp:256 */ /* <3b40ed> ../cstrike/dlls/bot/cs_bot_statemachine.cpp:256 */
bool CCSBot::TryToRetreat(void) bool CCSBot::TryToRetreat()
{ {
const float maxRange = 1000.0f; const float maxRange = 1000.0f;
const Vector *spot = FindNearbyRetreatSpot(this, maxRange); const Vector *spot = FindNearbyRetreatSpot(this, maxRange);
@ -262,7 +262,7 @@ bool CCSBot::TryToRetreat(void)
} }
/* <3b426a> ../cstrike/dlls/bot/cs_bot_statemachine.cpp:280 */ /* <3b426a> ../cstrike/dlls/bot/cs_bot_statemachine.cpp:280 */
void CCSBot::Hunt(void) void CCSBot::Hunt()
{ {
SetState(&m_huntState); SetState(&m_huntState);
} }
@ -316,7 +316,7 @@ void CCSBot::Attack(CBasePlayer *victim)
if (deltaYaw < 0.0f) if (deltaYaw < 0.0f)
deltaYaw = -deltaYaw; deltaYaw = -deltaYaw;
// immediately aim at enemy - accuracy penalty depending on how far we must turn to aim // immediately aim at enemy - accuracy penalty depending on how far we must turn to aim
// accuracy is halved if we have to turn 180 degrees // accuracy is halved if we have to turn 180 degrees
float turn = deltaYaw / 180.0f; float turn = deltaYaw / 180.0f;
@ -332,7 +332,7 @@ void CCSBot::Attack(CBasePlayer *victim)
// Exit the Attack state // Exit the Attack state
/* <3b4416> ../cstrike/dlls/bot/cs_bot_statemachine.cpp:366 */ /* <3b4416> ../cstrike/dlls/bot/cs_bot_statemachine.cpp:366 */
void CCSBot::StopAttacking(void) void CCSBot::StopAttacking()
{ {
PrintIfWatched("ATTACK END\n"); PrintIfWatched("ATTACK END\n");
m_attackState.OnExit(this); m_attackState.OnExit(this);
@ -346,7 +346,7 @@ void CCSBot::StopAttacking(void)
} }
/* <3b447d> ../cstrike/dlls/bot/cs_bot_statemachine.cpp:378 */ /* <3b447d> ../cstrike/dlls/bot/cs_bot_statemachine.cpp:378 */
bool CCSBot::IsAttacking(void) const bool CCSBot::IsAttacking() const
{ {
return m_isAttacking; return m_isAttacking;
} }
@ -354,7 +354,7 @@ bool CCSBot::IsAttacking(void) const
// Return true if we are escaping from the bomb // Return true if we are escaping from the bomb
/* <3b449f> ../cstrike/dlls/bot/cs_bot_statemachine.cpp:387 */ /* <3b449f> ../cstrike/dlls/bot/cs_bot_statemachine.cpp:387 */
bool CCSBot::IsEscapingFromBomb(void) const bool CCSBot::IsEscapingFromBomb() const
{ {
if (m_state == static_cast<const BotState *>(&m_escapeFromBombState)) if (m_state == static_cast<const BotState *>(&m_escapeFromBombState))
return true; return true;
@ -365,7 +365,7 @@ bool CCSBot::IsEscapingFromBomb(void) const
// Return true if we are defusing the bomb // Return true if we are defusing the bomb
/* <3b44c6> ../cstrike/dlls/bot/cs_bot_statemachine.cpp:399 */ /* <3b44c6> ../cstrike/dlls/bot/cs_bot_statemachine.cpp:399 */
bool CCSBot::IsDefusingBomb(void) const bool CCSBot::IsDefusingBomb() const
{ {
if (m_state == static_cast<const BotState *>(&m_defuseBombState)) if (m_state == static_cast<const BotState *>(&m_defuseBombState))
return true; return true;
@ -376,7 +376,7 @@ bool CCSBot::IsDefusingBomb(void) const
// Return true if we are hiding // Return true if we are hiding
/* <3b44ed> ../cstrike/dlls/bot/cs_bot_statemachine.cpp:411 */ /* <3b44ed> ../cstrike/dlls/bot/cs_bot_statemachine.cpp:411 */
bool CCSBot::IsHiding(void) const bool CCSBot::IsHiding() const
{ {
if (m_state == static_cast<const BotState *>(&m_hideState)) if (m_state == static_cast<const BotState *>(&m_hideState))
return true; return true;
@ -387,7 +387,7 @@ bool CCSBot::IsHiding(void) const
// Return true if we are hiding and at our hiding spot // Return true if we are hiding and at our hiding spot
/* <3b450f> ../cstrike/dlls/bot/cs_bot_statemachine.cpp:423 */ /* <3b450f> ../cstrike/dlls/bot/cs_bot_statemachine.cpp:423 */
bool CCSBot::IsAtHidingSpot(void) const bool CCSBot::IsAtHidingSpot() const
{ {
if (!IsHiding()) if (!IsHiding())
return false; return false;
@ -398,7 +398,7 @@ bool CCSBot::IsAtHidingSpot(void) const
// Return true if we are huting // Return true if we are huting
/* <3b454a> ../cstrike/dlls/bot/cs_bot_statemachine.cpp:435 */ /* <3b454a> ../cstrike/dlls/bot/cs_bot_statemachine.cpp:435 */
bool CCSBot::IsHunting(void) const bool CCSBot::IsHunting() const
{ {
if (m_state == static_cast<const BotState *>(&m_huntState)) if (m_state == static_cast<const BotState *>(&m_huntState))
return true; return true;
@ -409,7 +409,7 @@ bool CCSBot::IsHunting(void) const
// Return true if we are in the MoveTo state // Return true if we are in the MoveTo state
/* <3b4571> ../cstrike/dlls/bot/cs_bot_statemachine.cpp:447 */ /* <3b4571> ../cstrike/dlls/bot/cs_bot_statemachine.cpp:447 */
bool CCSBot::IsMovingTo(void) const bool CCSBot::IsMovingTo() const
{ {
if (m_state == static_cast<const BotState *>(&m_moveToState)) if (m_state == static_cast<const BotState *>(&m_moveToState))
return true; return true;
@ -420,7 +420,7 @@ bool CCSBot::IsMovingTo(void) const
// Return true if we are buying // Return true if we are buying
/* <3b4598> ../cstrike/dlls/bot/cs_bot_statemachine.cpp:460 */ /* <3b4598> ../cstrike/dlls/bot/cs_bot_statemachine.cpp:460 */
bool CCSBot::IsBuying(void) const bool CCSBot::IsBuying() const
{ {
if (m_state == static_cast<const BotState *>(&m_buyState)) if (m_state == static_cast<const BotState *>(&m_buyState))
return true; return true;
@ -439,7 +439,7 @@ void CCSBot::MoveTo(const Vector *pos, RouteType route)
} }
/* <3b463c> ../cstrike/dlls/bot/cs_bot_statemachine.cpp:480 */ /* <3b463c> ../cstrike/dlls/bot/cs_bot_statemachine.cpp:480 */
void CCSBot::PlantBomb(void) void CCSBot::PlantBomb()
{ {
SetState(&m_plantBombState); SetState(&m_plantBombState);
} }
@ -447,13 +447,13 @@ void CCSBot::PlantBomb(void)
// Bomb has been dropped - go get it // Bomb has been dropped - go get it
/* <3b4663> ../cstrike/dlls/bot/cs_bot_statemachine.cpp:489 */ /* <3b4663> ../cstrike/dlls/bot/cs_bot_statemachine.cpp:489 */
void CCSBot::FetchBomb(void) void CCSBot::FetchBomb()
{ {
SetState(&m_fetchBombState); SetState(&m_fetchBombState);
} }
/* <3b468a> ../cstrike/dlls/bot/cs_bot_statemachine.cpp:495 */ /* <3b468a> ../cstrike/dlls/bot/cs_bot_statemachine.cpp:495 */
void CCSBot::DefuseBomb(void) void CCSBot::DefuseBomb()
{ {
SetState(&m_defuseBombState); SetState(&m_defuseBombState);
} }
@ -461,7 +461,7 @@ void CCSBot::DefuseBomb(void)
// Investigate recent enemy noise // Investigate recent enemy noise
/* <3b46b1> ../cstrike/dlls/bot/cs_bot_statemachine.cpp:504 */ /* <3b46b1> ../cstrike/dlls/bot/cs_bot_statemachine.cpp:504 */
void CCSBot::InvestigateNoise(void) void CCSBot::InvestigateNoise()
{ {
SetState(&m_investigateNoiseState); SetState(&m_investigateNoiseState);
} }

View File

@ -3,7 +3,7 @@
// Lightweight maintenance, invoked frequently // Lightweight maintenance, invoked frequently
/* <3c635f> ../cstrike/dlls/bot/cs_bot_update.cpp:26 */ /* <3c635f> ../cstrike/dlls/bot/cs_bot_update.cpp:26 */
void CCSBot::__MAKE_VHOOK(Upkeep)(void) void CCSBot::__MAKE_VHOOK(Upkeep)()
{ {
CCSBotManager *ctrl = TheCSBots(); CCSBotManager *ctrl = TheCSBots();
@ -153,7 +153,7 @@ void CCSBot::__MAKE_VHOOK(Upkeep)(void)
// Heavyweight processing, invoked less often // Heavyweight processing, invoked less often
/* <3c6e1e> ../cstrike/dlls/bot/cs_bot_update.cpp:208 */ /* <3c6e1e> ../cstrike/dlls/bot/cs_bot_update.cpp:208 */
void CCSBot::__MAKE_VHOOK(Update)(void) void CCSBot::__MAKE_VHOOK(Update)()
{ {
CCSBotManager *ctrl = TheCSBots(); CCSBotManager *ctrl = TheCSBots();
@ -175,7 +175,7 @@ void CCSBot::__MAKE_VHOOK(Update)(void)
// need to allow bots to finish their chatter even if they are dead // need to allow bots to finish their chatter even if they are dead
GetChatter()->Update(); GetChatter()->Update();
if (m_voiceFeedbackEndTimestamp != 0.0f if (m_voiceFeedbackEndTimestamp != 0.0f
&& (m_voiceFeedbackEndTimestamp <= gpGlobals->time || gpGlobals->time < m_voiceFeedbackStartTimestamp)) && (m_voiceFeedbackEndTimestamp <= gpGlobals->time || gpGlobals->time < m_voiceFeedbackStartTimestamp))
{ {
EndVoiceFeedback(NO_FORCE); EndVoiceFeedback(NO_FORCE);
@ -268,10 +268,10 @@ void CCSBot::__MAKE_VHOOK(Update)(void)
{ {
switch (m_blindMoveDir) switch (m_blindMoveDir)
{ {
case FORWARD: MoveForward(); break; case FORWARD: MoveForward(); break;
case RIGHT: StrafeRight(); break; case RIGHT: StrafeRight(); break;
case BACKWARD: MoveBackward(); break; case BACKWARD: MoveBackward(); break;
case LEFT: StrafeLeft(); break; case LEFT: StrafeLeft(); break;
default: Crouch(); break; default: Crouch(); break;
} }
} }
@ -745,17 +745,3 @@ void CCSBot::__MAKE_VHOOK(Update)(void)
// remember our prior safe time status // remember our prior safe time status
m_wasSafe = IsSafe(); m_wasSafe = IsSafe();
} }
#ifdef HOOK_GAMEDLL
void CCSBot::Upkeep(void)
{
Upkeep_();
}
void CCSBot::Update(void)
{
Update_();
}
#endif // HOOK_GAMEDLL

View File

@ -31,7 +31,7 @@ float StayOnLadderLine(CCSBot *me, const CNavLadder *ladder)
/* <3d882c> ../cstrike/dlls/bot/cs_bot_vision.cpp:48 */ /* <3d882c> ../cstrike/dlls/bot/cs_bot_vision.cpp:48 */
#ifndef HOOK_GAMEDLL #ifndef HOOK_GAMEDLL
void CCSBot::UpdateLookAngles(void) void CCSBot::UpdateLookAngles()
{ {
const float deltaT = g_flBotCommandInterval; const float deltaT = g_flBotCommandInterval;
float maxAccel; float maxAccel;
@ -293,7 +293,7 @@ bool CCSBot::__MAKE_VHOOK(IsEnemyPartVisible)(VisiblePartType part) const
} }
/* <3d8f0d> ../cstrike/dlls/bot/cs_bot_vision.cpp:331 */ /* <3d8f0d> ../cstrike/dlls/bot/cs_bot_vision.cpp:331 */
void CCSBot::UpdateLookAt(void) void CCSBot::UpdateLookAt()
{ {
Vector to = m_lookAtSpot - EyePosition(); Vector to = m_lookAtSpot - EyePosition();
Vector idealAngle = UTIL_VecToAngles(to); Vector idealAngle = UTIL_VecToAngles(to);
@ -348,7 +348,7 @@ void CCSBot::InhibitLookAround(float duration)
// Update enounter spot timestamps, etc // Update enounter spot timestamps, etc
/* <3d90d3> ../cstrike/dlls/bot/cs_bot_vision.cpp:392 */ /* <3d90d3> ../cstrike/dlls/bot/cs_bot_vision.cpp:392 */
void CCSBot::UpdatePeripheralVision(void) void CCSBot::UpdatePeripheralVision()
{ {
// if we update at 10Hz, this ensures we test once every three // if we update at 10Hz, this ensures we test once every three
const float peripheralUpdateInterval = 0.29f; const float peripheralUpdateInterval = 0.29f;
@ -653,7 +653,7 @@ bool CCSBot::BendLineOfSight(const Vector *eye, const Vector *point, Vector *ben
} }
/* <3d99e8> ../cstrike/dlls/bot/cs_bot_vision.cpp:707 */ /* <3d99e8> ../cstrike/dlls/bot/cs_bot_vision.cpp:707 */
CBasePlayer *CCSBot::FindMostDangerousThreat(void) CBasePlayer *CCSBot::FindMostDangerousThreat()
{ {
// maximum number of simulataneously attendable threats // maximum number of simulataneously attendable threats
enum { MAX_THREATS = 16 }; enum { MAX_THREATS = 16 };
@ -909,7 +909,7 @@ CBasePlayer *CCSBot::FindMostDangerousThreat(void)
// Update our reaction time queue // Update our reaction time queue
/* <3d9f7d> ../cstrike/dlls/bot/cs_bot_vision.cpp:960 */ /* <3d9f7d> ../cstrike/dlls/bot/cs_bot_vision.cpp:960 */
void CCSBot::UpdateReactionQueue(void) void CCSBot::UpdateReactionQueue()
{ {
// zombies dont see any threats // zombies dont see any threats
if (cv_bot_zombie.value > 0.0f) if (cv_bot_zombie.value > 0.0f)
@ -961,7 +961,7 @@ void CCSBot::UpdateReactionQueue(void)
// Return the most dangerous threat we are "conscious" of // Return the most dangerous threat we are "conscious" of
/* <3da052> ../cstrike/dlls/bot/cs_bot_vision.cpp:1013 */ /* <3da052> ../cstrike/dlls/bot/cs_bot_vision.cpp:1013 */
CBasePlayer *CCSBot::GetRecognizedEnemy(void) CBasePlayer *CCSBot::GetRecognizedEnemy()
{ {
if (m_enemyQueueAttendIndex >= m_enemyQueueCount) if (m_enemyQueueAttendIndex >= m_enemyQueueCount)
return NULL; return NULL;
@ -972,7 +972,7 @@ CBasePlayer *CCSBot::GetRecognizedEnemy(void)
// Return true if the enemy we are "conscious" of is reloading // Return true if the enemy we are "conscious" of is reloading
/* <3da075> ../cstrike/dlls/bot/cs_bot_vision.cpp:1025 */ /* <3da075> ../cstrike/dlls/bot/cs_bot_vision.cpp:1025 */
bool CCSBot::IsRecognizedEnemyReloading(void) bool CCSBot::IsRecognizedEnemyReloading()
{ {
if (m_enemyQueueAttendIndex >= m_enemyQueueCount) if (m_enemyQueueAttendIndex >= m_enemyQueueCount)
return false; return false;
@ -983,7 +983,7 @@ bool CCSBot::IsRecognizedEnemyReloading(void)
// Return true if the enemy we are "conscious" of is hiding behind a shield // Return true if the enemy we are "conscious" of is hiding behind a shield
/* <3da09d> ../cstrike/dlls/bot/cs_bot_vision.cpp:1037 */ /* <3da09d> ../cstrike/dlls/bot/cs_bot_vision.cpp:1037 */
bool CCSBot::IsRecognizedEnemyProtectedByShield(void) bool CCSBot::IsRecognizedEnemyProtectedByShield()
{ {
if (m_enemyQueueAttendIndex >= m_enemyQueueCount) if (m_enemyQueueAttendIndex >= m_enemyQueueCount)
return false; return false;
@ -994,7 +994,7 @@ bool CCSBot::IsRecognizedEnemyProtectedByShield(void)
// Return distance to closest enemy we are "conscious" of // Return distance to closest enemy we are "conscious" of
/* <3da0c5> ../cstrike/dlls/bot/cs_bot_vision.cpp:1049 */ /* <3da0c5> ../cstrike/dlls/bot/cs_bot_vision.cpp:1049 */
float CCSBot::GetRangeToNearestRecognizedEnemy(void) float CCSBot::GetRangeToNearestRecognizedEnemy()
{ {
const CBasePlayer *enemy = GetRecognizedEnemy(); const CBasePlayer *enemy = GetRecognizedEnemy();
@ -1030,33 +1030,3 @@ void CCSBot::__MAKE_VHOOK(Blind)(float duration, float holdTime, float fadeTime,
// no longer safe // no longer safe
AdjustSafeTime(); AdjustSafeTime();
} }
#ifdef HOOK_GAMEDLL
void (*pCCSBot__UpdateLookAngles)(void);
void __declspec(naked) CCSBot::UpdateLookAngles(void)
{
__asm { jmp pCCSBot__UpdateLookAngles }
}
void CCSBot::Blind(float duration, float holdTime, float fadeTime, int alpha)
{
Blind_(duration, holdTime, fadeTime, alpha);
}
bool CCSBot::IsVisible(const Vector *pos, bool testFOV) const
{
return IsVisible_(pos, testFOV);
}
bool CCSBot::IsVisible(CBasePlayer *player, bool testFOV, unsigned char *visParts) const
{
return IsVisible_(player, testFOV, visParts);
}
bool CCSBot::IsEnemyPartVisible(VisiblePartType part) const
{
return IsEnemyPartVisible_(part);
}
#endif // HOOK_GAMEDLL

View File

@ -4,7 +4,7 @@
// NOTE: Aiming our weapon is handled in RunBotUpkeep() // NOTE: Aiming our weapon is handled in RunBotUpkeep()
/* <3eb434> ../cstrike/dlls/bot/cs_bot_weapon.cpp:17 */ /* <3eb434> ../cstrike/dlls/bot/cs_bot_weapon.cpp:17 */
void CCSBot::FireWeaponAtEnemy(void) void CCSBot::FireWeaponAtEnemy()
{ {
CBasePlayer *enemy = GetEnemy(); CBasePlayer *enemy = GetEnemy();
if (enemy == NULL) if (enemy == NULL)
@ -195,7 +195,7 @@ void CCSBot::SetAimOffset(float accuracy)
// Wiggle aim error based on GetProfile()->GetSkill() // Wiggle aim error based on GetProfile()->GetSkill()
/* <3ea224> ../cstrike/dlls/bot/cs_bot_weapon.cpp:252 */ /* <3ea224> ../cstrike/dlls/bot/cs_bot_weapon.cpp:252 */
void CCSBot::UpdateAimOffset(void) void CCSBot::UpdateAimOffset()
{ {
if (gpGlobals->time >= m_aimOffsetTimestamp) if (gpGlobals->time >= m_aimOffsetTimestamp)
{ {
@ -287,7 +287,7 @@ bool isSniperRifle(CBasePlayerItem *item)
} }
/* <3ea3ab> ../cstrike/dlls/bot/cs_bot_weapon.cpp:342 */ /* <3ea3ab> ../cstrike/dlls/bot/cs_bot_weapon.cpp:342 */
bool CCSBot::IsUsingAWP(void) const bool CCSBot::IsUsingAWP() const
{ {
CBasePlayerWeapon *weapon = GetActiveWeapon(); CBasePlayerWeapon *weapon = GetActiveWeapon();
@ -300,7 +300,7 @@ bool CCSBot::IsUsingAWP(void) const
// Returns true if we are using a weapon with a removable silencer // Returns true if we are using a weapon with a removable silencer
/* <3ea3ce> ../cstrike/dlls/bot/cs_bot_weapon.cpp:357 */ /* <3ea3ce> ../cstrike/dlls/bot/cs_bot_weapon.cpp:357 */
bool CCSBot::DoesActiveWeaponHaveSilencer(void) const bool CCSBot::DoesActiveWeaponHaveSilencer() const
{ {
CBasePlayerWeapon *weapon = GetActiveWeapon(); CBasePlayerWeapon *weapon = GetActiveWeapon();
@ -316,7 +316,7 @@ bool CCSBot::DoesActiveWeaponHaveSilencer(void) const
// Return true if we are using a sniper rifle // Return true if we are using a sniper rifle
/* <3ea3f1> ../cstrike/dlls/bot/cs_bot_weapon.cpp:375 */ /* <3ea3f1> ../cstrike/dlls/bot/cs_bot_weapon.cpp:375 */
bool CCSBot::IsUsingSniperRifle(void) const bool CCSBot::IsUsingSniperRifle() const
{ {
CBasePlayerWeapon *weapon = GetActiveWeapon(); CBasePlayerWeapon *weapon = GetActiveWeapon();
@ -329,7 +329,7 @@ bool CCSBot::IsUsingSniperRifle(void) const
// Return true if we have a sniper rifle in our inventory // Return true if we have a sniper rifle in our inventory
/* <3ea462> ../cstrike/dlls/bot/cs_bot_weapon.cpp:387 */ /* <3ea462> ../cstrike/dlls/bot/cs_bot_weapon.cpp:387 */
bool CCSBot::IsSniper(void) const bool CCSBot::IsSniper() const
{ {
for (int i = 0; i < MAX_ITEM_TYPES; ++i) for (int i = 0; i < MAX_ITEM_TYPES; ++i)
{ {
@ -350,7 +350,7 @@ bool CCSBot::IsSniper(void) const
// Return true if we are actively sniping (moving to sniper spot or settled in) // Return true if we are actively sniping (moving to sniper spot or settled in)
/* <3ea4c1> ../cstrike/dlls/bot/cs_bot_weapon.cpp:405 */ /* <3ea4c1> ../cstrike/dlls/bot/cs_bot_weapon.cpp:405 */
bool CCSBot::IsSniping(void) const bool CCSBot::IsSniping() const
{ {
if (GetTask() == MOVE_TO_SNIPER_SPOT || GetTask() == SNIPING) if (GetTask() == MOVE_TO_SNIPER_SPOT || GetTask() == SNIPING)
return true; return true;
@ -361,7 +361,7 @@ bool CCSBot::IsSniping(void) const
// Return true if we are using a shotgun // Return true if we are using a shotgun
/* <3ea4e8> ../cstrike/dlls/bot/cs_bot_weapon.cpp:417 */ /* <3ea4e8> ../cstrike/dlls/bot/cs_bot_weapon.cpp:417 */
bool CCSBot::IsUsingShotgun(void) const bool CCSBot::IsUsingShotgun() const
{ {
CBasePlayerWeapon *weapon = GetActiveWeapon(); CBasePlayerWeapon *weapon = GetActiveWeapon();
@ -377,7 +377,7 @@ bool CCSBot::IsUsingShotgun(void) const
// Returns true if using the big 'ol machinegun // Returns true if using the big 'ol machinegun
/* <3ea50f> ../cstrike/dlls/bot/cs_bot_weapon.cpp:437 */ /* <3ea50f> ../cstrike/dlls/bot/cs_bot_weapon.cpp:437 */
bool CCSBot::IsUsingMachinegun(void) const bool CCSBot::IsUsingMachinegun() const
{ {
CBasePlayerWeapon *weapon = GetActiveWeapon(); CBasePlayerWeapon *weapon = GetActiveWeapon();
@ -390,7 +390,7 @@ bool CCSBot::IsUsingMachinegun(void) const
// Return true if primary weapon doesn't exist or is totally out of ammo // Return true if primary weapon doesn't exist or is totally out of ammo
/* <3ea532> ../cstrike/dlls/bot/cs_bot_weapon.cpp:449 */ /* <3ea532> ../cstrike/dlls/bot/cs_bot_weapon.cpp:449 */
bool CCSBot::IsPrimaryWeaponEmpty(void) const bool CCSBot::IsPrimaryWeaponEmpty() const
{ {
CBasePlayerWeapon *weapon = static_cast<CBasePlayerWeapon *>(m_rgpPlayerItems[ PRIMARY_WEAPON_SLOT ]); CBasePlayerWeapon *weapon = static_cast<CBasePlayerWeapon *>(m_rgpPlayerItems[ PRIMARY_WEAPON_SLOT ]);
@ -407,13 +407,13 @@ bool CCSBot::IsPrimaryWeaponEmpty(void) const
// Return true if pistol doesn't exist or is totally out of ammo // Return true if pistol doesn't exist or is totally out of ammo
/* <3ea578> ../cstrike/dlls/bot/cs_bot_weapon.cpp:467 */ /* <3ea578> ../cstrike/dlls/bot/cs_bot_weapon.cpp:467 */
bool CCSBot::IsPistolEmpty(void) const bool CCSBot::IsPistolEmpty() const
{ {
CBasePlayerWeapon *weapon = static_cast<CBasePlayerWeapon *>(m_rgpPlayerItems[ PISTOL_SLOT ]); CBasePlayerWeapon *weapon = static_cast<CBasePlayerWeapon *>(m_rgpPlayerItems[ PISTOL_SLOT ]);
if (weapon == NULL) if (weapon == NULL)
return true; return true;
// check if gun has any ammo left // check if gun has any ammo left
if (HasAnyAmmo(weapon)) if (HasAnyAmmo(weapon))
{ {
@ -490,7 +490,7 @@ void CCSBot::EquipBestWeapon(bool mustEquip)
// Equip our pistol // Equip our pistol
/* <3ea7fe> ../cstrike/dlls/bot/cs_bot_weapon.cpp:557 */ /* <3ea7fe> ../cstrike/dlls/bot/cs_bot_weapon.cpp:557 */
void CCSBot::EquipPistol(void) void CCSBot::EquipPistol()
{ {
// throttle how often equipping is allowed // throttle how often equipping is allowed
if (m_equipTimer.GetElapsedTime() < minEquipInterval) if (m_equipTimer.GetElapsedTime() < minEquipInterval)
@ -506,7 +506,7 @@ void CCSBot::EquipPistol(void)
// Equip the knife // Equip the knife
/* <3ea91a> ../cstrike/dlls/bot/cs_bot_weapon.cpp:575 */ /* <3ea91a> ../cstrike/dlls/bot/cs_bot_weapon.cpp:575 */
void CCSBot::EquipKnife(void) void CCSBot::EquipKnife()
{ {
if (!IsUsingKnife()) if (!IsUsingKnife())
{ {
@ -521,7 +521,7 @@ void CCSBot::EquipKnife(void)
// Return true if we have a grenade in our inventory // Return true if we have a grenade in our inventory
/* <3ea98b> ../cstrike/dlls/bot/cs_bot_weapon.cpp:589 */ /* <3ea98b> ../cstrike/dlls/bot/cs_bot_weapon.cpp:589 */
bool CCSBot::HasGrenade(void) const bool CCSBot::HasGrenade() const
{ {
CBasePlayerWeapon *grenade = static_cast<CBasePlayerWeapon *>(m_rgpPlayerItems[ GRENADE_SLOT ]); CBasePlayerWeapon *grenade = static_cast<CBasePlayerWeapon *>(m_rgpPlayerItems[ GRENADE_SLOT ]);
return grenade != NULL; return grenade != NULL;
@ -546,7 +546,7 @@ bool CCSBot::EquipGrenade(bool noSmoke)
if (grenade != NULL) if (grenade != NULL)
{ {
if (noSmoke && grenade->m_iId == WEAPON_SMOKEGRENADE) if (noSmoke && grenade->m_iId == WEAPON_SMOKEGRENADE)
return false; return false;
SelectItem(STRING(grenade->pev->classname)); SelectItem(STRING(grenade->pev->classname));
return true; return true;
@ -559,7 +559,7 @@ bool CCSBot::EquipGrenade(bool noSmoke)
// Returns true if we have knife equipped // Returns true if we have knife equipped
/* <3eaa8c> ../cstrike/dlls/bot/cs_bot_weapon.cpp:624 */ /* <3eaa8c> ../cstrike/dlls/bot/cs_bot_weapon.cpp:624 */
bool CCSBot::IsUsingKnife(void) const bool CCSBot::IsUsingKnife() const
{ {
CBasePlayerWeapon *weapon = GetActiveWeapon(); CBasePlayerWeapon *weapon = GetActiveWeapon();
@ -572,7 +572,7 @@ bool CCSBot::IsUsingKnife(void) const
// Returns true if we have pistol equipped // Returns true if we have pistol equipped
/* <3eaac2> ../cstrike/dlls/bot/cs_bot_weapon.cpp:638 */ /* <3eaac2> ../cstrike/dlls/bot/cs_bot_weapon.cpp:638 */
bool CCSBot::IsUsingPistol(void) const bool CCSBot::IsUsingPistol() const
{ {
CBasePlayerWeapon *weapon = GetActiveWeapon(); CBasePlayerWeapon *weapon = GetActiveWeapon();
@ -585,7 +585,7 @@ bool CCSBot::IsUsingPistol(void) const
// Returns true if we have a grenade equipped // Returns true if we have a grenade equipped
/* <3eab09> ../cstrike/dlls/bot/cs_bot_weapon.cpp:652 */ /* <3eab09> ../cstrike/dlls/bot/cs_bot_weapon.cpp:652 */
bool CCSBot::IsUsingGrenade(void) const bool CCSBot::IsUsingGrenade() const
{ {
CBasePlayerWeapon *weapon = GetActiveWeapon(); CBasePlayerWeapon *weapon = GetActiveWeapon();
@ -601,7 +601,7 @@ bool CCSBot::IsUsingGrenade(void) const
} }
/* <3eab3f> ../cstrike/dlls/bot/cs_bot_weapon.cpp:672 */ /* <3eab3f> ../cstrike/dlls/bot/cs_bot_weapon.cpp:672 */
bool CCSBot::IsUsingHEGrenade(void) const bool CCSBot::IsUsingHEGrenade() const
{ {
CBasePlayerWeapon *weapon = GetActiveWeapon(); CBasePlayerWeapon *weapon = GetActiveWeapon();
@ -674,7 +674,7 @@ bool CCSBot::FindGrenadeTossPathTarget(Vector *pos)
// check +X // check +X
check = visibleSpot + Vector(999.9f, 0, 0); check = visibleSpot + Vector(999.9f, 0, 0);
UTIL_TraceLine(visibleSpot, check, dont_ignore_monsters, ignore_glass, ENT(pev), &result); UTIL_TraceLine(visibleSpot, check, dont_ignore_monsters, ignore_glass, ENT(pev), &result);
if (result.flFraction < 1.0f) if (result.flFraction < 1.0f)
{ {
float range = result.vecEndPos.x - visibleSpot.x; float range = result.vecEndPos.x - visibleSpot.x;
@ -730,7 +730,7 @@ bool CCSBot::FindGrenadeTossPathTarget(Vector *pos)
// Reload our weapon if we must // Reload our weapon if we must
/* <3eaf22> ../cstrike/dlls/bot/cs_bot_weapon.cpp:810 */ /* <3eaf22> ../cstrike/dlls/bot/cs_bot_weapon.cpp:810 */
void CCSBot::ReloadCheck(void) void CCSBot::ReloadCheck()
{ {
const float safeReloadWaitTime = 3.0f; const float safeReloadWaitTime = 3.0f;
const float reloadAmmoRatio = 0.6f; const float reloadAmmoRatio = 0.6f;
@ -804,7 +804,7 @@ void CCSBot::ReloadCheck(void)
// Silence/unsilence our weapon if we must // Silence/unsilence our weapon if we must
/* <3eb0ac> ../cstrike/dlls/bot/cs_bot_weapon.cpp:885 */ /* <3eb0ac> ../cstrike/dlls/bot/cs_bot_weapon.cpp:885 */
void CCSBot::SilencerCheck(void) void CCSBot::SilencerCheck()
{ {
// longer than reload check because reloading should take precedence // longer than reload check because reloading should take precedence
const float safeSilencerWaitTime = 3.5f; const float safeSilencerWaitTime = 3.5f;
@ -838,7 +838,7 @@ void CCSBot::SilencerCheck(void)
return; return;
// equip silencer if we want to and we don't have a shield. // equip silencer if we want to and we don't have a shield.
if (isSilencerOn != (GetProfile()->PrefersSilencer() || GetProfile()->GetSkill() > 0.7f) && !HasShield()) if (isSilencerOn != (GetProfile()->PrefersSilencer() || GetProfile()->GetSkill() > 0.7f) && !HasShield())
#endif // REGAMEDLL_FIXES #endif // REGAMEDLL_FIXES
{ {
PrintIfWatched("%s silencer!\n", (isSilencerOn) ? "Unequipping" : "Equipping"); PrintIfWatched("%s silencer!\n", (isSilencerOn) ? "Unequipping" : "Equipping");
@ -898,7 +898,7 @@ void CCSBot::__MAKE_VHOOK(OnTouchingWeapon)(CWeaponBox *box)
// TODO: Check more rays for safety. // TODO: Check more rays for safety.
/* <3eb277> ../cstrike/dlls/bot/cs_bot_weapon.cpp:977 */ /* <3eb277> ../cstrike/dlls/bot/cs_bot_weapon.cpp:977 */
bool CCSBot::IsFriendInLineOfFire(void) bool CCSBot::IsFriendInLineOfFire()
{ {
UTIL_MakeVectors(pev->punchangle + pev->v_angle); UTIL_MakeVectors(pev->punchangle + pev->v_angle);
@ -930,7 +930,7 @@ bool CCSBot::IsFriendInLineOfFire(void)
// TODO: Re-use this computation with IsFriendInLineOfFire() // TODO: Re-use this computation with IsFriendInLineOfFire()
/* <3eb84d> ../cstrike/dlls/bot/cs_bot_weapon.cpp:1009 */ /* <3eb84d> ../cstrike/dlls/bot/cs_bot_weapon.cpp:1009 */
float CCSBot::ComputeWeaponSightRange(void) float CCSBot::ComputeWeaponSightRange()
{ {
UTIL_MakeVectors(pev->punchangle + pev->v_angle); UTIL_MakeVectors(pev->punchangle + pev->v_angle);
@ -944,12 +944,3 @@ float CCSBot::ComputeWeaponSightRange(void)
return (GetGunPosition() - result.vecEndPos).Length(); return (GetGunPosition() - result.vecEndPos).Length();
} }
#ifdef HOOK_GAMEDLL
void CCSBot::OnTouchingWeapon(CWeaponBox *box)
{
OnTouchingWeapon_(box);
}
#endif // HOOK_GAMEDLL

View File

@ -19,7 +19,7 @@ CSGameState::CSGameState(CCSBot *owner)
for (int i = 0; i < MAX_HOSTAGES; ++i) for (int i = 0; i < MAX_HOSTAGES; ++i)
{ {
HostageInfo *info = &m_hostage[i]; HostageInfo *info = &m_hostage[i];
info->hostage = NULL; info->hostage = NULL;
info->knownPos = Vector(0, 0, 0); info->knownPos = Vector(0, 0, 0);
info->isValid = false; info->isValid = false;
@ -31,7 +31,7 @@ CSGameState::CSGameState(CCSBot *owner)
// Reset at round start // Reset at round start
/* <3fd4f4> ../cstrike/dlls/bot/cs_gamestate.cpp:55 */ /* <3fd4f4> ../cstrike/dlls/bot/cs_gamestate.cpp:55 */
void CSGameState::Reset(void) void CSGameState::Reset()
{ {
int i; int i;
CCSBotManager *ctrl = TheCSBots(); CCSBotManager *ctrl = TheCSBots();
@ -105,7 +105,7 @@ void CSGameState::OnEvent(GameEventType event, CBaseEntity *entity, CBaseEntity
// True if round has been won or lost (but not yet reset) // True if round has been won or lost (but not yet reset)
/* <3fcf9c> ../cstrike/dlls/bot/cs_gamestate.cpp:144 */ /* <3fcf9c> ../cstrike/dlls/bot/cs_gamestate.cpp:144 */
bool CSGameState::IsRoundOver(void) const bool CSGameState::IsRoundOver() const
{ {
return m_isRoundOver; return m_isRoundOver;
} }
@ -131,13 +131,13 @@ void CSGameState::UpdateLooseBomb(const Vector *pos)
} }
/* <3fd06e> ../cstrike/dlls/bot/cs_gamestate.cpp:170 */ /* <3fd06e> ../cstrike/dlls/bot/cs_gamestate.cpp:170 */
float CSGameState::TimeSinceLastSawLooseBomb(void) const float CSGameState::TimeSinceLastSawLooseBomb() const
{ {
return m_lastSawLooseBomb.GetElapsedTime(); return m_lastSawLooseBomb.GetElapsedTime();
} }
/* <3fd0f4> ../cstrike/dlls/bot/cs_gamestate.cpp:176 */ /* <3fd0f4> ../cstrike/dlls/bot/cs_gamestate.cpp:176 */
bool CSGameState::IsLooseBombLocationKnown(void) const bool CSGameState::IsLooseBombLocationKnown() const
{ {
if (m_bombState != LOOSE) if (m_bombState != LOOSE)
return false; return false;
@ -156,13 +156,13 @@ void CSGameState::UpdateBomber(const Vector *pos)
} }
/* <3fd1b1> ../cstrike/dlls/bot/cs_gamestate.cpp:195 */ /* <3fd1b1> ../cstrike/dlls/bot/cs_gamestate.cpp:195 */
float CSGameState::TimeSinceLastSawBomber(void) const float CSGameState::TimeSinceLastSawBomber() const
{ {
return m_lastSawBomber.GetElapsedTime(); return m_lastSawBomber.GetElapsedTime();
} }
/* <3fd237> ../cstrike/dlls/bot/cs_gamestate.cpp:201 */ /* <3fd237> ../cstrike/dlls/bot/cs_gamestate.cpp:201 */
bool CSGameState::IsPlantedBombLocationKnown(void) const bool CSGameState::IsPlantedBombLocationKnown() const
{ {
if (m_bombState != PLANTED) if (m_bombState != PLANTED)
return false; return false;
@ -173,7 +173,7 @@ bool CSGameState::IsPlantedBombLocationKnown(void) const
// Return the zone index of the planted bombsite, or UNKNOWN // Return the zone index of the planted bombsite, or UNKNOWN
/* <3fd25a> ../cstrike/dlls/bot/cs_gamestate.cpp:213 */ /* <3fd25a> ../cstrike/dlls/bot/cs_gamestate.cpp:213 */
int CSGameState::GetPlantedBombsite(void) const int CSGameState::GetPlantedBombsite() const
{ {
if (m_bombState != PLANTED) if (m_bombState != PLANTED)
return UNKNOWN; return UNKNOWN;
@ -184,7 +184,7 @@ int CSGameState::GetPlantedBombsite(void) const
// Return true if we are currently in the bombsite where the bomb is planted // Return true if we are currently in the bombsite where the bomb is planted
/* <3fd284> ../cstrike/dlls/bot/cs_gamestate.cpp:225 */ /* <3fd284> ../cstrike/dlls/bot/cs_gamestate.cpp:225 */
bool CSGameState::IsAtPlantedBombsite(void) const bool CSGameState::IsAtPlantedBombsite() const
{ {
if (m_bombState != PLANTED) if (m_bombState != PLANTED)
return false; return false;
@ -203,7 +203,7 @@ bool CSGameState::IsAtPlantedBombsite(void) const
// Return the zone index of the next bombsite to search // Return the zone index of the next bombsite to search
/* <3fd2d2> ../cstrike/dlls/bot/cs_gamestate.cpp:246 */ /* <3fd2d2> ../cstrike/dlls/bot/cs_gamestate.cpp:246 */
int CSGameState::GetNextBombsiteToSearch(void) int CSGameState::GetNextBombsiteToSearch()
{ {
if (m_bombsiteCount <= 0) if (m_bombsiteCount <= 0)
return 0; return 0;
@ -234,7 +234,7 @@ int CSGameState::GetNextBombsiteToSearch(void)
// or NULL if we don't know where the bomb is // or NULL if we don't know where the bomb is
/* <3fd32c> ../cstrike/dlls/bot/cs_gamestate.cpp:277 */ /* <3fd32c> ../cstrike/dlls/bot/cs_gamestate.cpp:277 */
const Vector *CSGameState::GetBombPosition(void) const const Vector *CSGameState::GetBombPosition() const
{ {
switch (m_bombState) switch (m_bombState)
{ {
@ -315,7 +315,7 @@ bool CSGameState::IsBombsiteClear(int zoneIndex) const
} }
/* <3fd4b0> ../cstrike/dlls/bot/cs_gamestate.cpp:367 */ /* <3fd4b0> ../cstrike/dlls/bot/cs_gamestate.cpp:367 */
void CSGameState::InitializeHostageInfo(void) void CSGameState::InitializeHostageInfo()
{ {
m_hostageCount = 0; m_hostageCount = 0;
m_allHostagesRescued = 0; m_allHostagesRescued = 0;
@ -340,7 +340,7 @@ void CSGameState::InitializeHostageInfo(void)
} }
// Return the closest free and live hostage // Return the closest free and live hostage
// If we are a CT this information is perfect. // If we are a CT this information is perfect.
// Otherwise, this is based on our individual memory of the game state. // Otherwise, this is based on our individual memory of the game state.
// If NULL is returned, we don't think there are any hostages left, or we dont know where they are. // If NULL is returned, we don't think there are any hostages left, or we dont know where they are.
// NOTE: a T can remember a hostage who has died. knowPos will be filled in, but NULL will be // NOTE: a T can remember a hostage who has died. knowPos will be filled in, but NULL will be
@ -414,7 +414,7 @@ CHostage *CSGameState::GetNearestFreeHostage(Vector *knowPos) const
// Return the location of a "free" hostage, or NULL if we dont know of any // Return the location of a "free" hostage, or NULL if we dont know of any
/* <3fdbd3> ../cstrike/dlls/bot/cs_gamestate.cpp:461 */ /* <3fdbd3> ../cstrike/dlls/bot/cs_gamestate.cpp:461 */
const Vector *CSGameState::GetRandomFreeHostagePosition(void) const Vector *CSGameState::GetRandomFreeHostagePosition()
{ {
// TODO: use static? // TODO: use static?
const Vector *freePos[MAX_HOSTAGES]; const Vector *freePos[MAX_HOSTAGES];
@ -462,12 +462,12 @@ const Vector *CSGameState::GetRandomFreeHostagePosition(void)
// Return status of any changes (a hostage died or was moved) // Return status of any changes (a hostage died or was moved)
/* <3fdcd2> ../cstrike/dlls/bot/cs_gamestate.cpp:509 */ /* <3fdcd2> ../cstrike/dlls/bot/cs_gamestate.cpp:509 */
CSGameState::ValidateStatusType CSGameState::ValidateHostagePositions(void) CSGameState::ValidateStatusType CSGameState::ValidateHostagePositions()
{ {
// limit how often we validate // limit how often we validate
if (!m_validateInterval.IsElapsed()) if (!m_validateInterval.IsElapsed())
return NO_CHANGE; return NO_CHANGE;
const float validateInterval = 0.5f; const float validateInterval = 0.5f;
m_validateInterval.Start(validateInterval); m_validateInterval.Start(validateInterval);
@ -580,14 +580,14 @@ CSGameState::ValidateStatusType CSGameState::ValidateHostagePositions(void)
// Since we can actually see any hostage we return, we know its actual position // Since we can actually see any hostage we return, we know its actual position
/* <3fdef7> ../cstrike/dlls/bot/cs_gamestate.cpp:626 */ /* <3fdef7> ../cstrike/dlls/bot/cs_gamestate.cpp:626 */
CHostage *CSGameState::GetNearestVisibleFreeHostage(void) const CHostage *CSGameState::GetNearestVisibleFreeHostage() const
{ {
CHostage *close = NULL; CHostage *close = NULL;
float closeRangeSq = 999999999.9f; float closeRangeSq = 999999999.9f;
float rangeSq; float rangeSq;
Vector pos; Vector pos;
for (int i = 0; i < m_hostageCount; ++i) for (int i = 0; i < m_hostageCount; ++i)
{ {
const HostageInfo *info = &m_hostage[i]; const HostageInfo *info = &m_hostage[i];
@ -623,7 +623,7 @@ CHostage *CSGameState::GetNearestVisibleFreeHostage(void) const
// Return true if there are no free hostages // Return true if there are no free hostages
/* <3fe064> ../cstrike/dlls/bot/cs_gamestate.cpp:668 */ /* <3fe064> ../cstrike/dlls/bot/cs_gamestate.cpp:668 */
bool CSGameState::AreAllHostagesBeingRescued(void) const bool CSGameState::AreAllHostagesBeingRescued() const
{ {
// if the hostages have all been rescued, they are not being rescued any longer // if the hostages have all been rescued, they are not being rescued any longer
if (m_allHostagesRescued) if (m_allHostagesRescued)
@ -666,7 +666,7 @@ bool CSGameState::AreAllHostagesBeingRescued(void) const
// All hostages have been rescued or are dead // All hostages have been rescued or are dead
/* <3fe148> ../cstrike/dlls/bot/cs_gamestate.cpp:712 */ /* <3fe148> ../cstrike/dlls/bot/cs_gamestate.cpp:712 */
bool CSGameState::AreAllHostagesGone(void) const bool CSGameState::AreAllHostagesGone() const
{ {
if (m_allHostagesRescued) if (m_allHostagesRescued)
return true; return true;
@ -695,7 +695,7 @@ bool CSGameState::AreAllHostagesGone(void) const
// Someone told us all the hostages are gone // Someone told us all the hostages are gone
/* <3fe1a2> ../cstrike/dlls/bot/cs_gamestate.cpp:742 */ /* <3fe1a2> ../cstrike/dlls/bot/cs_gamestate.cpp:742 */
void CSGameState::AllHostagesGone(void) void CSGameState::AllHostagesGone()
{ {
for (int i = 0; i < m_hostageCount; ++i) for (int i = 0; i < m_hostageCount; ++i)
m_hostage[i].isValid = false; m_hostage[i].isValid = false;

View File

@ -41,9 +41,9 @@ public:
CSGameState() {}; CSGameState() {};
CSGameState(CCSBot *owner); CSGameState(CCSBot *owner);
void Reset(void); void Reset();
void OnEvent(GameEventType event, CBaseEntity *entity, CBaseEntity *other); // Event handling void OnEvent(GameEventType event, CBaseEntity *entity, CBaseEntity *other); // Event handling
bool IsRoundOver(void) const; // true if round has been won or lost (but not yet reset) bool IsRoundOver() const; // true if round has been won or lost (but not yet reset)
// bomb defuse scenario // bomb defuse scenario
enum BombState enum BombState
@ -55,43 +55,43 @@ public:
EXPLODED, // the bomb has exploded EXPLODED, // the bomb has exploded
}; };
bool IsBombMoving(void) const { return (m_bombState == MOVING); } bool IsBombMoving() const { return (m_bombState == MOVING); }
bool IsBombLoose(void) const { return (m_bombState == LOOSE); } bool IsBombLoose() const { return (m_bombState == LOOSE); }
bool IsBombPlanted(void) const { return (m_bombState == PLANTED); } bool IsBombPlanted() const { return (m_bombState == PLANTED); }
bool IsBombDefused(void) const { return (m_bombState == DEFUSED); } bool IsBombDefused() const { return (m_bombState == DEFUSED); }
bool IsBombExploded(void) const { return (m_bombState == EXPLODED); } bool IsBombExploded() const { return (m_bombState == EXPLODED); }
void UpdateLooseBomb(const Vector *pos); // we see the loose bomb void UpdateLooseBomb(const Vector *pos); // we see the loose bomb
float TimeSinceLastSawLooseBomb(void) const; // how long has is been since we saw the loose bomb float TimeSinceLastSawLooseBomb() const; // how long has is been since we saw the loose bomb
bool IsLooseBombLocationKnown(void) const; // do we know where the loose bomb is bool IsLooseBombLocationKnown() const; // do we know where the loose bomb is
void UpdateBomber(const Vector *pos); // we see the bomber void UpdateBomber(const Vector *pos); // we see the bomber
float TimeSinceLastSawBomber(void) const; // how long has is been since we saw the bomber float TimeSinceLastSawBomber() const; // how long has is been since we saw the bomber
void UpdatePlantedBomb(const Vector *pos); // we see the planted bomb void UpdatePlantedBomb(const Vector *pos); // we see the planted bomb
bool IsPlantedBombLocationKnown(void) const; // do we know where the bomb was planted bool IsPlantedBombLocationKnown() const; // do we know where the bomb was planted
void MarkBombsiteAsPlanted(int zoneIndex); // mark bombsite as the location of the planted bomb void MarkBombsiteAsPlanted(int zoneIndex); // mark bombsite as the location of the planted bomb
enum { UNKNOWN = -1 }; enum { UNKNOWN = -1 };
int GetPlantedBombsite(void) const; // return the zone index of the planted bombsite, or UNKNOWN int GetPlantedBombsite() const; // return the zone index of the planted bombsite, or UNKNOWN
bool IsAtPlantedBombsite(void) const; // return true if we are currently in the bombsite where the bomb is planted bool IsAtPlantedBombsite() const; // return true if we are currently in the bombsite where the bomb is planted
int GetNextBombsiteToSearch(void); // return the zone index of the next bombsite to search int GetNextBombsiteToSearch(); // return the zone index of the next bombsite to search
bool IsBombsiteClear(int zoneIndex) const; // return true if given bombsite has been cleared bool IsBombsiteClear(int zoneIndex) const; // return true if given bombsite has been cleared
void ClearBombsite(int zoneIndex); // mark bombsite as clear void ClearBombsite(int zoneIndex); // mark bombsite as clear
const Vector *GetBombPosition(void) const; // return where we think the bomb is, or NULL if we don't know const Vector *GetBombPosition() const; // return where we think the bomb is, or NULL if we don't know
// hostage rescue scenario // hostage rescue scenario
CHostage *GetNearestFreeHostage(Vector *knowPos = NULL) const; // return the closest free hostage, and where we think it is (knowPos) CHostage *GetNearestFreeHostage(Vector *knowPos = NULL) const; // return the closest free hostage, and where we think it is (knowPos)
const Vector *GetRandomFreeHostagePosition(void); const Vector *GetRandomFreeHostagePosition();
bool AreAllHostagesBeingRescued(void) const; // return true if there are no free hostages bool AreAllHostagesBeingRescued() const; // return true if there are no free hostages
bool AreAllHostagesGone(void) const; // all hostages have been rescued or are dead bool AreAllHostagesGone() const; // all hostages have been rescued or are dead
void AllHostagesGone(void); // someone told us all the hostages are gone void AllHostagesGone(); // someone told us all the hostages are gone
bool HaveSomeHostagesBeenTaken(void) const { return m_haveSomeHostagesBeenTaken; } // return true if one or more hostages have been moved by the CT's bool HaveSomeHostagesBeenTaken() const { return m_haveSomeHostagesBeenTaken; } // return true if one or more hostages have been moved by the CT's
void HostageWasTaken(void) { m_haveSomeHostagesBeenTaken = true; } // someone told us a CT is talking to a hostage void HostageWasTaken() { m_haveSomeHostagesBeenTaken = true; } // someone told us a CT is talking to a hostage
CHostage *GetNearestVisibleFreeHostage(void) const; CHostage *GetNearestVisibleFreeHostage() const;
// hostage rescue scenario // hostage rescue scenario
enum ValidateStatusType:uint8 enum ValidateStatusType:uint8
@ -101,7 +101,7 @@ public:
HOSTAGE_GONE = 0x02, HOSTAGE_GONE = 0x02,
HOSTAGES_ALL_GONE = 0x04 HOSTAGES_ALL_GONE = 0x04
}; };
ValidateStatusType ValidateHostagePositions(void); // update our knowledge with what we currently see - returns bitflag events ValidateStatusType ValidateHostagePositions(); // update our knowledge with what we currently see - returns bitflag events
#ifndef HOOK_GAMEDLL #ifndef HOOK_GAMEDLL
private: private:
@ -112,7 +112,7 @@ private:
// bomb defuse scenario // bomb defuse scenario
void SetBombState(BombState state); void SetBombState(BombState state);
BombState GetBombState(void) { return m_bombState; } BombState GetBombState() { return m_bombState; }
BombState m_bombState; // what we think the bomb is doing BombState m_bombState; // what we think the bomb is doing
@ -144,12 +144,11 @@ private:
m_hostage[ MAX_HOSTAGES ]; m_hostage[ MAX_HOSTAGES ];
int m_hostageCount; // number of hostages left in map int m_hostageCount; // number of hostages left in map
CountdownTimer m_validateInterval; CountdownTimer m_validateInterval;
NOXREF CBaseEntity *GetNearestHostage(void) const; // return the closest live hostage NOXREF CBaseEntity *GetNearestHostage() const; // return the closest live hostage
void InitializeHostageInfo(void); // initialize our knowledge of the number and location of hostages void InitializeHostageInfo(); // initialize our knowledge of the number and location of hostages
bool m_allHostagesRescued; // if true, so every hostages been is rescued bool m_allHostagesRescued; // if true, so every hostages been is rescued
bool m_haveSomeHostagesBeenTaken; // true if a hostage has been moved by a CT (and we've seen it) bool m_haveSomeHostagesBeenTaken; // true if a hostage has been moved by a CT (and we've seen it)
};
};/* size: 348, cachelines: 6, members: 19 */
#endif // CS_GAMESTATE_H #endif // CS_GAMESTATE_H

View File

@ -132,410 +132,410 @@ void AttackState::StopAttacking(CCSBot *me)
/* <51997e> ../cstrike/dlls/bot/states/cs_bot_attack.cpp:152 */ /* <51997e> ../cstrike/dlls/bot/states/cs_bot_attack.cpp:152 */
void AttackState::__MAKE_VHOOK(OnUpdate)(CCSBot *me) void AttackState::__MAKE_VHOOK(OnUpdate)(CCSBot *me)
{ {
// can't be stuck while attacking // can't be stuck while attacking
me->ResetStuckMonitor(); me->ResetStuckMonitor();
me->StopRapidFire(); me->StopRapidFire();
CBasePlayerWeapon *weapon = me->GetActiveWeapon(); CBasePlayerWeapon *weapon = me->GetActiveWeapon();
if (weapon != NULL) if (weapon != NULL)
{ {
if (weapon->m_iId == WEAPON_C4 || if (weapon->m_iId == WEAPON_C4 ||
weapon->m_iId == WEAPON_HEGRENADE || weapon->m_iId == WEAPON_HEGRENADE ||
weapon->m_iId == WEAPON_FLASHBANG || weapon->m_iId == WEAPON_FLASHBANG ||
weapon->m_iId == WEAPON_SMOKEGRENADE) weapon->m_iId == WEAPON_SMOKEGRENADE)
{ {
me->EquipBestWeapon(); me->EquipBestWeapon();
} }
} }
CBasePlayer *enemy = me->GetEnemy(); CBasePlayer *enemy = me->GetEnemy();
if (enemy == NULL) if (enemy == NULL)
{ {
StopAttacking(me); StopAttacking(me);
return; return;
} }
// keep track of whether we have seen our enemy at least once yet // keep track of whether we have seen our enemy at least once yet
if (!m_haveSeenEnemy) if (!m_haveSeenEnemy)
m_haveSeenEnemy = me->IsEnemyVisible(); m_haveSeenEnemy = me->IsEnemyVisible();
// Retreat check // Retreat check
// Do not retreat if the enemy is too close // Do not retreat if the enemy is too close
if (m_retreatTimer.IsElapsed()) if (m_retreatTimer.IsElapsed())
{ {
// If we've been fighting this battle for awhile, we're "pinned down" and // If we've been fighting this battle for awhile, we're "pinned down" and
// need to do something else. // need to do something else.
// If we are outnumbered, retreat. // If we are outnumbered, retreat.
bool isPinnedDown = (gpGlobals->time > m_pinnedDownTimestamp); bool isPinnedDown = (gpGlobals->time > m_pinnedDownTimestamp);
if (isPinnedDown || if (isPinnedDown ||
(me->IsOutnumbered() && m_isCoward) || (me->IsOutnumbered() && m_isCoward) ||
(me->OutnumberedCount() >= 2 && me->GetProfile()->GetAggression() < 1.0f)) (me->OutnumberedCount() >= 2 && me->GetProfile()->GetAggression() < 1.0f))
{ {
// tell our teammates our plight // tell our teammates our plight
if (isPinnedDown) if (isPinnedDown)
me->GetChatter()->PinnedDown(); me->GetChatter()->PinnedDown();
else else
me->GetChatter()->Scared(); me->GetChatter()->Scared();
m_retreatTimer.Start(RANDOM_FLOAT(3.0f, 15.0f)); m_retreatTimer.Start(RANDOM_FLOAT(3.0f, 15.0f));
// try to retreat // try to retreat
if (me->TryToRetreat()) if (me->TryToRetreat())
{ {
// if we are a sniper, equip our pistol so we can fire while retreating // if we are a sniper, equip our pistol so we can fire while retreating
if (me->IsUsingSniperRifle()) if (me->IsUsingSniperRifle())
{ {
me->EquipPistol(); me->EquipPistol();
} }
} }
else else
{ {
me->PrintIfWatched("I want to retreat, but no safe spots nearby!\n"); me->PrintIfWatched("I want to retreat, but no safe spots nearby!\n");
} }
} }
} }
// Knife fighting // Knife fighting
// We need to pathfind right to the enemy to cut him // We need to pathfind right to the enemy to cut him
if (me->IsUsingKnife()) if (me->IsUsingKnife())
{ {
// can't crouch and hold with a knife // can't crouch and hold with a knife
m_crouchAndHold = false; m_crouchAndHold = false;
me->StandUp(); me->StandUp();
// if we are using a knife and our prey is looking towards us, run at him // if we are using a knife and our prey is looking towards us, run at him
if (me->IsPlayerFacingMe(enemy)) if (me->IsPlayerFacingMe(enemy))
{ {
me->ForceRun(5.0f); me->ForceRun(5.0f);
me->Hurry(10.0f); me->Hurry(10.0f);
} }
else else
{ {
me->Walk(); me->Walk();
} }
// slash our victim // slash our victim
me->FireWeaponAtEnemy(); me->FireWeaponAtEnemy();
// if our victim has moved, repath // if our victim has moved, repath
bool repath = false; bool repath = false;
if (me->HasPath()) if (me->HasPath())
{ {
const float repathRange = 100.0f; const float repathRange = 100.0f;
if ((me->GetPathEndpoint() - enemy->pev->origin).IsLengthGreaterThan(repathRange)) if ((me->GetPathEndpoint() - enemy->pev->origin).IsLengthGreaterThan(repathRange))
{ {
repath = true; repath = true;
} }
} }
else else
{ {
repath = true; repath = true;
} }
if (repath && m_repathTimer.IsElapsed()) if (repath && m_repathTimer.IsElapsed())
{ {
me->ComputePath(TheNavAreaGrid.GetNearestNavArea(&enemy->pev->origin), &enemy->pev->origin, FASTEST_ROUTE); me->ComputePath(TheNavAreaGrid.GetNearestNavArea(&enemy->pev->origin), &enemy->pev->origin, FASTEST_ROUTE);
const float repathInterval = 0.5f; const float repathInterval = 0.5f;
m_repathTimer.Start(repathInterval); m_repathTimer.Start(repathInterval);
} }
// move towards victim // move towards victim
if (me->UpdatePathMovement(NO_SPEED_CHANGE) != CCSBot::PROGRESSING) if (me->UpdatePathMovement(NO_SPEED_CHANGE) != CCSBot::PROGRESSING)
{ {
me->DestroyPath(); me->DestroyPath();
} }
return; return;
} }
// Simple shield usage // Simple shield usage
if (me->HasShield()) if (me->HasShield())
{ {
if (me->IsEnemyVisible() && !m_shieldForceOpen) if (me->IsEnemyVisible() && !m_shieldForceOpen)
{ {
if (!me->IsRecognizedEnemyReloading() && !me->IsReloading() && me->IsPlayerLookingAtMe(enemy)) if (!me->IsRecognizedEnemyReloading() && !me->IsReloading() && me->IsPlayerLookingAtMe(enemy))
{ {
// close up - enemy is pointing his gun at us // close up - enemy is pointing his gun at us
if (!me->IsProtectedByShield()) if (!me->IsProtectedByShield())
me->SecondaryAttack(); me->SecondaryAttack();
} }
else else
{ {
// enemy looking away or reloading his weapon - open up and shoot him // enemy looking away or reloading his weapon - open up and shoot him
if (me->IsProtectedByShield()) if (me->IsProtectedByShield())
me->SecondaryAttack(); me->SecondaryAttack();
} }
} }
else else
{ {
// can't see enemy, open up // can't see enemy, open up
if (me->IsProtectedByShield()) if (me->IsProtectedByShield())
me->SecondaryAttack(); me->SecondaryAttack();
} }
if (gpGlobals->time > m_shieldToggleTimestamp) if (gpGlobals->time > m_shieldToggleTimestamp)
{ {
m_shieldToggleTimestamp = gpGlobals->time + RANDOM_FLOAT(0.5, 2.0f); m_shieldToggleTimestamp = gpGlobals->time + RANDOM_FLOAT(0.5, 2.0f);
// toggle shield force open // toggle shield force open
m_shieldForceOpen = !m_shieldForceOpen; m_shieldForceOpen = !m_shieldForceOpen;
} }
} }
// check if our weapon range is bad and we should switch to pistol // check if our weapon range is bad and we should switch to pistol
if (me->IsUsingSniperRifle()) if (me->IsUsingSniperRifle())
{ {
// if we have a sniper rifle and our enemy is too close, switch to pistol // if we have a sniper rifle and our enemy is too close, switch to pistol
// NOTE: Must be larger than NO_ZOOM range in AdjustZoom() // NOTE: Must be larger than NO_ZOOM range in AdjustZoom()
const float sniperMinRange = 310.0f; const float sniperMinRange = 310.0f;
if ((enemy->pev->origin - me->pev->origin).IsLengthLessThan(sniperMinRange)) if ((enemy->pev->origin - me->pev->origin).IsLengthLessThan(sniperMinRange))
me->EquipPistol(); me->EquipPistol();
} }
else if (me->IsUsingShotgun()) else if (me->IsUsingShotgun())
{ {
// if we have a shotgun equipped and enemy is too far away, switch to pistol // if we have a shotgun equipped and enemy is too far away, switch to pistol
const float shotgunMaxRange = 1000.0f; const float shotgunMaxRange = 1000.0f;
if ((enemy->pev->origin - me->pev->origin).IsLengthGreaterThan(shotgunMaxRange)) if ((enemy->pev->origin - me->pev->origin).IsLengthGreaterThan(shotgunMaxRange))
me->EquipPistol(); me->EquipPistol();
} }
// if we're sniping, look through the scope - need to do this here in case a reload resets our scope // if we're sniping, look through the scope - need to do this here in case a reload resets our scope
if (me->IsUsingSniperRifle()) if (me->IsUsingSniperRifle())
{ {
// for Scouts and AWPs, we need to wait for zoom to resume // for Scouts and AWPs, we need to wait for zoom to resume
if (me->m_bResumeZoom) if (me->m_bResumeZoom)
{ {
m_scopeTimestamp = gpGlobals->time; m_scopeTimestamp = gpGlobals->time;
return; return;
} }
Vector toAimSpot3D = me->m_aimSpot - me->pev->origin; Vector toAimSpot3D = me->m_aimSpot - me->pev->origin;
float targetRange = toAimSpot3D.Length(); float targetRange = toAimSpot3D.Length();
// dont adjust zoom level if we're already zoomed in - just fire // dont adjust zoom level if we're already zoomed in - just fire
if (me->GetZoomLevel() == CCSBot::NO_ZOOM && me->AdjustZoom(targetRange)) if (me->GetZoomLevel() == CCSBot::NO_ZOOM && me->AdjustZoom(targetRange))
m_scopeTimestamp = gpGlobals->time; m_scopeTimestamp = gpGlobals->time;
const float waitScopeTime = 0.2f + me->GetProfile()->GetReactionTime(); const float waitScopeTime = 0.2f + me->GetProfile()->GetReactionTime();
if (gpGlobals->time - m_scopeTimestamp < waitScopeTime) if (gpGlobals->time - m_scopeTimestamp < waitScopeTime)
{ {
// force us to wait until zoomed in before firing // force us to wait until zoomed in before firing
return; return;
} }
} }
// see if we "notice" that our prey is dead // see if we "notice" that our prey is dead
if (me->IsAwareOfEnemyDeath()) if (me->IsAwareOfEnemyDeath())
{ {
// let team know if we killed the last enemy // let team know if we killed the last enemy
if (me->GetLastVictimID() == enemy->entindex() && me->GetNearbyEnemyCount() <= 1) if (me->GetLastVictimID() == enemy->entindex() && me->GetNearbyEnemyCount() <= 1)
{ {
me->GetChatter()->KilledMyEnemy(enemy->entindex()); me->GetChatter()->KilledMyEnemy(enemy->entindex());
} }
StopAttacking(me); StopAttacking(me);
return; return;
} }
float notSeenEnemyTime = gpGlobals->time - me->GetLastSawEnemyTimestamp(); float notSeenEnemyTime = gpGlobals->time - me->GetLastSawEnemyTimestamp();
// if we haven't seen our enemy for a moment, continue on if we dont want to fight, or decide to ambush if we do // if we haven't seen our enemy for a moment, continue on if we dont want to fight, or decide to ambush if we do
if (!me->IsEnemyVisible()) if (!me->IsEnemyVisible())
{ {
// attend to nearby enemy gunfire // attend to nearby enemy gunfire
if (notSeenEnemyTime > 0.5f && me->CanHearNearbyEnemyGunfire()) if (notSeenEnemyTime > 0.5f && me->CanHearNearbyEnemyGunfire())
{ {
// give up the attack, since we didn't want it in the first place // give up the attack, since we didn't want it in the first place
StopAttacking(me); StopAttacking(me);
me->SetLookAt("Nearby enemy gunfire", me->GetNoisePosition(), PRIORITY_HIGH, 0.0f); me->SetLookAt("Nearby enemy gunfire", me->GetNoisePosition(), PRIORITY_HIGH, 0.0f);
me->PrintIfWatched("Checking nearby threatening enemy gunfire!\n"); me->PrintIfWatched("Checking nearby threatening enemy gunfire!\n");
return; return;
} }
// check if we have lost track of our enemy during combat // check if we have lost track of our enemy during combat
if (notSeenEnemyTime > 0.25f) if (notSeenEnemyTime > 0.25f)
{ {
m_isEnemyHidden = true; m_isEnemyHidden = true;
} }
if (notSeenEnemyTime > 0.1f) if (notSeenEnemyTime > 0.1f)
{ {
if (me->GetDisposition() == CCSBot::ENGAGE_AND_INVESTIGATE) if (me->GetDisposition() == CCSBot::ENGAGE_AND_INVESTIGATE)
{ {
// decide whether we should hide and "ambush" our enemy // decide whether we should hide and "ambush" our enemy
if (m_haveSeenEnemy && !m_didAmbushCheck) if (m_haveSeenEnemy && !m_didAmbushCheck)
{ {
const float hideChance = 33.3f; const float hideChance = 33.3f;
if (RANDOM_FLOAT(0.0, 100.0f) < hideChance) if (RANDOM_FLOAT(0.0, 100.0f) < hideChance)
{ {
float ambushTime = RANDOM_FLOAT(3.0f, 15.0f); float ambushTime = RANDOM_FLOAT(3.0f, 15.0f);
// hide in ambush nearby // hide in ambush nearby
// TODO: look towards where we know enemy is // TODO: look towards where we know enemy is
const Vector *spot = FindNearbyRetreatSpot(me, 200.0f); const Vector *spot = FindNearbyRetreatSpot(me, 200.0f);
if (spot != NULL) if (spot != NULL)
{ {
me->IgnoreEnemies(1.0f); me->IgnoreEnemies(1.0f);
me->Run(); me->Run();
me->StandUp(); me->StandUp();
me->Hide(spot, ambushTime, true); me->Hide(spot, ambushTime, true);
return; return;
} }
} }
// don't check again // don't check again
m_didAmbushCheck = true; m_didAmbushCheck = true;
} }
} }
else else
{ {
// give up the attack, since we didn't want it in the first place // give up the attack, since we didn't want it in the first place
StopAttacking(me); StopAttacking(me);
return; return;
} }
} }
} }
else else
{ {
// we can see the enemy again - reset our ambush check // we can see the enemy again - reset our ambush check
m_didAmbushCheck = false; m_didAmbushCheck = false;
// if the enemy is coming out of hiding, we need time to react // if the enemy is coming out of hiding, we need time to react
if (m_isEnemyHidden) if (m_isEnemyHidden)
{ {
m_reacquireTimestamp = gpGlobals->time + me->GetProfile()->GetReactionTime(); m_reacquireTimestamp = gpGlobals->time + me->GetProfile()->GetReactionTime();
m_isEnemyHidden = false; m_isEnemyHidden = false;
} }
} }
// if we haven't seen our enemy for a long time, chase after them // if we haven't seen our enemy for a long time, chase after them
float chaseTime = 2.0f + 2.0f * (1.0f - me->GetProfile()->GetAggression()); float chaseTime = 2.0f + 2.0f * (1.0f - me->GetProfile()->GetAggression());
// if we are sniping, be very patient // if we are sniping, be very patient
if (me->IsUsingSniperRifle()) if (me->IsUsingSniperRifle())
chaseTime += 3.0f; chaseTime += 3.0f;
// if we are crouching, be a little patient // if we are crouching, be a little patient
else if (me->IsCrouching()) else if (me->IsCrouching())
chaseTime += 1.0f; chaseTime += 1.0f;
// if we can't see the enemy, and have either seen him but currently lost sight of him, // if we can't see the enemy, and have either seen him but currently lost sight of him,
// or haven't yet seen him, chase after him (unless we are a sniper) // or haven't yet seen him, chase after him (unless we are a sniper)
if (!me->IsEnemyVisible() && (notSeenEnemyTime > chaseTime || !m_haveSeenEnemy)) if (!me->IsEnemyVisible() && (notSeenEnemyTime > chaseTime || !m_haveSeenEnemy))
{ {
// snipers don't chase their prey - they wait for their prey to come to them // snipers don't chase their prey - they wait for their prey to come to them
if (me->GetTask() == CCSBot::SNIPING) if (me->GetTask() == CCSBot::SNIPING)
{ {
StopAttacking(me); StopAttacking(me);
return; return;
} }
else else
{ {
// move to last known position of enemy // move to last known position of enemy
me->SetTask(CCSBot::MOVE_TO_LAST_KNOWN_ENEMY_POSITION, enemy); me->SetTask(CCSBot::MOVE_TO_LAST_KNOWN_ENEMY_POSITION, enemy);
me->MoveTo(&me->GetLastKnownEnemyPosition()); me->MoveTo(&me->GetLastKnownEnemyPosition());
return; return;
} }
} }
// if we can't see our enemy at the moment, and were shot by // if we can't see our enemy at the moment, and were shot by
// a different visible enemy, engage them instead // a different visible enemy, engage them instead
const float hurtRecentlyTime = 3.0f; const float hurtRecentlyTime = 3.0f;
if (!me->IsEnemyVisible() && if (!me->IsEnemyVisible() &&
me->GetTimeSinceAttacked() < hurtRecentlyTime && me->GetTimeSinceAttacked() < hurtRecentlyTime &&
me->GetAttacker() != NULL && me->GetAttacker() != NULL &&
me->GetAttacker() != me->GetEnemy()) me->GetAttacker() != me->GetEnemy())
{ {
// if we can see them, attack, otherwise panic // if we can see them, attack, otherwise panic
if (me->IsVisible(me->GetAttacker(), CHECK_FOV)) if (me->IsVisible(me->GetAttacker(), CHECK_FOV))
{ {
me->Attack(me->GetAttacker()); me->Attack(me->GetAttacker());
me->PrintIfWatched("Switching targets to retaliate against new attacker!\n"); me->PrintIfWatched("Switching targets to retaliate against new attacker!\n");
} }
return; return;
} }
if (gpGlobals->time > m_reacquireTimestamp) if (gpGlobals->time > m_reacquireTimestamp)
me->FireWeaponAtEnemy(); me->FireWeaponAtEnemy();
// do dodge behavior // do dodge behavior
// If sniping or crouching, stand still. // If sniping or crouching, stand still.
if (m_dodge && !me->IsUsingSniperRifle() && !m_crouchAndHold) if (m_dodge && !me->IsUsingSniperRifle() && !m_crouchAndHold)
{ {
Vector toEnemy = enemy->pev->origin - me->pev->origin; Vector toEnemy = enemy->pev->origin - me->pev->origin;
float range = toEnemy.Length2D(); float range = toEnemy.Length2D();
const float hysterisRange = 125.0f; // (+/-) m_combatRange const float hysterisRange = 125.0f; // (+/-) m_combatRange
float minRange = me->GetCombatRange() - hysterisRange; float minRange = me->GetCombatRange() - hysterisRange;
float maxRange = me->GetCombatRange() + hysterisRange; float maxRange = me->GetCombatRange() + hysterisRange;
// move towards (or away from) enemy if we are using a knife, behind a corner, or we aren't very skilled // move towards (or away from) enemy if we are using a knife, behind a corner, or we aren't very skilled
if (me->GetProfile()->GetSkill() < 0.66f || !me->IsEnemyVisible()) if (me->GetProfile()->GetSkill() < 0.66f || !me->IsEnemyVisible())
{ {
if (range > maxRange) if (range > maxRange)
me->MoveForward(); me->MoveForward();
else if (range < minRange) else if (range < minRange)
me->MoveBackward(); me->MoveBackward();
} }
// don't dodge if enemy is facing away // don't dodge if enemy is facing away
const float dodgeRange = 2000.0f; const float dodgeRange = 2000.0f;
if (range > dodgeRange || !me->IsPlayerFacingMe(enemy)) if (range > dodgeRange || !me->IsPlayerFacingMe(enemy))
{ {
m_dodgeState = STEADY_ON; m_dodgeState = STEADY_ON;
m_nextDodgeStateTimestamp = 0.0f; m_nextDodgeStateTimestamp = 0.0f;
} }
else if (gpGlobals->time >= m_nextDodgeStateTimestamp) else if (gpGlobals->time >= m_nextDodgeStateTimestamp)
{ {
int next; int next;
// select next dodge state that is different that our current one // select next dodge state that is different that our current one
do do
{ {
// high-skill bots may jump when first engaging the enemy (if they are moving) // high-skill bots may jump when first engaging the enemy (if they are moving)
const float jumpChance = 33.3f; const float jumpChance = 33.3f;
if (m_firstDodge && me->GetProfile()->GetSkill() > 0.5f && RANDOM_FLOAT(0, 100) < jumpChance && !me->IsNotMoving()) if (m_firstDodge && me->GetProfile()->GetSkill() > 0.5f && RANDOM_FLOAT(0, 100) < jumpChance && !me->IsNotMoving())
next = RANDOM_LONG(0, NUM_ATTACK_STATES - 1); next = RANDOM_LONG(0, NUM_ATTACK_STATES - 1);
else else
next = RANDOM_LONG(0, NUM_ATTACK_STATES - 2); next = RANDOM_LONG(0, NUM_ATTACK_STATES - 2);
} }
while (!m_firstDodge && next == m_dodgeState); while (!m_firstDodge && next == m_dodgeState);
m_dodgeState = (DodgeStateType)next; m_dodgeState = (DodgeStateType)next;
m_nextDodgeStateTimestamp = gpGlobals->time + RANDOM_FLOAT(0.3f, 1.0f); m_nextDodgeStateTimestamp = gpGlobals->time + RANDOM_FLOAT(0.3f, 1.0f);
m_firstDodge = false; m_firstDodge = false;
} }
switch (m_dodgeState) switch (m_dodgeState)
{ {
case STEADY_ON: case STEADY_ON:
{ {
break; break;
} }
case SLIDE_LEFT: case SLIDE_LEFT:
{ {
me->StrafeLeft(); me->StrafeLeft();
break; break;
} }
case SLIDE_RIGHT: case SLIDE_RIGHT:
{ {
me->StrafeRight(); me->StrafeRight();
break; break;
} }
case JUMP: case JUMP:
{ {
if (me->m_isEnemyVisible) if (me->m_isEnemyVisible)
{ {
me->Jump(); me->Jump();
} }
break; break;
} }
} }
} }
} }
@ -562,22 +562,3 @@ void AttackState::__MAKE_VHOOK(OnExit)(CCSBot *me)
me->StopRapidFire(); me->StopRapidFire();
me->ClearSurpriseDelay(); me->ClearSurpriseDelay();
} }
#ifdef HOOK_GAMEDLL
void AttackState::OnEnter(CCSBot *me)
{
OnEnter_(me);
}
void AttackState::OnUpdate(CCSBot *me)
{
OnUpdate_(me);
}
void AttackState::OnExit(CCSBot *me)
{
OnExit_(me);
}
#endif // HOOK_GAMEDLL

View File

@ -4,7 +4,7 @@
bool HasDefaultPistol(CCSBot *me) bool HasDefaultPistol(CCSBot *me)
{ {
CBasePlayerWeapon *pistol = static_cast<CBasePlayerWeapon *>(me->m_rgpPlayerItems[ PISTOL_SLOT ]); CBasePlayerWeapon *pistol = static_cast<CBasePlayerWeapon *>(me->m_rgpPlayerItems[ PISTOL_SLOT ]);
if (pistol == NULL) if (pistol == NULL)
return false; return false;
@ -283,7 +283,7 @@ void BuyState::__MAKE_VHOOK(OnUpdate)(CCSBot *me)
++m_prefIndex; ++m_prefIndex;
m_prefRetries = 0; m_prefRetries = 0;
return; return;
} }
int weaponPreference = me->GetProfile()->GetWeaponPreference(m_prefIndex); int weaponPreference = me->GetProfile()->GetWeaponPreference(m_prefIndex);
@ -357,9 +357,9 @@ void BuyState::__MAKE_VHOOK(OnUpdate)(CCSBot *me)
// bail out so we dont waste money on other equipment // bail out so we dont waste money on other equipment
// unless everything we prefer has been disallowed, then buy at random // unless everything we prefer has been disallowed, then buy at random
if (isPreferredAllDisallowed == false) if (isPreferredAllDisallowed == false)
return; return;
} }
// if we have no preferred primary weapon (or everything we want is disallowed), buy at random // if we have no preferred primary weapon (or everything we want is disallowed), buy at random
if (!me->m_bHasPrimary && (isPreferredAllDisallowed || !me->GetProfile()->HasPrimaryPreference())) if (!me->m_bHasPrimary && (isPreferredAllDisallowed || !me->GetProfile()->HasPrimaryPreference()))
{ {
@ -521,22 +521,3 @@ void BuyState::__MAKE_VHOOK(OnExit)(CCSBot *me)
me->ResetStuckMonitor(); me->ResetStuckMonitor();
me->EquipBestWeapon(); me->EquipBestWeapon();
} }
#ifdef HOOK_GAMEDLL
void BuyState::OnEnter(CCSBot *me)
{
OnEnter_(me);
}
void BuyState::OnUpdate(CCSBot *me)
{
OnUpdate_(me);
}
void BuyState::OnExit(CCSBot *me)
{
OnExit_(me);
}
#endif // HOOK_GAMEDLL

View File

@ -66,22 +66,3 @@ void DefuseBombState::__MAKE_VHOOK(OnExit)(CCSBot *me)
me->SetDisposition(CCSBot::ENGAGE_AND_INVESTIGATE); me->SetDisposition(CCSBot::ENGAGE_AND_INVESTIGATE);
me->ClearLookAt(); me->ClearLookAt();
} }
#ifdef HOOK_GAMEDLL
void DefuseBombState::OnEnter(CCSBot *me)
{
OnEnter_(me);
}
void DefuseBombState::OnUpdate(CCSBot *me)
{
OnUpdate_(me);
}
void DefuseBombState::OnExit(CCSBot *me)
{
OnExit_(me);
}
#endif // HOOK_GAMEDLL

View File

@ -45,22 +45,3 @@ void EscapeFromBombState::__MAKE_VHOOK(OnExit)(CCSBot *me)
{ {
me->EquipBestWeapon(); me->EquipBestWeapon();
} }
#ifdef HOOK_GAMEDLL
void EscapeFromBombState::OnEnter(CCSBot *me)
{
OnEnter_(me);
}
void EscapeFromBombState::OnUpdate(CCSBot *me)
{
OnUpdate_(me);
}
void EscapeFromBombState::OnExit(CCSBot *me)
{
OnExit_(me);
}
#endif // HOOK_GAMEDLL

View File

@ -50,17 +50,3 @@ void FetchBombState::__MAKE_VHOOK(OnUpdate)(CCSBot *me)
if (me->UpdatePathMovement() != CCSBot::PROGRESSING) if (me->UpdatePathMovement() != CCSBot::PROGRESSING)
me->Idle(); me->Idle();
} }
#ifdef HOOK_GAMEDLL
void FetchBombState::OnEnter(CCSBot *me)
{
OnEnter_(me);
}
void FetchBombState::OnUpdate(CCSBot *me)
{
OnUpdate_(me);
}
#endif // HOOK_GAMEDLL

View File

@ -265,22 +265,3 @@ void FollowState::__MAKE_VHOOK(OnExit)(CCSBot *me)
{ {
; ;
} }
#ifdef HOOK_GAMEDLL
void FollowState::OnEnter(CCSBot *me)
{
OnEnter_(me);
}
void FollowState::OnUpdate(CCSBot *me)
{
OnUpdate_(me);
}
void FollowState::OnExit(CCSBot *me)
{
OnExit_(me);
}
#endif // HOOK_GAMEDLL

View File

@ -346,11 +346,11 @@ void HideState::__MAKE_VHOOK(OnUpdate)(CCSBot *me)
toSpot.y = m_hidingSpot.y - me->pev->origin.y; toSpot.y = m_hidingSpot.y - me->pev->origin.y;
toSpot.z = m_hidingSpot.z - me->GetFeetZ(); // use feet location toSpot.z = m_hidingSpot.z - me->GetFeetZ(); // use feet location
float dist = toSpot.Length(); float dist = toSpot.Length();
const float crouchDist = 200.0f; const float crouchDist = 200.0f;
if (dist < crouchDist) if (dist < crouchDist)
me->Crouch(); me->Crouch();
const float atDist = 20.0f; const float atDist = 20.0f;
if (dist < atDist) if (dist < atDist)
{ {
@ -435,22 +435,3 @@ void HideState::__MAKE_VHOOK(OnExit)(CCSBot *me)
if (me->HasShield() && me->IsProtectedByShield()) if (me->HasShield() && me->IsProtectedByShield())
me->SecondaryAttack(); me->SecondaryAttack();
} }
#ifdef HOOK_GAMEDLL
void HideState::OnEnter(CCSBot *me)
{
OnEnter_(me);
}
void HideState::OnUpdate(CCSBot *me)
{
OnUpdate_(me);
}
void HideState::OnExit(CCSBot *me)
{
OnExit_(me);
}
#endif // HOOK_GAMEDLL

View File

@ -200,22 +200,3 @@ void HuntState::__MAKE_VHOOK(OnExit)(CCSBot *me)
{ {
; ;
} }
#ifdef HOOK_GAMEDLL
void HuntState::OnEnter(CCSBot *me)
{
OnEnter_(me);
}
void HuntState::OnUpdate(CCSBot *me)
{
OnUpdate_(me);
}
void HuntState::OnExit(CCSBot *me)
{
OnExit_(me);
}
#endif // HOOK_GAMEDLL

View File

@ -754,17 +754,3 @@ void IdleState::__MAKE_VHOOK(OnUpdate)(CCSBot *me)
// if we have nothing special to do, go hunting for enemies // if we have nothing special to do, go hunting for enemies
me->Hunt(); me->Hunt();
} }
#ifdef HOOK_GAMEDLL
void IdleState::OnEnter(CCSBot *me)
{
OnEnter_(me);
}
void IdleState::OnUpdate(CCSBot *me)
{
OnUpdate_(me);
}
#endif // HOOK_GAMEDLL

View File

@ -15,7 +15,7 @@ void InvestigateNoiseState::AttendCurrentNoise(CCSBot *me)
if (me->IsWellPastSafe() && me->HasNotSeenEnemyForLongTime() && me->GetNoisePriority() != PRIORITY_HIGH) if (me->IsWellPastSafe() && me->HasNotSeenEnemyForLongTime() && me->GetNoisePriority() != PRIORITY_HIGH)
me->GetChatter()->HeardNoise(me->GetNoisePosition()); me->GetChatter()->HeardNoise(me->GetNoisePosition());
// figure out how to get to the noise // figure out how to get to the noise
me->PrintIfWatched("Attending to noise...\n"); me->PrintIfWatched("Attending to noise...\n");
me->ComputePath(me->GetNoiseArea(), &m_checkNoisePosition, SAFEST_ROUTE); me->ComputePath(me->GetNoiseArea(), &m_checkNoisePosition, SAFEST_ROUTE);
@ -115,22 +115,3 @@ void InvestigateNoiseState::__MAKE_VHOOK(OnExit)(CCSBot *me)
// reset to run mode in case we were sneaking about // reset to run mode in case we were sneaking about
me->Run(); me->Run();
} }
#ifdef HOOK_GAMEDLL
void InvestigateNoiseState::OnEnter(CCSBot *me)
{
OnEnter_(me);
}
void InvestigateNoiseState::OnUpdate(CCSBot *me)
{
OnUpdate_(me);
}
void InvestigateNoiseState::OnExit(CCSBot *me)
{
OnExit_(me);
}
#endif // HOOK_GAMEDLL

View File

@ -300,22 +300,3 @@ void MoveToState::__MAKE_VHOOK(OnExit)(CCSBot *me)
me->SetDisposition(CCSBot::ENGAGE_AND_INVESTIGATE); me->SetDisposition(CCSBot::ENGAGE_AND_INVESTIGATE);
//me->StopAiming(); //me->StopAiming();
} }
#ifdef HOOK_GAMEDLL
void MoveToState::OnEnter(CCSBot *me)
{
OnEnter_(me);
}
void MoveToState::OnUpdate(CCSBot *me)
{
OnUpdate_(me);
}
void MoveToState::OnExit(CCSBot *me)
{
OnExit_(me);
}
#endif // HOOK_GAMEDLL

View File

@ -58,22 +58,3 @@ void PlantBombState::__MAKE_VHOOK(OnExit)(CCSBot *me)
me->SetDisposition(CCSBot::ENGAGE_AND_INVESTIGATE); me->SetDisposition(CCSBot::ENGAGE_AND_INVESTIGATE);
me->ClearLookAt(); me->ClearLookAt();
} }
#ifdef HOOK_GAMEDLL
void PlantBombState::OnEnter(CCSBot *me)
{
OnEnter_(me);
}
void PlantBombState::OnUpdate(CCSBot *me)
{
OnUpdate_(me);
}
void PlantBombState::OnExit(CCSBot *me)
{
OnExit_(me);
}
#endif // HOOK_GAMEDLL

View File

@ -47,22 +47,3 @@ void UseEntityState::__MAKE_VHOOK(OnExit)(CCSBot *me)
me->ClearLookAt(); me->ClearLookAt();
me->ResetStuckMonitor(); me->ResetStuckMonitor();
} }
#ifdef HOOK_GAMEDLL
void UseEntityState::OnEnter(CCSBot *me)
{
OnEnter_(me);
}
void UseEntityState::OnUpdate(CCSBot *me)
{
OnUpdate_(me);
}
void UseEntityState::OnExit(CCSBot *me)
{
OnExit_(me);
}
#endif // HOOK_GAMEDLL

View File

@ -14,7 +14,7 @@ TYPEDESCRIPTION CEnvGlobal::m_SaveData[] =
TYPEDESCRIPTION CMultiSource::m_SaveData[] = TYPEDESCRIPTION CMultiSource::m_SaveData[] =
{ {
//!!!BUGBUG FIX // BUGBUG FIX
DEFINE_ARRAY(CMultiSource, m_rgEntities, FIELD_EHANDLE, MS_MAX_TARGETS), DEFINE_ARRAY(CMultiSource, m_rgEntities, FIELD_EHANDLE, MS_MAX_TARGETS),
DEFINE_ARRAY(CMultiSource, m_rgTriggered, FIELD_INTEGER, MS_MAX_TARGETS), DEFINE_ARRAY(CMultiSource, m_rgTriggered, FIELD_INTEGER, MS_MAX_TARGETS),
DEFINE_FIELD(CMultiSource, m_iTotal, FIELD_INTEGER), DEFINE_FIELD(CMultiSource, m_iTotal, FIELD_INTEGER),
@ -50,14 +50,6 @@ TYPEDESCRIPTION CEnvSpark::m_SaveData[] =
DEFINE_FIELD(CEnvSpark, m_flDelay, FIELD_FLOAT), DEFINE_FIELD(CEnvSpark, m_flDelay, FIELD_FLOAT),
}; };
#else
TYPEDESCRIPTION IMPL_CLASS(CEnvGlobal, m_SaveData)[3];
TYPEDESCRIPTION IMPL_CLASS(CMultiSource, m_SaveData)[4];
TYPEDESCRIPTION IMPL_CLASS(CBaseButton, m_SaveData)[8];
TYPEDESCRIPTION IMPL_CLASS(CMomentaryRotButton, m_SaveData)[6];
TYPEDESCRIPTION IMPL_CLASS(CEnvSpark, m_SaveData)[1];
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
/* <260d6> ../cstrike/dlls/buttons.cpp:62 */ /* <260d6> ../cstrike/dlls/buttons.cpp:62 */
@ -89,7 +81,7 @@ void CEnvGlobal::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
} }
/* <26486> ../cstrike/dlls/buttons.cpp:80 */ /* <26486> ../cstrike/dlls/buttons.cpp:80 */
void CEnvGlobal::__MAKE_VHOOK(Spawn)(void) void CEnvGlobal::__MAKE_VHOOK(Spawn)()
{ {
if (!m_globalstate) if (!m_globalstate)
{ {
@ -177,7 +169,7 @@ void CMultiSource::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
} }
/* <256e2> ../cstrike/dlls/buttons.cpp:168 */ /* <256e2> ../cstrike/dlls/buttons.cpp:168 */
void CMultiSource::__MAKE_VHOOK(Spawn)(void) void CMultiSource::__MAKE_VHOOK(Spawn)()
{ {
// set up think for later registration // set up think for later registration
pev->solid = SOLID_NOT; pev->solid = SOLID_NOT;
@ -256,7 +248,7 @@ BOOL CMultiSource::__MAKE_VHOOK(IsTriggered)(CBaseEntity *)
} }
/* <25d5a> ../cstrike/dlls/buttons.cpp:236 */ /* <25d5a> ../cstrike/dlls/buttons.cpp:236 */
void CMultiSource::Register(void) void CMultiSource::Register()
{ {
edict_t *pentTarget = NULL; edict_t *pentTarget = NULL;
@ -300,7 +292,7 @@ void CMultiSource::Register(void)
IMPLEMENT_SAVERESTORE(CBaseButton, CBaseToggle); IMPLEMENT_SAVERESTORE(CBaseButton, CBaseToggle);
/* <25709> ../cstrike/dlls/buttons.cpp:289 */ /* <25709> ../cstrike/dlls/buttons.cpp:289 */
void CBaseButton::__MAKE_VHOOK(Precache)(void) void CBaseButton::__MAKE_VHOOK(Precache)()
{ {
char *pszSound; char *pszSound;
@ -459,7 +451,7 @@ int CBaseButton::__MAKE_VHOOK(TakeDamage)(entvars_t *pevInflictor, entvars_t *pe
LINK_ENTITY_TO_CLASS(func_button, CBaseButton); LINK_ENTITY_TO_CLASS(func_button, CBaseButton);
/* <25c2c> ../cstrike/dlls/buttons.cpp:442 */ /* <25c2c> ../cstrike/dlls/buttons.cpp:442 */
void CBaseButton::__MAKE_VHOOK(Spawn)(void) void CBaseButton::__MAKE_VHOOK(Spawn)()
{ {
char *pszSound; char *pszSound;
@ -596,7 +588,7 @@ void DoSpark(entvars_t *pev, const Vector &location)
} }
/* <277fa> ../cstrike/dlls/buttons.cpp:568 */ /* <277fa> ../cstrike/dlls/buttons.cpp:568 */
void CBaseButton::ButtonSpark(void) void CBaseButton::ButtonSpark()
{ {
SetThink(&CBaseButton::ButtonSpark); SetThink(&CBaseButton::ButtonSpark);
@ -631,7 +623,7 @@ void CBaseButton::ButtonUse(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_T
} }
/* <27821> ../cstrike/dlls/buttons.cpp:603 */ /* <27821> ../cstrike/dlls/buttons.cpp:603 */
CBaseButton::BUTTON_CODE CBaseButton::ButtonResponseToTouch(void) CBaseButton::BUTTON_CODE CBaseButton::ButtonResponseToTouch()
{ {
// Ignore touches if button is moving, or pushed-in and waiting to auto-come-out. // Ignore touches if button is moving, or pushed-in and waiting to auto-come-out.
if (m_toggle_state == TS_GOING_UP || m_toggle_state == TS_GOING_DOWN || (m_toggle_state == TS_AT_TOP && !m_fStayPushed && !(pev->spawnflags & SF_BUTTON_TOGGLE))) if (m_toggle_state == TS_GOING_UP || m_toggle_state == TS_GOING_DOWN || (m_toggle_state == TS_AT_TOP && !m_fStayPushed && !(pev->spawnflags & SF_BUTTON_TOGGLE)))
@ -693,7 +685,7 @@ void CBaseButton::ButtonTouch(CBaseEntity *pOther)
// Starts the button moving "in/up". // Starts the button moving "in/up".
/* <27843> ../cstrike/dlls/buttons.cpp:664 */ /* <27843> ../cstrike/dlls/buttons.cpp:664 */
void CBaseButton::ButtonActivate(void) void CBaseButton::ButtonActivate()
{ {
EMIT_SOUND(ENT(pev), CHAN_VOICE, (char *)STRING(pev->noise), VOL_NORM, ATTN_NORM); EMIT_SOUND(ENT(pev), CHAN_VOICE, (char *)STRING(pev->noise), VOL_NORM, ATTN_NORM);
@ -726,7 +718,7 @@ void CBaseButton::ButtonActivate(void)
// Button has reached the "in/up" position. Activate its "targets", and pause before "popping out". // Button has reached the "in/up" position. Activate its "targets", and pause before "popping out".
/* <263dd> ../cstrike/dlls/buttons.cpp:693 */ /* <263dd> ../cstrike/dlls/buttons.cpp:693 */
void CBaseButton::TriggerAndWait(void) void CBaseButton::TriggerAndWait()
{ {
assert(m_toggle_state == TS_GOING_UP); assert(m_toggle_state == TS_GOING_UP);
@ -762,7 +754,7 @@ void CBaseButton::TriggerAndWait(void)
// Starts the button moving "out/down". // Starts the button moving "out/down".
/* <25bb7> ../cstrike/dlls/buttons.cpp:730 */ /* <25bb7> ../cstrike/dlls/buttons.cpp:730 */
void CBaseButton::ButtonReturn(void) void CBaseButton::ButtonReturn()
{ {
assert(m_toggle_state == TS_AT_TOP); assert(m_toggle_state == TS_AT_TOP);
m_toggle_state = TS_GOING_DOWN; m_toggle_state = TS_GOING_DOWN;
@ -784,7 +776,7 @@ void CBaseButton::ButtonReturn(void)
// Button has returned to start state. Quiesce it. // Button has returned to start state. Quiesce it.
/* <26658> ../cstrike/dlls/buttons.cpp:748 */ /* <26658> ../cstrike/dlls/buttons.cpp:748 */
void CBaseButton::ButtonBackHome(void) void CBaseButton::ButtonBackHome()
{ {
assert(m_toggle_state == TS_GOING_DOWN); assert(m_toggle_state == TS_GOING_DOWN);
m_toggle_state = TS_AT_BOTTOM; m_toggle_state = TS_AT_BOTTOM;
@ -842,7 +834,7 @@ void CBaseButton::ButtonBackHome(void)
LINK_ENTITY_TO_CLASS(func_rot_button, CRotButton); LINK_ENTITY_TO_CLASS(func_rot_button, CRotButton);
/* <25a06> ../cstrike/dlls/buttons.cpp:808 */ /* <25a06> ../cstrike/dlls/buttons.cpp:808 */
void CRotButton::__MAKE_VHOOK(Spawn)(void) void CRotButton::__MAKE_VHOOK(Spawn)()
{ {
char *pszSound; char *pszSound;
@ -913,7 +905,7 @@ IMPLEMENT_SAVERESTORE(CMomentaryRotButton, CBaseToggle);
LINK_ENTITY_TO_CLASS(momentary_rot_button, CMomentaryRotButton); LINK_ENTITY_TO_CLASS(momentary_rot_button, CMomentaryRotButton);
/* <25acc> ../cstrike/dlls/buttons.cpp:922 */ /* <25acc> ../cstrike/dlls/buttons.cpp:922 */
void CMomentaryRotButton::__MAKE_VHOOK(Spawn)(void) void CMomentaryRotButton::__MAKE_VHOOK(Spawn)()
{ {
CBaseToggle::AxisDir(pev); CBaseToggle::AxisDir(pev);
@ -971,7 +963,7 @@ void CMomentaryRotButton::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
} }
/* <27a57> ../cstrike/dlls/buttons.cpp:974 */ /* <27a57> ../cstrike/dlls/buttons.cpp:974 */
void CMomentaryRotButton::PlaySound(void) void CMomentaryRotButton::PlaySound()
{ {
EMIT_SOUND(ENT(pev), CHAN_VOICE, (char *)STRING(pev->noise), VOL_NORM, ATTN_NORM); EMIT_SOUND(ENT(pev), CHAN_VOICE, (char *)STRING(pev->noise), VOL_NORM, ATTN_NORM);
} }
@ -1091,7 +1083,7 @@ void CMomentaryRotButton::UpdateTarget(float value)
} }
/* <25f88> ../cstrike/dlls/buttons.cpp:1072 */ /* <25f88> ../cstrike/dlls/buttons.cpp:1072 */
void CMomentaryRotButton::Off(void) void CMomentaryRotButton::Off()
{ {
pev->avelocity = g_vecZero; pev->avelocity = g_vecZero;
m_lastUsed = 0; m_lastUsed = 0;
@ -1107,7 +1099,7 @@ void CMomentaryRotButton::Off(void)
} }
/* <27d60> ../cstrike/dlls/buttons.cpp:1086 */ /* <27d60> ../cstrike/dlls/buttons.cpp:1086 */
void CMomentaryRotButton::Return(void) void CMomentaryRotButton::Return()
{ {
float value = CBaseToggle::AxisDelta(pev->spawnflags, pev->angles, m_start) / m_flMoveDistance; float value = CBaseToggle::AxisDelta(pev->spawnflags, pev->angles, m_start) / m_flMoveDistance;
@ -1147,7 +1139,7 @@ LINK_ENTITY_TO_CLASS(env_spark, CEnvSpark);
LINK_ENTITY_TO_CLASS(env_debris, CEnvSpark); LINK_ENTITY_TO_CLASS(env_debris, CEnvSpark);
/* <257b7> ../cstrike/dlls/buttons.cpp:1146 */ /* <257b7> ../cstrike/dlls/buttons.cpp:1146 */
void CEnvSpark::__MAKE_VHOOK(Spawn)(void) void CEnvSpark::__MAKE_VHOOK(Spawn)()
{ {
SetThink(NULL); SetThink(NULL);
SetUse(NULL); SetUse(NULL);
@ -1181,7 +1173,7 @@ void CEnvSpark::__MAKE_VHOOK(Spawn)(void)
} }
/* <257de> ../cstrike/dlls/buttons.cpp:1173 */ /* <257de> ../cstrike/dlls/buttons.cpp:1173 */
void CEnvSpark::__MAKE_VHOOK(Precache)(void) void CEnvSpark::__MAKE_VHOOK(Precache)()
{ {
PRECACHE_SOUND("buttons/spark1.wav"); PRECACHE_SOUND("buttons/spark1.wav");
PRECACHE_SOUND("buttons/spark2.wav"); PRECACHE_SOUND("buttons/spark2.wav");
@ -1211,7 +1203,7 @@ void CEnvSpark::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
} }
/* <277d3> ../cstrike/dlls/buttons.cpp:1201 */ /* <277d3> ../cstrike/dlls/buttons.cpp:1201 */
void CEnvSpark::SparkThink(void) void CEnvSpark::SparkThink()
{ {
pev->nextthink = gpGlobals->time + 0.1 + RANDOM_FLOAT(0, m_flDelay); pev->nextthink = gpGlobals->time + 0.1 + RANDOM_FLOAT(0, m_flDelay);
DoSpark(pev, pev->origin); DoSpark(pev, pev->origin);
@ -1236,7 +1228,7 @@ void CEnvSpark::SparkStop(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYP
LINK_ENTITY_TO_CLASS(button_target, CButtonTarget); LINK_ENTITY_TO_CLASS(button_target, CButtonTarget);
/* <258ca> ../cstrike/dlls/buttons.cpp:1235 */ /* <258ca> ../cstrike/dlls/buttons.cpp:1235 */
void CButtonTarget::__MAKE_VHOOK(Spawn)(void) void CButtonTarget::__MAKE_VHOOK(Spawn)()
{ {
pev->movetype = MOVETYPE_PUSH; pev->movetype = MOVETYPE_PUSH;
pev->solid = SOLID_BSP; pev->solid = SOLID_BSP;
@ -1267,7 +1259,7 @@ void CButtonTarget::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCal
} }
/* <258f1> ../cstrike/dlls/buttons.cpp:1258 */ /* <258f1> ../cstrike/dlls/buttons.cpp:1258 */
int CButtonTarget::__MAKE_VHOOK(ObjectCaps)(void) int CButtonTarget::__MAKE_VHOOK(ObjectCaps)()
{ {
int caps = CBaseEntity::ObjectCaps() & ~FCAP_ACROSS_TRANSITION; int caps = CBaseEntity::ObjectCaps() & ~FCAP_ACROSS_TRANSITION;
@ -1281,170 +1273,5 @@ int CButtonTarget::__MAKE_VHOOK(ObjectCaps)(void)
int CButtonTarget::__MAKE_VHOOK(TakeDamage)(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType) int CButtonTarget::__MAKE_VHOOK(TakeDamage)(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType)
{ {
Use(Instance(pevAttacker), this, USE_TOGGLE, 0); Use(Instance(pevAttacker), this, USE_TOGGLE, 0);
return 1; return 1;
} }
#ifdef HOOK_GAMEDLL
void CBaseButton::Spawn(void)
{
Spawn_();
}
void CBaseButton::Precache(void)
{
Precache_();
}
void CBaseButton::KeyValue(KeyValueData *pkvd)
{
KeyValue_(pkvd);
}
int CBaseButton::TakeDamage(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType)
{
return TakeDamage_(pevInflictor, pevAttacker, flDamage, bitsDamageType);
}
int CBaseButton::Save(CSave &save)
{
return Save_(save);
}
int CBaseButton::Restore(CRestore &restore)
{
return Restore_(restore);
}
void CEnvGlobal::Spawn(void)
{
Spawn_();
}
void CEnvGlobal::KeyValue(KeyValueData *pkvd)
{
KeyValue_(pkvd);
}
int CEnvGlobal::Save(CSave &save)
{
return Save_(save);
}
int CEnvGlobal::Restore(CRestore &restore)
{
return Restore_(restore);
}
void CEnvGlobal::Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
{
Use_(pActivator, pCaller, useType, value);
}
void CMultiSource::Spawn(void)
{
Spawn_();
}
void CMultiSource::KeyValue(KeyValueData *pkvd)
{
KeyValue_(pkvd);
}
void CMultiSource::Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
{
Use_(pActivator, pCaller, useType, value);
}
BOOL CMultiSource::IsTriggered(CBaseEntity *pActivator)
{
return IsTriggered_(pActivator);
}
int CMultiSource::Save(CSave &save)
{
return Save_(save);
}
int CMultiSource::Restore(CRestore &restore)
{
return Restore_(restore);
}
void CRotButton::Spawn(void)
{
Spawn_();
}
void CMomentaryRotButton::Spawn(void)
{
Spawn_();
}
void CMomentaryRotButton::KeyValue(KeyValueData *pkvd)
{
KeyValue_(pkvd);
}
int CMomentaryRotButton::Save(CSave &save)
{
return Save_(save);
}
int CMomentaryRotButton::Restore(CRestore &restore)
{
return Restore_(restore);
}
void CMomentaryRotButton::Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
{
Use_(pActivator, pCaller, useType, value);
}
void CEnvSpark::Spawn(void)
{
Spawn_();
}
void CEnvSpark::Precache(void)
{
Precache_();
}
void CEnvSpark::KeyValue(KeyValueData *pkvd)
{
KeyValue_(pkvd);
}
int CEnvSpark::Save(CSave &save)
{
return Save_(save);
}
int CEnvSpark::Restore(CRestore &restore)
{
return Restore_(restore);
}
void CButtonTarget::Spawn(void)
{
Spawn_();
}
int CButtonTarget::ObjectCaps(void)
{
return ObjectCaps_();
}
int CButtonTarget::TakeDamage(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType)
{
return TakeDamage_(pevInflictor, pevAttacker, flDamage, bitsDamageType);
}
void CButtonTarget::Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
{
Use_(pActivator, pCaller, useType, value);
}
#endif // HOOK_GAMEDLL

View File

@ -58,7 +58,7 @@
class CEnvGlobal: public CPointEntity class CEnvGlobal: public CPointEntity
{ {
public: public:
virtual void Spawn(void); virtual void Spawn();
virtual void KeyValue(KeyValueData *pkvd); virtual void KeyValue(KeyValueData *pkvd);
virtual int Save(CSave &save); virtual int Save(CSave &save);
virtual int Restore(CRestore &restore); virtual int Restore(CRestore &restore);
@ -66,7 +66,7 @@ public:
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Spawn_(void); void Spawn_();
void KeyValue_(KeyValueData *pkvd); void KeyValue_(KeyValueData *pkvd);
int Save_(CSave &save); int Save_(CSave &save);
int Restore_(CRestore &restore); int Restore_(CRestore &restore);
@ -81,32 +81,31 @@ public:
string_t m_globalstate; string_t m_globalstate;
int m_triggermode; int m_triggermode;
int m_initialstate; int m_initialstate;
};
};/* size: 164, cachelines: 3, members: 5 */
/* <24b67> ../cstrike/dlls/buttons.cpp:800 */ /* <24b67> ../cstrike/dlls/buttons.cpp:800 */
class CRotButton: public CBaseButton class CRotButton: public CBaseButton
{ {
public: public:
virtual void Spawn(void); virtual void Spawn();
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Spawn_(void); void Spawn_();
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
};/* size: 368, cachelines: 6, members: 1 */ };
/* <24bba> ../cstrike/dlls/buttons.cpp:873 */ /* <24bba> ../cstrike/dlls/buttons.cpp:873 */
class CMomentaryRotButton: public CBaseToggle class CMomentaryRotButton: public CBaseToggle
{ {
public: public:
virtual void Spawn(void); virtual void Spawn();
virtual void KeyValue(KeyValueData *pkvd); virtual void KeyValue(KeyValueData *pkvd);
virtual int Save(CSave &save); virtual int Save(CSave &save);
virtual int Restore(CRestore &restore); virtual int Restore(CRestore &restore);
virtual int ObjectCaps(void) virtual int ObjectCaps()
{ {
int flags = CBaseToggle::ObjectCaps() & (~FCAP_ACROSS_TRANSITION); int flags = CBaseToggle::ObjectCaps() & (~FCAP_ACROSS_TRANSITION);
@ -121,7 +120,7 @@ public:
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Spawn_(void); void Spawn_();
void KeyValue_(KeyValueData *pkvd); void KeyValue_(KeyValueData *pkvd);
int Save_(CSave &save); int Save_(CSave &save);
int Restore_(CRestore &restore); int Restore_(CRestore &restore);
@ -130,46 +129,42 @@ public:
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
public: public:
void EXPORT Off(void); void EXPORT Off();
void EXPORT Return(void); void EXPORT Return();
void UpdateSelf(float value); void UpdateSelf(float value);
void UpdateSelfReturn(float value); void UpdateSelfReturn(float value);
void UpdateAllButtons(float value, int start); void UpdateAllButtons(float value, int start);
void PlaySound(void); void PlaySound();
void UpdateTarget(float value); void UpdateTarget(float value);
public: public:
static CMomentaryRotButton *Instance(edict_t *pent) static CMomentaryRotButton *Instance(edict_t *pent) { return (CMomentaryRotButton *)GET_PRIVATE(pent); }
{
return (CMomentaryRotButton *)GET_PRIVATE(pent);
}
public: public:
static TYPEDESCRIPTION IMPL(m_SaveData)[6]; static TYPEDESCRIPTION IMPL(m_SaveData)[6];
public:
int m_lastUsed; int m_lastUsed;
int m_direction; int m_direction;
float m_returnSpeed; float m_returnSpeed;
Vector m_start; Vector m_start;
Vector m_end; Vector m_end;
int m_sounds; int m_sounds;
};
};/* size: 352, cachelines: 6, members: 8 */
/* <24c08> ../cstrike/dlls/buttons.cpp:1117 */ /* <24c08> ../cstrike/dlls/buttons.cpp:1117 */
class CEnvSpark: public CBaseEntity class CEnvSpark: public CBaseEntity
{ {
public: public:
virtual void Spawn(void); virtual void Spawn();
virtual void Precache(void); virtual void Precache();
virtual void KeyValue(KeyValueData *pkvd); virtual void KeyValue(KeyValueData *pkvd);
virtual int Save(CSave &save); virtual int Save(CSave &save);
virtual int Restore(CRestore &restore); virtual int Restore(CRestore &restore);
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Spawn_(void); void Spawn_();
void Precache_(void); void Precache_();
void KeyValue_(KeyValueData *pkvd); void KeyValue_(KeyValueData *pkvd);
int Save_(CSave &save); int Save_(CSave &save);
int Restore_(CRestore &restore); int Restore_(CRestore &restore);
@ -177,53 +172,37 @@ public:
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
public: public:
void EXPORT SparkThink(void); void EXPORT SparkThink();
void EXPORT SparkStart(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value); void EXPORT SparkStart(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
void EXPORT SparkStop(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value); void EXPORT SparkStop(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
public: public:
static TYPEDESCRIPTION IMPL(m_SaveData)[1]; static TYPEDESCRIPTION IMPL(m_SaveData)[1];
public:
float m_flDelay; float m_flDelay;
};
};/* size: 156, cachelines: 3, members: 3 */
/* <24c24> ../cstrike/dlls/buttons.cpp:1223 */ /* <24c24> ../cstrike/dlls/buttons.cpp:1223 */
class CButtonTarget: public CBaseEntity class CButtonTarget: public CBaseEntity
{ {
public: public:
virtual void Spawn(void); virtual void Spawn();
virtual int ObjectCaps(void); virtual int ObjectCaps();
virtual int TakeDamage(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType); virtual int TakeDamage(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType);
virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value); virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Spawn_(void); void Spawn_();
int ObjectCaps_(void); int ObjectCaps_();
int TakeDamage_(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType); int TakeDamage_(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType);
void Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value); void Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
};/* size: 152, cachelines: 3, members: 1 */ };
char *ButtonSound(int sound); char *ButtonSound(int sound);
void DoSpark(entvars_t *pev, const Vector &location); void DoSpark(entvars_t *pev, const Vector &location);
#ifdef HOOK_GAMEDLL
// linked objects
C_DLLEXPORT void env_global(entvars_t *pev);
C_DLLEXPORT void multisource(entvars_t *pev);
C_DLLEXPORT void func_button(entvars_t *pev);
C_DLLEXPORT void func_rot_button(entvars_t *pev);
C_DLLEXPORT void momentary_rot_button(entvars_t *pev);
C_DLLEXPORT void env_spark(entvars_t *pev);
C_DLLEXPORT void env_debris(entvars_t *pev);
C_DLLEXPORT void button_target(entvars_t *pev);
#endif // HOOK_GAMEDLL
#endif // BUTTON_H #endif // BUTTON_H

View File

@ -32,11 +32,6 @@ const TaskInfo taskInfo[] =
{ NULL, EVENT_INVALID, &CCareerTask::NewTask } { NULL, EVENT_INVALID, &CCareerTask::NewTask }
}; };
#else
CCareerTaskManager *TheCareerTasks;
const TaskInfo taskInfo[21];
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
/* <1ef647> ../cstrike/dlls/career_tasks.cpp:133 */ /* <1ef647> ../cstrike/dlls/career_tasks.cpp:133 */
@ -60,7 +55,7 @@ CPreventDefuseTask::CPreventDefuseTask(const char *taskName, GameEventType event
} }
/* <1ef296> ../cstrike/dlls/career_tasks.cpp:147 */ /* <1ef296> ../cstrike/dlls/career_tasks.cpp:147 */
void CPreventDefuseTask::__MAKE_VHOOK(Reset)(void) void CPreventDefuseTask::__MAKE_VHOOK(Reset)()
{ {
m_bombPlantedThisRound = false; m_bombPlantedThisRound = false;
m_defuseStartedThisRound = false; m_defuseStartedThisRound = false;
@ -135,7 +130,7 @@ CCareerTask::CCareerTask(const char *taskName, GameEventType event, const char *
} }
/* <1ef211> ../cstrike/dlls/career_tasks.cpp:240 */ /* <1ef211> ../cstrike/dlls/career_tasks.cpp:240 */
void CCareerTask::__MAKE_VHOOK(Reset)(void) void CCareerTask::__MAKE_VHOOK(Reset)()
{ {
m_eventsSeen = 0; m_eventsSeen = 0;
m_isComplete = false; m_isComplete = false;
@ -153,7 +148,7 @@ void CCareerTask::__MAKE_VHOOK(Reset)(void)
} }
/* <1ef74c> ../cstrike/dlls/career_tasks.cpp:256 */ /* <1ef74c> ../cstrike/dlls/career_tasks.cpp:256 */
void CCareerTask::SendPartialNotification(void) void CCareerTask::SendPartialNotification()
{ {
MESSAGE_BEGIN(MSG_ALL, gmsgCZCareer); MESSAGE_BEGIN(MSG_ALL, gmsgCZCareer);
WRITE_STRING("TASKPART"); WRITE_STRING("TASKPART");
@ -188,7 +183,7 @@ void CCareerTask::OnWeaponKill(int weaponId, int weaponClassId, bool headshot, b
continue; continue;
CHostage *hostage = static_cast<CHostage *>(hostageEntity); CHostage *hostage = static_cast<CHostage *>(hostageEntity);
if (!hostage->IsFollowingSomeone()) if (!hostage->IsFollowingSomeone())
continue; continue;
@ -422,7 +417,7 @@ void CCareerTask::__MAKE_VHOOK(OnEvent)(GameEventType event, CBasePlayer *pVicti
} }
/* <1efeed> ../cstrike/dlls/career_tasks.cpp:623 */ /* <1efeed> ../cstrike/dlls/career_tasks.cpp:623 */
void CCareerTaskManager::Create(void) void CCareerTaskManager::Create()
{ {
if (TheCareerTasks != NULL) if (TheCareerTasks != NULL)
{ {
@ -434,7 +429,7 @@ void CCareerTaskManager::Create(void)
} }
/* <1eff77> ../cstrike/dlls/career_tasks.cpp:636 */ /* <1eff77> ../cstrike/dlls/career_tasks.cpp:636 */
CCareerTaskManager::CCareerTaskManager(void) CCareerTaskManager::CCareerTaskManager()
{ {
m_taskTime = 0; m_taskTime = 0;
Reset(); Reset();
@ -613,7 +608,7 @@ void CCareerTaskManager::HandleDeath(int team, CBasePlayer *pAttacker)
} }
/* <1f0a5d> ../cstrike/dlls/career_tasks.cpp:805 */ /* <1f0a5d> ../cstrike/dlls/career_tasks.cpp:805 */
bool CCareerTaskManager::AreAllTasksComplete(void) bool CCareerTaskManager::AreAllTasksComplete()
{ {
for (CareerTaskListIt it = m_tasks.begin(); it != m_tasks.end(); ++it) for (CareerTaskListIt it = m_tasks.begin(); it != m_tasks.end(); ++it)
{ {
@ -625,7 +620,7 @@ bool CCareerTaskManager::AreAllTasksComplete(void)
} }
/* <1f0abc> ../cstrike/dlls/career_tasks.cpp:818 */ /* <1f0abc> ../cstrike/dlls/career_tasks.cpp:818 */
int CCareerTaskManager::GetNumRemainingTasks(void) int CCareerTaskManager::GetNumRemainingTasks()
{ {
int ret = 0; int ret = 0;
for (CareerTaskListIt it = m_tasks.begin(); it != m_tasks.end(); ++it) for (CareerTaskListIt it = m_tasks.begin(); it != m_tasks.end(); ++it)
@ -638,44 +633,20 @@ int CCareerTaskManager::GetNumRemainingTasks(void)
} }
/* <1f0b33> ../cstrike/dlls/career_tasks.cpp:832 */ /* <1f0b33> ../cstrike/dlls/career_tasks.cpp:832 */
float CCareerTaskManager::GetRoundElapsedTime(void) float CCareerTaskManager::GetRoundElapsedTime()
{ {
return (gpGlobals->time - m_roundStartTime); return (gpGlobals->time - m_roundStartTime);
} }
/* <1f0b56> ../cstrike/dlls/career_tasks.cpp:838 */ /* <1f0b56> ../cstrike/dlls/career_tasks.cpp:838 */
void CCareerTaskManager::LatchRoundEndMessage(void) void CCareerTaskManager::LatchRoundEndMessage()
{ {
m_shouldLatchRoundEndMessage = true; m_shouldLatchRoundEndMessage = true;
} }
/* <1f0b81> ../cstrike/dlls/career_tasks.cpp:844 */ /* <1f0b81> ../cstrike/dlls/career_tasks.cpp:844 */
void CCareerTaskManager::UnlatchRoundEndMessage(void) void CCareerTaskManager::UnlatchRoundEndMessage()
{ {
m_shouldLatchRoundEndMessage = false; m_shouldLatchRoundEndMessage = false;
HandleEvent(m_roundEndMessage); HandleEvent(m_roundEndMessage);
} }
#ifdef HOOK_GAMEDLL
void CCareerTask::OnEvent(GameEventType event, CBasePlayer *pAttacker, CBasePlayer *pVictim)
{
OnEvent_(event, pAttacker, pVictim);
}
void CCareerTask::Reset(void)
{
Reset_();
}
void CPreventDefuseTask::OnEvent(GameEventType event, CBasePlayer *pAttacker, CBasePlayer *pVictim)
{
OnEvent_(event, pAttacker, pVictim);
}
void CPreventDefuseTask::Reset(void)
{
Reset_();
}
#endif // HOOK_GAMEDLL

View File

@ -38,17 +38,17 @@
class CCareerTask class CCareerTask
{ {
public: public:
CCareerTask(void) {}; CCareerTask() {};
CCareerTask(const char *taskName, GameEventType event, const char *weaponName, int n, bool mustLive, bool crossRounds, int id, bool isComplete); CCareerTask(const char *taskName, GameEventType event, const char *weaponName, int n, bool mustLive, bool crossRounds, int id, bool isComplete);
public: public:
virtual void OnEvent(GameEventType event, CBasePlayer *pAttacker, CBasePlayer *pVictim); virtual void OnEvent(GameEventType event, CBasePlayer *pAttacker, CBasePlayer *pVictim);
virtual void Reset(void); virtual void Reset();
virtual bool IsTaskCompletableThisRound(void) { return true; } virtual bool IsTaskCompletableThisRound() { return true; }
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void OnEvent_(GameEventType event, CBasePlayer *pAttacker, CBasePlayer *pVictim); void OnEvent_(GameEventType event, CBasePlayer *pAttacker, CBasePlayer *pVictim);
void Reset_(void); void Reset_();
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
@ -58,17 +58,16 @@ public:
void OnWeaponKill(int weaponId, int weaponClassId, bool headshot, bool killerHasShield, CBasePlayer *pAttacker, CBasePlayer *pVictim); void OnWeaponKill(int weaponId, int weaponClassId, bool headshot, bool killerHasShield, CBasePlayer *pAttacker, CBasePlayer *pVictim);
void OnWeaponInjury(int weaponId, int weaponClassId, bool attackerHasShield, CBasePlayer *pAttacker); void OnWeaponInjury(int weaponId, int weaponClassId, bool attackerHasShield, CBasePlayer *pAttacker);
bool IsComplete(void) { return m_isComplete;} bool IsComplete() { return m_isComplete;}
const char *GetTaskName(void) { return m_name; } const char *GetTaskName() { return m_name; }
int GetWeaponId(void) { return m_weaponId; } int GetWeaponId() { return m_weaponId; }
int GetWeaponClassId(void) { return m_weaponClassId; } int GetWeaponClassId() { return m_weaponClassId; }
bool IsValidFor(CBasePlayer *pPlayer) { return true; } bool IsValidFor(CBasePlayer *pPlayer) { return true; }
void SendPartialNotification(void); void SendPartialNotification();
private: private:
bool m_isComplete; bool m_isComplete;
const char *m_name; const char *m_name;
int m_id; int m_id;
@ -83,8 +82,7 @@ private:
bool m_rescuer; bool m_rescuer;
bool m_defuser; bool m_defuser;
bool m_vip; bool m_vip;
};
};/* size: 44, cachelines: 1, members: 15 */
typedef std::STD_LIST<CCareerTask *> CareerTaskList; typedef std::STD_LIST<CCareerTask *> CareerTaskList;
typedef CareerTaskList::iterator CareerTaskListIt; typedef CareerTaskList::iterator CareerTaskListIt;
@ -98,13 +96,13 @@ public:
CPreventDefuseTask(const char *taskName, GameEventType event, const char *weaponName, int n, bool mustLive, bool crossRounds, int id, bool isComplete); CPreventDefuseTask(const char *taskName, GameEventType event, const char *weaponName, int n, bool mustLive, bool crossRounds, int id, bool isComplete);
public: public:
virtual void OnEvent(GameEventType event, CBasePlayer *pAttacker, CBasePlayer *pVictim); virtual void OnEvent(GameEventType event, CBasePlayer *pAttacker, CBasePlayer *pVictim);
virtual void Reset(void); virtual void Reset();
virtual bool IsTaskCompletableThisRound(void) { return m_bombPlantedThisRound && !m_defuseStartedThisRound; } virtual bool IsTaskCompletableThisRound() { return m_bombPlantedThisRound && !m_defuseStartedThisRound; }
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void OnEvent_(GameEventType event, CBasePlayer *pAttacker, CBasePlayer *pVictim); void OnEvent_(GameEventType event, CBasePlayer *pAttacker, CBasePlayer *pVictim);
void Reset_(void); void Reset_();
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
@ -114,17 +112,16 @@ public:
protected: protected:
bool m_bombPlantedThisRound; bool m_bombPlantedThisRound;
bool m_defuseStartedThisRound; bool m_defuseStartedThisRound;
};
};/* size: 48, cachelines: 1, members: 3 */
/* <1efed1> ../cstrike/dlls/career_tasks.cpp:636 */ /* <1efed1> ../cstrike/dlls/career_tasks.cpp:636 */
class CCareerTaskManager class CCareerTaskManager
{ {
public: public:
CCareerTaskManager(void); CCareerTaskManager();
public: public:
static void Create(void); static void Create();
void Reset(bool deleteTasks = true); void Reset(bool deleteTasks = true);
void AddTask(const char *taskName, const char *weaponName, int eventCount, bool mustLive, bool crossRounds, bool isComplete); void AddTask(const char *taskName, const char *weaponName, int eventCount, bool mustLive, bool crossRounds, bool isComplete);
@ -136,16 +133,16 @@ public:
void HandleWeaponInjury(int weaponId, int weaponClassId, bool attackerHasShield, CBasePlayer *pAttacker); void HandleWeaponInjury(int weaponId, int weaponClassId, bool attackerHasShield, CBasePlayer *pAttacker);
void HandleEnemyInjury(const char *weaponName, bool attackerHasShield, CBasePlayer *pAttacker); void HandleEnemyInjury(const char *weaponName, bool attackerHasShield, CBasePlayer *pAttacker);
bool AreAllTasksComplete(void); bool AreAllTasksComplete();
int GetNumRemainingTasks(void); int GetNumRemainingTasks();
float GetRoundElapsedTime(void); float GetRoundElapsedTime();
int GetTaskTime(void) { return m_taskTime; } int GetTaskTime() { return m_taskTime; }
void SetFinishedTaskTime(int val); void SetFinishedTaskTime(int val);
int GetFinishedTaskTime(void) { return m_finishedTaskTime; } int GetFinishedTaskTime() { return m_finishedTaskTime; }
int GetFinishedTaskRound(void) { return m_finishedTaskRound; } int GetFinishedTaskRound() { return m_finishedTaskRound; }
CareerTaskList *GetTasks(void) { return &m_tasks; } CareerTaskList *GetTasks() { return &m_tasks; }
void LatchRoundEndMessage(void); void LatchRoundEndMessage();
void UnlatchRoundEndMessage(void); void UnlatchRoundEndMessage();
private: private:
CareerTaskList m_tasks; CareerTaskList m_tasks;
@ -158,25 +155,15 @@ private:
int m_finishedTaskRound; int m_finishedTaskRound;
GameEventType m_roundEndMessage; GameEventType m_roundEndMessage;
bool m_shouldLatchRoundEndMessage; bool m_shouldLatchRoundEndMessage;
};
};/* size: 36, cachelines: 1, members: 8 */
struct TaskInfo struct TaskInfo
{ {
const char *taskName; const char *taskName;
GameEventType event; GameEventType event;
TaskFactoryFunction factory; TaskFactoryFunction factory;
};
};/* size: 12, cachelines: 1, members: 3 */
#ifdef HOOK_GAMEDLL
#define TheCareerTasks (*pTheCareerTasks)
#define taskInfo (*ptaskInfo)
#endif // HOOK_GAMEDLL
extern CCareerTaskManager *TheCareerTasks; extern CCareerTaskManager *TheCareerTasks;
extern const TaskInfo taskInfo[21];
#endif // CAREER_TASK_H #endif // CAREER_TASK_H

View File

@ -70,7 +70,7 @@ static NEW_DLL_FUNCTIONS gNewDLLFunctions
TYPEDESCRIPTION CBaseEntity::m_SaveData[] = TYPEDESCRIPTION CBaseEntity::m_SaveData[] =
{ {
DEFINE_FIELD(CBaseEntity, m_pGoalEnt, FIELD_CLASSPTR), DEFINE_FIELD(CBaseEntity, m_pGoalEnt, FIELD_CLASSPTR),
DEFINE_FIELD(CBaseEntity, m_pfnThink, FIELD_FUNCTION), // UNDONE: Build table of these!!! DEFINE_FIELD(CBaseEntity, m_pfnThink, FIELD_FUNCTION), // UNDONE: Build table of these!
DEFINE_FIELD(CBaseEntity, m_pfnTouch, FIELD_FUNCTION), DEFINE_FIELD(CBaseEntity, m_pfnTouch, FIELD_FUNCTION),
DEFINE_FIELD(CBaseEntity, m_pfnUse, FIELD_FUNCTION), DEFINE_FIELD(CBaseEntity, m_pfnUse, FIELD_FUNCTION),
DEFINE_FIELD(CBaseEntity, m_pfnBlocked, FIELD_FUNCTION), DEFINE_FIELD(CBaseEntity, m_pfnBlocked, FIELD_FUNCTION),
@ -79,15 +79,6 @@ TYPEDESCRIPTION CBaseEntity::m_SaveData[] =
CMemoryPool hashItemMemPool(sizeof(hash_item_t), 64); CMemoryPool hashItemMemPool(sizeof(hash_item_t), 64);
BOOL gTouchDisabled = FALSE; BOOL gTouchDisabled = FALSE;
#else // HOOK_GAMEDLL
DLL_FUNCTIONS gFunctionTable;
NEW_DLL_FUNCTIONS gNewDLLFunctions;
TYPEDESCRIPTION IMPL_CLASS(CBaseEntity, m_SaveData)[5];
CMemoryPool hashItemMemPool;
BOOL gTouchDisabled;
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
/* <30850> ../cstrike/dlls/cbase.cpp:117 */ /* <30850> ../cstrike/dlls/cbase.cpp:117 */
@ -112,7 +103,7 @@ int CaseInsensitiveHash(const char *string, int iBounds)
} }
/* <30d81> ../cstrike/dlls/cbase.cpp:136 */ /* <30d81> ../cstrike/dlls/cbase.cpp:136 */
void EmptyEntityHashTable(void) void EmptyEntityHashTable()
{ {
int i; int i;
hash_item_t *item, *temp, *free; hash_item_t *item, *temp, *free;
@ -279,7 +270,7 @@ void RemoveEntityHashValue(entvars_t *pev, const char *value, hash_types_e field
} }
/* <31125> ../cstrike/dlls/cbase.cpp:337 */ /* <31125> ../cstrike/dlls/cbase.cpp:337 */
void printEntities(void) void printEntities()
{ {
for (int i = 0; i < stringsHashTable.Count(); ++i) for (int i = 0; i < stringsHashTable.Count(); ++i)
{ {
@ -332,7 +323,7 @@ void CONSOLE_ECHO_(char *pszMsg, ...)
} }
/* <31273> ../cstrike/dlls/cbase.cpp:386 */ /* <31273> ../cstrike/dlls/cbase.cpp:386 */
void loopPerformance(void) void loopPerformance()
{ {
CPerformanceCounter loopCounter; CPerformanceCounter loopCounter;
loopCounter.InitializePerformanceCounter(); loopCounter.InitializePerformanceCounter();
@ -770,7 +761,7 @@ void EXT_FUNC SaveReadFields(SAVERESTOREDATA *pSaveData, const char *pname, void
} }
/* <31a74> ../cstrike/dlls/cbase.cpp:802 */ /* <31a74> ../cstrike/dlls/cbase.cpp:802 */
edict_t *EHANDLE::Get(void) edict_t *EHANDLE::Get()
{ {
if (!m_pent || m_pent->serialnumber != m_serialnumber) if (!m_pent || m_pent->serialnumber != m_serialnumber)
return NULL; return NULL;
@ -789,7 +780,7 @@ edict_t *EHANDLE::Set(edict_t *pent)
} }
/* <31ace> ../cstrike/dlls/cbase.cpp:823 */ /* <31ace> ../cstrike/dlls/cbase.cpp:823 */
EHANDLE::operator CBaseEntity *(void) EHANDLE::operator CBaseEntity *()
{ {
return (CBaseEntity *)GET_PRIVATE(Get()); return (CBaseEntity *)GET_PRIVATE(Get());
} }
@ -813,13 +804,13 @@ CBaseEntity *EHANDLE::operator=(CBaseEntity *pEntity)
} }
/* <31b69> ../cstrike/dlls/cbase.cpp:845 */ /* <31b69> ../cstrike/dlls/cbase.cpp:845 */
EHANDLE::operator int(void) EHANDLE::operator int()
{ {
return Get() != NULL; return Get() != NULL;
} }
/* <31bac> ../cstrike/dlls/cbase.cpp:850 */ /* <31bac> ../cstrike/dlls/cbase.cpp:850 */
CBaseEntity *EHANDLE::operator->(void) CBaseEntity *EHANDLE::operator->()
{ {
return (CBaseEntity *)GET_PRIVATE(Get()); return (CBaseEntity *)GET_PRIVATE(Get());
} }
@ -902,7 +893,7 @@ void CBaseEntity::__MAKE_VHOOK(Killed)(entvars_t *pevAttacker, int iGib)
} }
/* <2fc1c> ../cstrike/dlls/cbase.cpp:935 */ /* <2fc1c> ../cstrike/dlls/cbase.cpp:935 */
CBaseEntity *CBaseEntity::__MAKE_VHOOK(GetNextTarget)(void) CBaseEntity *CBaseEntity::__MAKE_VHOOK(GetNextTarget)()
{ {
if (FStringNull(pev->target)) if (FStringNull(pev->target))
return NULL; return NULL;
@ -1004,7 +995,7 @@ void SetObjectCollisionBox(entvars_t *pev)
} }
/* <2fe2a> ../cstrike/dlls/cbase.cpp:1030 */ /* <2fe2a> ../cstrike/dlls/cbase.cpp:1030 */
void CBaseEntity::__MAKE_VHOOK(SetObjectCollisionBox)(void) void CBaseEntity::__MAKE_VHOOK(SetObjectCollisionBox)()
{ {
::SetObjectCollisionBox(pev); ::SetObjectCollisionBox(pev);
} }
@ -1023,7 +1014,7 @@ int CBaseEntity::Intersects(CBaseEntity *pOther)
} }
/* <31c43> ../cstrike/dlls/cbase.cpp:1048 */ /* <31c43> ../cstrike/dlls/cbase.cpp:1048 */
void CBaseEntity::MakeDormant(void) void CBaseEntity::MakeDormant()
{ {
pev->flags |= FL_DORMANT; pev->flags |= FL_DORMANT;
@ -1044,13 +1035,13 @@ void CBaseEntity::MakeDormant(void)
} }
/* <31c66> ../cstrike/dlls/cbase.cpp:1064 */ /* <31c66> ../cstrike/dlls/cbase.cpp:1064 */
int CBaseEntity::IsDormant(void) int CBaseEntity::IsDormant()
{ {
return (pev->flags & FL_DORMANT) == FL_DORMANT; return (pev->flags & FL_DORMANT) == FL_DORMANT;
} }
/* <30221> ../cstrike/dlls/cbase.cpp:1069 */ /* <30221> ../cstrike/dlls/cbase.cpp:1069 */
BOOL CBaseEntity::__MAKE_VHOOK(IsInWorld)(void) BOOL CBaseEntity::__MAKE_VHOOK(IsInWorld)()
{ {
// position // position
if (pev->origin.x >= 4096.0 || pev->origin.y >= 4096.0 || pev->origin.z >= 4096.0) if (pev->origin.x >= 4096.0 || pev->origin.y >= 4096.0 || pev->origin.z >= 4096.0)
@ -1136,72 +1127,3 @@ void OnFreeEntPrivateData(edict_t *pEnt)
pEntity->UpdateOnRemove(); pEntity->UpdateOnRemove();
RemoveEntityHashValue(pEntity->pev, STRING(pEntity->pev->classname), CLASSNAME); RemoveEntityHashValue(pEntity->pev, STRING(pEntity->pev->classname), CLASSNAME);
} }
#ifdef HOOK_GAMEDLL
int CBaseEntity::Save(CSave &save)
{
return Save_(save);
}
int CBaseEntity::Restore(CRestore &restore)
{
return Restore_(restore);
}
void CBaseEntity::SetObjectCollisionBox(void)
{
SetObjectCollisionBox_();
}
void CBaseEntity::TraceAttack(entvars_t *pevAttacker,float flDamage,Vector vecDir,TraceResult *ptr,int bitsDamageType)
{
TraceAttack_(pevAttacker,flDamage,vecDir,ptr,bitsDamageType);
}
int CBaseEntity::TakeDamage(entvars_t *pevInflictor,entvars_t *pevAttacker,float flDamage,int bitsDamageType)
{
return TakeDamage_(pevInflictor,pevAttacker,flDamage,bitsDamageType);
}
int CBaseEntity::TakeHealth(float flHealth,int bitsDamageType)
{
return TakeHealth_(flHealth, bitsDamageType);
}
void CBaseEntity::Killed(entvars_t *pevAttacker,int iGib)
{
Killed_(pevAttacker,iGib);
}
void CBaseEntity::TraceBleed(float flDamage,Vector vecDir,TraceResult *ptr,int bitsDamageType)
{
TraceBleed_(flDamage,vecDir,ptr,bitsDamageType);
}
int CBaseEntity::DamageDecal(int bitsDamageType)
{
return DamageDecal_(bitsDamageType);
}
BOOL CBaseEntity::IsInWorld(void)
{
return IsInWorld_();
}
CBaseEntity *CBaseEntity::GetNextTarget(void)
{
return GetNextTarget_();
}
BOOL CBaseEntity::FVisible(CBaseEntity *pEntity)
{
return FVisible_(pEntity);
}
BOOL CBaseEntity::FVisible(const Vector &vecOrigin)
{
return FVisible_(vecOrigin);
}
#endif // HOOK_GAMEDLL

View File

@ -52,7 +52,7 @@
#define FCAP_FORCE_TRANSITION 0x00000080 #define FCAP_FORCE_TRANSITION 0x00000080
#define SetThink(a)\ #define SetThink(a)\
m_pfnThink = static_cast<void (CBaseEntity::*)(void)>(a) m_pfnThink = static_cast<void (CBaseEntity::*)()>(a)
#define SetTouch(a)\ #define SetTouch(a)\
m_pfnTouch = static_cast<void (CBaseEntity::*)(CBaseEntity *)>(a) m_pfnTouch = static_cast<void (CBaseEntity::*)(CBaseEntity *)>(a)
#define SetUse(a)\ #define SetUse(a)\
@ -61,7 +61,7 @@
m_pfnBlocked = static_cast<void (CBaseEntity::*)(CBaseEntity *)>(a) m_pfnBlocked = static_cast<void (CBaseEntity::*)(CBaseEntity *)>(a)
#define SetMoveDone(a)\ #define SetMoveDone(a)\
m_pfnCallWhenMoveDone = static_cast<void (CBaseToggle::*)(void)>(a) m_pfnCallWhenMoveDone = static_cast<void (CBaseToggle::*)()>(a)
#define CLASS_NONE 0 #define CLASS_NONE 0
#define CLASS_MACHINE 1 #define CLASS_MACHINE 1
@ -177,7 +177,7 @@
#define MS_MAX_TARGETS 32 #define MS_MAX_TARGETS 32
#ifdef _WIN32 #ifdef _WIN32
#define EXPORT _declspec(dllexport) #define EXPORT __declspec(dllexport)
#else #else
#define EXPORT /**/ #define EXPORT /**/
#endif // _WIN32 #endif // _WIN32
@ -195,7 +195,6 @@ typedef struct hash_item_s
int pevIndex; int pevIndex;
} hash_item_t; } hash_item_t;
/* size: 16, cachelines: 1, members: 4 */
typedef struct locksounds typedef struct locksounds
{ {
@ -211,7 +210,6 @@ typedef struct locksounds
BYTE bEOFUnlocked; BYTE bEOFUnlocked;
} locksound_t; } locksound_t;
/* size: 36, cachelines: 1, members: 10 */
typedef enum typedef enum
{ {
@ -240,44 +238,15 @@ class CSquadMonster;
class CCineMonster; class CCineMonster;
class CSound; class CSound;
#ifdef HOOK_GAMEDLL
#define stringsHashTable (*pstringsHashTable)
#define hashItemMemPool (*phashItemMemPool)
#define gTouchDisabled (*pgTouchDisabled)
#define gFunctionTable (*pgFunctionTable)
#define gNewDLLFunctions (*pgNewDLLFunctions)
#define grgszTextureName (*pgrgszTextureName)
#define grgchTextureType (*pgrgchTextureType)
#define fTextureTypeInit (*pfTextureTypeInit)
#define gcTextures (*pgcTextures)
#endif // HOOK_GAMEDLL
extern CMemoryPool hashItemMemPool;
extern BOOL gTouchDisabled;
extern DLL_FUNCTIONS gFunctionTable;
extern NEW_DLL_FUNCTIONS gNewDLLFunctions;
extern char grgszTextureName[ CTEXTURESMAX ][ CBTEXTURENAMEMAX ];
extern char grgchTextureType[ CTEXTURESMAX ];
extern int fTextureTypeInit;
extern int gcTextures;
extern CUtlVector< hash_item_t > stringsHashTable;
class EHANDLE class EHANDLE
{ {
public: public:
edict_t *Get(void); edict_t *Get();
edict_t *Set(edict_t *pent); edict_t *Set(edict_t *pent);
operator int(); operator int();
operator CBaseEntity*(); operator CBaseEntity*();
operator CBasePlayer*() { return static_cast<CBasePlayer *>(GET_PRIVATE(Get())); } // custom operator CBasePlayer*() { return static_cast<CBasePlayer *>(GET_PRIVATE(Get())); }
CBaseEntity *operator=(CBaseEntity *pEntity); CBaseEntity *operator=(CBaseEntity *pEntity);
CBaseEntity *operator->(); CBaseEntity *operator->();
@ -285,124 +254,57 @@ public:
private: private:
edict_t *m_pent; edict_t *m_pent;
int m_serialnumber; int m_serialnumber;
};
};/* size: 8, cachelines: 1, members: 2 */
/* <48e9c1> ../cstrike/dlls/cbase.h:166 */ /* <48e9c1> ../cstrike/dlls/cbase.h:166 */
class CBaseEntity class CBaseEntity
{ {
public: public:
virtual void Spawn(void) {} virtual void Spawn() {}
virtual void Precache(void) {} virtual void Precache() {}
virtual void Restart(void) {} virtual void Restart() {}
virtual void KeyValue(KeyValueData *pkvd) virtual void KeyValue(KeyValueData *pkvd) { pkvd->fHandled = FALSE; }
{
pkvd->fHandled = FALSE;
}
virtual int Save(CSave &save); virtual int Save(CSave &save);
virtual int Restore(CRestore &restore); virtual int Restore(CRestore &restore);
virtual int ObjectCaps(void) virtual int ObjectCaps() { return FCAP_ACROSS_TRANSITION; }
{ virtual void Activate() {}
return FCAP_ACROSS_TRANSITION; virtual void SetObjectCollisionBox();
} virtual int Classify() { return CLASS_NONE; }
virtual void Activate(void) {}
virtual void SetObjectCollisionBox(void);
virtual int Classify(void)
{
return CLASS_NONE;
}
virtual void DeathNotice(entvars_t *pevChild) {} virtual void DeathNotice(entvars_t *pevChild) {}
virtual void TraceAttack(entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType); virtual void TraceAttack(entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType);
virtual int TakeDamage(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType); virtual int TakeDamage(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType);
virtual int TakeHealth(float flHealth, int bitsDamageType); virtual int TakeHealth(float flHealth, int bitsDamageType);
virtual void Killed(entvars_t *pevAttacker, int iGib); virtual void Killed(entvars_t *pevAttacker, int iGib);
virtual int BloodColor(void) virtual int BloodColor() { return DONT_BLEED; }
{
return DONT_BLEED;
}
virtual void TraceBleed(float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType); virtual void TraceBleed(float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType);
virtual BOOL IsTriggered(CBaseEntity *pActivator) virtual BOOL IsTriggered(CBaseEntity *pActivator) { return TRUE; }
{ virtual CBaseMonster *MyMonsterPointer() { return NULL; }
return TRUE; virtual CSquadMonster *MySquadMonsterPointer() { return NULL; }
} virtual int GetToggleState() { return TS_AT_TOP; }
virtual CBaseMonster *MyMonsterPointer(void)
{
return NULL;
}
virtual CSquadMonster *MySquadMonsterPointer(void)
{
return NULL;
}
virtual int GetToggleState(void)
{
return TS_AT_TOP;
}
virtual void AddPoints(int score, BOOL bAllowNegativeScore) {} virtual void AddPoints(int score, BOOL bAllowNegativeScore) {}
virtual void AddPointsToTeam(int score, BOOL bAllowNegativeScore) {} virtual void AddPointsToTeam(int score, BOOL bAllowNegativeScore) {}
virtual BOOL AddPlayerItem(CBasePlayerItem *pItem) virtual BOOL AddPlayerItem(CBasePlayerItem *pItem) { return FALSE; }
{ virtual BOOL RemovePlayerItem(CBasePlayerItem *pItem) { return FALSE; }
return FALSE; virtual int GiveAmmo(int iAmount, char *szName, int iMax) { return -1; }
} virtual float GetDelay() { return 0.0f; }
virtual BOOL RemovePlayerItem(CBasePlayerItem *pItem) virtual int IsMoving() { return (pev->velocity != g_vecZero); }
{ virtual void OverrideReset() {}
return FALSE;
}
virtual int GiveAmmo(int iAmount, char *szName, int iMax)
{
return -1;
}
virtual float GetDelay(void)
{
return 0.0f;
}
virtual int IsMoving(void)
{
return (pev->velocity != g_vecZero);
}
virtual void OverrideReset(void) {}
virtual int DamageDecal(int bitsDamageType); virtual int DamageDecal(int bitsDamageType);
virtual void SetToggleState(int state) {} virtual void SetToggleState(int state) {}
virtual void StartSneaking(void) {} virtual void StartSneaking() {}
virtual void StopSneaking(void) {} virtual void StopSneaking() {}
virtual BOOL OnControls(entvars_t *onpev) virtual BOOL OnControls(entvars_t *onpev) { return FALSE; }
{ virtual BOOL IsSneaking() { return FALSE; }
return FALSE; virtual BOOL IsAlive() { return (pev->deadflag == DEAD_NO && pev->health > 0.0f); }
} virtual BOOL IsBSPModel() { return (pev->solid == SOLID_BSP || pev->movetype == MOVETYPE_PUSHSTEP); }
virtual BOOL IsSneaking(void) virtual BOOL ReflectGauss() { return (IsBSPModel() && pev->takedamage == DAMAGE_NO); }
{ virtual BOOL HasTarget(string_t targetname) { return FStrEq(STRING(targetname),STRING(pev->targetname)); }
return FALSE; virtual BOOL IsInWorld();
} virtual BOOL IsPlayer() { return FALSE; }
virtual BOOL IsAlive(void) virtual BOOL IsNetClient() { return FALSE; }
{ virtual const char *TeamID() { return ""; }
return (pev->deadflag == DEAD_NO && pev->health > 0.0f); virtual CBaseEntity *GetNextTarget();
} virtual void Think()
virtual BOOL IsBSPModel(void)
{
return (pev->solid == SOLID_BSP || pev->movetype == MOVETYPE_PUSHSTEP);
}
virtual BOOL ReflectGauss(void)
{
return (IsBSPModel() && pev->takedamage == DAMAGE_NO);
}
virtual BOOL HasTarget(string_t targetname)
{
return FStrEq(STRING(targetname),STRING(pev->targetname));
}
virtual BOOL IsInWorld(void);
virtual BOOL IsPlayer(void)
{
return FALSE;
}
virtual BOOL IsNetClient(void)
{
return FALSE;
}
virtual const char *TeamID(void)
{
return "";
}
virtual CBaseEntity *GetNextTarget(void);
virtual void Think(void)
{ {
if (m_pfnThink) if (m_pfnThink)
{ {
@ -430,35 +332,14 @@ public:
(this->*m_pfnBlocked)(pOther); (this->*m_pfnBlocked)(pOther);
} }
} }
virtual CBaseEntity *Respawn(void) virtual CBaseEntity *Respawn() { return NULL; }
{ virtual void UpdateOwner() {}
return NULL; virtual BOOL FBecomeProne() { return FALSE; }
} virtual Vector Center() { return (pev->absmax + pev->absmin) * 0.5f; }
virtual void UpdateOwner(void) {} virtual Vector EyePosition() { return (pev->origin + pev->view_ofs); }
virtual BOOL FBecomeProne(void) virtual Vector EarPosition() { return (pev->origin + pev->view_ofs); }
{ virtual Vector BodyTarget(const Vector &posSrc) { return Center(); }
return FALSE; virtual int Illumination() { return GETENTITYILLUM(ENT(pev)); }
}
virtual Vector Center(void)
{
return (pev->absmax + pev->absmin) * 0.5f;
}
virtual Vector EyePosition(void)
{
return (pev->origin + pev->view_ofs);
}
virtual Vector EarPosition(void)
{
return (pev->origin + pev->view_ofs);
}
virtual Vector BodyTarget(const Vector &posSrc)
{
return Center();
}
virtual int Illumination(void)
{
return GETENTITYILLUM(ENT(pev));
}
virtual BOOL FVisible(CBaseEntity *pEntity); virtual BOOL FVisible(CBaseEntity *pEntity);
virtual BOOL FVisible(const Vector &vecOrigin); virtual BOOL FVisible(const Vector &vecOrigin);
@ -467,62 +348,43 @@ public:
int Save_(CSave &save); int Save_(CSave &save);
int Restore_(CRestore &restore); int Restore_(CRestore &restore);
void SetObjectCollisionBox_(void); void SetObjectCollisionBox_();
void TraceAttack_(entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType); void TraceAttack_(entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType);
int TakeDamage_(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType); int TakeDamage_(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType);
int TakeHealth_(float flHealth, int bitsDamageType); int TakeHealth_(float flHealth, int bitsDamageType);
void Killed_(entvars_t *pevAttacker, int iGib); void Killed_(entvars_t *pevAttacker, int iGib);
void TraceBleed_(float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType); void TraceBleed_(float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType);
int DamageDecal_(int bitsDamageType); int DamageDecal_(int bitsDamageType);
BOOL IsInWorld_(void); BOOL IsInWorld_();
CBaseEntity *GetNextTarget_(void); CBaseEntity *GetNextTarget_();
BOOL FVisible_(CBaseEntity *pEntity); BOOL FVisible_(CBaseEntity *pEntity);
BOOL FVisible_(const Vector &vecOrigin); BOOL FVisible_(const Vector &vecOrigin);
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
public: public:
void *operator new(size_t stAllocateBlock, entvars_t *pevnew) void *operator new(size_t stAllocateBlock, entvars_t *pevnew) { return ALLOC_PRIVATE(ENT(pevnew), stAllocateBlock); }
{ void operator delete(void *pMem, entvars_t *pev) { pev->flags |= FL_KILLME; }
return ALLOC_PRIVATE(ENT(pevnew), stAllocateBlock); void UpdateOnRemove();
} void EXPORT SUB_Remove();
void operator delete(void *pMem, entvars_t *pev) void EXPORT SUB_DoNothing();
{ void EXPORT SUB_StartFadeOut();
pev->flags |= FL_KILLME; void EXPORT SUB_FadeOut();
} void EXPORT SUB_CallUseToggle() { Use(this, this, USE_TOGGLE, 0); }
void UpdateOnRemove(void);
void EXPORT SUB_Remove(void);
void EXPORT SUB_DoNothing(void);
void EXPORT SUB_StartFadeOut(void);
void EXPORT SUB_FadeOut(void);
void EXPORT SUB_CallUseToggle(void)
{
Use(this, this, USE_TOGGLE, 0);
}
int ShouldToggle(USE_TYPE useType, BOOL currentState); int ShouldToggle(USE_TYPE useType, BOOL currentState);
void FireBullets(ULONG cShots, Vector vecSrc, Vector vecDirShooting, Vector vecSpread, float flDistance, int iBulletType, int iTracerFreq = 4, int iDamage = 0, entvars_t *pevAttacker = NULL); void FireBullets(ULONG cShots, Vector vecSrc, Vector vecDirShooting, Vector vecSpread, float flDistance, int iBulletType, int iTracerFreq = 4, int iDamage = 0, entvars_t *pevAttacker = NULL);
Vector FireBullets3(Vector vecSrc, Vector vecDirShooting, float vecSpread, float flDistance, int iPenetration, int iBulletType, int iDamage, float flRangeModifier, entvars_t *pevAttacker, bool bPistol, int shared_rand = 0); Vector FireBullets3(Vector vecSrc, Vector vecDirShooting, float vecSpread, float flDistance, int iPenetration, int iBulletType, int iDamage, float flRangeModifier, entvars_t *pevAttacker, bool bPistol, int shared_rand = 0);
void SUB_UseTargets(CBaseEntity *pActivator, USE_TYPE useType, float value); void SUB_UseTargets(CBaseEntity *pActivator, USE_TYPE useType, float value);
int Intersects(CBaseEntity *pOther); int Intersects(CBaseEntity *pOther);
void MakeDormant(void); void MakeDormant();
int IsDormant(void); int IsDormant();
BOOL IsLockedByMaster(void) BOOL IsLockedByMaster() { return FALSE; }
{
return FALSE;
}
public: public:
static CBaseEntity *Instance(edict_t *pent) static CBaseEntity *Instance(edict_t *pent) { return (CBaseEntity *)GET_PRIVATE(pent ? pent : ENT(0)); }
{ static CBaseEntity *Instance(entvars_t *pev) { return Instance(ENT(pev)); }
return (CBaseEntity *)GET_PRIVATE(pent ? pent : ENT(0)); static CBaseEntity *Instance(int offset) { return Instance(ENT(offset)); }
}
static CBaseEntity *Instance(entvars_t *pev)
{
return Instance(ENT(pev));
}
static CBaseEntity *Instance(int offset)
{
return Instance(ENT(offset));
}
CBaseMonster *GetMonsterPointer(entvars_t *pevMonster) CBaseMonster *GetMonsterPointer(entvars_t *pevMonster)
{ {
CBaseEntity *pEntity = Instance(pevMonster); CBaseEntity *pEntity = Instance(pevMonster);
@ -539,19 +401,12 @@ public:
return pEntity->MyMonsterPointer(); return pEntity->MyMonsterPointer();
return NULL; return NULL;
} }
static CBaseEntity *Create(char *szName, const Vector &vecOrigin, const Vector &vecAngles, edict_t *pentOwner = NULL); static CBaseEntity *Create(char *szName, const Vector &vecOrigin, const Vector &vecAngles, edict_t *pentOwner = NULL);
edict_t *edict(void) edict_t *edict() { return ENT(pev); }
{ EOFFSET eoffset() { return OFFSET(pev); }
return ENT(pev); int entindex() { return ENTINDEX(edict()); }
}
EOFFSET eoffset(void)
{
return OFFSET(pev);
}
int entindex(void)
{
return ENTINDEX(edict());
}
public: public:
entvars_t *pev; entvars_t *pev;
CBaseEntity *m_pGoalEnt; CBaseEntity *m_pGoalEnt;
@ -559,17 +414,10 @@ public:
static TYPEDESCRIPTION IMPL(m_SaveData)[5]; static TYPEDESCRIPTION IMPL(m_SaveData)[5];
void (CBaseEntity::*m_pfnThink)(void); void (CBaseEntity::*m_pfnThink)();
//int m_pfnThink_Flag;
void (CBaseEntity::*m_pfnTouch)(CBaseEntity *pOther); void (CBaseEntity::*m_pfnTouch)(CBaseEntity *pOther);
//int m_pfnTouch_Flag;
void (CBaseEntity::*m_pfnUse)(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value); void (CBaseEntity::*m_pfnUse)(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
//int m_pfnUse_Flag;
void (CBaseEntity::*m_pfnBlocked)(CBaseEntity *pOther); void (CBaseEntity::*m_pfnBlocked)(CBaseEntity *pOther);
//int m_pfnBlocked_Flag;
int *current_ammo; int *current_ammo;
float currentammo; float currentammo;
@ -597,8 +445,7 @@ public:
float m_flReleaseThrow; float m_flReleaseThrow;
int m_iSwing; int m_iSwing;
bool has_disconnected; bool has_disconnected;
};
};/* size: 152, cachelines: 3, members: 35 */
/* <48d2a5> ../cstrike/dlls/cbase.h:273 */ /* <48d2a5> ../cstrike/dlls/cbase.h:273 */
inline int FNullEnt(CBaseEntity *ent) inline int FNullEnt(CBaseEntity *ent)
@ -616,38 +463,32 @@ inline int FNullEnt(EHANDLE hent)
class CPointEntity: public CBaseEntity class CPointEntity: public CBaseEntity
{ {
public: public:
virtual void Spawn(void); virtual void Spawn();
virtual int ObjectCaps(void) virtual int ObjectCaps() { return (CBaseEntity::ObjectCaps() & ~FCAP_ACROSS_TRANSITION); }
{
return (CBaseEntity::ObjectCaps() & ~FCAP_ACROSS_TRANSITION);
}
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Spawn_(void); void Spawn_();
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
};/* size: 152, cachelines: 3, members: 1 */ };
/* <249f0> ../cstrike/dlls/cbase.h:484 */ /* <249f0> ../cstrike/dlls/cbase.h:484 */
class CMultiSource: public CPointEntity class CMultiSource: public CPointEntity
{ {
public: public:
virtual void Spawn(void); virtual void Spawn();
virtual void KeyValue(KeyValueData *pkvd); virtual void KeyValue(KeyValueData *pkvd);
virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value); virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
virtual int ObjectCaps(void) virtual int ObjectCaps() { return (CPointEntity::ObjectCaps() | FCAP_MASTER); }
{
return (CPointEntity::ObjectCaps() | FCAP_MASTER);
}
virtual BOOL IsTriggered(CBaseEntity *pActivator); virtual BOOL IsTriggered(CBaseEntity *pActivator);
virtual int Save(CSave &save); virtual int Save(CSave &save);
virtual int Restore(CRestore &restore); virtual int Restore(CRestore &restore);
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Spawn_(void); void Spawn_();
void KeyValue_(KeyValueData *pkvd); void KeyValue_(KeyValueData *pkvd);
void Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value); void Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
BOOL IsTriggered_(CBaseEntity *pActivator); BOOL IsTriggered_(CBaseEntity *pActivator);
@ -657,7 +498,7 @@ public:
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
public: public:
void EXPORT Register(void); void EXPORT Register();
public: public:
static TYPEDESCRIPTION IMPL(m_SaveData)[4]; static TYPEDESCRIPTION IMPL(m_SaveData)[4];
@ -666,8 +507,7 @@ public:
int m_rgTriggered[MS_MAX_TARGETS]; int m_rgTriggered[MS_MAX_TARGETS];
int m_iTotal; int m_iTotal;
string_t m_globalstate; string_t m_globalstate;
};
};/* size: 544, cachelines: 9, members: 6 */
/* <48ea00> ../cstrike/dlls/cbase.h:509 */ /* <48ea00> ../cstrike/dlls/cbase.h:509 */
class CBaseDelay: public CBaseEntity class CBaseDelay: public CBaseEntity
@ -687,14 +527,13 @@ public:
public: public:
void SUB_UseTargets(CBaseEntity *pActivator, USE_TYPE useType, float value); void SUB_UseTargets(CBaseEntity *pActivator, USE_TYPE useType, float value);
void EXPORT DelayThink(void); void EXPORT DelayThink();
public: public:
static TYPEDESCRIPTION IMPL(m_SaveData)[2]; static TYPEDESCRIPTION IMPL(m_SaveData)[2];
float m_flDelay; float m_flDelay;
int m_iszKillTarget; int m_iszKillTarget;
};
};/* size: 160, cachelines: 3, members: 4 */
/* <48ea6f> ../cstrike/dlls/cbase.h:526 */ /* <48ea6f> ../cstrike/dlls/cbase.h:526 */
class CBaseAnimating: public CBaseDelay class CBaseAnimating: public CBaseDelay
@ -713,14 +552,14 @@ public:
public: public:
float StudioFrameAdvance(float flInterval = 0.0f); float StudioFrameAdvance(float flInterval = 0.0f);
BOOL GetSequenceFlags(void); BOOL GetSequenceFlags();
int LookupActivity(int activity); int LookupActivity(int activity);
int LookupActivityHeaviest(int activity); int LookupActivityHeaviest(int activity);
int LookupSequence(const char *label); int LookupSequence(const char *label);
void ResetSequenceInfo(void); void ResetSequenceInfo();
void DispatchAnimEvents(float flFutureInterval = 0.1f); void DispatchAnimEvents(float flFutureInterval = 0.1f);
float SetBoneController(int iController, float flValue = 0.0f); float SetBoneController(int iController, float flValue = 0.0f);
void InitBoneControllers(void); void InitBoneControllers();
NOXREF float SetBlending(int iBlender, float flValue); NOXREF float SetBlending(int iBlender, float flValue);
NOXREF void GetBonePosition(int iBone, Vector &origin, Vector &angles); NOXREF void GetBonePosition(int iBone, Vector &origin, Vector &angles);
@ -731,7 +570,7 @@ public:
NOXREF int GetBodygroup(int iGroup); NOXREF int GetBodygroup(int iGroup);
int ExtractBbox(int sequence, float *mins, float *maxs); int ExtractBbox(int sequence, float *mins, float *maxs);
void SetSequenceBox(void); void SetSequenceBox();
public: public:
static TYPEDESCRIPTION IMPL(m_SaveData)[5]; static TYPEDESCRIPTION IMPL(m_SaveData)[5];
@ -740,8 +579,7 @@ public:
float m_flLastEventCheck; float m_flLastEventCheck;
BOOL m_fSequenceFinished; BOOL m_fSequenceFinished;
BOOL m_fSequenceLoops; BOOL m_fSequenceLoops;
};
};/* size: 180, cachelines: 3, members: 7 */
/* <48eb06> ../cstrike/dlls/cbase.h:569 */ /* <48eb06> ../cstrike/dlls/cbase.h:569 */
class CBaseToggle: public CBaseAnimating class CBaseToggle: public CBaseAnimating
@ -750,14 +588,9 @@ public:
virtual void KeyValue(KeyValueData *pkvd); virtual void KeyValue(KeyValueData *pkvd);
virtual int Save(CSave &save); virtual int Save(CSave &save);
virtual int Restore(CRestore &restore); virtual int Restore(CRestore &restore);
virtual int GetToggleState(void) virtual int GetToggleState() { return m_toggle_state; }
{ virtual float GetDelay() { return m_flWait; }
return m_toggle_state;
}
virtual float GetDelay(void)
{
return m_flWait;
}
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void KeyValue_(KeyValueData *pkvd); void KeyValue_(KeyValueData *pkvd);
@ -768,10 +601,10 @@ public:
public: public:
void LinearMove(Vector vecDest, float flSpeed); void LinearMove(Vector vecDest, float flSpeed);
void EXPORT LinearMoveDone(void); void EXPORT LinearMoveDone();
void AngularMove(Vector vecDestAngle, float flSpeed); void AngularMove(Vector vecDestAngle, float flSpeed);
void EXPORT AngularMoveDone(void); void EXPORT AngularMoveDone();
NOXREF BOOL IsLockedByMaster(void); NOXREF BOOL IsLockedByMaster();
public: public:
static float AxisValue(int flags, const Vector &angles); static float AxisValue(int flags, const Vector &angles);
@ -795,13 +628,12 @@ public:
int m_cTriggersLeft; int m_cTriggersLeft;
float m_flHeight; float m_flHeight;
EHANDLE m_hActivator; EHANDLE m_hActivator;
void (CBaseToggle::*m_pfnCallWhenMoveDone)(void); void (CBaseToggle::*m_pfnCallWhenMoveDone)();
Vector m_vecFinalDest; Vector m_vecFinalDest;
Vector m_vecFinalAngle; Vector m_vecFinalAngle;
int m_bitsDamageInflict; int m_bitsDamageInflict;
string_t m_sMaster; string_t m_sMaster;
};
};/* size: 312, cachelines: 5, members: 21 */
#include "basemonster.h" #include "basemonster.h"
@ -818,13 +650,13 @@ class CBaseButton: public CBaseToggle
}; };
public: public:
virtual void Spawn(void); virtual void Spawn();
virtual void Precache(void); virtual void Precache();
virtual void KeyValue(KeyValueData *pkvd); virtual void KeyValue(KeyValueData *pkvd);
virtual int TakeDamage(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType); virtual int TakeDamage(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType);
virtual int Save(CSave &save); virtual int Save(CSave &save);
virtual int Restore(CRestore &restore); virtual int Restore(CRestore &restore);
virtual int ObjectCaps(void) virtual int ObjectCaps()
{ {
if (pev->takedamage == DAMAGE_NO) if (pev->takedamage == DAMAGE_NO)
{ {
@ -836,8 +668,8 @@ public:
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Spawn_(void); void Spawn_();
void Precache_(void); void Precache_();
void KeyValue_(KeyValueData *pkvd); void KeyValue_(KeyValueData *pkvd);
int TakeDamage_(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType); int TakeDamage_(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType);
int Save_(CSave &save); int Save_(CSave &save);
@ -846,19 +678,19 @@ public:
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
public: public:
NOXREF void RotSpawn(void); NOXREF void RotSpawn();
void ButtonActivate(void); void ButtonActivate();
NOXREF void SparkSoundCache(void); NOXREF void SparkSoundCache();
NOXREF void EXPORT ButtonShot(void); NOXREF void EXPORT ButtonShot();
void EXPORT ButtonTouch(CBaseEntity *pOther); void EXPORT ButtonTouch(CBaseEntity *pOther);
void EXPORT ButtonSpark(void); void EXPORT ButtonSpark();
void EXPORT TriggerAndWait(void); void EXPORT TriggerAndWait();
void EXPORT ButtonReturn(void); void EXPORT ButtonReturn();
void EXPORT ButtonBackHome(void); void EXPORT ButtonBackHome();
void EXPORT ButtonUse(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value); void EXPORT ButtonUse(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
BUTTON_CODE ButtonResponseToTouch(void); BUTTON_CODE ButtonResponseToTouch();
public: public:
static TYPEDESCRIPTION IMPL(m_SaveData)[8]; static TYPEDESCRIPTION IMPL(m_SaveData)[8];
@ -872,60 +704,25 @@ public:
BYTE m_bUnlockedSound; BYTE m_bUnlockedSound;
BYTE m_bUnlockedSentence; BYTE m_bUnlockedSentence;
int m_sounds; int m_sounds;
};
};/* size: 368, cachelines: 6, members: 11 */
/* <1da023> ../cstrike/dlls/cbase.h:861 */ /* <1da023> ../cstrike/dlls/cbase.h:861 */
class CWorld: public CBaseEntity class CWorld: public CBaseEntity
{ {
public: public:
virtual void Spawn(void); virtual void Spawn();
virtual void Precache(void); virtual void Precache();
virtual void KeyValue(KeyValueData *pkvd); virtual void KeyValue(KeyValueData *pkvd);
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Spawn_(void); void Spawn_();
void Precache_(void); void Precache_();
void KeyValue_(KeyValueData *pkvd); void KeyValue_(KeyValueData *pkvd);
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
};/* size: 152, cachelines: 3, members: 1 */ };
/* <1d9f84> ../cstrike/dlls/world.cpp:111 */
class CDecal: public CBaseEntity
{
public:
virtual void Spawn(void);
virtual void KeyValue(KeyValueData *);
#ifdef HOOK_GAMEDLL
void Spawn_(void);
void KeyValue_(KeyValueData *);
#endif // HOOK_GAMEDLL
public:
void EXPORT StaticDecal(void);
void EXPORT TriggerDecal(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
};/* size: 152, cachelines: 3, members: 1 */
// Body queue class here.... It's really just CBaseEntity
/* <1d9fd1> ../cstrike/dlls/world.cpp:207 */
class CCorpse: public CBaseEntity
{
public:
/* <1dabe0> ../cstrike/dlls/world.cpp:209 */
virtual int ObjectCaps(void)
{
return FCAP_DONT_SAVE;
}
};/* size: 152, cachelines: 3, members: 1 */
template <class T> template <class T>
T *GetClassPtr(T *a) T *GetClassPtr(T *a)
@ -944,18 +741,21 @@ T *GetClassPtr(T *a)
#endif // _WIN32 && HOOK_GAMEDLL #endif // _WIN32 && HOOK_GAMEDLL
} }
return a; return a;
} }
extern CUtlVector<hash_item_t> stringsHashTable;
int CaseInsensitiveHash(const char *string, int iBounds); int CaseInsensitiveHash(const char *string, int iBounds);
void EmptyEntityHashTable(void); void EmptyEntityHashTable();
void AddEntityHashValue(entvars_t *pev, const char *value, hash_types_e fieldType); void AddEntityHashValue(entvars_t *pev, const char *value, hash_types_e fieldType);
void RemoveEntityHashValue(entvars_t *pev, const char *value, hash_types_e fieldType); void RemoveEntityHashValue(entvars_t *pev, const char *value, hash_types_e fieldType);
void printEntities(void); void printEntities();
edict_t *CREATE_NAMED_ENTITY(string_t iClass); edict_t *CREATE_NAMED_ENTITY(string_t iClass);
void REMOVE_ENTITY(edict_t *e); void REMOVE_ENTITY(edict_t *e);
void CONSOLE_ECHO_(char *pszMsg, ...); void CONSOLE_ECHO_(char *pszMsg, ...);
void loopPerformance(void); void loopPerformance();
C_DLLEXPORT int GetEntityAPI(DLL_FUNCTIONS *pFunctionTable, int interfaceVersion); C_DLLEXPORT int GetEntityAPI(DLL_FUNCTIONS *pFunctionTable, int interfaceVersion);
NOXREF int GetEntityAPI2(DLL_FUNCTIONS *pFunctionTable, int *interfaceVersion); NOXREF int GetEntityAPI2(DLL_FUNCTIONS *pFunctionTable, int *interfaceVersion);
@ -976,18 +776,4 @@ void SaveReadFields(SAVERESTOREDATA *pSaveData, const char *pname, void *pBaseDa
void SetObjectCollisionBox(entvars_t *pev); void SetObjectCollisionBox(entvars_t *pev);
void OnFreeEntPrivateData(edict_t *pEnt); void OnFreeEntPrivateData(edict_t *pEnt);
#ifdef HOOK_GAMEDLL
typedef BOOL (CBaseEntity::*FVISIBLE_ENTITY)(CBaseEntity *);
typedef BOOL (CBaseEntity::*FVISIBLE_VECTOR)(const Vector &);
typedef void (CGrenade::*EXPLODE_VECTOR)(Vector, Vector);
typedef void (CGrenade::*EXPLODE_TRACERESULT)(TraceResult *, int);
typedef CBaseEntity *(CBaseEntity::*CBASE_ISTANCE_EDICT)(edict_t *);
typedef CBaseEntity *(CBaseEntity::*CBASE_ISTANCE_ENTVARS)(entvars_t *);
typedef CBaseEntity *(CBaseEntity::*CBASE_ISTANCE_INT)(int);
#endif // HOOK_GAMEDLL
#endif // CBASE_H #endif // CBASE_H

View File

@ -59,20 +59,6 @@ static entity_field_alias_t custom_entity_field_alias[] =
static int g_serveractive = 0; static int g_serveractive = 0;
#else
float g_flTimeLimit;
float g_flResetTime;
bool g_bClientPrintEnable;
char *sPlayerModelFiles[12];
bool g_skipCareerInitialSpawn;
entity_field_alias_t entity_field_alias[6];
entity_field_alias_t player_field_alias[3];
entity_field_alias_t custom_entity_field_alias[9];
int g_serveractive;
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
PLAYERPVSSTATUS g_PVSStatus[MAX_CLIENTS]; PLAYERPVSSTATUS g_PVSStatus[MAX_CLIENTS];
@ -80,7 +66,7 @@ unsigned short m_usResetDecals;
unsigned short g_iShadowSprite; unsigned short g_iShadowSprite;
/* <47b45> ../cstrike/dlls/client.cpp:76 */ /* <47b45> ../cstrike/dlls/client.cpp:76 */
int CMD_ARGC_(void) int CMD_ARGC_()
{ {
if (!UseBotArgs) if (!UseBotArgs)
return CMD_ARGC(); return CMD_ARGC();
@ -162,7 +148,7 @@ BOOL EXT_FUNC ClientConnect(edict_t *pEntity, const char *pszName, const char *p
/* <47f5b> ../cstrike/dlls/client.cpp:255 */ /* <47f5b> ../cstrike/dlls/client.cpp:255 */
void EXT_FUNC ClientDisconnect(edict_t *pEntity) void EXT_FUNC ClientDisconnect(edict_t *pEntity)
{ {
CBasePlayer *pPlayer = (CBasePlayer *)CBaseEntity::Instance(pEntity); CBasePlayer *pPlayer = dynamic_cast<CBasePlayer *>(CBaseEntity::Instance(pEntity));
if (!g_fGameOver) if (!g_fGameOver)
{ {
@ -176,14 +162,14 @@ void EXT_FUNC ClientDisconnect(edict_t *pEntity)
pEntity->v.solid = SOLID_NOT; pEntity->v.solid = SOLID_NOT;
pEntity->v.flags = FL_DORMANT; pEntity->v.flags = FL_DORMANT;
if (pPlayer) if (pPlayer != NULL)
pPlayer->SetThink(NULL); pPlayer->SetThink(NULL);
UTIL_SetOrigin(&pEntity->v, pEntity->v.origin); UTIL_SetOrigin(&pEntity->v, pEntity->v.origin);
g_pGameRules->ClientDisconnected(pEntity); g_pGameRules->ClientDisconnected(pEntity);
} }
if (TheBots != NULL && pPlayer && pPlayer->IsBot()) if (TheBots != NULL && pPlayer != NULL && pPlayer->IsBot())
{ {
TheBots->ClientDisconnect(pPlayer); TheBots->ClientDisconnect(pPlayer);
} }
@ -276,7 +262,7 @@ void ShowVGUIMenu(CBasePlayer *pPlayer, int MenuType, int BitMask, char *szOldMe
} }
/* <4c3c5> ../cstrike/dlls/client.cpp:414 */ /* <4c3c5> ../cstrike/dlls/client.cpp:414 */
NOXREF int CountTeams(void) NOXREF int CountTeams()
{ {
int iNumCT = 0, iNumTerrorist = 0; int iNumCT = 0, iNumTerrorist = 0;
CBaseEntity *pPlayer = NULL; CBaseEntity *pPlayer = NULL;
@ -426,7 +412,7 @@ void ProcessKickVote(CBasePlayer *pVotingPlayer, CBasePlayer *pKickPlayer)
} }
/* <48298> ../cstrike/dlls/client.cpp:580 */ /* <48298> ../cstrike/dlls/client.cpp:580 */
TeamName SelectDefaultTeam(void) TeamName SelectDefaultTeam()
{ {
TeamName team = UNASSIGNED; TeamName team = UNASSIGNED;
CHalfLifeMultiplay *mp = g_pGameRules; CHalfLifeMultiplay *mp = g_pGameRules;
@ -485,7 +471,7 @@ TeamName SelectDefaultTeam(void)
} }
/* <473a3> ../cstrike/dlls/client.cpp:638 */ /* <473a3> ../cstrike/dlls/client.cpp:638 */
void CheckStartMoney(void) void CheckStartMoney()
{ {
int money = (int)startmoney.value; int money = (int)startmoney.value;
@ -713,7 +699,7 @@ void Host_Say(edict_t *pEntity, int teamonly)
// team only // team only
if (teamonly) if (teamonly)
{ {
if (UTIL_IsGame("czero") && (player->m_iTeam == CT || player->m_iTeam == TERRORIST)) if (g_bIsCzeroGame && (player->m_iTeam == CT || player->m_iTeam == TERRORIST))
{ {
// search the place name where is located the player // search the place name where is located the player
Place playerPlace = TheNavAreaGrid.GetPlace(&player->pev->origin); Place playerPlace = TheNavAreaGrid.GetPlace(&player->pev->origin);
@ -1808,7 +1794,7 @@ void BuyItem(CBasePlayer *pPlayer, int iSlot)
void HandleMenu_ChooseAppearance(CBasePlayer *player, int slot) void HandleMenu_ChooseAppearance(CBasePlayer *player, int slot)
{ {
CHalfLifeMultiplay *mp = g_pGameRules; CHalfLifeMultiplay *mp = g_pGameRules;
int numSkins = UTIL_IsGame("czero") ? CZ_NUM_SKIN : CS_NUM_SKIN; int numSkins = g_bIsCzeroGame ? CZ_NUM_SKIN : CS_NUM_SKIN;
struct struct
{ {
@ -1846,7 +1832,7 @@ void HandleMenu_ChooseAppearance(CBasePlayer *player, int slot)
appearance.model_name = "guerilla"; appearance.model_name = "guerilla";
break; break;
case 5: case 5:
if (UTIL_IsGame("czero")) if (g_bIsCzeroGame)
{ {
appearance.model_id = MODEL_MILITIA; appearance.model_id = MODEL_MILITIA;
appearance.model_name = "militia"; appearance.model_name = "militia";
@ -1895,7 +1881,7 @@ void HandleMenu_ChooseAppearance(CBasePlayer *player, int slot)
appearance.model_name = "gign"; appearance.model_name = "gign";
break; break;
case 5: case 5:
if (UTIL_IsGame("czero")) if (g_bIsCzeroGame)
{ {
appearance.model_id = MODEL_SPETSNAZ; appearance.model_id = MODEL_SPETSNAZ;
appearance.model_name = "spetsnaz"; appearance.model_name = "spetsnaz";
@ -2247,19 +2233,17 @@ BOOL HandleMenu_ChooseTeam(CBasePlayer *player, int slot)
if (!g_pGameRules->IsCareer()) if (!g_pGameRules->IsCareer())
{ {
bool isCZero = UTIL_IsGame("czero");
switch (team) switch (team)
{ {
case CT: case CT:
if (isCZero) if (g_bIsCzeroGame)
ShowVGUIMenu(player, VGUI_Menu_Class_CT, (MENU_KEY_1 | MENU_KEY_2 | MENU_KEY_3 | MENU_KEY_4 | MENU_KEY_5 | MENU_KEY_6), "#CT_Select"); ShowVGUIMenu(player, VGUI_Menu_Class_CT, (MENU_KEY_1 | MENU_KEY_2 | MENU_KEY_3 | MENU_KEY_4 | MENU_KEY_5 | MENU_KEY_6), "#CT_Select");
else else
ShowVGUIMenu(player, VGUI_Menu_Class_CT, (MENU_KEY_1 | MENU_KEY_2 | MENU_KEY_3 | MENU_KEY_4 | MENU_KEY_5), "#CT_Select"); ShowVGUIMenu(player, VGUI_Menu_Class_CT, (MENU_KEY_1 | MENU_KEY_2 | MENU_KEY_3 | MENU_KEY_4 | MENU_KEY_5), "#CT_Select");
break; break;
case TERRORIST: case TERRORIST:
if (isCZero) if (g_bIsCzeroGame)
ShowVGUIMenu(player, VGUI_Menu_Class_T, (MENU_KEY_1 | MENU_KEY_2 | MENU_KEY_3 | MENU_KEY_4 | MENU_KEY_5 | MENU_KEY_6), "#Terrorist_Select"); ShowVGUIMenu(player, VGUI_Menu_Class_T, (MENU_KEY_1 | MENU_KEY_2 | MENU_KEY_3 | MENU_KEY_4 | MENU_KEY_5 | MENU_KEY_6), "#Terrorist_Select");
else else
ShowVGUIMenu(player, VGUI_Menu_Class_T, (MENU_KEY_1 | MENU_KEY_2 | MENU_KEY_3 | MENU_KEY_4 | MENU_KEY_5), "#Terrorist_Select"); ShowVGUIMenu(player, VGUI_Menu_Class_T, (MENU_KEY_1 | MENU_KEY_2 | MENU_KEY_3 | MENU_KEY_4 | MENU_KEY_5), "#Terrorist_Select");
@ -2628,7 +2612,7 @@ CBaseEntity *EntityFromUserID(int userID)
} }
/* <4baa5> ../cstrike/dlls/client.cpp:2958 */ /* <4baa5> ../cstrike/dlls/client.cpp:2958 */
NOXREF int CountPlayersInServer(void) NOXREF int CountPlayersInServer()
{ {
int count = 0; int count = 0;
CBaseEntity *pTempEntity = NULL; CBaseEntity *pTempEntity = NULL;
@ -3639,7 +3623,7 @@ void EXT_FUNC ClientCommand(edict_t *pEntity)
for (int i = 1; i <= gpGlobals->maxClients; ++i) for (int i = 1; i <= gpGlobals->maxClients; ++i)
{ {
CBasePlayer *pObserver = reinterpret_cast<CBasePlayer *>(UTIL_PlayerByIndex(i)); CBasePlayer *pObserver = static_cast<CBasePlayer *>(UTIL_PlayerByIndex(i));
if (pObserver && pObserver->IsObservingPlayer(player)) if (pObserver && pObserver->IsObservingPlayer(player))
{ {
@ -3665,7 +3649,7 @@ void EXT_FUNC ClientCommand(edict_t *pEntity)
for (int i = 1; i <= gpGlobals->maxClients; ++i) for (int i = 1; i <= gpGlobals->maxClients; ++i)
{ {
CBasePlayer *pObserver = reinterpret_cast<CBasePlayer *>(UTIL_PlayerByIndex(i)); CBasePlayer *pObserver = static_cast<CBasePlayer *>(UTIL_PlayerByIndex(i));
if (pObserver && pObserver->IsObservingPlayer(player)) if (pObserver && pObserver->IsObservingPlayer(player))
{ {
@ -3936,7 +3920,7 @@ void EXT_FUNC ClientUserInfoChanged(edict_t *pEntity, char *infobuffer)
} }
/* <4a378> ../cstrike/dlls/client.cpp:4362 */ /* <4a378> ../cstrike/dlls/client.cpp:4362 */
void EXT_FUNC ServerDeactivate(void) void EXT_FUNC ServerDeactivate()
{ {
// It's possible that the engine will call this function more times than is necessary // It's possible that the engine will call this function more times than is necessary
// Therefore, only run it one time for each call to ServerActivate // Therefore, only run it one time for each call to ServerActivate
@ -4041,13 +4025,13 @@ void EXT_FUNC PlayerPostThink(edict_t *pEntity)
} }
/* <4a4f4> ../cstrike/dlls/client.cpp:4486 */ /* <4a4f4> ../cstrike/dlls/client.cpp:4486 */
void EXT_FUNC ParmsNewLevel(void) void EXT_FUNC ParmsNewLevel()
{ {
; ;
} }
/* <4a50d> ../cstrike/dlls/client.cpp:4491 */ /* <4a50d> ../cstrike/dlls/client.cpp:4491 */
void EXT_FUNC ParmsChangeLevel(void) void EXT_FUNC ParmsChangeLevel()
{ {
// retrieve the pointer to the save data // retrieve the pointer to the save data
SAVERESTOREDATA *pSaveData = (SAVERESTOREDATA *)gpGlobals->pSaveData; SAVERESTOREDATA *pSaveData = (SAVERESTOREDATA *)gpGlobals->pSaveData;
@ -4059,7 +4043,7 @@ void EXT_FUNC ParmsChangeLevel(void)
} }
/* <4a548> ../cstrike/dlls/client.cpp:4504 */ /* <4a548> ../cstrike/dlls/client.cpp:4504 */
void EXT_FUNC StartFrame(void) void EXT_FUNC StartFrame()
{ {
if (g_pGameRules != NULL) if (g_pGameRules != NULL)
{ {
@ -4099,10 +4083,9 @@ void EXT_FUNC StartFrame(void)
} }
/* <4a581> ../cstrike/dlls/client.cpp:4534 */ /* <4a581> ../cstrike/dlls/client.cpp:4534 */
void ClientPrecache(void) void ClientPrecache()
{ {
int i; int i;
bool isCZero = UTIL_IsGame("czero");
PRECACHE_SOUND("weapons/dryfire_pistol.wav"); PRECACHE_SOUND("weapons/dryfire_pistol.wav");
PRECACHE_SOUND("weapons/dryfire_rifle.wav"); PRECACHE_SOUND("weapons/dryfire_rifle.wav");
@ -4217,7 +4200,7 @@ void ClientPrecache(void)
PRECACHE_SOUND("player/pl_pain7.wav"); PRECACHE_SOUND("player/pl_pain7.wav");
int numPlayerModels; int numPlayerModels;
if (isCZero) if (g_bIsCzeroGame)
numPlayerModels = ARRAYSIZE(sPlayerModelFiles); numPlayerModels = ARRAYSIZE(sPlayerModelFiles);
else else
numPlayerModels = ARRAYSIZE(sPlayerModelFiles) - 2; numPlayerModels = ARRAYSIZE(sPlayerModelFiles) - 2;
@ -4225,7 +4208,7 @@ void ClientPrecache(void)
for (i = 0; i < numPlayerModels; ++i) for (i = 0; i < numPlayerModels; ++i)
PRECACHE_MODEL(sPlayerModelFiles[i]); PRECACHE_MODEL(sPlayerModelFiles[i]);
if (isCZero) if (g_bIsCzeroGame)
{ {
for (i = FirstCustomSkin; i <= LastCustomSkin; ++i) for (i = FirstCustomSkin; i <= LastCustomSkin; ++i)
{ {
@ -4290,7 +4273,7 @@ void ClientPrecache(void)
for (i = 0; i < numPlayerModels; ++i) for (i = 0; i < numPlayerModels; ++i)
ENGINE_FORCE_UNMODIFIED(force_model_specifybounds, (float *)&vMin, (float *)&vMax, sPlayerModelFiles[i]); ENGINE_FORCE_UNMODIFIED(force_model_specifybounds, (float *)&vMin, (float *)&vMax, sPlayerModelFiles[i]);
if (isCZero) if (g_bIsCzeroGame)
{ {
for (i = FirstCustomSkin; i <= LastCustomSkin; ++i) for (i = FirstCustomSkin; i <= LastCustomSkin; ++i)
{ {
@ -4315,7 +4298,7 @@ void ClientPrecache(void)
ENGINE_FORCE_UNMODIFIED(force_exactfile, (float *)&temp, (float *)&temp, "sprites/scope_arc_ne.tga"); ENGINE_FORCE_UNMODIFIED(force_exactfile, (float *)&temp, (float *)&temp, "sprites/scope_arc_ne.tga");
ENGINE_FORCE_UNMODIFIED(force_exactfile, (float *)&temp, (float *)&temp, "sprites/scope_arc_sw.tga"); ENGINE_FORCE_UNMODIFIED(force_exactfile, (float *)&temp, (float *)&temp, "sprites/scope_arc_sw.tga");
if (isCZero) if (g_bIsCzeroGame)
{ {
vMin = Vector(-13, -6, -22); vMin = Vector(-13, -6, -22);
vMax = Vector(13, 6, 22); vMax = Vector(13, 6, 22);
@ -4333,7 +4316,7 @@ void ClientPrecache(void)
ENGINE_FORCE_UNMODIFIED(force_model_specifybounds, (float *)&vMin, (float *)&vMax, "models/p_fiveseven.mdl"); ENGINE_FORCE_UNMODIFIED(force_model_specifybounds, (float *)&vMin, (float *)&vMax, "models/p_fiveseven.mdl");
ENGINE_FORCE_UNMODIFIED(force_model_specifybounds, (float *)&vMin, (float *)&vMax, "models/p_glock18.mdl"); ENGINE_FORCE_UNMODIFIED(force_model_specifybounds, (float *)&vMin, (float *)&vMax, "models/p_glock18.mdl");
if (isCZero) if (g_bIsCzeroGame)
{ {
vMin = Vector(-26, -19, -21); vMin = Vector(-26, -19, -21);
vMax = Vector(26, 23, 21); vMax = Vector(26, 23, 21);
@ -4347,7 +4330,7 @@ void ClientPrecache(void)
ENGINE_FORCE_UNMODIFIED(force_model_specifybounds, (float *)&vMin, (float *)&vMax, "models/p_xm1014.mdl"); ENGINE_FORCE_UNMODIFIED(force_model_specifybounds, (float *)&vMin, (float *)&vMax, "models/p_xm1014.mdl");
ENGINE_FORCE_UNMODIFIED(force_model_specifybounds, (float *)&vMin, (float *)&vMax, "models/p_m3.mdl"); ENGINE_FORCE_UNMODIFIED(force_model_specifybounds, (float *)&vMin, (float *)&vMax, "models/p_m3.mdl");
if (isCZero) if (g_bIsCzeroGame)
{ {
vMin = Vector(-23, -9, -20); vMin = Vector(-23, -9, -20);
vMax = Vector(23, 17, 20); vMax = Vector(23, 17, 20);
@ -4364,7 +4347,7 @@ void ClientPrecache(void)
ENGINE_FORCE_UNMODIFIED(force_model_specifybounds, (float *)&vMin, (float *)&vMax, "models/p_tmp.mdl"); ENGINE_FORCE_UNMODIFIED(force_model_specifybounds, (float *)&vMin, (float *)&vMax, "models/p_tmp.mdl");
ENGINE_FORCE_UNMODIFIED(force_model_specifybounds, (float *)&vMin, (float *)&vMax, "models/p_p90.mdl"); ENGINE_FORCE_UNMODIFIED(force_model_specifybounds, (float *)&vMin, (float *)&vMax, "models/p_p90.mdl");
if (isCZero) if (g_bIsCzeroGame)
{ {
vMin = Vector(-38, -33, -22); vMin = Vector(-38, -33, -22);
vMax = Vector(38, 15, 35); vMax = Vector(38, 15, 35);
@ -4386,7 +4369,7 @@ void ClientPrecache(void)
ENGINE_FORCE_UNMODIFIED(force_model_specifybounds, (float *)&vMin, (float *)&vMax, "models/p_famas.mdl"); ENGINE_FORCE_UNMODIFIED(force_model_specifybounds, (float *)&vMin, (float *)&vMax, "models/p_famas.mdl");
ENGINE_FORCE_UNMODIFIED(force_model_specifybounds, (float *)&vMin, (float *)&vMax, "models/p_galil.mdl"); ENGINE_FORCE_UNMODIFIED(force_model_specifybounds, (float *)&vMin, (float *)&vMax, "models/p_galil.mdl");
if (isCZero) if (g_bIsCzeroGame)
{ {
vMin = Vector(-30, -10, -20); vMin = Vector(-30, -10, -20);
vMax = Vector(30, 11, 20); vMax = Vector(30, 11, 20);
@ -4407,7 +4390,7 @@ void ClientPrecache(void)
vMin = Vector(-4, -8, -3); vMin = Vector(-4, -8, -3);
vMax = Vector(3, 7, 3); vMax = Vector(3, 7, 3);
if (isCZero) if (g_bIsCzeroGame)
{ {
vMin = Vector(-17, -8, -3); vMin = Vector(-17, -8, -3);
vMax = Vector(17, 7, 3); vMax = Vector(17, 7, 3);
@ -4420,7 +4403,7 @@ void ClientPrecache(void)
ENGINE_FORCE_UNMODIFIED(force_model_specifybounds, (float *)&vMin, (float *)&vMax, "models/w_c4.mdl"); ENGINE_FORCE_UNMODIFIED(force_model_specifybounds, (float *)&vMin, (float *)&vMax, "models/w_c4.mdl");
if (isCZero) if (g_bIsCzeroGame)
{ {
vMin = Vector(-7, -3, -18); vMin = Vector(-7, -3, -18);
vMax = Vector(7, 2, 18); vMax = Vector(7, 2, 18);
@ -4435,7 +4418,7 @@ void ClientPrecache(void)
ENGINE_FORCE_UNMODIFIED(force_model_specifybounds, (float *)&vMin, (float *)&vMax, "models/p_hegrenade.mdl"); ENGINE_FORCE_UNMODIFIED(force_model_specifybounds, (float *)&vMin, (float *)&vMax, "models/p_hegrenade.mdl");
ENGINE_FORCE_UNMODIFIED(force_model_specifybounds, (float *)&vMin, (float *)&vMax, "models/p_smokegrenade.mdl"); ENGINE_FORCE_UNMODIFIED(force_model_specifybounds, (float *)&vMin, (float *)&vMax, "models/p_smokegrenade.mdl");
if (isCZero) if (g_bIsCzeroGame)
vMin = Vector(-5, -5, -7); vMin = Vector(-5, -5, -7);
else else
vMin = Vector(-5, -5, -5); vMin = Vector(-5, -5, -5);
@ -4451,7 +4434,7 @@ void ClientPrecache(void)
ENGINE_FORCE_UNMODIFIED(force_model_specifybounds, (float *)&vMin, (float *)&vMax, "models/p_knife.mdl"); ENGINE_FORCE_UNMODIFIED(force_model_specifybounds, (float *)&vMin, (float *)&vMax, "models/p_knife.mdl");
if (isCZero) if (g_bIsCzeroGame)
{ {
vMin = Vector(-21, -25, -54); vMin = Vector(-21, -25, -54);
vMax = Vector(21, 23, 24); vMax = Vector(21, 23, 24);
@ -4526,9 +4509,9 @@ void ClientPrecache(void)
} }
/* <4a6e5> ../cstrike/dlls/client.cpp:4996 */ /* <4a6e5> ../cstrike/dlls/client.cpp:4996 */
const char *EXT_FUNC GetGameDescription(void) const char *EXT_FUNC GetGameDescription()
{ {
if (UTIL_IsGame("czero")) if (g_bIsCzeroGame)
return "Condition Zero"; return "Condition Zero";
return "Counter-Strike"; return "Counter-Strike";
@ -4623,9 +4606,9 @@ void EXT_FUNC SetupVisibility(edict_t *pViewEntity, edict_t *pClient, unsigned c
return; return;
} }
CBasePlayer *pPlayer = reinterpret_cast<CBasePlayer *>(CBasePlayer::Instance(pClient)); CBasePlayer *pPlayer = dynamic_cast<CBasePlayer *>(CBasePlayer::Instance(pClient));
if (pPlayer->pev->iuser2 && pPlayer->m_hObserverTarget) if (pPlayer != NULL && pPlayer->pev->iuser2 && pPlayer->m_hObserverTarget)
{ {
if (pPlayer->m_afPhysicsFlags & PFLAG_OBSERVER) if (pPlayer->m_afPhysicsFlags & PFLAG_OBSERVER)
{ {
@ -5066,7 +5049,7 @@ void Custom_Encode(struct delta_s *pFields, const unsigned char *from, const uns
} }
/* <4b08a> ../cstrike/dlls/client.cpp:5811 */ /* <4b08a> ../cstrike/dlls/client.cpp:5811 */
void EXT_FUNC RegisterEncoders(void) void EXT_FUNC RegisterEncoders()
{ {
DELTA_ADDENCODER("Entity_Encode", Entity_Encode); DELTA_ADDENCODER("Entity_Encode", Entity_Encode);
DELTA_ADDENCODER("Custom_Encode", Custom_Encode); DELTA_ADDENCODER("Custom_Encode", Custom_Encode);
@ -5077,7 +5060,7 @@ void EXT_FUNC RegisterEncoders(void)
int EXT_FUNC GetWeaponData(edict_s *player, struct weapon_data_s *info) int EXT_FUNC GetWeaponData(edict_s *player, struct weapon_data_s *info)
{ {
entvars_t *pev = &player->v; entvars_t *pev = &player->v;
CBasePlayer *pl = reinterpret_cast<CBasePlayer *>(CBasePlayer::Instance(pev)); CBasePlayer *pl = dynamic_cast<CBasePlayer *>(CBasePlayer::Instance(pev));
Q_memset(info, 0, sizeof(weapon_data_t) * MAX_WEAPONS); Q_memset(info, 0, sizeof(weapon_data_t) * MAX_WEAPONS);
@ -5092,9 +5075,9 @@ int EXT_FUNC GetWeaponData(edict_s *player, struct weapon_data_s *info)
while (pPlayerItem != NULL) while (pPlayerItem != NULL)
{ {
CBasePlayerWeapon *gun = reinterpret_cast<CBasePlayerWeapon *>(pPlayerItem->GetWeaponPtr()); CBasePlayerWeapon *gun = dynamic_cast<CBasePlayerWeapon *>(pPlayerItem->GetWeaponPtr());
if (gun && gun->UseDecrement()) if (gun != NULL && gun->UseDecrement())
{ {
ItemInfo II; ItemInfo II;
Q_memset(&II, 0, sizeof(II)); Q_memset(&II, 0, sizeof(II));
@ -5137,14 +5120,14 @@ void EXT_FUNC UpdateClientData(const struct edict_s *ent, int sendweapons, struc
} }
entvars_t *pevOrg = NULL; entvars_t *pevOrg = NULL;
entvars_t *pev = (entvars_t *)&ent->v; entvars_t *pev = const_cast<entvars_t *>(&ent->v);
CBasePlayer *pl = reinterpret_cast<CBasePlayer *>(CBasePlayer::Instance(pev)); CBasePlayer *pl = dynamic_cast<CBasePlayer *>(CBasePlayer::Instance(pev));
if (pl->pev->iuser1 == OBS_IN_EYE && pl->m_hObserverTarget) if (pl != NULL && pl->pev->iuser1 == OBS_IN_EYE && pl->m_hObserverTarget)
{ {
pevOrg = pev; pevOrg = pev;
pev = pl->m_hObserverTarget->pev; pev = pl->m_hObserverTarget->pev;
pl = reinterpret_cast<CBasePlayer *>(CBasePlayer::Instance(pev)); pl = dynamic_cast<CBasePlayer *>(CBasePlayer::Instance(pev));
} }
cd->flags = pev->flags; cd->flags = pev->flags;
@ -5228,7 +5211,7 @@ void EXT_FUNC UpdateClientData(const struct edict_s *ent, int sendweapons, struc
ItemInfo II; ItemInfo II;
Q_memset(&II, 0, sizeof(II)); Q_memset(&II, 0, sizeof(II));
CBasePlayerWeapon *gun = reinterpret_cast<CBasePlayerWeapon *>(pl->m_pActiveItem->GetWeaponPtr()); CBasePlayerWeapon *gun = dynamic_cast<CBasePlayerWeapon *>(pl->m_pActiveItem->GetWeaponPtr());
if (gun != NULL && gun->UseDecrement() && gun->GetItemInfo(&II)) if (gun != NULL && gun->UseDecrement() && gun->GetItemInfo(&II))
{ {
@ -5252,36 +5235,34 @@ void EXT_FUNC UpdateClientData(const struct edict_s *ent, int sendweapons, struc
/* <4b3ee> ../cstrike/dlls/client.cpp:6050 */ /* <4b3ee> ../cstrike/dlls/client.cpp:6050 */
void EXT_FUNC CmdStart(const edict_t *player, const struct usercmd_s *cmd, unsigned int random_seed) void EXT_FUNC CmdStart(const edict_t *player, const struct usercmd_s *cmd, unsigned int random_seed)
{ {
entvars_t *pev = (entvars_t *)&player->v; entvars_t *pev = const_cast<entvars_t *>(&player->v);
CBasePlayer *pl = reinterpret_cast<CBasePlayer *>(CBasePlayer::Instance(pev)); CBasePlayer *pl = dynamic_cast<CBasePlayer *>(CBasePlayer::Instance(pev));
if (!pl) if (pl != NULL)
{ {
return; if (pl->pev->groupinfo)
} {
UTIL_SetGroupTrace(pl->pev->groupinfo, GROUP_OP_AND);
}
if (pl->pev->groupinfo) pl->random_seed = random_seed;
{
UTIL_SetGroupTrace(pl->pev->groupinfo, GROUP_OP_AND);
} }
pl->random_seed = random_seed;
} }
/* <4b4eb> ../cstrike/dlls/client.cpp:6074 */ /* <4b4eb> ../cstrike/dlls/client.cpp:6074 */
void EXT_FUNC CmdEnd(const edict_t *player) void EXT_FUNC CmdEnd(const edict_t *player)
{ {
entvars_t *pev = (entvars_t *)&player->v; entvars_t *pev = const_cast<entvars_t *>(&player->v);
CBasePlayer *pl = reinterpret_cast<CBasePlayer *>(CBasePlayer::Instance(pev)); CBasePlayer *pl = dynamic_cast<CBasePlayer *>(CBasePlayer::Instance(pev));
if (!pl) if (pl != NULL)
return; {
if (pl->pev->groupinfo)
UTIL_UnsetGroupTrace();
if (pl->pev->groupinfo) if (pev->flags & FL_DUCKING)
UTIL_UnsetGroupTrace(); UTIL_SetSize(pev, VEC_DUCK_HULL_MIN, VEC_DUCK_HULL_MAX);
}
if (pev->flags & FL_DUCKING)
UTIL_SetSize(pev, VEC_DUCK_HULL_MIN, VEC_DUCK_HULL_MAX);
} }
/* <4b644> ../cstrike/dlls/client.cpp:6101 */ /* <4b644> ../cstrike/dlls/client.cpp:6101 */
@ -5309,7 +5290,7 @@ int EXT_FUNC GetHullBounds(int hullnumber, float *mins, float *maxs)
// to be created during play ( e.g., grenades, ammo packs, projectiles, corpses, etc. ) // to be created during play ( e.g., grenades, ammo packs, projectiles, corpses, etc. )
/* <4b733> ../cstrike/dlls/client.cpp:6156 */ /* <4b733> ../cstrike/dlls/client.cpp:6156 */
void EXT_FUNC CreateInstancedBaselines(void) void EXT_FUNC CreateInstancedBaselines()
{ {
int iret = 0; int iret = 0;
entity_state_t state; entity_state_t state;
@ -5344,7 +5325,7 @@ int EXT_FUNC InconsistentFile(const edict_t *player, const char *filename, char
// if you want. // if you want.
/* <4b7cf> ../cstrike/dlls/client.cpp:6204 */ /* <4b7cf> ../cstrike/dlls/client.cpp:6204 */
int EXT_FUNC AllowLagCompensation(void) int EXT_FUNC AllowLagCompensation()
{ {
return 1; return 1;
} }

View File

@ -86,62 +86,29 @@ typedef struct
float m_fTimeEnteredPVS; float m_fTimeEnteredPVS;
} ENTITYPVSSTATUS; } ENTITYPVSSTATUS;
/* size: 4, cachelines: 1, members: 1 */
typedef struct struct PLAYERPVSSTATUS
{ {
ENTITYPVSSTATUS m_Status[1380]; ENTITYPVSSTATUS m_Status[1380];
int headnode; int headnode;
int num_leafs; int num_leafs;
short int leafnums[ MAX_ENT_LEAFS ]; short int leafnums[ MAX_ENT_LEAFS ];
};
} PLAYERPVSSTATUS; struct entity_field_alias_t
/* size: 5624, cachelines: 88, members: 4 */
typedef struct
{ {
char name[32]; char name[32];
int field; int field;
};
} entity_field_alias_t; extern float g_flTimeLimit;
/* size: 36, cachelines: 1, members: 2 */
#ifdef HOOK_GAMEDLL
#define g_flTimeLimit (*pg_flTimeLimit)
#define g_flResetTime (*pg_flResetTime)
#define g_bClientPrintEnable (*pg_bClientPrintEnable)
#define g_PVSStatus (*pg_PVSStatus)
#define m_usResetDecals (*pm_usResetDecals)
#define g_iShadowSprite (*pg_iShadowSprite)
#define sPlayerModelFiles (*psPlayerModelFiles)
#define g_skipCareerInitialSpawn (*pg_skipCareerInitialSpawn)
#define entity_field_alias (*pentity_field_alias)
#define player_field_alias (*pplayer_field_alias)
#define custom_entity_field_alias (*pcustom_entity_field_alias)
#define g_serveractive (*pg_serveractive)
#endif // HOOK_GAMEDLL
extern PLAYERPVSSTATUS g_PVSStatus[32];
extern float g_flTimeLimit;// exported
extern float g_flResetTime; extern float g_flResetTime;
extern bool g_bClientPrintEnable;
extern bool g_skipCareerInitialSpawn; extern bool g_skipCareerInitialSpawn;
extern char *sPlayerModelFiles[12];
extern bool g_skipCareerInitialSpawn;
extern entity_field_alias_t entity_field_alias[6];
extern entity_field_alias_t player_field_alias[3];
extern entity_field_alias_t custom_entity_field_alias[9];
extern int g_serveractive;
extern unsigned short m_usResetDecals; extern unsigned short m_usResetDecals;
extern unsigned short g_iShadowSprite; extern unsigned short g_iShadowSprite;
int CMD_ARGC_(void); int CMD_ARGC_();
const char *CMD_ARGV_(int i); const char *CMD_ARGV_(int i);
NOXREF void set_suicide_frame(entvars_t *pev); NOXREF void set_suicide_frame(entvars_t *pev);
void TeamChangeUpdate(CBasePlayer *player, int team_id); void TeamChangeUpdate(CBasePlayer *player, int team_id);
@ -152,12 +119,12 @@ void respawn(entvars_t *pev, BOOL fCopyCorpse = FALSE);
void ClientKill(edict_t *pEntity); void ClientKill(edict_t *pEntity);
void ShowMenu(CBasePlayer *pPlayer, int bitsValidSlots, int nDisplayTime, BOOL fNeedMore, char *pszText); void ShowMenu(CBasePlayer *pPlayer, int bitsValidSlots, int nDisplayTime, BOOL fNeedMore, char *pszText);
void ShowVGUIMenu(CBasePlayer *pPlayer, int MenuType, int BitMask, char *szOldMenu); void ShowVGUIMenu(CBasePlayer *pPlayer, int MenuType, int BitMask, char *szOldMenu);
NOXREF C_DLLEXPORT int CountTeams(void); NOXREF C_DLLEXPORT int CountTeams();
void ListPlayers(CBasePlayer *current); void ListPlayers(CBasePlayer *current);
C_DLLEXPORT int CountTeamPlayers(int iTeam); C_DLLEXPORT int CountTeamPlayers(int iTeam);
void ProcessKickVote(CBasePlayer *pVotingPlayer, CBasePlayer *pKickPlayer); void ProcessKickVote(CBasePlayer *pVotingPlayer, CBasePlayer *pKickPlayer);
TeamName SelectDefaultTeam(void); TeamName SelectDefaultTeam();
void CheckStartMoney(void); void CheckStartMoney();
void ClientPutInServer(edict_t *pEntity); void ClientPutInServer(edict_t *pEntity);
int Q_strlen_(const char *str); int Q_strlen_(const char *str);
void Host_Say(edict_t *pEntity, int teamonly); void Host_Say(edict_t *pEntity, int teamonly);
@ -179,20 +146,20 @@ void Radio3(CBasePlayer *player, int slot);
bool BuyGunAmmo(CBasePlayer *player, CBasePlayerItem *weapon, bool bBlinkMoney); bool BuyGunAmmo(CBasePlayer *player, CBasePlayerItem *weapon, bool bBlinkMoney);
bool BuyAmmo(CBasePlayer *player, int nSlot, bool bBlinkMoney); bool BuyAmmo(CBasePlayer *player, int nSlot, bool bBlinkMoney);
CBaseEntity *EntityFromUserID(int userID); CBaseEntity *EntityFromUserID(int userID);
NOXREF int CountPlayersInServer(void); NOXREF int CountPlayersInServer();
BOOL HandleBuyAliasCommands(CBasePlayer *pPlayer, const char *pszCommand); BOOL HandleBuyAliasCommands(CBasePlayer *pPlayer, const char *pszCommand);
BOOL HandleRadioAliasCommands(CBasePlayer *pPlayer, const char *pszCommand); BOOL HandleRadioAliasCommands(CBasePlayer *pPlayer, const char *pszCommand);
void ClientCommand(edict_t *pEntity); void ClientCommand(edict_t *pEntity);
void ClientUserInfoChanged(edict_t *pEntity, char *infobuffer); void ClientUserInfoChanged(edict_t *pEntity, char *infobuffer);
void ServerDeactivate(void); void ServerDeactivate();
void ServerActivate(edict_t *pEdictList, int edictCount, int clientMax); void ServerActivate(edict_t *pEdictList, int edictCount, int clientMax);
void PlayerPreThink(edict_t *pEntity); void PlayerPreThink(edict_t *pEntity);
void PlayerPostThink(edict_t *pEntity); void PlayerPostThink(edict_t *pEntity);
void ParmsNewLevel(void); void ParmsNewLevel();
void ParmsChangeLevel(void); void ParmsChangeLevel();
void StartFrame(void); void StartFrame();
void ClientPrecache(void); void ClientPrecache();
const char *GetGameDescription(void); const char *GetGameDescription();
void Sys_Error(const char *error_string); void Sys_Error(const char *error_string);
void PlayerCustomization(edict_t *pEntity, customization_t *pCust); void PlayerCustomization(edict_t *pEntity, customization_t *pCust);
void SpectatorConnect(edict_t *pEntity); void SpectatorConnect(edict_t *pEntity);
@ -211,15 +178,15 @@ void Player_FieldInit(struct delta_s *pFields);
void Player_Encode(struct delta_s *pFields, const unsigned char *from, const unsigned char *to); void Player_Encode(struct delta_s *pFields, const unsigned char *from, const unsigned char *to);
void Custom_Entity_FieldInit(delta_s *pFields); void Custom_Entity_FieldInit(delta_s *pFields);
void Custom_Encode(struct delta_s *pFields, const unsigned char *from, const unsigned char *to); void Custom_Encode(struct delta_s *pFields, const unsigned char *from, const unsigned char *to);
void RegisterEncoders(void); void RegisterEncoders();
int GetWeaponData(edict_s *player, struct weapon_data_s *info); int GetWeaponData(edict_s *player, struct weapon_data_s *info);
void UpdateClientData(const edict_s *ent, int sendweapons, struct clientdata_s *cd); void UpdateClientData(const edict_s *ent, int sendweapons, struct clientdata_s *cd);
void CmdStart(const edict_t *player, const struct usercmd_s *cmd, unsigned int random_seed); void CmdStart(const edict_t *player, const struct usercmd_s *cmd, unsigned int random_seed);
void CmdEnd(const edict_t *player); void CmdEnd(const edict_t *player);
int ConnectionlessPacket(const struct netadr_s *net_from, const char *args, char *response_buffer, int *response_buffer_size); int ConnectionlessPacket(const struct netadr_s *net_from, const char *args, char *response_buffer, int *response_buffer_size);
int GetHullBounds(int hullnumber, float *mins, float *maxs); int GetHullBounds(int hullnumber, float *mins, float *maxs);
void CreateInstancedBaselines(void); void CreateInstancedBaselines();
int InconsistentFile(const edict_t *player, const char *filename, char *disconnect_message); int InconsistentFile(const edict_t *player, const char *filename, char *disconnect_message);
int AllowLagCompensation(void); int AllowLagCompensation();
#endif // CLIENT_H #endif // CLIENT_H

View File

@ -1,7 +1,7 @@
#include "precompiled.h" #include "precompiled.h"
/* <5f4cb> ../cstrike/dlls/combat.cpp:52 */ /* <5f4cb> ../cstrike/dlls/combat.cpp:52 */
void CGib::LimitVelocity(void) void CGib::LimitVelocity()
{ {
float length = pev->velocity.Length(); float length = pev->velocity.Length();
@ -208,7 +208,7 @@ void CGib::SpawnRandomGibs(entvars_t *pevVictim, int cGibs, int human)
} }
/* <5f58a> ../cstrike/dlls/combat.cpp:263 */ /* <5f58a> ../cstrike/dlls/combat.cpp:263 */
BOOL CBaseMonster::__MAKE_VHOOK(HasHumanGibs)(void) BOOL CBaseMonster::__MAKE_VHOOK(HasHumanGibs)()
{ {
int myClass = Classify(); int myClass = Classify();
@ -222,7 +222,7 @@ BOOL CBaseMonster::__MAKE_VHOOK(HasHumanGibs)(void)
} }
/* <5f5ca> ../cstrike/dlls/combat.cpp:278 */ /* <5f5ca> ../cstrike/dlls/combat.cpp:278 */
BOOL CBaseMonster::__MAKE_VHOOK(HasAlienGibs)(void) BOOL CBaseMonster::__MAKE_VHOOK(HasAlienGibs)()
{ {
int myClass = Classify(); int myClass = Classify();
if (myClass == CLASS_ALIEN_MILITARY if (myClass == CLASS_ALIEN_MILITARY
@ -237,7 +237,7 @@ BOOL CBaseMonster::__MAKE_VHOOK(HasAlienGibs)(void)
} }
/* <5f60a> ../cstrike/dlls/combat.cpp:295 */ /* <5f60a> ../cstrike/dlls/combat.cpp:295 */
void CBaseMonster::__MAKE_VHOOK(FadeMonster)(void) void CBaseMonster::__MAKE_VHOOK(FadeMonster)()
{ {
StopAnimation(); StopAnimation();
@ -251,14 +251,14 @@ void CBaseMonster::__MAKE_VHOOK(FadeMonster)(void)
} }
/* <60a59> ../cstrike/dlls/combat.cpp:310 */ /* <60a59> ../cstrike/dlls/combat.cpp:310 */
void CBaseMonster::__MAKE_VHOOK(GibMonster)(void) void CBaseMonster::__MAKE_VHOOK(GibMonster)()
{ {
TraceResult tr; TraceResult tr;
BOOL gibbed = FALSE; BOOL gibbed = FALSE;
EMIT_SOUND(ENT(pev), CHAN_WEAPON, "common/bodysplat.wav", VOL_NORM, ATTN_NORM); EMIT_SOUND(ENT(pev), CHAN_WEAPON, "common/bodysplat.wav", VOL_NORM, ATTN_NORM);
// only humans throw skulls !!!UNDONE - eventually monsters will have their own sets of gibs // only humans throw skulls UNDONE - eventually monsters will have their own sets of gibs
if (HasHumanGibs()) if (HasHumanGibs())
{ {
// Only the player will ever get here // Only the player will ever get here
@ -299,7 +299,7 @@ void CBaseMonster::__MAKE_VHOOK(GibMonster)(void)
// anim to play. // anim to play.
/* <5f65e> ../cstrike/dlls/combat.cpp:355 */ /* <5f65e> ../cstrike/dlls/combat.cpp:355 */
Activity CBaseMonster::__MAKE_VHOOK(GetDeathActivity)(void) Activity CBaseMonster::__MAKE_VHOOK(GetDeathActivity)()
{ {
Activity deathActivity; Activity deathActivity;
BOOL fTriedDirection; BOOL fTriedDirection;
@ -419,7 +419,7 @@ Activity CBaseMonster::__MAKE_VHOOK(GetDeathActivity)(void)
// anim to play. // anim to play.
/* <5f848> ../cstrike/dlls/combat.cpp:476 */ /* <5f848> ../cstrike/dlls/combat.cpp:476 */
NOXREF Activity CBaseMonster::GetSmallFlinchActivity(void) NOXREF Activity CBaseMonster::GetSmallFlinchActivity()
{ {
Activity flinchActivity; Activity flinchActivity;
BOOL fTriedDirection; BOOL fTriedDirection;
@ -467,7 +467,7 @@ NOXREF Activity CBaseMonster::GetSmallFlinchActivity(void)
} }
/* <5f8a6> ../cstrike/dlls/combat.cpp:525 */ /* <5f8a6> ../cstrike/dlls/combat.cpp:525 */
void CBaseMonster::__MAKE_VHOOK(BecomeDead)(void) void CBaseMonster::__MAKE_VHOOK(BecomeDead)()
{ {
// don't let autoaim aim at corpses. // don't let autoaim aim at corpses.
pev->takedamage = DAMAGE_YES; pev->takedamage = DAMAGE_YES;
@ -494,7 +494,7 @@ BOOL CBaseMonster::ShouldGibMonster(int iGib)
} }
/* <5f8f8> ../cstrike/dlls/combat.cpp:551 */ /* <5f8f8> ../cstrike/dlls/combat.cpp:551 */
void CBaseMonster::CallGibMonster(void) void CBaseMonster::CallGibMonster()
{ {
BOOL fade = FALSE; BOOL fade = FALSE;
@ -587,7 +587,7 @@ void CBaseMonster::__MAKE_VHOOK(Killed)(entvars_t *pevAttacker, int iGib)
} }
/* <5e84e> ../cstrike/dlls/combat.cpp:652 */ /* <5e84e> ../cstrike/dlls/combat.cpp:652 */
void CBaseEntity::SUB_StartFadeOut(void) void CBaseEntity::SUB_StartFadeOut()
{ {
if (pev->rendermode == kRenderNormal) if (pev->rendermode == kRenderNormal)
{ {
@ -603,7 +603,7 @@ void CBaseEntity::SUB_StartFadeOut(void)
} }
/* <5ea72> ../cstrike/dlls/combat.cpp:667 */ /* <5ea72> ../cstrike/dlls/combat.cpp:667 */
void CBaseEntity::SUB_FadeOut(void) void CBaseEntity::SUB_FadeOut()
{ {
if (pev->renderamt > 7) if (pev->renderamt > 7)
{ {
@ -619,7 +619,7 @@ void CBaseEntity::SUB_FadeOut(void)
} }
/* <5eab1> ../cstrike/dlls/combat.cpp:688 */ /* <5eab1> ../cstrike/dlls/combat.cpp:688 */
void CGib::WaitTillLand(void) void CGib::WaitTillLand()
{ {
if (!IsInWorld()) if (!IsInWorld())
{ {
@ -779,7 +779,7 @@ int CBaseMonster::__MAKE_VHOOK(TakeDamage)(entvars_t *pevInflictor, entvars_t *p
PainSound(); PainSound();
} }
//!!!LATER - make armor consideration here! // LATER: make armor consideration here!
flTake = flDamage; flTake = flDamage;
// set damage type sustained // set damage type sustained
@ -1049,7 +1049,7 @@ void RadiusFlash(Vector vecSrc, entvars_t *pevInflictor, entvars_t *pevAttacker,
for (int i = 1; i <= gpGlobals->maxClients; ++i) for (int i = 1; i <= gpGlobals->maxClients; ++i)
{ {
CBasePlayer *pObserver = reinterpret_cast<CBasePlayer *>(UTIL_PlayerByIndex(i)); CBasePlayer *pObserver = static_cast<CBasePlayer *>(UTIL_PlayerByIndex(i));
if (!pObserver || !pObserver->IsObservingPlayer(pPlayer)) if (!pObserver || !pObserver->IsObservingPlayer(pPlayer))
continue; continue;
@ -1179,7 +1179,7 @@ void RadiusDamage(Vector vecSrc, entvars_t *pevInflictor, entvars_t *pevAttacker
bool useLOS = false; bool useLOS = false;
float damageRatio = 1.0f; float damageRatio = 1.0f;
if ((bitsDamageType & DMG_EXPLOSION) && UTIL_IsGame("czero")) if ((bitsDamageType & DMG_EXPLOSION) && g_bIsCzeroGame)
{ {
useLOS = true; useLOS = true;
damageRatio = GetAmountOfPlayerVisible(vecSrc, pEntity); damageRatio = GetAmountOfPlayerVisible(vecSrc, pEntity);
@ -1996,102 +1996,3 @@ void CBaseMonster::BloodSplat(const Vector &vecSrc, const Vector &vecDir, int Hi
WRITE_BYTE(iVelocity + RANDOM_LONG(0, 100)); WRITE_BYTE(iVelocity + RANDOM_LONG(0, 100));
MESSAGE_END(); MESSAGE_END();
} }
#ifdef HOOK_GAMEDLL
void CBaseMonster::KeyValue(KeyValueData *pkvd)
{
KeyValue_(pkvd);
}
void CBaseMonster::TraceAttack(entvars_t *pevAttacker,float flDamage,Vector vecDir,TraceResult *ptr,int bitsDamageType)
{
TraceAttack_(pevAttacker, flDamage, vecDir, ptr, bitsDamageType);
}
int CBaseMonster::TakeDamage(entvars_t *pevInflictor,entvars_t *pevAttacker,float flDamage,int bitsDamageType)
{
return TakeDamage_(pevInflictor, pevAttacker, flDamage, bitsDamageType);
}
int CBaseMonster::TakeHealth(float flHealth,int bitsDamageType)
{
return TakeHealth_(flHealth, bitsDamageType);
}
void CBaseMonster::Killed(entvars_t *pevAttacker,int iGib)
{
Killed_(pevAttacker, iGib);
}
float CBaseMonster::ChangeYaw(int speed)
{
return ChangeYaw_(speed);
}
BOOL CBaseMonster::HasHumanGibs(void)
{
return HasHumanGibs_();
}
BOOL CBaseMonster::HasAlienGibs(void)
{
return HasHumanGibs_();
}
void CBaseMonster::FadeMonster(void)
{
FadeMonster_();
}
void CBaseMonster::GibMonster(void)
{
GibMonster_();
}
Activity CBaseMonster::GetDeathActivity(void)
{
return GetDeathActivity_();
}
void CBaseMonster::BecomeDead(void)
{
BecomeDead_();
}
BOOL CBaseMonster::ShouldFadeOnDeath(void)
{
return ShouldFadeOnDeath_();
}
int CBaseMonster::IRelationship(CBaseEntity *pTarget)
{
return IRelationship_(pTarget);
}
void CBaseMonster::MonsterInitDead(void)
{
MonsterInitDead_();
}
void CBaseMonster::Look(int iDistance)
{
Look_(iDistance);
}
CBaseEntity *CBaseMonster::BestVisibleEnemy(void)
{
return BestVisibleEnemy_();
}
BOOL CBaseMonster::FInViewCone(CBaseEntity *pEntity)
{
return FInViewCone_(pEntity);
}
BOOL CBaseMonster::FInViewCone(const Vector *pOrigin)
{
return FInViewCone_(pOrigin);
}
#endif // HOOK_GAMEDLL

View File

@ -18,16 +18,10 @@ DebugOutputLevel outputLevel[ NUM_LEVELS ] =
unsigned int theDebugOutputTypes; unsigned int theDebugOutputTypes;
static char theDebugBuffer[ DebugBufferSize ]; static char theDebugBuffer[ DebugBufferSize ];
#else // HOOK_GAMEDLL
DebugOutputLevel outputLevel[ NUM_LEVELS ];
unsigned int theDebugOutputTypes;
char theDebugBuffer[ DebugBufferSize ];
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
/* <22fe8b> ../cstrike/dlls/debug.cpp:39 */ /* <22fe8b> ../cstrike/dlls/debug.cpp:39 */
bool IsDeveloper(void) bool IsDeveloper()
{ {
return (CVAR_GET_FLOAT("developer") > 0.0); return (CVAR_GET_FLOAT("developer") > 0.0);
} }
@ -64,7 +58,7 @@ void UTIL_DPrintf(char *pszMsg, ...)
} }
/* <22fe97> ../cstrike/dlls/debug.cpp:78 */ /* <22fe97> ../cstrike/dlls/debug.cpp:78 */
void PrintDebugFlags(void) void PrintDebugFlags()
{ {
char *tmp; char *tmp;
int remainder = DebugBufferSize; int remainder = DebugBufferSize;

View File

@ -38,11 +38,11 @@ const int DebugBufferSize = 1024;
typedef enum typedef enum
{ {
DEBUG_NONE = 0, DEBUG_NONE = 0,
DEBUG_BOT = (1<<0), DEBUG_BOT = (1 << 0),
DEBUG_CAREER = (1<<1), DEBUG_CAREER = (1 << 1),
DEBUG_TUTOR = (1<<2), DEBUG_TUTOR = (1 << 2),
DEBUG_STATS = (1<<3), DEBUG_STATS = (1 << 3),
DEBUG_HOSTAGE = (1<<4), DEBUG_HOSTAGE = (1 << 4),
DEBUG_ALL = 0xFFFFFFFF, DEBUG_ALL = 0xFFFFFFFF,
} DebugOutputType; } DebugOutputType;
@ -51,25 +51,12 @@ struct DebugOutputLevel
{ {
const char *name; const char *name;
DebugOutputType value; DebugOutputType value;
};
};/* size: 8, cachelines: 1, members: 2 */ bool IsDeveloper();
#ifdef HOOK_GAMEDLL
#define outputLevel (*poutputLevel)
#define theDebugOutputTypes (*ptheDebugOutputTypes)
#define theDebugBuffer (*ptheDebugBuffer)
#endif // HOOK_GAMEDLL
extern DebugOutputLevel outputLevel[ NUM_LEVELS ];
extern unsigned int theDebugOutputTypes;
extern char theDebugBuffer[ DebugBufferSize ];
bool IsDeveloper(void);
NOXREF void UTIL_DPrintf(DebugOutputType outputType, char *pszMsg, ...); NOXREF void UTIL_DPrintf(DebugOutputType outputType, char *pszMsg, ...);
void UTIL_DPrintf(char *pszMsg, ...); void UTIL_DPrintf(char *pszMsg, ...);
void PrintDebugFlags(void); void PrintDebugFlags();
void SetDebugFlag(const char *flagStr, bool state); void SetDebugFlag(const char *flagStr, bool state);
void PrintDebugFlag(const char *flagStr); void PrintDebugFlag(const char *flagStr);
@ -81,11 +68,4 @@ NOXREF void UTIL_TutorDPrintf(char *pszMsg, ...);
NOXREF void UTIL_StatsDPrintf(char *pszMsg, ...); NOXREF void UTIL_StatsDPrintf(char *pszMsg, ...);
NOXREF void UTIL_HostageDPrintf(char *pszMsg, ...); NOXREF void UTIL_HostageDPrintf(char *pszMsg, ...);
#ifdef HOOK_GAMEDLL
typedef void (*DPrintf_Flag)(DebugOutputType outputType, char *pszMsg, ...);
typedef void (*DPrintf_MSG)(char *pszMsg, ...);
#endif // HOOK_GAMEDLL
#endif // DEBUG_H #endif // DEBUG_H

View File

@ -84,13 +84,6 @@ typedef struct
int index; int index;
} DLL_DECALLIST; } DLL_DECALLIST;
/* size: 8, cachelines: 1, members: 2 */
#ifdef HOOK_GAMEDLL
#define gDecals (*pgDecals)
#endif //HOOK_GAMEDLL
extern DLL_DECALLIST gDecals[42]; extern DLL_DECALLIST gDecals[42];

View File

@ -21,11 +21,6 @@ TYPEDESCRIPTION CMomentaryDoor::m_SaveData[] =
DEFINE_FIELD(CMomentaryDoor, m_bMoveSnd, FIELD_CHARACTER), DEFINE_FIELD(CMomentaryDoor, m_bMoveSnd, FIELD_CHARACTER),
}; };
#else
TYPEDESCRIPTION IMPL_CLASS(CBaseDoor, m_SaveData)[7];
TYPEDESCRIPTION IMPL_CLASS(CMomentaryDoor, m_SaveData)[1];
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
/* <693c0> ../cstrike/dlls/doors.cpp:98 */ /* <693c0> ../cstrike/dlls/doors.cpp:98 */
@ -58,9 +53,9 @@ void PlayLockSounds(entvars_t *pev, locksound_t *pls, int flocked, int fbutton)
float fvol; float fvol;
if (fplaysound && fplaysentence) if (fplaysound && fplaysentence)
fvol = 0.25; fvol = 0.25f;
else else
fvol = 1.0; fvol = 1.0f;
// if there is a locked sound, and we've debounced, play sound // if there is a locked sound, and we've debounced, play sound
if (fplaysound) if (fplaysound)
@ -94,9 +89,9 @@ void PlayLockSounds(entvars_t *pev, locksound_t *pls, int flocked, int fbutton)
// if playing both sentence and sound, lower sound volume so we hear sentence // if playing both sentence and sound, lower sound volume so we hear sentence
if (fplaysound && fplaysentence) if (fplaysound && fplaysentence)
fvol = 0.25; fvol = 0.25f;
else else
fvol = 1.0; fvol = 1.0f;
// play 'door unlocked' sound if set // play 'door unlocked' sound if set
if (fplaysound) if (fplaysound)
@ -207,7 +202,7 @@ LINK_ENTITY_TO_CLASS(func_door, CBaseDoor);
LINK_ENTITY_TO_CLASS(func_water, CBaseDoor); LINK_ENTITY_TO_CLASS(func_water, CBaseDoor);
/* <690bc> ../cstrike/dlls/doors.cpp:285 */ /* <690bc> ../cstrike/dlls/doors.cpp:285 */
void CBaseDoor::__MAKE_VHOOK(Spawn)(void) void CBaseDoor::__MAKE_VHOOK(Spawn)()
{ {
Precache(); Precache();
SetMovedir(pev); SetMovedir(pev);
@ -267,7 +262,7 @@ void CBaseDoor::__MAKE_VHOOK(Spawn)(void)
} }
/* <69949> ../cstrike/dlls/doors.cpp:334 */ /* <69949> ../cstrike/dlls/doors.cpp:334 */
void CBaseDoor::__MAKE_VHOOK(Restart)(void) void CBaseDoor::__MAKE_VHOOK(Restart)()
{ {
SetMovedir(pev); SetMovedir(pev);
m_toggle_state = TS_AT_BOTTOM; m_toggle_state = TS_AT_BOTTOM;
@ -292,7 +287,7 @@ void CBaseDoor::__MAKE_VHOOK(SetToggleState)(int state)
#define noiseArrived noise2 #define noiseArrived noise2
/* <6924c> ../cstrike/dlls/doors.cpp:359 */ /* <6924c> ../cstrike/dlls/doors.cpp:359 */
void CBaseDoor::__MAKE_VHOOK(Precache)(void) void CBaseDoor::__MAKE_VHOOK(Precache)()
{ {
char *pszSound; char *pszSound;
@ -488,7 +483,7 @@ void CBaseDoor::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCaller,
// Causes the door to "do its thing", i.e. start moving, and cascade activation. // Causes the door to "do its thing", i.e. start moving, and cascade activation.
/* <6a319> ../cstrike/dlls/doors.cpp:554 */ /* <6a319> ../cstrike/dlls/doors.cpp:554 */
int CBaseDoor::DoorActivate(void) int CBaseDoor::DoorActivate()
{ {
if (!UTIL_IsMasterTriggered(m_sMaster, m_hActivator)) if (!UTIL_IsMasterTriggered(m_sMaster, m_hActivator))
return 0; return 0;
@ -519,7 +514,7 @@ int CBaseDoor::DoorActivate(void)
// Starts the door going to its "up" position (simply ToggleData->vecPosition2). // Starts the door going to its "up" position (simply ToggleData->vecPosition2).
/* <6a125> ../cstrike/dlls/doors.cpp:588 */ /* <6a125> ../cstrike/dlls/doors.cpp:588 */
void CBaseDoor::DoorGoUp(void) void CBaseDoor::DoorGoUp()
{ {
entvars_t *pevActivator; entvars_t *pevActivator;
bool isReversing = (m_toggle_state == TS_GOING_DOWN); bool isReversing = (m_toggle_state == TS_GOING_DOWN);
@ -549,7 +544,7 @@ void CBaseDoor::DoorGoUp(void)
SetMoveDone(&CBaseDoor::DoorHitTop); SetMoveDone(&CBaseDoor::DoorHitTop);
// !!! BUGBUG Triggered doors don't work with this yet // BUGBUG: Triggered doors don't work with this yet
if (FClassnameIs(pev, "func_door_rotating")) if (FClassnameIs(pev, "func_door_rotating"))
{ {
float sign = 1.0; float sign = 1.0;
@ -634,7 +629,7 @@ void CBaseDoor::DoorGoUp(void)
// The door has reached the "up" position. Either go back down, or wait for another activation. // The door has reached the "up" position. Either go back down, or wait for another activation.
/* <6940c> ../cstrike/dlls/doors.cpp:721 */ /* <6940c> ../cstrike/dlls/doors.cpp:721 */
void CBaseDoor::DoorHitTop(void) void CBaseDoor::DoorHitTop()
{ {
if (!(pev->spawnflags & SF_DOOR_SILENT)) if (!(pev->spawnflags & SF_DOOR_SILENT))
{ {
@ -679,7 +674,7 @@ void CBaseDoor::DoorHitTop(void)
// Starts the door going to its "down" position (simply ToggleData->vecPosition1). // Starts the door going to its "down" position (simply ToggleData->vecPosition1).
/* <697ad> ../cstrike/dlls/doors.cpp:762 */ /* <697ad> ../cstrike/dlls/doors.cpp:762 */
void CBaseDoor::DoorGoDown(void) void CBaseDoor::DoorGoDown()
{ {
bool isReversing = (m_toggle_state == TS_GOING_UP); bool isReversing = (m_toggle_state == TS_GOING_UP);
@ -719,7 +714,7 @@ void CBaseDoor::DoorGoDown(void)
// The door has reached the "down" position. Back to quiescence. // The door has reached the "down" position. Back to quiescence.
/* <694a5> ../cstrike/dlls/doors.cpp:791 */ /* <694a5> ../cstrike/dlls/doors.cpp:791 */
void CBaseDoor::DoorHitBottom(void) void CBaseDoor::DoorHitBottom()
{ {
if (!(pev->spawnflags & SF_DOOR_SILENT)) if (!(pev->spawnflags & SF_DOOR_SILENT))
{ {
@ -879,7 +874,7 @@ void CBaseDoor::__MAKE_VHOOK(Blocked)(CBaseEntity *pOther)
LINK_ENTITY_TO_CLASS(func_door_rotating, CRotDoor); LINK_ENTITY_TO_CLASS(func_door_rotating, CRotDoor);
/* <698be> ../cstrike/dlls/doors.cpp:946 */ /* <698be> ../cstrike/dlls/doors.cpp:946 */
void CRotDoor::__MAKE_VHOOK(Restart)(void) void CRotDoor::__MAKE_VHOOK(Restart)()
{ {
CBaseToggle::AxisDir(pev); CBaseToggle::AxisDir(pev);
@ -907,7 +902,7 @@ void CRotDoor::__MAKE_VHOOK(Restart)(void)
} }
/* <69177> ../cstrike/dlls/doors.cpp:978 */ /* <69177> ../cstrike/dlls/doors.cpp:978 */
void CRotDoor::__MAKE_VHOOK(Spawn)(void) void CRotDoor::__MAKE_VHOOK(Spawn)()
{ {
Precache(); Precache();
@ -984,7 +979,7 @@ LINK_ENTITY_TO_CLASS(momentary_door, CMomentaryDoor);
IMPLEMENT_SAVERESTORE(CMomentaryDoor, CBaseToggle); IMPLEMENT_SAVERESTORE(CMomentaryDoor, CBaseToggle);
/* <69001> ../cstrike/dlls/doors.cpp:1065 */ /* <69001> ../cstrike/dlls/doors.cpp:1065 */
void CMomentaryDoor::__MAKE_VHOOK(Spawn)(void) void CMomentaryDoor::__MAKE_VHOOK(Spawn)()
{ {
SetMovedir(pev); SetMovedir(pev);
@ -1020,7 +1015,7 @@ void CMomentaryDoor::__MAKE_VHOOK(Spawn)(void)
} }
/* <68fa5> ../cstrike/dlls/doors.cpp:1096 */ /* <68fa5> ../cstrike/dlls/doors.cpp:1096 */
void CMomentaryDoor::__MAKE_VHOOK(Precache)(void) void CMomentaryDoor::__MAKE_VHOOK(Precache)()
{ {
// set the door's "in-motion" sound // set the door's "in-motion" sound
switch (m_bMoveSnd) switch (m_bMoveSnd)
@ -1097,8 +1092,8 @@ void CMomentaryDoor::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCa
return; return;
} }
if (value > 1.0) if (value > 1.0f)
value = 1.0; value = 1.0f;
Vector move = m_vecPosition1 + (value * (m_vecPosition2 - m_vecPosition1)); Vector move = m_vecPosition1 + (value * (m_vecPosition2 - m_vecPosition1));
Vector delta = move - pev->origin; Vector delta = move - pev->origin;
@ -1106,7 +1101,7 @@ void CMomentaryDoor::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCa
//float speed = delta.Length() * 10; //float speed = delta.Length() * 10;
// move there in 0.1 sec // move there in 0.1 sec
float speed = delta.Length() / 0.1; float speed = delta.Length() / 0.1f;
if (speed == 0) if (speed == 0)
return; return;
@ -1129,97 +1124,3 @@ void CMomentaryDoor::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCa
LinearMove(move, speed); LinearMove(move, speed);
} }
#ifdef HOOK_GAMEDLL
void CBaseDoor::Spawn(void)
{
Spawn_();
}
void CBaseDoor::Precache(void)
{
Precache_();
}
void CBaseDoor::Restart(void)
{
Restart_();
}
void CBaseDoor::KeyValue(KeyValueData *pkvd)
{
KeyValue_(pkvd);
}
int CBaseDoor::Save(CSave &save)
{
return Save_(save);
}
int CBaseDoor::Restore(CRestore &restore)
{
return Restore_(restore);
}
void CBaseDoor::SetToggleState(int state)
{
SetToggleState_(state);
}
void CBaseDoor::Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
{
Use_(pActivator, pCaller, useType, value);
}
void CBaseDoor::Blocked(CBaseEntity *pOther)
{
Blocked_(pOther);
}
void CRotDoor::Spawn(void)
{
Spawn_();
}
void CRotDoor::Restart(void)
{
Restart_();
}
void CRotDoor::SetToggleState(int state)
{
SetToggleState_(state);
}
void CMomentaryDoor::Spawn(void)
{
Spawn_();
}
void CMomentaryDoor::Precache(void)
{
Precache_();
}
void CMomentaryDoor::KeyValue(KeyValueData *pkvd)
{
KeyValue_(pkvd);
}
int CMomentaryDoor::Save(CSave &save)
{
return Save_(save);
}
int CMomentaryDoor::Restore(CRestore &restore)
{
return Restore_(restore);
}
void CMomentaryDoor::Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
{
Use_(pActivator, pCaller, useType, value);
}
#endif // HOOK_GAMEDLL

View File

@ -52,13 +52,13 @@
class CBaseDoor: public CBaseToggle class CBaseDoor: public CBaseToggle
{ {
public: public:
virtual void Spawn(void); virtual void Spawn();
virtual void Precache(void); virtual void Precache();
virtual void Restart(void); virtual void Restart();
virtual void KeyValue(KeyValueData *pkvd); virtual void KeyValue(KeyValueData *pkvd);
virtual int Save(CSave &save); virtual int Save(CSave &save);
virtual int Restore(CRestore &restore); virtual int Restore(CRestore &restore);
virtual int ObjectCaps(void) virtual int ObjectCaps()
{ {
if (pev->spawnflags & SF_ITEM_USE_ONLY) if (pev->spawnflags & SF_ITEM_USE_ONLY)
return (CBaseToggle::ObjectCaps() & ~FCAP_ACROSS_TRANSITION) | FCAP_IMPULSE_USE; return (CBaseToggle::ObjectCaps() & ~FCAP_ACROSS_TRANSITION) | FCAP_IMPULSE_USE;
@ -71,9 +71,9 @@ public:
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Spawn_(void); void Spawn_();
void Precache_(void); void Precache_();
void Restart_(void); void Restart_();
void KeyValue_(KeyValueData *pkvd); void KeyValue_(KeyValueData *pkvd);
int Save_(CSave &save); int Save_(CSave &save);
int Restore_(CRestore &restore); int Restore_(CRestore &restore);
@ -86,14 +86,13 @@ public:
public: public:
static TYPEDESCRIPTION IMPL(m_SaveData)[7]; static TYPEDESCRIPTION IMPL(m_SaveData)[7];
public:
// used to selectivly override defaults // used to selectivly override defaults
void EXPORT DoorTouch(CBaseEntity *pOther); void EXPORT DoorTouch(CBaseEntity *pOther);
int DoorActivate(void); int DoorActivate();
void EXPORT DoorGoUp(void); void EXPORT DoorGoUp();
void EXPORT DoorGoDown(void); void EXPORT DoorGoDown();
void EXPORT DoorHitTop(void); void EXPORT DoorHitTop();
void EXPORT DoorHitBottom(void); void EXPORT DoorHitBottom();
public: public:
BYTE m_bHealthValue; // some doors are medi-kit doors, they give players health BYTE m_bHealthValue; // some doors are medi-kit doors, they give players health
@ -109,46 +108,42 @@ public:
BYTE m_bUnlockedSentence; BYTE m_bUnlockedSentence;
float m_lastBlockedTimestamp; float m_lastBlockedTimestamp;
};
};/* size: 360, cachelines: 6, members: 11 */
/* <684c0> ../cstrike/dlls/doors.cpp:935 */ /* <684c0> ../cstrike/dlls/doors.cpp:935 */
class CRotDoor: public CBaseDoor class CRotDoor: public CBaseDoor
{ {
public: public:
virtual void Spawn(void); virtual void Spawn();
virtual void Restart(void); virtual void Restart();
virtual void SetToggleState(int state); virtual void SetToggleState(int state);
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Spawn_(void); void Spawn_();
void Restart_(void); void Restart_();
void SetToggleState_(int state); void SetToggleState_(int state);
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
};/* size: 360, cachelines: 6, members: 1 */ };
/* <68513> ../cstrike/dlls/doors.cpp:1039 */ /* <68513> ../cstrike/dlls/doors.cpp:1039 */
class CMomentaryDoor: public CBaseToggle class CMomentaryDoor: public CBaseToggle
{ {
public: public:
virtual void Spawn(void); virtual void Spawn();
virtual void Precache(void); virtual void Precache();
virtual void KeyValue(KeyValueData *pkvd); virtual void KeyValue(KeyValueData *pkvd);
virtual int Save(CSave &save); virtual int Save(CSave &save);
virtual int Restore(CRestore &restore); virtual int Restore(CRestore &restore);
virtual int ObjectCaps(void) virtual int ObjectCaps() { return (CBaseToggle::ObjectCaps() & ~FCAP_ACROSS_TRANSITION); }
{
return CBaseToggle::ObjectCaps() & ~FCAP_ACROSS_TRANSITION;
}
virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value); virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Spawn_(void); void Spawn_();
void Precache_(void); void Precache_();
void KeyValue_(KeyValueData *pkvd); void KeyValue_(KeyValueData *pkvd);
int Save_(CSave &save); int Save_(CSave &save);
int Restore_(CRestore &restore); int Restore_(CRestore &restore);
@ -159,21 +154,9 @@ public:
public: public:
static TYPEDESCRIPTION IMPL(m_SaveData)[1]; static TYPEDESCRIPTION IMPL(m_SaveData)[1];
public:
BYTE m_bMoveSnd; // sound a door makes while moving BYTE m_bMoveSnd; // sound a door makes while moving
};
};/* size: 316, cachelines: 5, members: 3 */
void PlayLockSounds(entvars_t *pev, locksound_t *pls, int flocked, int fbutton); void PlayLockSounds(entvars_t *pev, locksound_t *pls, int flocked, int fbutton);
#ifdef HOOK_GAMEDLL
// linked objects
C_DLLEXPORT void func_door(entvars_t *pev);
C_DLLEXPORT void func_water(entvars_t *pev);
C_DLLEXPORT void func_door_rotating(entvars_t *pev);
C_DLLEXPORT void momentary_door(entvars_t *pev);
#endif // HOOK_GAMEDLL
#endif // DOORS_H #endif // DOORS_H

View File

@ -59,15 +59,6 @@ TYPEDESCRIPTION CGibShooter::m_SaveData[] =
DEFINE_FIELD(CGibShooter, m_flGibLife, FIELD_FLOAT), DEFINE_FIELD(CGibShooter, m_flGibLife, FIELD_FLOAT),
}; };
#else
TYPEDESCRIPTION IMPL_CLASS(CBubbling, m_SaveData)[3];
TYPEDESCRIPTION IMPL_CLASS(CLightning, m_SaveData)[13];
TYPEDESCRIPTION IMPL_CLASS(CLaser, m_SaveData)[3];
TYPEDESCRIPTION IMPL_CLASS(CGlow, m_SaveData)[2];
TYPEDESCRIPTION IMPL_CLASS(CSprite, m_SaveData)[2];
TYPEDESCRIPTION IMPL_CLASS(CGibShooter, m_SaveData)[7];
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
/* <76042> ../cstrike/dlls/effects.cpp:33 */ /* <76042> ../cstrike/dlls/effects.cpp:33 */
@ -80,7 +71,7 @@ LINK_ENTITY_TO_CLASS(env_bubbles, CBubbling);
IMPLEMENT_SAVERESTORE(CBubbling, CBaseEntity); IMPLEMENT_SAVERESTORE(CBubbling, CBaseEntity);
/* <7344d> ../cstrike/dlls/effects.cpp:73 */ /* <7344d> ../cstrike/dlls/effects.cpp:73 */
void CBubbling::__MAKE_VHOOK(Spawn)(void) void CBubbling::__MAKE_VHOOK(Spawn)()
{ {
Precache(); Precache();
SET_MODEL(ENT(pev), STRING(pev->model)); // Set size SET_MODEL(ENT(pev), STRING(pev->model)); // Set size
@ -94,7 +85,7 @@ void CBubbling::__MAKE_VHOOK(Spawn)(void)
int speed = (pev->speed > 0) ? pev->speed : -pev->speed; int speed = (pev->speed > 0) ? pev->speed : -pev->speed;
// HACKHACK!!! - Speed in rendercolor // HACKHACK: Speed in rendercolor
pev->rendercolor.x = (speed >> 8); pev->rendercolor.x = (speed >> 8);
pev->rendercolor.y = (speed & 255); pev->rendercolor.y = (speed & 255);
pev->rendercolor.z = (pev->speed < 0) ? 1 : 0; pev->rendercolor.z = (pev->speed < 0) ? 1 : 0;
@ -103,7 +94,7 @@ void CBubbling::__MAKE_VHOOK(Spawn)(void)
{ {
SetThink(&CBubbling::FizzThink); SetThink(&CBubbling::FizzThink);
pev->nextthink = gpGlobals->time + 2.0; pev->nextthink = gpGlobals->time + 2.0f;
m_state = 1; m_state = 1;
} }
else else
@ -111,7 +102,7 @@ void CBubbling::__MAKE_VHOOK(Spawn)(void)
} }
/* <73489> ../cstrike/dlls/effects.cpp:99 */ /* <73489> ../cstrike/dlls/effects.cpp:99 */
void CBubbling::__MAKE_VHOOK(Precache)(void) void CBubbling::__MAKE_VHOOK(Precache)()
{ {
// Precache bubble sprite // Precache bubble sprite
m_bubbleModel = PRECACHE_MODEL("sprites/bubble.spr"); m_bubbleModel = PRECACHE_MODEL("sprites/bubble.spr");
@ -126,7 +117,7 @@ void CBubbling::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCaller,
if (m_state) if (m_state)
{ {
SetThink(&CBubbling::FizzThink); SetThink(&CBubbling::FizzThink);
pev->nextthink = gpGlobals->time + 0.1; pev->nextthink = gpGlobals->time + 0.1f;
} }
else else
{ {
@ -158,7 +149,7 @@ void CBubbling::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
} }
/* <73d03> ../cstrike/dlls/effects.cpp:145 */ /* <73d03> ../cstrike/dlls/effects.cpp:145 */
void CBubbling::FizzThink(void) void CBubbling::FizzThink()
{ {
MESSAGE_BEGIN(MSG_PAS, SVC_TEMPENTITY, VecBModelOrigin(pev)); MESSAGE_BEGIN(MSG_PAS, SVC_TEMPENTITY, VecBModelOrigin(pev));
WRITE_BYTE(TE_FIZZ); WRITE_BYTE(TE_FIZZ);
@ -168,16 +159,16 @@ void CBubbling::FizzThink(void)
MESSAGE_END(); MESSAGE_END();
if (m_frequency > 19) if (m_frequency > 19)
pev->nextthink = gpGlobals->time + 0.5; pev->nextthink = gpGlobals->time + 0.5f;
else else
pev->nextthink = gpGlobals->time + 2.5 - (0.1 * m_frequency); pev->nextthink = gpGlobals->time + 2.5f - (0.1f * m_frequency);
} }
/* <7620c> ../cstrike/dlls/effects.cpp:166 */ /* <7620c> ../cstrike/dlls/effects.cpp:166 */
LINK_ENTITY_TO_CLASS(beam, CBeam); LINK_ENTITY_TO_CLASS(beam, CBeam);
/* <734b0> ../cstrike/dlls/effects.cpp:168 */ /* <734b0> ../cstrike/dlls/effects.cpp:168 */
void CBeam::__MAKE_VHOOK(Spawn)(void) void CBeam::__MAKE_VHOOK(Spawn)()
{ {
// Remove model & collisions // Remove model & collisions
pev->solid = SOLID_NOT; pev->solid = SOLID_NOT;
@ -185,7 +176,7 @@ void CBeam::__MAKE_VHOOK(Spawn)(void)
} }
/* <734d6> ../cstrike/dlls/effects.cpp:174 */ /* <734d6> ../cstrike/dlls/effects.cpp:174 */
void CBeam::__MAKE_VHOOK(Precache)(void) void CBeam::__MAKE_VHOOK(Precache)()
{ {
if (pev->owner) if (pev->owner)
{ {
@ -212,7 +203,7 @@ void CBeam::SetEndEntity(int entityIndex)
} }
/* <7632e> ../cstrike/dlls/effects.cpp:196 */ /* <7632e> ../cstrike/dlls/effects.cpp:196 */
const Vector &CBeam::GetStartPos(void) const Vector &CBeam::GetStartPos()
{ {
if (GetType() == BEAM_ENTS) if (GetType() == BEAM_ENTS)
{ {
@ -224,7 +215,7 @@ const Vector &CBeam::GetStartPos(void)
} }
/* <7639a> ../cstrike/dlls/effects.cpp:207 */ /* <7639a> ../cstrike/dlls/effects.cpp:207 */
const Vector &CBeam::GetEndPos(void) const Vector &CBeam::GetEndPos()
{ {
int type = GetType(); int type = GetType();
if (type == BEAM_POINTS || type == BEAM_HOSE) if (type == BEAM_POINTS || type == BEAM_HOSE)
@ -233,7 +224,7 @@ const Vector &CBeam::GetEndPos(void)
} }
edict_t *pent = INDEXENT(GetEndEntity()); edict_t *pent = INDEXENT(GetEndEntity());
if (pent) if (pent != NULL)
{ {
return pent->v.origin; return pent->v.origin;
} }
@ -322,7 +313,7 @@ void CBeam::EntsInit(int startIndex, int endIndex)
} }
/* <7663a> ../cstrike/dlls/effects.cpp:294 */ /* <7663a> ../cstrike/dlls/effects.cpp:294 */
void CBeam::RelinkBeam(void) void CBeam::RelinkBeam()
{ {
const Vector &startPos = GetStartPos(); const Vector &startPos = GetStartPos();
const Vector &endPos = GetEndPos(); const Vector &endPos = GetEndPos();
@ -401,7 +392,7 @@ LINK_ENTITY_TO_CLASS(env_beam, CLightning);
IMPLEMENT_SAVERESTORE(CLightning, CBeam); IMPLEMENT_SAVERESTORE(CLightning, CBeam);
/* <744b2> ../cstrike/dlls/effects.cpp:444 */ /* <744b2> ../cstrike/dlls/effects.cpp:444 */
void CLightning::__MAKE_VHOOK(Spawn)(void) void CLightning::__MAKE_VHOOK(Spawn)()
{ {
if (FStringNull(m_iszSpriteName)) if (FStringNull(m_iszSpriteName))
{ {
@ -453,14 +444,14 @@ void CLightning::__MAKE_VHOOK(Spawn)(void)
} }
/* <7357f> ../cstrike/dlls/effects.cpp:493 */ /* <7357f> ../cstrike/dlls/effects.cpp:493 */
void CLightning::__MAKE_VHOOK(Precache)(void) void CLightning::__MAKE_VHOOK(Precache)()
{ {
m_spriteTexture = PRECACHE_MODEL((char *)STRING(m_iszSpriteName)); m_spriteTexture = PRECACHE_MODEL((char *)STRING(m_iszSpriteName));
CBeam::Precache(); CBeam::Precache();
} }
/* <786a1> ../cstrike/dlls/effects.cpp:500 */ /* <786a1> ../cstrike/dlls/effects.cpp:500 */
void CLightning::__MAKE_VHOOK(Activate)(void) void CLightning::__MAKE_VHOOK(Activate)()
{ {
if (ServerSide()) if (ServerSide())
BeamUpdateVars(); BeamUpdateVars();
@ -585,11 +576,12 @@ int IsPointEntity(CBaseEntity *pEnt)
{ {
return 1; return 1;
} }
return 0; return 0;
} }
/* <77f64> ../cstrike/dlls/effects.cpp:625 */ /* <77f64> ../cstrike/dlls/effects.cpp:625 */
void CLightning::StrikeThink(void) void CLightning::StrikeThink()
{ {
if (m_life != 0.0f) if (m_life != 0.0f)
{ {
@ -598,6 +590,7 @@ void CLightning::StrikeThink(void)
else else
pev->nextthink = gpGlobals->time + m_life + m_restrike; pev->nextthink = gpGlobals->time + m_life + m_restrike;
} }
m_active = 1; m_active = 1;
if (FStringNull(m_iszEndEntity)) if (FStringNull(m_iszEndEntity))
@ -729,9 +722,9 @@ void CBeam::BeamDamage(TraceResult *ptr)
} }
/* <777dd> ../cstrike/dlls/effects.cpp:753 */ /* <777dd> ../cstrike/dlls/effects.cpp:753 */
void CLightning::DamageThink(void) void CLightning::DamageThink()
{ {
pev->nextthink = gpGlobals->time + 0.1; pev->nextthink = gpGlobals->time + 0.1f;
TraceResult tr; TraceResult tr;
UTIL_TraceLine(GetStartPos(), GetEndPos(), dont_ignore_monsters, NULL, &tr); UTIL_TraceLine(GetStartPos(), GetEndPos(), dont_ignore_monsters, NULL, &tr);
@ -766,7 +759,7 @@ void CLightning::Zap(const Vector &vecSrc, const Vector &vecDest)
} }
/* <77b45> ../cstrike/dlls/effects.cpp:789 */ /* <77b45> ../cstrike/dlls/effects.cpp:789 */
void CLightning::RandomArea(void) void CLightning::RandomArea()
{ {
for (int iLoops = 0; iLoops < 10; iLoops++) for (int iLoops = 0; iLoops < 10; iLoops++)
{ {
@ -811,9 +804,7 @@ void CLightning::RandomArea(void)
/* <77de8> ../cstrike/dlls/effects.cpp:831 */ /* <77de8> ../cstrike/dlls/effects.cpp:831 */
void CLightning::RandomPoint(Vector &vecSrc) void CLightning::RandomPoint(Vector &vecSrc)
{ {
int iLoops = 0; for (int iLoops = 0; iLoops < 10; iLoops++)
for (iLoops = 0; iLoops < 10; iLoops++)
{ {
Vector vecDir1 = Vector(RANDOM_FLOAT(-1, 1), RANDOM_FLOAT(-1, 1), RANDOM_FLOAT(-1, 1)); Vector vecDir1 = Vector(RANDOM_FLOAT(-1, 1), RANDOM_FLOAT(-1, 1), RANDOM_FLOAT(-1, 1));
vecDir1 = vecDir1.Normalize(); vecDir1 = vecDir1.Normalize();
@ -833,7 +824,7 @@ void CLightning::RandomPoint(Vector &vecSrc)
} }
/* <78313> ../cstrike/dlls/effects.cpp:855 */ /* <78313> ../cstrike/dlls/effects.cpp:855 */
void CLightning::BeamUpdateVars(void) void CLightning::BeamUpdateVars()
{ {
int beamType; int beamType;
int pointStart, pointEnd; int pointStart, pointEnd;
@ -913,7 +904,7 @@ LINK_ENTITY_TO_CLASS(env_laser, CLaser);
IMPLEMENT_SAVERESTORE(CLaser, CBeam); IMPLEMENT_SAVERESTORE(CLaser, CBeam);
/* <76b3f> ../cstrike/dlls/effects.cpp:931 */ /* <76b3f> ../cstrike/dlls/effects.cpp:931 */
void CLaser::__MAKE_VHOOK(Spawn)(void) void CLaser::__MAKE_VHOOK(Spawn)()
{ {
if (FStringNull(pev->model)) if (FStringNull(pev->model))
{ {
@ -945,7 +936,7 @@ void CLaser::__MAKE_VHOOK(Spawn)(void)
} }
/* <73d82> ../cstrike/dlls/effects.cpp:960 */ /* <73d82> ../cstrike/dlls/effects.cpp:960 */
void CLaser::__MAKE_VHOOK(Precache)(void) void CLaser::__MAKE_VHOOK(Precache)()
{ {
pev->modelindex = PRECACHE_MODEL((char *)STRING(pev->model)); pev->modelindex = PRECACHE_MODEL((char *)STRING(pev->model));
@ -1003,7 +994,7 @@ void CLaser::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
} }
/* <787a8> ../cstrike/dlls/effects.cpp:1015 */ /* <787a8> ../cstrike/dlls/effects.cpp:1015 */
int CLaser::IsOn(void) int CLaser::IsOn()
{ {
if (pev->effects & EF_NODRAW) if (pev->effects & EF_NODRAW)
return 0; return 0;
@ -1012,7 +1003,7 @@ int CLaser::IsOn(void)
} }
/* <787c9> ../cstrike/dlls/effects.cpp:1023 */ /* <787c9> ../cstrike/dlls/effects.cpp:1023 */
void CLaser::TurnOff(void) void CLaser::TurnOff()
{ {
pev->effects |= EF_NODRAW; pev->effects |= EF_NODRAW;
pev->nextthink = 0; pev->nextthink = 0;
@ -1024,7 +1015,7 @@ void CLaser::TurnOff(void)
} }
/* <78804> ../cstrike/dlls/effects.cpp:1032 */ /* <78804> ../cstrike/dlls/effects.cpp:1032 */
void CLaser::TurnOn(void) void CLaser::TurnOn()
{ {
pev->effects &= ~EF_NODRAW; pev->effects &= ~EF_NODRAW;
@ -1064,7 +1055,7 @@ void CLaser::FireAtPoint(TraceResult &tr)
} }
/* <778f6> ../cstrike/dlls/effects.cpp:1069 */ /* <778f6> ../cstrike/dlls/effects.cpp:1069 */
void CLaser::StrikeThink(void) void CLaser::StrikeThink()
{ {
CBaseEntity *pEnd = RandomTargetname(STRING(pev->message)); CBaseEntity *pEnd = RandomTargetname(STRING(pev->message));
@ -1084,7 +1075,7 @@ LINK_ENTITY_TO_CLASS(env_glow, CGlow);
IMPLEMENT_SAVERESTORE(CGlow, CPointEntity); IMPLEMENT_SAVERESTORE(CGlow, CPointEntity);
/* <735a6> ../cstrike/dlls/effects.cpp:1109 */ /* <735a6> ../cstrike/dlls/effects.cpp:1109 */
void CGlow::__MAKE_VHOOK(Spawn)(void) void CGlow::__MAKE_VHOOK(Spawn)()
{ {
pev->solid = SOLID_NOT; pev->solid = SOLID_NOT;
pev->movetype = MOVETYPE_NONE; pev->movetype = MOVETYPE_NONE;
@ -1105,7 +1096,7 @@ void CGlow::__MAKE_VHOOK(Spawn)(void)
} }
/* <74606> ../cstrike/dlls/effects.cpp:1127 */ /* <74606> ../cstrike/dlls/effects.cpp:1127 */
void CGlow::__MAKE_VHOOK(Think)(void) void CGlow::__MAKE_VHOOK(Think)()
{ {
Animate(pev->framerate * (gpGlobals->time - m_lastTime)); Animate(pev->framerate * (gpGlobals->time - m_lastTime));
@ -1124,7 +1115,7 @@ void CGlow::Animate(float frames)
LINK_ENTITY_TO_CLASS(env_bombglow, CBombGlow); LINK_ENTITY_TO_CLASS(env_bombglow, CBombGlow);
/* <735cd> ../cstrike/dlls/effects.cpp:1161 */ /* <735cd> ../cstrike/dlls/effects.cpp:1161 */
void CBombGlow::__MAKE_VHOOK(Spawn)(void) void CBombGlow::__MAKE_VHOOK(Spawn)()
{ {
#ifdef REGAMEDLL_FIXES #ifdef REGAMEDLL_FIXES
PRECACHE_MODEL("sprites/flare1.spr"); PRECACHE_MODEL("sprites/flare1.spr");
@ -1134,7 +1125,7 @@ void CBombGlow::__MAKE_VHOOK(Spawn)(void)
pev->movetype = MOVETYPE_NONE; pev->movetype = MOVETYPE_NONE;
pev->effects = 0; pev->effects = 0;
pev->frame = 0; pev->frame = 0;
pev->nextthink = gpGlobals->time + 0.05; pev->nextthink = gpGlobals->time + 0.05f;
pev->rendermode = kRenderGlow; pev->rendermode = kRenderGlow;
pev->rendercolor.x = 255; pev->rendercolor.x = 255;
pev->rendercolor.y = 15; pev->rendercolor.y = 15;
@ -1148,7 +1139,7 @@ void CBombGlow::__MAKE_VHOOK(Spawn)(void)
} }
/* <73a40> ../cstrike/dlls/effects.cpp:1184 */ /* <73a40> ../cstrike/dlls/effects.cpp:1184 */
void CBombGlow::__MAKE_VHOOK(Think)(void) void CBombGlow::__MAKE_VHOOK(Think)()
{ {
if (!m_bSetModel) if (!m_bSetModel)
{ {
@ -1182,7 +1173,7 @@ LINK_ENTITY_TO_CLASS(env_sprite, CSprite);
IMPLEMENT_SAVERESTORE(CSprite, CPointEntity); IMPLEMENT_SAVERESTORE(CSprite, CPointEntity);
/* <75dc8> ../cstrike/dlls/effects.cpp:1236 */ /* <75dc8> ../cstrike/dlls/effects.cpp:1236 */
void CSprite::__MAKE_VHOOK(Spawn)(void) void CSprite::__MAKE_VHOOK(Spawn)()
{ {
pev->solid = SOLID_NOT; pev->solid = SOLID_NOT;
pev->movetype = MOVETYPE_NONE; pev->movetype = MOVETYPE_NONE;
@ -1207,7 +1198,7 @@ void CSprite::__MAKE_VHOOK(Spawn)(void)
} }
/* <75d55> ../cstrike/dlls/effects.cpp:1260 */ /* <75d55> ../cstrike/dlls/effects.cpp:1260 */
void CSprite::__MAKE_VHOOK(Restart)(void) void CSprite::__MAKE_VHOOK(Restart)()
{ {
pev->solid = SOLID_NOT; pev->solid = SOLID_NOT;
pev->movetype = MOVETYPE_NONE; pev->movetype = MOVETYPE_NONE;
@ -1221,7 +1212,7 @@ void CSprite::__MAKE_VHOOK(Restart)(void)
} }
/* <74436> ../cstrike/dlls/effects.cpp:1273 */ /* <74436> ../cstrike/dlls/effects.cpp:1273 */
void CSprite::__MAKE_VHOOK(Precache)(void) void CSprite::__MAKE_VHOOK(Precache)()
{ {
PRECACHE_MODEL((char *)STRING(pev->model)); PRECACHE_MODEL((char *)STRING(pev->model));
@ -1268,15 +1259,15 @@ CSprite *CSprite::SpriteCreate(const char *pSpriteName, const Vector &origin, BO
} }
/* <75679> ../cstrike/dlls/effects.cpp:1310 */ /* <75679> ../cstrike/dlls/effects.cpp:1310 */
void CSprite::AnimateThink(void) void CSprite::AnimateThink()
{ {
Animate(pev->framerate * (gpGlobals->time - m_lastTime)); Animate(pev->framerate * (gpGlobals->time - m_lastTime));
pev->nextthink = gpGlobals->time + 0.1; pev->nextthink = gpGlobals->time + 0.1f;
m_lastTime = gpGlobals->time; m_lastTime = gpGlobals->time;
} }
/* <78d6b> ../cstrike/dlls/effects.cpp:1318 */ /* <78d6b> ../cstrike/dlls/effects.cpp:1318 */
void CSprite::AnimateUntilDead(void) void CSprite::AnimateUntilDead()
{ {
if (gpGlobals->time > pev->dmgtime) if (gpGlobals->time > pev->dmgtime)
{ {
@ -1301,7 +1292,7 @@ NOXREF void CSprite::Expand(float scaleSpeed, float fadeSpeed)
} }
/* <73e2e> ../cstrike/dlls/effects.cpp:1340 */ /* <73e2e> ../cstrike/dlls/effects.cpp:1340 */
void CSprite::ExpandThink(void) void CSprite::ExpandThink()
{ {
float frametime = gpGlobals->time - m_lastTime; float frametime = gpGlobals->time - m_lastTime;
@ -1336,14 +1327,14 @@ void CSprite::Animate(float frames)
} }
/* <78e73> ../cstrike/dlls/effects.cpp:1376 */ /* <78e73> ../cstrike/dlls/effects.cpp:1376 */
void CSprite::TurnOff(void) void CSprite::TurnOff()
{ {
pev->effects = EF_NODRAW; pev->effects = EF_NODRAW;
pev->nextthink = 0; pev->nextthink = 0;
} }
/* <78e94> ../cstrike/dlls/effects.cpp:1383 */ /* <78e94> ../cstrike/dlls/effects.cpp:1383 */
void CSprite::TurnOn(void) void CSprite::TurnOn()
{ {
pev->effects = 0; pev->effects = 0;
@ -1378,7 +1369,7 @@ IMPLEMENT_SAVERESTORE(CGibShooter, CBaseDelay);
LINK_ENTITY_TO_CLASS(gibshooter, CGibShooter); LINK_ENTITY_TO_CLASS(gibshooter, CGibShooter);
/* <73dbb> ../cstrike/dlls/effects.cpp:1452 */ /* <73dbb> ../cstrike/dlls/effects.cpp:1452 */
void CGibShooter::__MAKE_VHOOK(Precache)(void) void CGibShooter::__MAKE_VHOOK(Precache)()
{ {
if (g_Language == LANGUAGE_GERMAN) if (g_Language == LANGUAGE_GERMAN)
{ {
@ -1425,7 +1416,7 @@ void CGibShooter::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCalle
} }
/* <73cb5> ../cstrike/dlls/effects.cpp:1499 */ /* <73cb5> ../cstrike/dlls/effects.cpp:1499 */
void CGibShooter::__MAKE_VHOOK(Spawn)(void) void CGibShooter::__MAKE_VHOOK(Spawn)()
{ {
Precache(); Precache();
@ -1439,7 +1430,7 @@ void CGibShooter::__MAKE_VHOOK(Spawn)(void)
if (m_flGibLife == 0.0f) if (m_flGibLife == 0.0f)
{ {
m_flGibLife = 25; m_flGibLife = 25.0f;
} }
SetMovedir(pev); SetMovedir(pev);
@ -1447,7 +1438,7 @@ void CGibShooter::__MAKE_VHOOK(Spawn)(void)
} }
/* <744ff> ../cstrike/dlls/effects.cpp:1521 */ /* <744ff> ../cstrike/dlls/effects.cpp:1521 */
CGib *CGibShooter::__MAKE_VHOOK(CreateGib)(void) CGib *CGibShooter::__MAKE_VHOOK(CreateGib)()
{ {
if (CVAR_GET_FLOAT("violence_hgibs") == 0) if (CVAR_GET_FLOAT("violence_hgibs") == 0)
return NULL; return NULL;
@ -1469,7 +1460,7 @@ CGib *CGibShooter::__MAKE_VHOOK(CreateGib)(void)
} }
/* <75751> ../cstrike/dlls/effects.cpp:1541 */ /* <75751> ../cstrike/dlls/effects.cpp:1541 */
void CGibShooter::ShootThink(void) void CGibShooter::ShootThink()
{ {
pev->nextthink = m_flDelay + gpGlobals->time; pev->nextthink = m_flDelay + gpGlobals->time;
@ -1566,7 +1557,6 @@ void CEnvShooter::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
case 4: case 4:
m_iGibMaterial = matRocks; m_iGibMaterial = matRocks;
break; break;
default: default:
case -1: case -1:
m_iGibMaterial = matNone; m_iGibMaterial = matNone;
@ -1578,14 +1568,14 @@ void CEnvShooter::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
} }
/* <73cdc> ../cstrike/dlls/effects.cpp:1644 */ /* <73cdc> ../cstrike/dlls/effects.cpp:1644 */
void CEnvShooter::__MAKE_VHOOK(Precache)(void) void CEnvShooter::__MAKE_VHOOK(Precache)()
{ {
m_iGibModelIndex = PRECACHE_MODEL((char *)STRING(pev->model)); m_iGibModelIndex = PRECACHE_MODEL((char *)STRING(pev->model));
CBreakable::MaterialSoundPrecache((Materials)m_iGibMaterial); CBreakable::MaterialSoundPrecache((Materials)m_iGibMaterial);
} }
/* <7464b> ../cstrike/dlls/effects.cpp:1651 */ /* <7464b> ../cstrike/dlls/effects.cpp:1651 */
CGib *CEnvShooter::__MAKE_VHOOK(CreateGib)(void) CGib *CEnvShooter::__MAKE_VHOOK(CreateGib)()
{ {
CGib *pGib = GetClassPtr((CGib *)NULL); CGib *pGib = GetClassPtr((CGib *)NULL);
@ -1614,19 +1604,19 @@ CGib *CEnvShooter::__MAKE_VHOOK(CreateGib)(void)
LINK_ENTITY_TO_CLASS(test_effect, CTestEffect); LINK_ENTITY_TO_CLASS(test_effect, CTestEffect);
/* <73656> ../cstrike/dlls/effects.cpp:1698 */ /* <73656> ../cstrike/dlls/effects.cpp:1698 */
void CTestEffect::__MAKE_VHOOK(Spawn)(void) void CTestEffect::__MAKE_VHOOK(Spawn)()
{ {
Precache(); Precache();
} }
/* <7367c> ../cstrike/dlls/effects.cpp:1703 */ /* <7367c> ../cstrike/dlls/effects.cpp:1703 */
void CTestEffect::__MAKE_VHOOK(Precache)(void) void CTestEffect::__MAKE_VHOOK(Precache)()
{ {
PRECACHE_MODEL("sprites/lgtning.spr"); PRECACHE_MODEL("sprites/lgtning.spr");
} }
/* <76e39> ../cstrike/dlls/effects.cpp:1708 */ /* <76e39> ../cstrike/dlls/effects.cpp:1708 */
void CTestEffect::TestThink(void) void CTestEffect::TestThink()
{ {
int i; int i;
float t = (gpGlobals->time - m_flStartTime); float t = (gpGlobals->time - m_flStartTime);
@ -1688,7 +1678,7 @@ void CTestEffect::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCalle
LINK_ENTITY_TO_CLASS(env_blood, CBlood); LINK_ENTITY_TO_CLASS(env_blood, CBlood);
/* <73c8f> ../cstrike/dlls/effects.cpp:1797 */ /* <73c8f> ../cstrike/dlls/effects.cpp:1797 */
void CBlood::__MAKE_VHOOK(Spawn)(void) void CBlood::__MAKE_VHOOK(Spawn)()
{ {
pev->solid = SOLID_NOT; pev->solid = SOLID_NOT;
pev->movetype = MOVETYPE_NONE; pev->movetype = MOVETYPE_NONE;
@ -1726,7 +1716,7 @@ void CBlood::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
} }
/* <791f7> ../cstrike/dlls/effects.cpp:1834 */ /* <791f7> ../cstrike/dlls/effects.cpp:1834 */
Vector CBlood::Direction(void) Vector CBlood::Direction()
{ {
if (pev->spawnflags & SF_BLOOD_RANDOM) if (pev->spawnflags & SF_BLOOD_RANDOM)
return UTIL_RandomBloodVector(); return UTIL_RandomBloodVector();
@ -1746,7 +1736,7 @@ Vector CBlood::BloodPosition(CBaseEntity *pActivator)
else else
pPlayer = INDEXENT(1); pPlayer = INDEXENT(1);
if (pPlayer) if (pPlayer != NULL)
{ {
return (pPlayer->v.origin + pPlayer->v.view_ofs) + Vector(RANDOM_FLOAT(-10, 10), RANDOM_FLOAT(-10, 10), RANDOM_FLOAT(-10, 10)); return (pPlayer->v.origin + pPlayer->v.view_ofs) + Vector(RANDOM_FLOAT(-10, 10), RANDOM_FLOAT(-10, 10), RANDOM_FLOAT(-10, 10));
} }
@ -1782,7 +1772,7 @@ void CBlood::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCaller, US
LINK_ENTITY_TO_CLASS(env_shake, CShake); LINK_ENTITY_TO_CLASS(env_shake, CShake);
/* <73705> ../cstrike/dlls/effects.cpp:1919 */ /* <73705> ../cstrike/dlls/effects.cpp:1919 */
void CShake::__MAKE_VHOOK(Spawn)(void) void CShake::__MAKE_VHOOK(Spawn)()
{ {
pev->solid = SOLID_NOT; pev->solid = SOLID_NOT;
pev->movetype = MOVETYPE_NONE; pev->movetype = MOVETYPE_NONE;
@ -1830,7 +1820,7 @@ void CShake::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCaller, US
LINK_ENTITY_TO_CLASS(env_fade, CFade); LINK_ENTITY_TO_CLASS(env_fade, CFade);
/* <7372b> ../cstrike/dlls/effects.cpp:1987 */ /* <7372b> ../cstrike/dlls/effects.cpp:1987 */
void CFade::__MAKE_VHOOK(Spawn)(void) void CFade::__MAKE_VHOOK(Spawn)()
{ {
pev->solid = SOLID_NOT; pev->solid = SOLID_NOT;
pev->movetype = MOVETYPE_NONE; pev->movetype = MOVETYPE_NONE;
@ -1883,7 +1873,7 @@ void CFade::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCaller, USE
LINK_ENTITY_TO_CLASS(env_message, CMessage); LINK_ENTITY_TO_CLASS(env_message, CMessage);
/* <73751> ../cstrike/dlls/effects.cpp:2051 */ /* <73751> ../cstrike/dlls/effects.cpp:2051 */
void CMessage::__MAKE_VHOOK(Spawn)(void) void CMessage::__MAKE_VHOOK(Spawn)()
{ {
Precache(); Precache();
@ -1913,11 +1903,11 @@ void CMessage::__MAKE_VHOOK(Spawn)(void)
// No volume, use normal // No volume, use normal
if (pev->scale <= 0.0f) if (pev->scale <= 0.0f)
pev->scale = 1.0; pev->scale = 1.0f;
} }
/* <73df7> ../cstrike/dlls/effects.cpp:2085 */ /* <73df7> ../cstrike/dlls/effects.cpp:2085 */
void CMessage::__MAKE_VHOOK(Precache)(void) void CMessage::__MAKE_VHOOK(Precache)()
{ {
if (pev->noise) if (pev->noise)
{ {
@ -1935,7 +1925,7 @@ void CMessage::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
} }
else if (FStrEq(pkvd->szKeyName, "messagevolume")) else if (FStrEq(pkvd->szKeyName, "messagevolume"))
{ {
pev->scale = Q_atof(pkvd->szValue) * 0.1; pev->scale = Q_atof(pkvd->szValue) * 0.1f;
pkvd->fHandled = TRUE; pkvd->fHandled = TRUE;
} }
else if (FStrEq(pkvd->szKeyName, "messageattenuation")) else if (FStrEq(pkvd->szKeyName, "messageattenuation"))
@ -1963,9 +1953,10 @@ void CMessage::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCaller,
pPlayer = CBaseEntity::Instance(INDEXENT(1)); pPlayer = CBaseEntity::Instance(INDEXENT(1));
} }
if (pPlayer) if (pPlayer != NULL)
UTIL_ShowMessage(STRING(pev->message), pPlayer); UTIL_ShowMessage(STRING(pev->message), pPlayer);
} }
if (pev->noise) if (pev->noise)
{ {
EMIT_SOUND(edict(), CHAN_BODY, STRING(pev->noise), pev->scale, pev->speed); EMIT_SOUND(edict(), CHAN_BODY, STRING(pev->noise), pev->scale, pev->speed);
@ -1980,7 +1971,7 @@ void CMessage::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCaller,
LINK_ENTITY_TO_CLASS(env_funnel, CEnvFunnel); LINK_ENTITY_TO_CLASS(env_funnel, CEnvFunnel);
/* <73778> ../cstrike/dlls/effects.cpp:2155 */ /* <73778> ../cstrike/dlls/effects.cpp:2155 */
void CEnvFunnel::__MAKE_VHOOK(Precache)(void) void CEnvFunnel::__MAKE_VHOOK(Precache)()
{ {
m_iSprite = PRECACHE_MODEL("sprites/flare6.spr"); m_iSprite = PRECACHE_MODEL("sprites/flare6.spr");
} }
@ -2013,7 +2004,7 @@ void CEnvFunnel::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCaller
} }
/* <7382b> ../cstrike/dlls/effects.cpp:2187 */ /* <7382b> ../cstrike/dlls/effects.cpp:2187 */
void CEnvFunnel::__MAKE_VHOOK(Spawn)(void) void CEnvFunnel::__MAKE_VHOOK(Spawn)()
{ {
Precache(); Precache();
pev->solid = SOLID_NOT; pev->solid = SOLID_NOT;
@ -2021,7 +2012,7 @@ void CEnvFunnel::__MAKE_VHOOK(Spawn)(void)
} }
/* <73852> ../cstrike/dlls/effects.cpp:2207 */ /* <73852> ../cstrike/dlls/effects.cpp:2207 */
void CEnvBeverage::__MAKE_VHOOK(Precache)(void) void CEnvBeverage::__MAKE_VHOOK(Precache)()
{ {
PRECACHE_MODEL("models/can.mdl"); PRECACHE_MODEL("models/can.mdl");
PRECACHE_SOUND("weapons/g_bounce3.wav"); PRECACHE_SOUND("weapons/g_bounce3.wav");
@ -2054,7 +2045,7 @@ void CEnvBeverage::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCall
} }
/* <73879> ../cstrike/dlls/effects.cpp:2242 */ /* <73879> ../cstrike/dlls/effects.cpp:2242 */
void CEnvBeverage::__MAKE_VHOOK(Spawn)(void) void CEnvBeverage::__MAKE_VHOOK(Spawn)()
{ {
Precache(); Precache();
pev->solid = SOLID_NOT; pev->solid = SOLID_NOT;
@ -2063,12 +2054,12 @@ void CEnvBeverage::__MAKE_VHOOK(Spawn)(void)
if (pev->health == 0.0f) if (pev->health == 0.0f)
{ {
pev->health = 10; pev->health = 10.0f;
} }
} }
/* <738a0> ../cstrike/dlls/effects.cpp:2267 */ /* <738a0> ../cstrike/dlls/effects.cpp:2267 */
void CItemSoda::__MAKE_VHOOK(Precache)(void) void CItemSoda::__MAKE_VHOOK(Precache)()
{ {
; ;
} }
@ -2077,7 +2068,7 @@ void CItemSoda::__MAKE_VHOOK(Precache)(void)
LINK_ENTITY_TO_CLASS(item_sodacan, CItemSoda); LINK_ENTITY_TO_CLASS(item_sodacan, CItemSoda);
/* <738c6> ../cstrike/dlls/effects.cpp:2273 */ /* <738c6> ../cstrike/dlls/effects.cpp:2273 */
void CItemSoda::__MAKE_VHOOK(Spawn)(void) void CItemSoda::__MAKE_VHOOK(Spawn)()
{ {
Precache(); Precache();
pev->solid = SOLID_NOT; pev->solid = SOLID_NOT;
@ -2091,7 +2082,7 @@ void CItemSoda::__MAKE_VHOOK(Spawn)(void)
} }
/* <73961> ../cstrike/dlls/effects.cpp:2286 */ /* <73961> ../cstrike/dlls/effects.cpp:2286 */
void CItemSoda::CanThink(void) void CItemSoda::CanThink()
{ {
EMIT_SOUND(ENT(pev), CHAN_WEAPON, "weapons/g_bounce3.wav", VOL_NORM, ATTN_NORM); EMIT_SOUND(ENT(pev), CHAN_WEAPON, "weapons/g_bounce3.wav", VOL_NORM, ATTN_NORM);
@ -2127,337 +2118,3 @@ void CItemSoda::CanTouch(CBaseEntity *pOther)
SetThink(&CItemSoda::SUB_Remove); SetThink(&CItemSoda::SUB_Remove);
pev->nextthink = gpGlobals->time; pev->nextthink = gpGlobals->time;
} }
#ifdef HOOK_GAMEDLL
void CBombGlow::Spawn(void)
{
Spawn_();
}
void CBombGlow::Think(void)
{
Think_();
}
void CSprite::Spawn(void)
{
Spawn_();
}
void CSprite::Precache(void)
{
Precache_();
}
void CSprite::Restart(void)
{
Restart_();
}
int CSprite::Save(CSave &save)
{
return Save_(save);
}
int CSprite::Restore(CRestore &restore)
{
return Restore_(restore);
}
void CSprite::Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
{
Use_(pActivator, pCaller, useType, value);
}
void CBeam::Spawn(void)
{
Spawn_();
}
void CBeam::Precache(void)
{
Precache_();
}
void CLaser::Spawn(void)
{
Spawn_();
}
void CLaser::Precache(void)
{
Precache_();
}
void CLaser::KeyValue(KeyValueData *pkvd)
{
KeyValue_(pkvd);
}
int CLaser::Save(CSave &save)
{
return Save_(save);
}
int CLaser::Restore(CRestore &restore)
{
return Restore_(restore);
}
void CLaser::Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
{
Use_(pActivator, pCaller, useType, value);
}
void CBubbling::Spawn(void)
{
Spawn_();
}
void CBubbling::Precache(void)
{
Precache_();
}
void CBubbling::KeyValue(KeyValueData *pkvd)
{
KeyValue_(pkvd);
}
int CBubbling::Save(CSave &save)
{
return Save_(save);
}
int CBubbling::Restore(CRestore &restore)
{
return Restore_(restore);
}
void CBubbling::Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
{
Use_(pActivator, pCaller, useType, value);
}
void CLightning::Spawn(void)
{
Spawn_();
}
void CLightning::Precache(void)
{
Precache_();
}
void CLightning::KeyValue(KeyValueData *pkvd)
{
KeyValue_(pkvd);
}
int CLightning::Save(CSave &save)
{
return Save_(save);
}
int CLightning::Restore(CRestore &restore)
{
return Restore_(restore);
}
void CLightning::Activate(void)
{
Activate_();
}
void CGlow::Spawn(void)
{
Spawn_();
}
int CGlow::Save(CSave &save)
{
return Save_(save);
}
int CGlow::Restore(CRestore &restore)
{
return Restore_(restore);
}
void CGlow::Think(void)
{
Think_();
}
void CGibShooter::Spawn(void)
{
Spawn_();
}
void CGibShooter::Precache(void)
{
Precache_();
}
void CGibShooter::KeyValue(KeyValueData *pkvd)
{
KeyValue_(pkvd);
}
int CGibShooter::Save(CSave &save)
{
return Save_(save);
}
int CGibShooter::Restore(CRestore &restore)
{
return Restore_(restore);
}
void CGibShooter::Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
{
Use_(pActivator, pCaller, useType, value);
}
CGib *CGibShooter::CreateGib(void)
{
return CreateGib_();
}
void CEnvShooter::Precache(void)
{
Precache_();
}
void CEnvShooter::KeyValue(KeyValueData *pkvd)
{
KeyValue_(pkvd);
}
CGib *CEnvShooter::CreateGib(void)
{
return CreateGib_();
}
void CTestEffect::Spawn(void)
{
Spawn_();
}
void CTestEffect::Precache(void)
{
Precache_();
}
void CTestEffect::Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
{
Use_(pActivator, pCaller, useType, value);
}
void CBlood::Spawn(void)
{
Spawn_();
}
void CBlood::KeyValue(KeyValueData *pkvd)
{
KeyValue_(pkvd);
}
void CBlood::Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
{
Use_(pActivator, pCaller, useType, value);
}
void CShake::Spawn(void)
{
Spawn_();
}
void CShake::KeyValue(KeyValueData *pkvd)
{
KeyValue_(pkvd);
}
void CShake::Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
{
Use_(pActivator, pCaller, useType, value);
}
void CFade::Spawn(void)
{
Spawn_();
}
void CFade::KeyValue(KeyValueData *pkvd)
{
KeyValue_(pkvd);
}
void CFade::Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
{
Use_(pActivator, pCaller, useType, value);
}
void CMessage::Spawn(void)
{
Spawn_();
}
void CMessage::Precache(void)
{
Precache_();
}
void CMessage::KeyValue(KeyValueData *pkvd)
{
KeyValue_(pkvd);
}
void CMessage::Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
{
Use_(pActivator, pCaller, useType, value);
}
void CEnvFunnel::Spawn(void)
{
Spawn_();
}
void CEnvFunnel::Precache(void)
{
Precache_();
}
void CEnvFunnel::Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
{
Use_(pActivator, pCaller, useType, value);
}
void CEnvBeverage::Spawn(void)
{
Spawn_();
}
void CEnvBeverage::Precache(void)
{
Precache_();
}
void CEnvBeverage::Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
{
Use_(pActivator, pCaller, useType, value);
}
void CItemSoda::Spawn(void)
{
Spawn_();
}
void CItemSoda::Precache(void)
{
Precache_();
}
#endif // HOOK_GAMEDLL

View File

@ -72,12 +72,12 @@
class CSprite: public CPointEntity class CSprite: public CPointEntity
{ {
public: public:
virtual void Spawn(void); virtual void Spawn();
virtual void Precache(void); virtual void Precache();
virtual void Restart(void); virtual void Restart();
virtual int Save(CSave &save); virtual int Save(CSave &save);
virtual int Restore(CRestore &restore); virtual int Restore(CRestore &restore);
virtual int ObjectCaps(void) virtual int ObjectCaps()
{ {
int flags = 0; int flags = 0;
if (pev->spawnflags & SF_SPRITE_TEMPORARY) if (pev->spawnflags & SF_SPRITE_TEMPORARY)
@ -89,9 +89,9 @@ public:
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Spawn_(void); void Spawn_();
void Precache_(void); void Precache_();
void Restart_(void); void Restart_();
int Save_(CSave &save); int Save_(CSave &save);
int Restore_(CRestore &restore); int Restore_(CRestore &restore);
void Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value); void Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
@ -99,8 +99,8 @@ public:
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
public: public:
void EXPORT AnimateThink(void); void EXPORT AnimateThink();
void EXPORT ExpandThink(void); void EXPORT ExpandThink();
void Animate(float frames); void Animate(float frames);
NOXREF void Expand(float scaleSpeed, float fadeSpeed); NOXREF void Expand(float scaleSpeed, float fadeSpeed);
@ -108,7 +108,7 @@ public:
void SetAttachment(edict_t *pEntity, int attachment) void SetAttachment(edict_t *pEntity, int attachment)
{ {
if (pEntity) if (pEntity != NULL)
{ {
pev->skin = ENTINDEX(pEntity); pev->skin = ENTINDEX(pEntity);
pev->body = attachment; pev->body = attachment;
@ -116,12 +116,11 @@ public:
pev->movetype = MOVETYPE_FOLLOW; pev->movetype = MOVETYPE_FOLLOW;
} }
} }
void TurnOff(void);
void TurnOn(void); void TurnOff();
float Frames(void) void TurnOn();
{
return m_maxFrame; float Frames() const { return m_maxFrame; }
}
void SetTransparency(int rendermode, int r, int g, int b, int a, int fx) void SetTransparency(int rendermode, int r, int g, int b, int a, int fx)
{ {
pev->rendermode = rendermode; pev->rendermode = rendermode;
@ -131,24 +130,12 @@ public:
pev->renderamt = a; pev->renderamt = a;
pev->renderfx = fx; pev->renderfx = fx;
} }
void SetTexture(int spriteIndex)
{ void SetTexture(int spriteIndex) { pev->modelindex = spriteIndex; }
pev->modelindex = spriteIndex; void SetScale(float scale) { pev->scale = scale; }
} void SetColor(int r, int g, int b) { pev->rendercolor.x = r; pev->rendercolor.y = g; pev->rendercolor.z = b; }
void SetScale(float scale) void SetBrightness(int brightness) { pev->renderamt = brightness; }
{
pev->scale = scale;
}
void SetColor(int r, int g, int b)
{
pev->rendercolor.x = r;
pev->rendercolor.y = g;
pev->rendercolor.z = b;
}
void SetBrightness(int brightness)
{
pev->renderamt = brightness;
}
void AnimateAndDie(float_precision framerate) void AnimateAndDie(float_precision framerate)
{ {
SetThink(&CSprite::AnimateUntilDead); SetThink(&CSprite::AnimateUntilDead);
@ -157,25 +144,23 @@ public:
pev->nextthink = gpGlobals->time; pev->nextthink = gpGlobals->time;
} }
void EXPORT AnimateUntilDead(void); void EXPORT AnimateUntilDead();
static CSprite *SpriteCreate(const char *pSpriteName, const Vector &origin, BOOL animate); static CSprite *SpriteCreate(const char *pSpriteName, const Vector &origin, BOOL animate);
static TYPEDESCRIPTION IMPL(m_SaveData)[2]; static TYPEDESCRIPTION IMPL(m_SaveData)[2];
private: private:
float m_lastTime; float m_lastTime;
float m_maxFrame; float m_maxFrame;
};
};/* size: 160, cachelines: 3, members: 4 */
/* <723cb> ../cstrike/dlls/effects.h:105 */ /* <723cb> ../cstrike/dlls/effects.h:105 */
class CBeam: public CBaseEntity class CBeam: public CBaseEntity
{ {
public: public:
virtual void Spawn(void); virtual void Spawn();
virtual void Precache(void); virtual void Precache();
virtual int ObjectCaps(void) virtual int ObjectCaps()
{ {
int flags = 0; int flags = 0;
if (pev->spawnflags & SF_BEAM_TEMPORARY) if (pev->spawnflags & SF_BEAM_TEMPORARY)
@ -183,123 +168,51 @@ public:
return (CBaseEntity::ObjectCaps() & ~FCAP_ACROSS_TRANSITION) | flags; return (CBaseEntity::ObjectCaps() & ~FCAP_ACROSS_TRANSITION) | flags;
} }
virtual Vector Center(void) virtual Vector Center() { return (GetStartPos() + GetEndPos()) * 0.5f; }
{
return (GetStartPos() + GetEndPos()) * 0.5;
}
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Spawn_(void); void Spawn_();
void Precache_(void); void Precache_();
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
public: public:
void EXPORT TriggerTouch(CBaseEntity *pOther); void EXPORT TriggerTouch(CBaseEntity *pOther);
void SetType(int type) void SetType(int type) { pev->rendermode = (pev->rendermode & 0xF0) | (type & 0x0F); }
{ void SetFlags(int flags) { pev->rendermode = (pev->rendermode & 0x0F) | (flags & 0xF0); }
pev->rendermode = (pev->rendermode & 0xF0) | (type & 0x0F); void SetStartPos(const Vector &pos) { pev->origin = pos; }
} void SetEndPos(const Vector &pos) { pev->angles = pos; }
void SetFlags(int flags)
{
pev->rendermode = (pev->rendermode & 0x0F) | (flags & 0xF0);
}
void SetStartPos(const Vector &pos)
{
pev->origin = pos;
}
void SetEndPos(const Vector &pos)
{
pev->angles = pos;
}
void SetStartEntity(int entityIndex); void SetStartEntity(int entityIndex);
void SetEndEntity(int entityIndex); void SetEndEntity(int entityIndex);
void SetStartAttachment(int attachment)
{
pev->sequence = (pev->sequence & 0x0FFF) | ((attachment & 0xF) << 12);
}
void SetEndAttachment(int attachment)
{
pev->skin = (pev->skin & 0x0FFF) | ((attachment & 0xF) << 12);
}
void SetTexture(int spriteIndex)
{
pev->modelindex = spriteIndex;
}
void SetWidth(int width)
{
pev->scale = width;
}
void SetNoise(int amplitude)
{
pev->body = amplitude;
}
void SetColor(int r, int g, int b)
{
pev->rendercolor.x = r;
pev->rendercolor.y = g;
pev->rendercolor.z = b;
}
void SetBrightness(int brightness)
{
pev->renderamt = brightness;
}
void SetFrame(float frame)
{
pev->frame = frame;
}
void SetScrollRate(int speed)
{
pev->animtime = speed;
}
int GetType(void)
{
return pev->rendermode & 0x0F;
}
int GetFlags(void)
{
return pev->rendermode & 0xF0;
}
int GetStartEntity(void)
{
return pev->sequence & 0xFFF;
}
int GetEndEntity(void)
{
return pev->skin & 0xFFF;
}
const Vector &GetStartPos(void); void SetStartAttachment(int attachment) { pev->sequence = (pev->sequence & 0x0FFF) | ((attachment & 0xF) << 12); }
const Vector &GetEndPos(void); void SetEndAttachment(int attachment) { pev->skin = (pev->skin & 0x0FFF) | ((attachment & 0xF) << 12); }
void SetTexture(int spriteIndex) { pev->modelindex = spriteIndex; }
void SetWidth(int width) { pev->scale = width; }
void SetNoise(int amplitude) { pev->body = amplitude; }
void SetColor(int r, int g, int b) { pev->rendercolor.x = r; pev->rendercolor.y = g; pev->rendercolor.z = b; }
void SetBrightness(int brightness) { pev->renderamt = brightness;}
void SetFrame(float frame) { pev->frame = frame; }
void SetScrollRate(int speed) { pev->animtime = speed; }
int GetType() const { return pev->rendermode & 0x0F; }
int GetFlags() const { return pev->rendermode & 0xF0; }
int GetStartEntity() const { return pev->sequence & 0xFFF; }
int GetEndEntity() const { return pev->skin & 0xFFF; }
int GetTexture(void) const Vector &GetStartPos();
{ const Vector &GetEndPos();
return pev->modelindex;
}
int GetWidth(void)
{
return pev->scale;
}
int GetNoise(void)
{
return pev->body;
}
int GetBrightness(void)
{
return pev->renderamt;
}
int GetFrame(void)
{
return pev->frame;
}
int GetScrollRate(void)
{
return pev->animtime;
}
void RelinkBeam(void); int GetTexture() const { return pev->modelindex; }
int GetWidth() const { return pev->scale; }
int GetNoise() const { return pev->body; }
int GetBrightness() const { return pev->renderamt; }
int GetFrame() const { return pev->frame; }
int GetScrollRate() const { return pev->animtime; }
void RelinkBeam();
void DoSparks(const Vector &start, const Vector &end); void DoSparks(const Vector &start, const Vector &end);
CBaseEntity *RandomTargetname(const char *szName); CBaseEntity *RandomTargetname(const char *szName);
void BeamDamage(TraceResult *ptr); void BeamDamage(TraceResult *ptr);
@ -322,15 +235,14 @@ public:
pev->dmgtime = gpGlobals->time - 1; pev->dmgtime = gpGlobals->time - 1;
BeamDamage(ptr); BeamDamage(ptr);
} }
};
};/* size: 152, cachelines: 3, members: 1 */
/* <72402> ../cstrike/dlls/effects.h:188 */ /* <72402> ../cstrike/dlls/effects.h:188 */
class CLaser: public CBeam class CLaser: public CBeam
{ {
public: public:
virtual void Spawn(void); virtual void Spawn();
virtual void Precache(void); virtual void Precache();
virtual void KeyValue(KeyValueData *pkvd); virtual void KeyValue(KeyValueData *pkvd);
virtual int Save(CSave &save); virtual int Save(CSave &save);
virtual int Restore(CRestore &restore); virtual int Restore(CRestore &restore);
@ -338,8 +250,8 @@ public:
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Spawn_(void); void Spawn_();
void Precache_(void); void Precache_();
void KeyValue_(KeyValueData *pkvd); void KeyValue_(KeyValueData *pkvd);
int Save_(CSave &save); int Save_(CSave &save);
int Restore_(CRestore &restore); int Restore_(CRestore &restore);
@ -348,42 +260,37 @@ public:
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
public: public:
void TurnOn(void); void TurnOn();
void TurnOff(void); void TurnOff();
int IsOn(void); int IsOn();
void FireAtPoint(TraceResult &point); void FireAtPoint(TraceResult &point);
void EXPORT StrikeThink(void); void EXPORT StrikeThink();
public: public:
static TYPEDESCRIPTION IMPL(m_SaveData)[3]; static TYPEDESCRIPTION IMPL(m_SaveData)[3];
public:
CSprite *m_pSprite; CSprite *m_pSprite;
int m_iszSpriteName; int m_iszSpriteName;
Vector m_firePosition; Vector m_firePosition;
};
};/* size: 172, cachelines: 3, members: 5 */
/* <7237e> ../cstrike/dlls/effects.cpp:36 */ /* <7237e> ../cstrike/dlls/effects.cpp:36 */
class CBubbling: public CBaseEntity class CBubbling: public CBaseEntity
{ {
public: public:
virtual void Spawn(void); virtual void Spawn();
virtual void Precache(void); virtual void Precache();
virtual void KeyValue(KeyValueData *pkvd); virtual void KeyValue(KeyValueData *pkvd);
virtual int Save(CSave &save); virtual int Save(CSave &save);
virtual int Restore(CRestore &restore); virtual int Restore(CRestore &restore);
virtual int ObjectCaps(void) virtual int ObjectCaps() { return (CBaseEntity::ObjectCaps() & ~FCAP_ACROSS_TRANSITION); }
{
return (CBaseEntity::ObjectCaps() & ~FCAP_ACROSS_TRANSITION);
}
virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value); virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Spawn_(void); void Spawn_();
void Precache_(void); void Precache_();
void KeyValue_(KeyValueData *pkvd); void KeyValue_(KeyValueData *pkvd);
int Save_(CSave &save); int Save_(CSave &save);
int Restore_(CRestore &restore); int Restore_(CRestore &restore);
@ -392,64 +299,60 @@ public:
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
public: public:
void EXPORT FizzThink(void); void EXPORT FizzThink();
public: public:
static TYPEDESCRIPTION IMPL(m_SaveData)[3]; static TYPEDESCRIPTION IMPL(m_SaveData)[3];
public:
int m_density; int m_density;
int m_frequency; int m_frequency;
int m_bubbleModel; int m_bubbleModel;
int m_state; int m_state;
};
}; /* size: 168, cachelines: 3, members: 6 */
/* <723e6> ../cstrike/dlls/effects.cpp:357 */ /* <723e6> ../cstrike/dlls/effects.cpp:357 */
class CLightning: public CBeam class CLightning: public CBeam
{ {
public: public:
virtual void Spawn(void); virtual void Spawn();
virtual void Precache(void); virtual void Precache();
virtual void KeyValue(KeyValueData *pkvd); virtual void KeyValue(KeyValueData *pkvd);
virtual int Save(CSave &save); virtual int Save(CSave &save);
virtual int Restore(CRestore &restore); virtual int Restore(CRestore &restore);
virtual void Activate(void); virtual void Activate();
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Spawn_(void); void Spawn_();
void Precache_(void); void Precache_();
void KeyValue_(KeyValueData *pkvd); void KeyValue_(KeyValueData *pkvd);
int Save_(CSave &save); int Save_(CSave &save);
int Restore_(CRestore &restore); int Restore_(CRestore &restore);
void Activate_(void); void Activate_();
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
public: public:
void EXPORT StrikeThink(void); void EXPORT StrikeThink();
void EXPORT DamageThink(void); void EXPORT DamageThink();
void RandomArea(void); void RandomArea();
void RandomPoint(Vector &vecSrc); void RandomPoint(Vector &vecSrc);
void Zap(const Vector &vecSrc, const Vector &vecDest); void Zap(const Vector &vecSrc, const Vector &vecDest);
void EXPORT StrikeUse(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value); void EXPORT StrikeUse(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
void EXPORT ToggleUse(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value); void EXPORT ToggleUse(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
/* <71e17> ../cstrike/dlls/effects.cpp:373 */ inline BOOL ServerSide() const
inline BOOL ServerSide(void)
{ {
if (!m_life && !(pev->spawnflags & SF_BEAM_RING)) if (!m_life && !(pev->spawnflags & SF_BEAM_RING))
return TRUE; return TRUE;
return FALSE; return FALSE;
} }
void BeamUpdateVars(void); void BeamUpdateVars();
public: public:
static TYPEDESCRIPTION IMPL(m_SaveData)[13]; static TYPEDESCRIPTION IMPL(m_SaveData)[13];
public:
int m_active; int m_active;
int m_iszStartEntity; int m_iszStartEntity;
int m_iszEndEntity; int m_iszEndEntity;
@ -463,48 +366,46 @@ public:
int m_iszSpriteName; int m_iszSpriteName;
int m_frameStart; int m_frameStart;
float m_radius; float m_radius;
};
}; /* size: 204, cachelines: 4, members: 15 */
/* <7244f> ../cstrike/dlls/effects.cpp:1085 */ /* <7244f> ../cstrike/dlls/effects.cpp:1085 */
class CGlow: public CPointEntity class CGlow: public CPointEntity
{ {
public: public:
virtual void Spawn(void); virtual void Spawn();
virtual int Save(CSave &save); virtual int Save(CSave &save);
virtual int Restore(CRestore &restore); virtual int Restore(CRestore &restore);
virtual void Think(void); virtual void Think();
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Spawn_(void); void Spawn_();
int Save_(CSave &save); int Save_(CSave &save);
int Restore_(CRestore &restore); int Restore_(CRestore &restore);
void Think_(void); void Think_();
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
void Animate(float frames); void Animate(float frames);
public: public:
static TYPEDESCRIPTION IMPL(m_SaveData)[2]; static TYPEDESCRIPTION IMPL(m_SaveData)[2];
public:
float m_lastTime; float m_lastTime;
float m_maxFrame; float m_maxFrame;
};
};/* size: 160, cachelines: 3, members: 4 */
/* <724b8> ../cstrike/dlls/effects.cpp:1146 */ /* <724b8> ../cstrike/dlls/effects.cpp:1146 */
class CBombGlow: public CSprite class CBombGlow: public CSprite
{ {
public: public:
virtual void Spawn(void); virtual void Spawn();
virtual void Think(void); virtual void Think();
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Spawn_(void); void Spawn_();
void Think_(void); void Think_();
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
@ -512,39 +413,38 @@ public:
float m_lastTime; float m_lastTime;
float m_tmBeepPeriod; float m_tmBeepPeriod;
bool m_bSetModel; bool m_bSetModel;
};
};/* size: 172, cachelines: 3, members: 4 */
/* <72581> ../cstrike/dlls/effects.cpp:1413 */ /* <72581> ../cstrike/dlls/effects.cpp:1413 */
class CGibShooter: public CBaseDelay class CGibShooter: public CBaseDelay
{ {
public: public:
virtual void Spawn(void); virtual void Spawn();
virtual void Precache(void); virtual void Precache();
virtual void KeyValue(KeyValueData *pkvd); virtual void KeyValue(KeyValueData *pkvd);
virtual int Save(CSave &save); virtual int Save(CSave &save);
virtual int Restore(CRestore &restore); virtual int Restore(CRestore &restore);
virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value); virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
virtual CGib *CreateGib(void); virtual CGib *CreateGib();
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Spawn_(void); void Spawn_();
void Precache_(void); void Precache_();
void KeyValue_(KeyValueData *pkvd); void KeyValue_(KeyValueData *pkvd);
int Save_(CSave &save); int Save_(CSave &save);
int Restore_(CRestore &restore); int Restore_(CRestore &restore);
void Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value); void Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
CGib *CreateGib_(void); CGib *CreateGib_();
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
public: public:
void EXPORT ShootThink(void); void EXPORT ShootThink();
public: public:
static TYPEDESCRIPTION IMPL(m_SaveData)[7]; static TYPEDESCRIPTION IMPL(m_SaveData)[7];
public:
int m_iGibs; int m_iGibs;
int m_iGibCapacity; int m_iGibCapacity;
int m_iGibMaterial; int m_iGibMaterial;
@ -553,26 +453,25 @@ public:
float m_flGibVelocity; float m_flGibVelocity;
float m_flVariance; float m_flVariance;
float m_flGibLife; float m_flGibLife;
};
};/* size: 188, cachelines: 3, members: 9 */
/* <725ef> ../cstrike/dlls/effects.cpp:1592 */ /* <725ef> ../cstrike/dlls/effects.cpp:1592 */
class CEnvShooter: public CGibShooter class CEnvShooter: public CGibShooter
{ {
public: public:
virtual void Precache(void); virtual void Precache();
virtual void KeyValue(KeyValueData *pkvd); virtual void KeyValue(KeyValueData *pkvd);
virtual CGib *CreateGib(void); virtual CGib *CreateGib();
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Precache_(void); void Precache_();
void KeyValue_(KeyValueData *pkvd); void KeyValue_(KeyValueData *pkvd);
CGib *CreateGib_(void); CGib *CreateGib_();
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
};/* size: 188, cachelines: 3, members: 1 */ };
#define MAX_BEAM 24 #define MAX_BEAM 24
@ -580,20 +479,20 @@ public:
class CTestEffect: public CBaseDelay class CTestEffect: public CBaseDelay
{ {
public: public:
virtual void Spawn(void); virtual void Spawn();
virtual void Precache(void); virtual void Precache();
virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value); virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Spawn_(void); void Spawn_();
void Precache_(void); void Precache_();
void Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value); void Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
public: public:
void EXPORT TestThink(void); void EXPORT TestThink();
public: public:
int m_iLoop; int m_iLoop;
@ -603,257 +502,165 @@ public:
float m_flBeamTime[ MAX_BEAM ]; float m_flBeamTime[ MAX_BEAM ];
float m_flStartTime; float m_flStartTime;
};
};/* size: 364, cachelines: 6, members: 6 */
/* <72690> ../cstrike/dlls/effects.cpp:1769 */ /* <72690> ../cstrike/dlls/effects.cpp:1769 */
class CBlood: public CPointEntity class CBlood: public CPointEntity
{ {
public: public:
virtual void Spawn(void); virtual void Spawn();
virtual void KeyValue(KeyValueData *pkvd); virtual void KeyValue(KeyValueData *pkvd);
virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value); virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Spawn_(void); void Spawn_();
void KeyValue_(KeyValueData *pkvd); void KeyValue_(KeyValueData *pkvd);
void Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value); void Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
public: public:
/* <7205b> ../cstrike/dlls/effects.cpp:1776 */ int Color() const { return pev->impulse; }
int Color(void) float BloodAmount() const { return pev->dmg; }
{
return pev->impulse; void SetColor(int color) { pev->impulse = color; }
} void SetBloodAmount(float amount) { pev->dmg = amount; }
/* <72079> ../cstrike/dlls/effects.cpp:1777 */
float BloodAmount(void)
{
return pev->dmg;
}
/* <72092> ../cstrike/dlls/effects.cpp:1779 */
void SetColor(int color)
{
pev->impulse = color;
}
/* <720b7> ../cstrike/dlls/effects.cpp:1780 */
void SetBloodAmount(float amount)
{
pev->dmg = amount;
}
public: public:
Vector Direction(void); Vector Direction();
Vector BloodPosition(CBaseEntity *pActivator); Vector BloodPosition(CBaseEntity *pActivator);
};
};/* size: 152, cachelines: 3, members: 1 */
/* <726de> ../cstrike/dlls/effects.cpp:1886 */ /* <726de> ../cstrike/dlls/effects.cpp:1886 */
class CShake: public CPointEntity class CShake: public CPointEntity
{ {
public: public:
virtual void Spawn(void); virtual void Spawn();
virtual void KeyValue(KeyValueData *pkvd); virtual void KeyValue(KeyValueData *pkvd);
virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value); virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Spawn_(void); void Spawn_();
void KeyValue_(KeyValueData *pkvd); void KeyValue_(KeyValueData *pkvd);
void Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value); void Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
public: public:
/* <7210f> ../cstrike/dlls/effects.cpp:1893 */ float Amplitude() const { return pev->scale; }
float Amplitude(void) float Frequency() const { return pev->dmg_save; }
{ float Duration() const { return pev->dmg_take; }
return pev->scale; float Radius() const { return pev->dmg; }
}
/* <7212d> ../cstrike/dlls/effects.cpp:1894 */
float Frequency(void)
{
return pev->dmg_save;
}
/* <72146> ../cstrike/dlls/effects.cpp:1895 */
float Duration(void)
{
return pev->dmg_take;
}
/* <7215f> ../cstrike/dlls/effects.cpp:1896 */
float Radius(void)
{
return pev->dmg;
}
/* <72178> ../cstrike/dlls/effects.cpp:1898 */
void SetAmplitude(float amplitude)
{
pev->scale = amplitude;
}
/* <7219d> ../cstrike/dlls/effects.cpp:1899 */
void SetFrequency(float frequency)
{
pev->dmg_save = frequency;
}
/* <721c2> ../cstrike/dlls/effects.cpp:1900 */
void SetDuration(float duration)
{
pev->dmg_take = duration;
}
/* <721e7> ../cstrike/dlls/effects.cpp:1901 */
void SetRadius(float radius)
{
pev->dmg = radius;
}
};/* size: 152, cachelines: 3, members: 1 */ void SetAmplitude(float amplitude) { pev->scale = amplitude; }
void SetFrequency(float frequency) { pev->dmg_save = frequency; }
void SetDuration(float duration) { pev->dmg_take = duration; }
void SetRadius(float radius) { pev->dmg = radius; }
};
/* <7272c> ../cstrike/dlls/effects.cpp:1964 */ /* <7272c> ../cstrike/dlls/effects.cpp:1964 */
class CFade: public CPointEntity class CFade: public CPointEntity
{ {
public: public:
virtual void Spawn(void); virtual void Spawn();
virtual void KeyValue(KeyValueData *pkvd); virtual void KeyValue(KeyValueData *pkvd);
virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value); virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Spawn_(void); void Spawn_();
void KeyValue_(KeyValueData *pkvd); void KeyValue_(KeyValueData *pkvd);
void Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value); void Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
public: public:
/* <72231> ../cstrike/dlls/effects.cpp:1971 */ float Duration() const { return pev->dmg_take; }
float Duration(void) float HoldTime() const { return pev->dmg_save; }
{
return pev->dmg_take;
}
/* <7224f> ../cstrike/dlls/effects.cpp:1972 */
float HoldTime(void)
{
return pev->dmg_save;
}
/* <72268> ../cstrike/dlls/effects.cpp:1974 */
void SetDuration(float duration)
{
pev->dmg_take = duration;
}
/* <7228d> ../cstrike/dlls/effects.cpp:1975 */
void SetHoldTime(float hold)
{
pev->dmg_save = hold;
}
};/* size: 152, cachelines: 3, members: 1 */ void SetDuration(float duration) { pev->dmg_take = duration; }
void SetHoldTime(float hold) { pev->dmg_save = hold; }
};
/* <7277a> ../cstrike/dlls/effects.cpp:2038 */ /* <7277a> ../cstrike/dlls/effects.cpp:2038 */
class CMessage: public CPointEntity class CMessage: public CPointEntity
{ {
public: public:
virtual void Spawn(void); virtual void Spawn();
virtual void Precache(void); virtual void Precache();
virtual void KeyValue(KeyValueData *pkvd); virtual void KeyValue(KeyValueData *pkvd);
virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value); virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Spawn_(void); void Spawn_();
void Precache_(void); void Precache_();
void KeyValue_(KeyValueData *pkvd); void KeyValue_(KeyValueData *pkvd);
void Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value); void Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
};/* size: 152, cachelines: 3, members: 1 */ };
/* <727c8> ../cstrike/dlls/effects.cpp:2145 */ /* <727c8> ../cstrike/dlls/effects.cpp:2145 */
class CEnvFunnel: public CBaseDelay class CEnvFunnel: public CBaseDelay
{ {
public: public:
virtual void Spawn(void); virtual void Spawn();
virtual void Precache(void); virtual void Precache();
virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value); virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Spawn_(void); void Spawn_();
void Precache_(void); void Precache_();
void Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value); void Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
public: public:
int m_iSprite; int m_iSprite;
};
};/* size: 164, cachelines: 3, members: 2 */
/* <7281b> ../cstrike/dlls/effects.cpp:2199 */ /* <7281b> ../cstrike/dlls/effects.cpp:2199 */
class CEnvBeverage: public CBaseDelay class CEnvBeverage: public CBaseDelay
{ {
public: public:
virtual void Spawn(void); virtual void Spawn();
virtual void Precache(void); virtual void Precache();
virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value); virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Spawn_(void); void Spawn_();
void Precache_(void); void Precache_();
void Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value); void Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
};/* size: 160, cachelines: 3, members: 1 */ };
/* <72869> ../cstrike/dlls/effects.cpp:2258 */ /* <72869> ../cstrike/dlls/effects.cpp:2258 */
class CItemSoda: public CBaseEntity class CItemSoda: public CBaseEntity
{ {
public: public:
virtual void Spawn(void); virtual void Spawn();
virtual void Precache(void); virtual void Precache();
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Spawn_(void); void Spawn_();
void Precache_(void); void Precache_();
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
public: public:
void EXPORT CanThink(void); void EXPORT CanThink();
void EXPORT CanTouch(CBaseEntity *pOther); void EXPORT CanTouch(CBaseEntity *pOther);
};
};/* size: 152, cachelines: 3, members: 1 */
int IsPointEntity(CBaseEntity *pEnt); int IsPointEntity(CBaseEntity *pEnt);
#ifdef HOOK_GAMEDLL
// linked objects
C_DLLEXPORT void info_target(entvars_t *pev);
C_DLLEXPORT void env_bubbles(entvars_t *pev);
C_DLLEXPORT void beam(entvars_t *pev);
C_DLLEXPORT void env_lightning(entvars_t *pev);
C_DLLEXPORT void env_beam(entvars_t *pev);
C_DLLEXPORT void env_laser(entvars_t *pev);
C_DLLEXPORT void env_glow(entvars_t *pev);
C_DLLEXPORT void env_bombglow(entvars_t *pev);
C_DLLEXPORT void env_sprite(entvars_t *pev);
C_DLLEXPORT void gibshooter(entvars_t *pev);
C_DLLEXPORT void env_shooter(entvars_t *pev);
C_DLLEXPORT void test_effect(entvars_t *pev);
C_DLLEXPORT void env_blood(entvars_t *pev);
C_DLLEXPORT void env_shake(entvars_t *pev);
C_DLLEXPORT void env_fade(entvars_t *pev);
C_DLLEXPORT void env_message(entvars_t *pev);
C_DLLEXPORT void env_funnel(entvars_t *pev);
C_DLLEXPORT void env_beverage(entvars_t *pev);
C_DLLEXPORT void item_sodacan(entvars_t *pev);
#endif // HOOK_GAMEDLL
#endif // EFFECTS_H #endif // EFFECTS_H

View File

@ -11,17 +11,13 @@ TYPEDESCRIPTION CEnvExplosion::m_SaveData[] =
DEFINE_FIELD(CEnvExplosion, m_spriteScale, FIELD_INTEGER), DEFINE_FIELD(CEnvExplosion, m_spriteScale, FIELD_INTEGER),
}; };
#else // HOOK_GAMEDLL
TYPEDESCRIPTION IMPL_CLASS(CEnvExplosion, m_SaveData)[2];
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
/* <7f660> ../cstrike/dlls/explode.cpp:37 */ /* <7f660> ../cstrike/dlls/explode.cpp:37 */
LINK_ENTITY_TO_CLASS(spark_shower, CShower); LINK_ENTITY_TO_CLASS(spark_shower, CShower);
/* <7f49c> ../cstrike/dlls/explode.cpp:39 */ /* <7f49c> ../cstrike/dlls/explode.cpp:39 */
void CShower::__MAKE_VHOOK(Spawn)(void) void CShower::__MAKE_VHOOK(Spawn)()
{ {
pev->velocity = RANDOM_FLOAT(200, 300) * pev->angles; pev->velocity = RANDOM_FLOAT(200, 300) * pev->angles;
pev->velocity.x += RANDOM_FLOAT(-100, 100); pev->velocity.x += RANDOM_FLOAT(-100, 100);
@ -47,7 +43,7 @@ void CShower::__MAKE_VHOOK(Spawn)(void)
} }
/* <7f475> ../cstrike/dlls/explode.cpp:61 */ /* <7f475> ../cstrike/dlls/explode.cpp:61 */
void CShower::__MAKE_VHOOK(Think)(void) void CShower::__MAKE_VHOOK(Think)()
{ {
UTIL_Sparks(pev->origin); UTIL_Sparks(pev->origin);
@ -94,7 +90,7 @@ void CEnvExplosion::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
} }
/* <7f1a5> ../cstrike/dlls/explode.cpp:120 */ /* <7f1a5> ../cstrike/dlls/explode.cpp:120 */
void CEnvExplosion::__MAKE_VHOOK(Spawn)(void) void CEnvExplosion::__MAKE_VHOOK(Spawn)()
{ {
pev->solid = SOLID_NOT; pev->solid = SOLID_NOT;
pev->effects = EF_NODRAW; pev->effects = EF_NODRAW;
@ -197,7 +193,7 @@ void CEnvExplosion::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCal
} }
/* <7f1e1> ../cstrike/dlls/explode.cpp:235 */ /* <7f1e1> ../cstrike/dlls/explode.cpp:235 */
void CEnvExplosion::Smoke(void) void CEnvExplosion::Smoke()
{ {
if (!(pev->spawnflags & SF_ENVEXPLOSION_NOSMOKE)) if (!(pev->spawnflags & SF_ENVEXPLOSION_NOSMOKE))
{ {
@ -243,47 +239,3 @@ void ExplosionCreate(const Vector &center, Vector &angles, edict_t *pOwner, int
pExplosion->Spawn(); pExplosion->Spawn();
pExplosion->Use(NULL, NULL, USE_TOGGLE, 0); pExplosion->Use(NULL, NULL, USE_TOGGLE, 0);
} }
#ifdef HOOK_GAMEDLL
void CShower::Spawn(void)
{
Spawn_();
}
void CShower::Think(void)
{
Think_();
}
void CShower::Touch(CBaseEntity *pOther)
{
Touch_(pOther);
}
void CEnvExplosion::Spawn(void)
{
Spawn_();
}
void CEnvExplosion::KeyValue(KeyValueData *pkvd)
{
KeyValue_(pkvd);
}
int CEnvExplosion::Save(CSave &save)
{
return Save_(save);
}
int CEnvExplosion::Restore(CRestore &restore)
{
return Restore_(restore);
}
void CEnvExplosion::Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
{
Use_(pActivator, pCaller, useType, value);
}
#endif // HOOK_GAMEDLL

View File

@ -43,29 +43,26 @@
class CShower: public CBaseEntity class CShower: public CBaseEntity
{ {
public: public:
virtual void Spawn(void); virtual void Spawn();
virtual int ObjectCaps(void) virtual int ObjectCaps() { return FCAP_DONT_SAVE; }
{ virtual void Think();
return FCAP_DONT_SAVE;
}
virtual void Think(void);
virtual void Touch(CBaseEntity *pOther); virtual void Touch(CBaseEntity *pOther);
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Spawn_(void); void Spawn_();
void Think_(void); void Think_();
void Touch_(CBaseEntity *pOther); void Touch_(CBaseEntity *pOther);
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
};/* size: 152, cachelines: 3, members: 1 */ };
/* <7e66b> ../cstrike/dlls/explode.cpp:84 */ /* <7e66b> ../cstrike/dlls/explode.cpp:84 */
class CEnvExplosion: public CBaseMonster class CEnvExplosion: public CBaseMonster
{ {
public: public:
virtual void Spawn(void); virtual void Spawn();
virtual void KeyValue(KeyValueData *pkvd); virtual void KeyValue(KeyValueData *pkvd);
virtual int Save(CSave &save); virtual int Save(CSave &save);
virtual int Restore(CRestore &restore); virtual int Restore(CRestore &restore);
@ -73,7 +70,7 @@ public:
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Spawn_(void); void Spawn_();
void KeyValue_(KeyValueData *pkvd); void KeyValue_(KeyValueData *pkvd);
int Save_(CSave &save); int Save_(CSave &save);
int Restore_(CRestore &restore); int Restore_(CRestore &restore);
@ -82,25 +79,15 @@ public:
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
public: public:
void EXPORT Smoke(void); void EXPORT Smoke();
public: public:
static TYPEDESCRIPTION IMPL(m_SaveData)[2]; static TYPEDESCRIPTION IMPL(m_SaveData)[2];
public:
int m_iMagnitude; int m_iMagnitude;
int m_spriteScale; int m_spriteScale;
};
};/* size: 412, cachelines: 7, members: 4 */
void ExplosionCreate(const Vector &center, Vector &angles, edict_t *pOwner, int magnitude, BOOL doDamage); void ExplosionCreate(const Vector &center, Vector &angles, edict_t *pOwner, int magnitude, BOOL doDamage);
#ifdef HOOK_GAMEDLL
// linked objects
C_DLLEXPORT void spark_shower(entvars_t *pev);
C_DLLEXPORT void env_explosion(entvars_t *pev);
#endif // HOOK_GAMEDLL
#endif // EXPLODE_H #endif // EXPLODE_H

View File

@ -48,7 +48,7 @@ const char *CBreakable::pSoundsWood[] =
{ {
"debris/wood1.wav", "debris/wood1.wav",
"debris/wood2.wav", "debris/wood2.wav",
"debris/wood3.wav", "debris/wood3.wav"
}; };
const char *CBreakable::pSoundsFlesh[] = const char *CBreakable::pSoundsFlesh[] =
@ -58,28 +58,28 @@ const char *CBreakable::pSoundsFlesh[] =
"debris/flesh3.wav", "debris/flesh3.wav",
"debris/flesh5.wav", "debris/flesh5.wav",
"debris/flesh6.wav", "debris/flesh6.wav",
"debris/flesh7.wav", "debris/flesh7.wav"
}; };
const char *CBreakable::pSoundsMetal[] = const char *CBreakable::pSoundsMetal[] =
{ {
"debris/metal1.wav", "debris/metal1.wav",
"debris/metal2.wav", "debris/metal2.wav",
"debris/metal3.wav", "debris/metal3.wav"
}; };
const char *CBreakable::pSoundsConcrete[] = const char *CBreakable::pSoundsConcrete[] =
{ {
"debris/concrete1.wav", "debris/concrete1.wav",
"debris/concrete2.wav", "debris/concrete2.wav",
"debris/concrete3.wav", "debris/concrete3.wav"
}; };
const char *CBreakable::pSoundsGlass[] = const char *CBreakable::pSoundsGlass[] =
{ {
"debris/glass1.wav", "debris/glass1.wav",
"debris/glass2.wav", "debris/glass2.wav",
"debris/glass3.wav", "debris/glass3.wav"
}; };
char *CPushable::m_soundNames[] = char *CPushable::m_soundNames[] =
@ -104,21 +104,6 @@ TYPEDESCRIPTION CPushable::m_SaveData[] =
DEFINE_FIELD(CPushable, m_soundTime, FIELD_TIME), DEFINE_FIELD(CPushable, m_soundTime, FIELD_TIME),
}; };
#else // HOOK_GAMEDLL
const char *(*CBreakable::ppSpawnObjects)[32];
const char *(*CBreakable::ppSoundsWood)[3];
const char *(*CBreakable::ppSoundsFlesh)[6];
const char *(*CBreakable::ppSoundsMetal)[3];
const char *(*CBreakable::ppSoundsConcrete)[3];
const char *(*CBreakable::ppSoundsGlass)[3];
char *(*CPushable::pm_soundNames)[3];
TYPEDESCRIPTION IMPL_CLASS(CBreakable, m_SaveData)[5];
TYPEDESCRIPTION IMPL_CLASS(CPushable, m_SaveData)[2];
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
/* <85bf3> ../cstrike/dlls/func_break.cpp:76 */ /* <85bf3> ../cstrike/dlls/func_break.cpp:76 */
@ -192,7 +177,7 @@ LINK_ENTITY_TO_CLASS(func_breakable, CBreakable);
IMPLEMENT_SAVERESTORE(CBreakable, CBaseEntity); IMPLEMENT_SAVERESTORE(CBreakable, CBaseEntity);
/* <85663> ../cstrike/dlls/func_break.cpp:157 */ /* <85663> ../cstrike/dlls/func_break.cpp:157 */
void CBreakable::__MAKE_VHOOK(Spawn)(void) void CBreakable::__MAKE_VHOOK(Spawn)()
{ {
Precache(); Precache();
@ -233,7 +218,7 @@ void CBreakable::__MAKE_VHOOK(Spawn)(void)
} }
/* <8568a> ../cstrike/dlls/func_break.cpp:191 */ /* <8568a> ../cstrike/dlls/func_break.cpp:191 */
void CBreakable::__MAKE_VHOOK(Restart)(void) void CBreakable::__MAKE_VHOOK(Restart)()
{ {
pev->solid = SOLID_BSP; pev->solid = SOLID_BSP;
pev->movetype = MOVETYPE_PUSH; pev->movetype = MOVETYPE_PUSH;
@ -340,7 +325,7 @@ void CBreakable::MaterialSoundRandom(edict_t *pEdict, Materials soundMaterial, f
} }
/* <8634b> ../cstrike/dlls/func_break.cpp:328 */ /* <8634b> ../cstrike/dlls/func_break.cpp:328 */
void CBreakable::__MAKE_VHOOK(Precache)(void) void CBreakable::__MAKE_VHOOK(Precache)()
{ {
const char *pGibName = NULL; const char *pGibName = NULL;
@ -418,7 +403,7 @@ void CBreakable::__MAKE_VHOOK(Precache)(void)
} }
/* <86676> ../cstrike/dlls/func_break.cpp:401 */ /* <86676> ../cstrike/dlls/func_break.cpp:401 */
void CBreakable::DamageSound(void) void CBreakable::DamageSound()
{ {
int pitch; int pitch;
float fvol; float fvol;
@ -507,18 +492,20 @@ void CBreakable::BreakTouch(CBaseEntity *pOther)
UTIL_MakeVectors(pev->angles); UTIL_MakeVectors(pev->angles);
g_vecAttackDir = gpGlobals->v_forward; g_vecAttackDir = gpGlobals->v_forward;
#ifndef REGAMEDLL_FIXES #ifndef REGAMEDLL_FIXES
pev->takedamage = DAMAGE_NO; pev->takedamage = DAMAGE_NO;
pev->deadflag = DEAD_DEAD; pev->deadflag = DEAD_DEAD;
pev->effects = EF_NODRAW; pev->effects = EF_NODRAW;
#endif // REGAMEDLL_FIXES #endif // REGAMEDLL_FIXES
Die(); Die();
} }
// can be broken when run into // can be broken when run into
if (pev->spawnflags & SF_BREAK_TOUCH) if (pev->spawnflags & SF_BREAK_TOUCH)
{ {
flDamage = pevToucher->velocity.Length() * 0.01; flDamage = pevToucher->velocity.Length() * 0.01f;
if (flDamage >= pev->health) if (flDamage >= pev->health)
{ {
@ -539,10 +526,10 @@ void CBreakable::BreakTouch(CBaseEntity *pOther)
SetThink(&CBreakable::Die); SetThink(&CBreakable::Die);
SetTouch(NULL); SetTouch(NULL);
// !!!BUGBUG - why doesn't zero delay work? // BUGBUG: why doesn't zero delay work?
if (m_flDelay == 0) if (m_flDelay == 0.0f)
{ {
m_flDelay = 0.1; m_flDelay = 0.1f;
} }
pev->nextthink = pev->ltime + m_flDelay; pev->nextthink = pev->ltime + m_flDelay;
@ -560,11 +547,13 @@ void CBreakable::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCaller
pev->angles.y = m_angle; pev->angles.y = m_angle;
UTIL_MakeVectors(pev->angles); UTIL_MakeVectors(pev->angles);
g_vecAttackDir = gpGlobals->v_forward; g_vecAttackDir = gpGlobals->v_forward;
#ifndef REGAMEDLL_FIXES #ifndef REGAMEDLL_FIXES
pev->takedamage = DAMAGE_NO; pev->takedamage = DAMAGE_NO;
pev->deadflag = DEAD_DEAD; pev->deadflag = DEAD_DEAD;
pev->effects = EF_NODRAW; pev->effects = EF_NODRAW;
#endif // REGAMEDLL_FIXES #endif // REGAMEDLL_FIXES
Die(); Die();
} }
} }
@ -616,7 +605,7 @@ int CBreakable::__MAKE_VHOOK(TakeDamage)(entvars_t *pevInflictor, entvars_t *pev
// (that is, no actual entity projectile was involved in the attack so use the shooter's origin). // (that is, no actual entity projectile was involved in the attack so use the shooter's origin).
if (pevAttacker == pevInflictor) if (pevAttacker == pevInflictor)
{ {
vecTemp = pevInflictor->origin - (pev->absmin + (pev->size * 0.5)); vecTemp = pevInflictor->origin - (pev->absmin + (pev->size * 0.5f));
// if a client hit the breakable with a crowbar, and breakable is crowbar-sensitive, break it now. // if a client hit the breakable with a crowbar, and breakable is crowbar-sensitive, break it now.
if ((pevAttacker->flags & FL_CLIENT) && (pev->spawnflags & SF_BREAK_CROWBAR) && (bitsDamageType & DMG_CLUB)) if ((pevAttacker->flags & FL_CLIENT) && (pev->spawnflags & SF_BREAK_CROWBAR) && (bitsDamageType & DMG_CLUB))
@ -627,7 +616,7 @@ int CBreakable::__MAKE_VHOOK(TakeDamage)(entvars_t *pevInflictor, entvars_t *pev
else else
{ {
// an actual missile was involved. // an actual missile was involved.
vecTemp = pevInflictor->origin - (pev->absmin + (pev->size * 0.5)); vecTemp = pevInflictor->origin - (pev->absmin + (pev->size * 0.5f));
} }
if (!IsBreakable()) if (!IsBreakable())
@ -636,13 +625,13 @@ int CBreakable::__MAKE_VHOOK(TakeDamage)(entvars_t *pevInflictor, entvars_t *pev
// Breakables take double damage from the crowbar // Breakables take double damage from the crowbar
if (bitsDamageType & DMG_CLUB) if (bitsDamageType & DMG_CLUB)
{ {
flDamage *= 2; flDamage *= 2.0f;
} }
// Boxes / glass / etc. don't take much poison damage, just the impact of the dart - consider that 10% // Boxes / glass / etc. don't take much poison damage, just the impact of the dart - consider that 10%
if (bitsDamageType & DMG_POISON) if (bitsDamageType & DMG_POISON)
{ {
flDamage *= 0.1; flDamage *= 0.1f;
} }
// this global is still used for glass and other non-monster killables, along with decals. // this global is still used for glass and other non-monster killables, along with decals.
@ -660,9 +649,9 @@ int CBreakable::__MAKE_VHOOK(TakeDamage)(entvars_t *pevInflictor, entvars_t *pev
#endif // REGAMEDLL_FIXES #endif // REGAMEDLL_FIXES
Die(); Die();
if (m_flDelay == 0) if (m_flDelay == 0.0f)
{ {
m_flDelay = 0.1; m_flDelay = 0.1f;
} }
pev->nextthink = pev->ltime + m_flDelay; pev->nextthink = pev->ltime + m_flDelay;
@ -672,12 +661,11 @@ int CBreakable::__MAKE_VHOOK(TakeDamage)(entvars_t *pevInflictor, entvars_t *pev
// Make a shard noise each time func breakable is hit. // Make a shard noise each time func breakable is hit.
// Don't play shard noise if cbreakable actually died. // Don't play shard noise if cbreakable actually died.
DamageSound(); DamageSound();
return 1; return 1;
} }
/* <856fe> ../cstrike/dlls/func_break.cpp:653 */ /* <856fe> ../cstrike/dlls/func_break.cpp:653 */
void CBreakable::Die(void) void CBreakable::Die()
{ {
Vector vecSpot; // shard origin Vector vecSpot; // shard origin
Vector vecVelocity; // shard velocity Vector vecVelocity; // shard velocity
@ -699,10 +687,10 @@ void CBreakable::Die(void)
// The more negative pev->health, the louder // The more negative pev->health, the louder
// the sound should be. // the sound should be.
fvol = RANDOM_FLOAT(0.85, 1.0) + (abs((int)pev->health) / 100.0); fvol = RANDOM_FLOAT(0.85, 1.0) + (abs((int)pev->health) / 100.0f);
if (fvol > 1.0) if (fvol > 1.0f)
fvol = 1.0; fvol = 1.0f;
switch (m_Material) switch (m_Material)
{ {
@ -794,7 +782,7 @@ void CBreakable::Die(void)
if (m_Explosion == expDirected) if (m_Explosion == expDirected)
{ {
vecVelocity = g_vecAttackDir * 200; vecVelocity = g_vecAttackDir * 200.0f;
} }
else else
{ {
@ -852,7 +840,7 @@ void CBreakable::Die(void)
SUB_UseTargets(NULL, USE_TOGGLE, 0); SUB_UseTargets(NULL, USE_TOGGLE, 0);
SetThink(NULL); SetThink(NULL);
pev->nextthink = pev->ltime + 0.1; pev->nextthink = pev->ltime + 0.1f;
if (m_iszSpawnObject) if (m_iszSpawnObject)
{ {
@ -866,7 +854,7 @@ void CBreakable::Die(void)
} }
/* <86992> ../cstrike/dlls/func_break.cpp:833 */ /* <86992> ../cstrike/dlls/func_break.cpp:833 */
BOOL CBreakable::IsBreakable(void) BOOL CBreakable::IsBreakable()
{ {
return m_Material != matUnbreakableGlass; return m_Material != matUnbreakableGlass;
} }
@ -890,7 +878,7 @@ LINK_ENTITY_TO_CLASS(func_pushable, CPushable);
IMPLEMENT_SAVERESTORE(CPushable, CBreakable); IMPLEMENT_SAVERESTORE(CPushable, CBreakable);
/* <856d7> ../cstrike/dlls/func_break.cpp:893 */ /* <856d7> ../cstrike/dlls/func_break.cpp:893 */
void CPushable::__MAKE_VHOOK(Spawn)(void) void CPushable::__MAKE_VHOOK(Spawn)()
{ {
if (pev->spawnflags & SF_PUSH_BREAKABLE) if (pev->spawnflags & SF_PUSH_BREAKABLE)
CBreakable::Spawn(); CBreakable::Spawn();
@ -922,7 +910,7 @@ void CPushable::__MAKE_VHOOK(Spawn)(void)
} }
/* <863eb> ../cstrike/dlls/func_break.cpp:920 */ /* <863eb> ../cstrike/dlls/func_break.cpp:920 */
void CPushable::__MAKE_VHOOK(Precache)(void) void CPushable::__MAKE_VHOOK(Precache)()
{ {
for (int i = 0; i < 3; ++i) for (int i = 0; i < 3; ++i)
{ {
@ -949,7 +937,7 @@ void CPushable::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
UTIL_SetSize(pev, Vector(-8, -8, -8), Vector(8, 8, 8)); UTIL_SetSize(pev, Vector(-8, -8, -8), Vector(8, 8, 8));
break; break;
case 2: // Big Hull!?!? !!!BUGBUG Figure out what this hull really is case 2: // TODO: Big Hull? BUGBUG: Figure out what this hull really is
UTIL_SetSize(pev, VEC_DUCK_HULL_MIN * 2, VEC_DUCK_HULL_MAX * 2); UTIL_SetSize(pev, VEC_DUCK_HULL_MIN * 2, VEC_DUCK_HULL_MAX * 2);
break; break;
@ -1015,7 +1003,7 @@ void CPushable::Move(CBaseEntity *pOther, int push)
// Only push if floating // Only push if floating
if (pev->waterlevel > 0) if (pev->waterlevel > 0)
{ {
pev->velocity.z += pevToucher->velocity.z * 0.1; pev->velocity.z += pevToucher->velocity.z * 0.1f;
} }
return; return;
@ -1042,13 +1030,13 @@ void CPushable::Move(CBaseEntity *pOther, int push)
if (pev->waterlevel < 1) if (pev->waterlevel < 1)
return; return;
else else
factor = 0.1; factor = 0.1f;
} }
else else
factor = 1; factor = 1.0f;
} }
else else
factor = 0.25; factor = 0.25f;
pev->velocity.x += pevToucher->velocity.x * factor; pev->velocity.x += pevToucher->velocity.x * factor;
pev->velocity.y += pevToucher->velocity.y * factor; pev->velocity.y += pevToucher->velocity.y * factor;
@ -1066,7 +1054,7 @@ void CPushable::Move(CBaseEntity *pOther, int push)
pevToucher->velocity.x = pev->velocity.x; pevToucher->velocity.x = pev->velocity.x;
pevToucher->velocity.y = pev->velocity.y; pevToucher->velocity.y = pev->velocity.y;
if ((gpGlobals->time - m_soundTime) > 0.7) if ((gpGlobals->time - m_soundTime) > 0.7f)
{ {
m_soundTime = gpGlobals->time; m_soundTime = gpGlobals->time;
@ -1094,97 +1082,3 @@ int CPushable::__MAKE_VHOOK(TakeDamage)(entvars_t *pevInflictor, entvars_t *pevA
return 1; return 1;
} }
#ifdef HOOK_GAMEDLL
void CBreakable::Spawn(void)
{
Spawn_();
}
void CBreakable::Precache(void)
{
Precache_();
}
void CBreakable::Restart(void)
{
Restart_();
}
void CBreakable::KeyValue(KeyValueData *pkvd)
{
KeyValue_(pkvd);
}
int CBreakable::Save(CSave &save)
{
return Save_(save);
}
int CBreakable::Restore(CRestore &restore)
{
return Restore_(restore);
}
void CBreakable::TraceAttack(entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType)
{
TraceAttack_(pevAttacker, flDamage, vecDir, ptr, bitsDamageType);
}
int CBreakable::TakeDamage(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType)
{
return TakeDamage_(pevInflictor, pevAttacker, flDamage, bitsDamageType);
}
int CBreakable::DamageDecal(int bitsDamageType)
{
return DamageDecal_(bitsDamageType);
}
void CBreakable::Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
{
Use_(pActivator, pCaller, useType, value);
}
void CPushable::Spawn(void)
{
Spawn_();
}
void CPushable::Precache(void)
{
Precache_();
}
void CPushable::KeyValue(KeyValueData *pkvd)
{
KeyValue_(pkvd);
}
int CPushable::Save(CSave &save)
{
return Save_(save);
}
int CPushable::Restore(CRestore &restore)
{
return Restore_(restore);
}
int CPushable::TakeDamage(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType)
{
return TakeDamage_(pevInflictor, pevAttacker, flDamage, bitsDamageType);
}
void CPushable::Touch(CBaseEntity *pOther)
{
Touch_(pOther);
}
void CPushable::Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
{
Use_(pActivator, pCaller, useType, value);
}
#endif // HOOK_GAMEDLL

View File

@ -67,33 +67,18 @@ typedef enum
} Materials; } Materials;
#ifdef HOOK_GAMEDLL
#define pSoundsWood (*ppSoundsWood)
#define pSoundsFlesh (*ppSoundsFlesh)
#define pSoundsGlass (*ppSoundsGlass)
#define pSoundsMetal (*ppSoundsMetal)
#define pSoundsConcrete (*ppSoundsConcrete)
#define pSpawnObjects (*ppSpawnObjects)
#define m_soundNames (*pm_soundNames)
#endif // HOOK_GAMEDLL
/* <84d53> ../cstrike/dlls/func_break.h:23 */ /* <84d53> ../cstrike/dlls/func_break.h:23 */
class CBreakable: public CBaseDelay class CBreakable: public CBaseDelay
{ {
public: public:
// basic functions // basic functions
virtual void Spawn(void); virtual void Spawn();
virtual void Precache(void); virtual void Precache();
virtual void Restart(void); virtual void Restart();
virtual void KeyValue(KeyValueData *pkvd); virtual void KeyValue(KeyValueData *pkvd);
virtual int Save(CSave &save); virtual int Save(CSave &save);
virtual int Restore(CRestore &restore); virtual int Restore(CRestore &restore);
virtual int ObjectCaps(void) virtual int ObjectCaps() { return (CBaseEntity::ObjectCaps() & ~FCAP_ACROSS_TRANSITION); }
{
return (CBaseEntity::ObjectCaps() & ~FCAP_ACROSS_TRANSITION);
}
// To spark when hit // To spark when hit
virtual void TraceAttack(entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType); virtual void TraceAttack(entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType);
@ -106,9 +91,9 @@ public:
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Spawn_(void); void Spawn_();
void Precache_(void); void Precache_();
void Restart_(void); void Restart_();
void KeyValue_(KeyValueData *pkvd); void KeyValue_(KeyValueData *pkvd);
int Save_(CSave &save); int Save_(CSave &save);
int Restore_(CRestore &restore); int Restore_(CRestore &restore);
@ -121,25 +106,17 @@ public:
public: public:
void EXPORT BreakTouch(CBaseEntity *pOther); void EXPORT BreakTouch(CBaseEntity *pOther);
void DamageSound(void); void DamageSound();
BOOL IsBreakable(void); BOOL IsBreakable();
NOXREF BOOL SparkWhenHit(void); NOXREF BOOL SparkWhenHit();
void EXPORT Die(void); void EXPORT Die();
BOOL Explodable(void) BOOL Explodable() const { return ExplosionMagnitude() > 0; }
{ int ExplosionMagnitude() const { return pev->impulse; }
return ExplosionMagnitude() > 0;
} void ExplosionSetMagnitude(int magnitude) { pev->impulse = magnitude; }
int ExplosionMagnitude(void)
{
return pev->impulse;
}
void ExplosionSetMagnitude(int magnitude)
{
pev->impulse = magnitude;
}
static void MaterialSoundPrecache(Materials precacheMaterial); static void MaterialSoundPrecache(Materials precacheMaterial);
static void MaterialSoundRandom(edict_t *pEdict, Materials soundMaterial, float volume); static void MaterialSoundRandom(edict_t *pEdict, Materials soundMaterial, float volume);
@ -162,30 +139,26 @@ public:
int m_iszGibModel; int m_iszGibModel;
int m_iszSpawnObject; int m_iszSpawnObject;
float m_flHealth; float m_flHealth;
};
};/* size: 188, cachelines: 3, members: 15 */
/* <84da0> ../cstrike/dlls/func_break.cpp:851 */ /* <84da0> ../cstrike/dlls/func_break.cpp:851 */
class CPushable: public CBreakable class CPushable: public CBreakable
{ {
public: public:
virtual void Spawn(void); virtual void Spawn();
virtual void Precache(void); virtual void Precache();
virtual void KeyValue(KeyValueData *pkvd); virtual void KeyValue(KeyValueData *pkvd);
virtual int Save(CSave &save); virtual int Save(CSave &save);
virtual int Restore(CRestore &restore); virtual int Restore(CRestore &restore);
virtual int ObjectCaps(void) virtual int ObjectCaps() { return (CBaseEntity::ObjectCaps() & ~FCAP_ACROSS_TRANSITION) | FCAP_CONTINUOUS_USE; }
{
return (CBaseEntity::ObjectCaps() & ~FCAP_ACROSS_TRANSITION) | FCAP_CONTINUOUS_USE;
}
virtual int TakeDamage(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType); virtual int TakeDamage(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType);
virtual void Touch(CBaseEntity *pOther); virtual void Touch(CBaseEntity *pOther);
virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value); virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Spawn_(void); void Spawn_();
void Precache_(void); void Precache_();
void KeyValue_(KeyValueData *pkvd); void KeyValue_(KeyValueData *pkvd);
int Save_(CSave &save); int Save_(CSave &save);
int Restore_(CRestore &restore); int Restore_(CRestore &restore);
@ -197,7 +170,7 @@ public:
public: public:
void Move(CBaseEntity *pMover, int push); void Move(CBaseEntity *pMover, int push);
void EXPORT StopSound(void) void EXPORT StopSound()
{ {
#if 0 #if 0
Vector dist = pev->oldorigin - pev->origin; Vector dist = pev->oldorigin - pev->origin;
@ -207,29 +180,15 @@ public:
} }
#endif #endif
} }
float MaxSpeed(void) float MaxSpeed() const { return m_maxSpeed; }
{
return m_maxSpeed;
}
public: public:
static TYPEDESCRIPTION IMPL(m_SaveData)[2]; static TYPEDESCRIPTION IMPL(m_SaveData)[2];
public:
static char *m_soundNames[3]; static char *m_soundNames[3];
int m_lastSound; int m_lastSound;
float m_maxSpeed; float m_maxSpeed;
float m_soundTime; float m_soundTime;
};
};/* size: 200, cachelines: 4, members: 6 */
#ifdef HOOK_GAMEDLL
// linked objects
C_DLLEXPORT void func_breakable(entvars_t *pev);
C_DLLEXPORT void func_pushable(entvars_t *pev);
#endif // HOOK_GAMEDLL
#endif // FUNC_BREAK_H #endif // FUNC_BREAK_H

View File

@ -46,7 +46,7 @@ TYPEDESCRIPTION CFuncTankControls::m_SaveData[] =
DEFINE_FIELD(CFuncTankControls, m_pTank, FIELD_CLASSPTR), DEFINE_FIELD(CFuncTankControls, m_pTank, FIELD_CLASSPTR),
}; };
static Vector gTankSpread[] = Vector gTankSpread[] =
{ {
Vector(0, 0, 0), // perfect Vector(0, 0, 0), // perfect
Vector(0.025, 0.025, 0.025), // small cone Vector(0.025, 0.025, 0.025), // small cone
@ -55,13 +55,6 @@ static Vector gTankSpread[] =
Vector(0.25, 0.25, 0.25), // extra-large cone Vector(0.25, 0.25, 0.25), // extra-large cone
}; };
#else
TYPEDESCRIPTION IMPL_CLASS(CFuncTank, m_SaveData)[26];
TYPEDESCRIPTION IMPL_CLASS(CFuncTankLaser, m_SaveData)[2];
TYPEDESCRIPTION IMPL_CLASS(CFuncTankControls, m_SaveData)[1];
Vector gTankSpread[5];
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
#define MAX_FIRING_SPREADS ARRAYSIZE(gTankSpread) #define MAX_FIRING_SPREADS ARRAYSIZE(gTankSpread)
@ -70,7 +63,7 @@ Vector gTankSpread[5];
IMPLEMENT_SAVERESTORE(CFuncTank, CBaseEntity); IMPLEMENT_SAVERESTORE(CFuncTank, CBaseEntity);
/* <8ea25> ../cstrike/dlls/func_tank.cpp:177 */ /* <8ea25> ../cstrike/dlls/func_tank.cpp:177 */
void CFuncTank::__MAKE_VHOOK(Spawn)(void) void CFuncTank::__MAKE_VHOOK(Spawn)()
{ {
Precache(); Precache();
@ -84,14 +77,14 @@ void CFuncTank::__MAKE_VHOOK(Spawn)(void)
if (IsActive()) if (IsActive())
{ {
pev->nextthink = pev->ltime + 1.0; pev->nextthink = pev->ltime + 1.0f;
} }
// Point at the end of the barrel // Point at the end of the barrel
m_sightOrigin = BarrelPosition(); m_sightOrigin = BarrelPosition();
if (m_fireRate <= 0) if (m_fireRate <= 0.0f)
m_fireRate = 1; m_fireRate = 1.0f;
if (m_spread > MAX_FIRING_SPREADS) if (m_spread > MAX_FIRING_SPREADS)
m_spread = 0; m_spread = 0;
@ -100,7 +93,7 @@ void CFuncTank::__MAKE_VHOOK(Spawn)(void)
} }
/* <8d64d> ../cstrike/dlls/func_tank.cpp:202 */ /* <8d64d> ../cstrike/dlls/func_tank.cpp:202 */
void CFuncTank::__MAKE_VHOOK(Precache)(void) void CFuncTank::__MAKE_VHOOK(Precache)()
{ {
if (m_iszSpriteSmoke) if (m_iszSpriteSmoke)
{ {
@ -238,7 +231,7 @@ BOOL CFuncTank::__MAKE_VHOOK(OnControls)(entvars_t *pevTest)
Vector offset = pevTest->origin - pev->origin; Vector offset = pevTest->origin - pev->origin;
if ((m_vecControllerUsePos - pevTest->origin).Length() < 30) if ((m_vecControllerUsePos - pevTest->origin).Length() < 30.0f)
{ {
return TRUE; return TRUE;
} }
@ -278,13 +271,13 @@ BOOL CFuncTank::StartControl(CBasePlayer *pController)
m_pController->m_iHideHUD |= HIDEHUD_WEAPONS; m_pController->m_iHideHUD |= HIDEHUD_WEAPONS;
m_vecControllerUsePos = m_pController->pev->origin; m_vecControllerUsePos = m_pController->pev->origin;
pev->nextthink = pev->ltime + 0.1; pev->nextthink = pev->ltime + 0.1f;
return TRUE; return TRUE;
} }
/* <8ebde> ../cstrike/dlls/func_tank.cpp:372 */ /* <8ebde> ../cstrike/dlls/func_tank.cpp:372 */
void CFuncTank::StopControl(void) void CFuncTank::StopControl()
{ {
// TODO: bring back the controllers current weapon // TODO: bring back the controllers current weapon
if (!m_pController) if (!m_pController)
@ -309,12 +302,12 @@ void CFuncTank::StopControl(void)
if (IsActive()) if (IsActive())
{ {
pev->nextthink = pev->ltime + 1.0; pev->nextthink = pev->ltime + 1.0f;
} }
} }
/* <8ec15> ../cstrike/dlls/func_tank.cpp:398 */ /* <8ec15> ../cstrike/dlls/func_tank.cpp:398 */
void CFuncTank::ControllerPostFrame(void) void CFuncTank::ControllerPostFrame()
{ {
assert(m_pController != NULL); assert(m_pController != NULL);
@ -326,7 +319,7 @@ void CFuncTank::ControllerPostFrame(void)
Vector vecForward; Vector vecForward;
UTIL_MakeVectorsPrivate(pev->angles, vecForward, NULL, NULL); UTIL_MakeVectorsPrivate(pev->angles, vecForward, NULL, NULL);
m_fireLast = gpGlobals->time - (1 / m_fireRate) - 0.01; m_fireLast = gpGlobals->time - (1.0f / m_fireRate) - 0.01f;
Fire(BarrelPosition(), vecForward, m_pController->pev); Fire(BarrelPosition(), vecForward, m_pController->pev);
if (m_pController && m_pController->IsPlayer()) if (m_pController && m_pController->IsPlayer())
@ -334,7 +327,7 @@ void CFuncTank::ControllerPostFrame(void)
m_pController->m_iWeaponVolume = LOUD_GUN_VOLUME; m_pController->m_iWeaponVolume = LOUD_GUN_VOLUME;
} }
m_flNextAttack = gpGlobals->time + (1 / m_fireRate); m_flNextAttack = gpGlobals->time + (1.0f / m_fireRate);
} }
} }
@ -392,7 +385,7 @@ BOOL CFuncTank::InRange(float range)
} }
/* <8f717> ../cstrike/dlls/func_tank.cpp:477 */ /* <8f717> ../cstrike/dlls/func_tank.cpp:477 */
void CFuncTank::__MAKE_VHOOK(Think)(void) void CFuncTank::__MAKE_VHOOK(Think)()
{ {
pev->avelocity = g_vecZero; pev->avelocity = g_vecZero;
TrackTarget(); TrackTarget();
@ -404,7 +397,7 @@ void CFuncTank::__MAKE_VHOOK(Think)(void)
} }
/* <8efe4> ../cstrike/dlls/func_tank.cpp:488 */ /* <8efe4> ../cstrike/dlls/func_tank.cpp:488 */
void CFuncTank::TrackTarget(void) void CFuncTank::TrackTarget()
{ {
TraceResult tr; TraceResult tr;
edict_t *pPlayer = FIND_CLIENT_IN_PVS(edict()); edict_t *pPlayer = FIND_CLIENT_IN_PVS(edict());
@ -418,12 +411,12 @@ void CFuncTank::TrackTarget(void)
// Tanks attempt to mirror the player's angles // Tanks attempt to mirror the player's angles
angles = m_pController->pev->v_angle; angles = m_pController->pev->v_angle;
angles.x = 0 - angles.x; angles.x = 0 - angles.x;
pev->nextthink = pev->ltime + 0.05; pev->nextthink = pev->ltime + 0.05f;
} }
else else
{ {
if (IsActive()) if (IsActive())
pev->nextthink = pev->ltime + 0.1; pev->nextthink = pev->ltime + 0.1f;
else else
return; return;
@ -432,7 +425,7 @@ void CFuncTank::TrackTarget(void)
if (IsActive()) if (IsActive())
{ {
// Wait 2 secs // Wait 2 secs
pev->nextthink = pev->ltime + 2; pev->nextthink = pev->ltime + 2.0f;
} }
return; return;
@ -469,7 +462,7 @@ void CFuncTank::TrackTarget(void)
} }
// Track sight origin // Track sight origin
// !!! I'm not sure what i changed // TODO: I'm not sure what i changed
direction = m_sightOrigin - pev->origin; direction = m_sightOrigin - pev->origin;
//direction = m_sightOrigin - barrelEnd; //direction = m_sightOrigin - barrelEnd;
angles = UTIL_VecToAngles(direction); angles = UTIL_VecToAngles(direction);
@ -507,7 +500,7 @@ void CFuncTank::TrackTarget(void)
// Move toward target at rate or less // Move toward target at rate or less
float_precision distY = UTIL_AngleDistance(angles.y, pev->angles.y); float_precision distY = UTIL_AngleDistance(angles.y, pev->angles.y);
pev->avelocity.y = distY * 10; pev->avelocity.y = distY * 10.0f;
if (pev->avelocity.y > m_yawRate) if (pev->avelocity.y > m_yawRate)
{ {
@ -530,7 +523,7 @@ void CFuncTank::TrackTarget(void)
// Move toward target at rate or less // Move toward target at rate or less
float_precision distX = UTIL_AngleDistance(angles.x, pev->angles.x); float_precision distX = UTIL_AngleDistance(angles.x, pev->angles.x);
pev->avelocity.x = distX * 10; pev->avelocity.x = distX * 10.0f;
if (pev->avelocity.x > m_pitchRate) if (pev->avelocity.x > m_pitchRate)
{ {
@ -583,7 +576,7 @@ void CFuncTank::AdjustAnglesForBarrel(Vector &angles, float distance)
{ {
float_precision r2, d2; float_precision r2, d2;
if (m_barrelPos.y != 0 || m_barrelPos.z != 0) if (m_barrelPos.y != 0.0f || m_barrelPos.z != 0.0f)
{ {
distance -= m_barrelPos.z; distance -= m_barrelPos.z;
d2 = distance * distance; d2 = distance * distance;
@ -591,13 +584,13 @@ void CFuncTank::AdjustAnglesForBarrel(Vector &angles, float distance)
if (m_barrelPos.y) if (m_barrelPos.y)
{ {
r2 = m_barrelPos.y * m_barrelPos.y; r2 = m_barrelPos.y * m_barrelPos.y;
angles.y += (180.0 / M_PI) * atan2(m_barrelPos.y, sqrt(d2 - r2)); angles.y += (180.0f / M_PI) * atan2(m_barrelPos.y, sqrt(d2 - r2));
} }
if (m_barrelPos.z) if (m_barrelPos.z)
{ {
r2 = m_barrelPos.z * m_barrelPos.z; r2 = m_barrelPos.z * m_barrelPos.z;
angles.x += (180.0 / M_PI) * atan2(-m_barrelPos.z, sqrt(d2 - r2)); angles.x += (180.0f / M_PI) * atan2(-m_barrelPos.z, sqrt(d2 - r2));
} }
} }
} }
@ -607,7 +600,7 @@ void CFuncTank::AdjustAnglesForBarrel(Vector &angles, float distance)
/* <8d4ad> ../cstrike/dlls/func_tank.cpp:656 */ /* <8d4ad> ../cstrike/dlls/func_tank.cpp:656 */
void CFuncTank::__MAKE_VHOOK(Fire)(const Vector &barrelEnd, const Vector &forward, entvars_t *pevAttacker) void CFuncTank::__MAKE_VHOOK(Fire)(const Vector &barrelEnd, const Vector &forward, entvars_t *pevAttacker)
{ {
if (m_fireLast != 0) if (m_fireLast != 0.0f)
{ {
if (m_iszSpriteSmoke) if (m_iszSpriteSmoke)
{ {
@ -655,12 +648,12 @@ void CFuncTank::TankTrace(const Vector &vecStart, const Vector &vecForward, cons
Vector vecDir = vecForward + x * vecSpread.x * gpGlobals->v_right + y * vecSpread.y * gpGlobals->v_up; Vector vecDir = vecForward + x * vecSpread.x * gpGlobals->v_right + y * vecSpread.y * gpGlobals->v_up;
Vector vecEnd; Vector vecEnd;
vecEnd = vecStart + vecDir * 4096; vecEnd = vecStart + vecDir * 4096.0f;
UTIL_TraceLine(vecStart, vecEnd, dont_ignore_monsters, edict(), &tr); UTIL_TraceLine(vecStart, vecEnd, dont_ignore_monsters, edict(), &tr);
} }
/* <8f9c0> ../cstrike/dlls/func_tank.cpp:703 */ /* <8f9c0> ../cstrike/dlls/func_tank.cpp:703 */
void CFuncTank::StartRotSound(void) void CFuncTank::StartRotSound()
{ {
if (!pev->noise || (pev->spawnflags & SF_TANK_SOUNDON)) if (!pev->noise || (pev->spawnflags & SF_TANK_SOUNDON))
{ {
@ -672,7 +665,7 @@ void CFuncTank::StartRotSound(void)
} }
/* <8fa1b> ../cstrike/dlls/func_tank.cpp:712 */ /* <8fa1b> ../cstrike/dlls/func_tank.cpp:712 */
void CFuncTank::StopRotSound(void) void CFuncTank::StopRotSound()
{ {
if (pev->spawnflags & SF_TANK_SOUNDON) if (pev->spawnflags & SF_TANK_SOUNDON)
{ {
@ -688,9 +681,7 @@ LINK_ENTITY_TO_CLASS(func_tank, CFuncTankGun);
/* <8c3d5> ../cstrike/dlls/func_tank.cpp:726 */ /* <8c3d5> ../cstrike/dlls/func_tank.cpp:726 */
void CFuncTankGun::__MAKE_VHOOK(Fire)(const Vector &barrelEnd, const Vector &forward, entvars_t *pevAttacker) void CFuncTankGun::__MAKE_VHOOK(Fire)(const Vector &barrelEnd, const Vector &forward, entvars_t *pevAttacker)
{ {
int i; if (m_fireLast != 0.0f)
if (m_fireLast != 0)
{ {
// FireBullets needs gpGlobals->v_up, etc. // FireBullets needs gpGlobals->v_up, etc.
UTIL_MakeAimVectors(pev->angles); UTIL_MakeAimVectors(pev->angles);
@ -699,7 +690,7 @@ void CFuncTankGun::__MAKE_VHOOK(Fire)(const Vector &barrelEnd, const Vector &for
if (bulletCount > 0) if (bulletCount > 0)
{ {
for (i = 0; i < bulletCount; ++i) for (int i = 0; i < bulletCount; ++i)
{ {
switch (m_bulletType) switch (m_bulletType)
{ {
@ -732,7 +723,7 @@ LINK_ENTITY_TO_CLASS(func_tanklaser, CFuncTankLaser);
IMPLEMENT_SAVERESTORE(CFuncTankLaser, CFuncTank); IMPLEMENT_SAVERESTORE(CFuncTankLaser, CFuncTank);
/* <8deed> ../cstrike/dlls/func_tank.cpp:795 */ /* <8deed> ../cstrike/dlls/func_tank.cpp:795 */
void CFuncTankLaser::__MAKE_VHOOK(Activate)(void) void CFuncTankLaser::__MAKE_VHOOK(Activate)()
{ {
if (!GetLaser()) if (!GetLaser())
{ {
@ -758,16 +749,14 @@ void CFuncTankLaser::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
} }
/* <8dd79> ../cstrike/dlls/func_tank.cpp:821 */ /* <8dd79> ../cstrike/dlls/func_tank.cpp:821 */
CLaser *CFuncTankLaser::GetLaser(void) CLaser *CFuncTankLaser::GetLaser()
{ {
if (m_pLaser != NULL) if (m_pLaser != NULL)
{ {
return m_pLaser; return m_pLaser;
} }
edict_t *pentLaser; edict_t *pentLaser = FIND_ENTITY_BY_TARGETNAME(NULL, STRING(pev->message));
pentLaser = FIND_ENTITY_BY_TARGETNAME(NULL, STRING(pev->message));
while (!FNullEnt(pentLaser)) while (!FNullEnt(pentLaser))
{ {
@ -785,7 +774,7 @@ CLaser *CFuncTankLaser::GetLaser(void)
} }
/* <8f809> ../cstrike/dlls/func_tank.cpp:845 */ /* <8f809> ../cstrike/dlls/func_tank.cpp:845 */
void CFuncTankLaser::__MAKE_VHOOK(Think)(void) void CFuncTankLaser::__MAKE_VHOOK(Think)()
{ {
if (m_pLaser != NULL && gpGlobals->time > m_laserTime) if (m_pLaser != NULL && gpGlobals->time > m_laserTime)
{ {
@ -801,13 +790,12 @@ void CFuncTankLaser::__MAKE_VHOOK(Fire)(const Vector &barrelEnd, const Vector &f
int i; int i;
TraceResult tr; TraceResult tr;
if (m_fireLast != 0 && GetLaser()) if (m_fireLast != 0.0f && GetLaser())
{ {
// TankTrace needs gpGlobals->v_up, etc. // TankTrace needs gpGlobals->v_up, etc.
UTIL_MakeAimVectors(pev->angles); UTIL_MakeAimVectors(pev->angles);
int bulletCount = (int)((gpGlobals->time - m_fireLast) * m_fireRate); int bulletCount = (int)((gpGlobals->time - m_fireLast) * m_fireRate);
if (bulletCount) if (bulletCount)
{ {
for (i = 0; i < bulletCount; ++i) for (i = 0; i < bulletCount; ++i)
@ -835,7 +823,7 @@ void CFuncTankLaser::__MAKE_VHOOK(Fire)(const Vector &barrelEnd, const Vector &f
LINK_ENTITY_TO_CLASS(func_tankrocket, CFuncTankRocket); LINK_ENTITY_TO_CLASS(func_tankrocket, CFuncTankRocket);
/* <8e736> ../cstrike/dlls/func_tank.cpp:895 */ /* <8e736> ../cstrike/dlls/func_tank.cpp:895 */
void CFuncTankRocket::__MAKE_VHOOK(Precache)(void) void CFuncTankRocket::__MAKE_VHOOK(Precache)()
{ {
UTIL_PrecacheOther("rpg_rocket"); UTIL_PrecacheOther("rpg_rocket");
CFuncTank::Precache(); CFuncTank::Precache();
@ -846,10 +834,9 @@ void CFuncTankRocket::__MAKE_VHOOK(Fire)(const Vector &barrelEnd, const Vector &
{ {
int i; int i;
if (m_fireLast != 0) if (m_fireLast != 0.0f)
{ {
int bulletCount = (int)((gpGlobals->time - m_fireLast) * m_fireRate); int bulletCount = (int)((gpGlobals->time - m_fireLast) * m_fireRate);
if (bulletCount > 0) if (bulletCount > 0)
{ {
for (i = 0; i < bulletCount; ++i) for (i = 0; i < bulletCount; ++i)
@ -882,7 +869,7 @@ void CFuncTankMortar::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
/* <8dbfa> ../cstrike/dlls/func_tank.cpp:945 */ /* <8dbfa> ../cstrike/dlls/func_tank.cpp:945 */
void CFuncTankMortar::__MAKE_VHOOK(Fire)(const Vector &barrelEnd, const Vector &forward, entvars_t *pevAttacker) void CFuncTankMortar::__MAKE_VHOOK(Fire)(const Vector &barrelEnd, const Vector &forward, entvars_t *pevAttacker)
{ {
if (m_fireLast != 0) if (m_fireLast != 0.0f)
{ {
int bulletCount = (int)((gpGlobals->time - m_fireLast) * m_fireRate); int bulletCount = (int)((gpGlobals->time - m_fireLast) * m_fireRate);
@ -925,7 +912,7 @@ void CFuncTankControls::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *
} }
/* <8d39a> ../cstrike/dlls/func_tank.cpp:1012 */ /* <8d39a> ../cstrike/dlls/func_tank.cpp:1012 */
void CFuncTankControls::__MAKE_VHOOK(Think)(void) void CFuncTankControls::__MAKE_VHOOK(Think)()
{ {
edict_t *pTarget = NULL; edict_t *pTarget = NULL;
@ -941,11 +928,11 @@ void CFuncTankControls::__MAKE_VHOOK(Think)(void)
return; return;
} }
m_pTank = reinterpret_cast<CFuncTank *>(Instance(pTarget)); m_pTank = static_cast<CFuncTank *>(Instance(pTarget));
} }
/* <8d373> ../cstrike/dlls/func_tank.cpp:1030 */ /* <8d373> ../cstrike/dlls/func_tank.cpp:1030 */
void CFuncTankControls::__MAKE_VHOOK(Spawn)(void) void CFuncTankControls::__MAKE_VHOOK(Spawn)()
{ {
pev->solid = SOLID_TRIGGER; pev->solid = SOLID_TRIGGER;
pev->movetype = MOVETYPE_NONE; pev->movetype = MOVETYPE_NONE;
@ -957,136 +944,7 @@ void CFuncTankControls::__MAKE_VHOOK(Spawn)(void)
UTIL_SetOrigin(pev, pev->origin); UTIL_SetOrigin(pev, pev->origin);
// After all the func_tank's have spawned // After all the func_tank's have spawned
pev->nextthink = gpGlobals->time + 0.3; pev->nextthink = gpGlobals->time + 0.3f;
CBaseEntity::Spawn(); CBaseEntity::Spawn();
} }
#ifdef HOOK_GAMEDLL
void CFuncTank::Spawn(void)
{
Spawn_();
}
void CFuncTank::Precache(void)
{
Precache_();
}
void CFuncTank::KeyValue(KeyValueData *pkvd)
{
KeyValue_(pkvd);
}
int CFuncTank::Save(CSave &save)
{
return Save_(save);
}
int CFuncTank::Restore(CRestore &restore)
{
return Restore_(restore);
}
BOOL CFuncTank::OnControls(entvars_t *pevTest)
{
OnControls_(pevTest);
}
void CFuncTank::Think(void)
{
Think_();
}
void CFuncTank::Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
{
Use_(pActivator, pCaller, useType, value);
}
void CFuncTank::Fire(const Vector &barrelEnd, const Vector &forward, entvars_t *pevAttacker)
{
Fire_(barrelEnd, forward, pevAttacker);
}
void CFuncTankGun::Fire(const Vector &barrelEnd, const Vector &forward, entvars_t *pevAttacker)
{
Fire_(barrelEnd, forward, pevAttacker);
}
void CFuncTankLaser::KeyValue(KeyValueData *pkvd)
{
KeyValue_(pkvd);
}
int CFuncTankLaser::Save(CSave &save)
{
return Save_(save);
}
int CFuncTankLaser::Restore(CRestore &restore)
{
return Restore_(restore);
}
void CFuncTankLaser::Activate(void)
{
Activate_();
}
void CFuncTankLaser::Think(void)
{
Think_();
}
void CFuncTankLaser::Fire(const Vector &barrelEnd, const Vector &forward, entvars_t *pevAttacker)
{
Fire_(barrelEnd, forward, pevAttacker);
}
void CFuncTankRocket::Precache(void)
{
Precache_();
}
void CFuncTankRocket::Fire(const Vector &barrelEnd, const Vector &forward, entvars_t *pevAttacker)
{
Fire_(barrelEnd, forward, pevAttacker);
}
void CFuncTankMortar::KeyValue(KeyValueData *pkvd)
{
KeyValue_(pkvd);
}
void CFuncTankMortar::Fire(const Vector &barrelEnd, const Vector &forward, entvars_t *pevAttacker)
{
Fire_(barrelEnd, forward, pevAttacker);
}
void CFuncTankControls::Spawn(void)
{
Spawn_();
}
int CFuncTankControls::Save(CSave &save)
{
return Save_(save);
}
int CFuncTankControls::Restore(CRestore &restore)
{
return Restore_(restore);
}
void CFuncTankControls::Think(void)
{
Think_();
}
void CFuncTankControls::Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
{
Use_(pActivator, pCaller, useType, value);
}
#endif // HOOK_GAMEDLL

View File

@ -52,73 +52,61 @@ enum TANKBULLET
class CFuncTank: public CBaseEntity class CFuncTank: public CBaseEntity
{ {
public: public:
virtual void Spawn(void); virtual void Spawn();
virtual void Precache(void); virtual void Precache();
virtual void KeyValue(KeyValueData *pkvd); virtual void KeyValue(KeyValueData *pkvd);
virtual int Save(CSave &save); virtual int Save(CSave &save);
virtual int Restore(CRestore &restore); virtual int Restore(CRestore &restore);
// Bmodels don't go across transitions // Bmodels don't go across transitions
virtual int ObjectCaps(void) virtual int ObjectCaps() { return CBaseEntity::ObjectCaps() & ~FCAP_ACROSS_TRANSITION; }
{
return CBaseEntity::ObjectCaps() & ~FCAP_ACROSS_TRANSITION;
}
virtual BOOL OnControls(entvars_t *pevTest); virtual BOOL OnControls(entvars_t *pevTest);
virtual void Think(void); virtual void Think();
virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value); virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
virtual void Fire(const Vector &barrelEnd, const Vector &forward, entvars_t *pevAttacker); virtual void Fire(const Vector &barrelEnd, const Vector &forward, entvars_t *pevAttacker);
virtual Vector UpdateTargetPosition(CBaseEntity *pTarget) virtual Vector UpdateTargetPosition(CBaseEntity *pTarget) { return pTarget->BodyTarget(pev->origin); }
{
return pTarget->BodyTarget(pev->origin);
}
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Spawn_(void); void Spawn_();
void Precache_(void); void Precache_();
void KeyValue_(KeyValueData *pkvd); void KeyValue_(KeyValueData *pkvd);
int Save_(CSave &save); int Save_(CSave &save);
int Restore_(CRestore &restore); int Restore_(CRestore &restore);
BOOL OnControls_(entvars_t *pevTest); BOOL OnControls_(entvars_t *pevTest);
void Think_(void); void Think_();
void Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value); void Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
void Fire_(const Vector &barrelEnd, const Vector &forward, entvars_t *pevAttacker); void Fire_(const Vector &barrelEnd, const Vector &forward, entvars_t *pevAttacker);
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
public: public:
void TrackTarget(void); void TrackTarget();
void StartRotSound(void); void StartRotSound();
void StopRotSound(void); void StopRotSound();
BOOL IsActive(void) BOOL IsActive() const { return (pev->spawnflags & SF_TANK_ACTIVE) == SF_TANK_ACTIVE; }
{ void TankActivate()
return (pev->spawnflags & SF_TANK_ACTIVE) == SF_TANK_ACTIVE;
}
void TankActivate(void)
{ {
pev->spawnflags |= SF_TANK_ACTIVE; pev->spawnflags |= SF_TANK_ACTIVE;
pev->nextthink = pev->ltime + 0.1f; pev->nextthink = pev->ltime + 0.1f;
m_fireLast = 0.0f; m_fireLast = 0.0f;
} }
void TankDeactivate(void) void TankDeactivate()
{ {
pev->spawnflags &= ~SF_TANK_ACTIVE; pev->spawnflags &= ~SF_TANK_ACTIVE;
m_fireLast = 0.0f; m_fireLast = 0.0f;
StopRotSound(); StopRotSound();
} }
BOOL CanFire(void)
{
return (gpGlobals->time - m_lastSightTime) < m_persist;
}
BOOL CanFire() const { return (gpGlobals->time - m_lastSightTime) < m_persist; }
BOOL InRange(float range); BOOL InRange(float range);
// Acquire a target. pPlayer is a player in the PVS // Acquire a target. pPlayer is a player in the PVS
edict_t *FindTarget(edict_t *pPlayer); edict_t *FindTarget(edict_t *pPlayer);
void TankTrace(const Vector &vecStart, const Vector &vecForward, const Vector &vecSpread, TraceResult &tr); void TankTrace(const Vector &vecStart, const Vector &vecForward, const Vector &vecSpread, TraceResult &tr);
Vector BarrelPosition(void) Vector BarrelPosition()
{ {
Vector forward, right, up; Vector forward, right, up;
UTIL_MakeVectorsPrivate(pev->angles, forward, right, up); UTIL_MakeVectorsPrivate(pev->angles, forward, right, up);
@ -127,8 +115,8 @@ public:
void AdjustAnglesForBarrel(Vector &angles, float distance); void AdjustAnglesForBarrel(Vector &angles, float distance);
BOOL StartControl(CBasePlayer *pController); BOOL StartControl(CBasePlayer *pController);
void StopControl(void); void StopControl();
void ControllerPostFrame(void); void ControllerPostFrame();
public: public:
static TYPEDESCRIPTION IMPL(m_SaveData)[26]; static TYPEDESCRIPTION IMPL(m_SaveData)[26];
@ -167,8 +155,7 @@ protected:
Vector m_sightOrigin; // Last sight of target Vector m_sightOrigin; // Last sight of target
int m_spread; // firing spread int m_spread; // firing spread
int m_iszMaster; // Master entity (game_team_master or multisource) int m_iszMaster; // Master entity (game_team_master or multisource)
};
};/* size: 280, cachelines: 5, members: 28 */
/* <8c79a> ../cstrike/dlls/func_tank.cpp:719 */ /* <8c79a> ../cstrike/dlls/func_tank.cpp:719 */
class CFuncTankGun: public CFuncTank class CFuncTankGun: public CFuncTank
@ -182,7 +169,7 @@ public:
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
};/* size: 280, cachelines: 5, members: 1 */ };
/* <8c7e8> ../cstrike/dlls/func_tank.cpp:768 */ /* <8c7e8> ../cstrike/dlls/func_tank.cpp:768 */
class CFuncTankLaser: public CFuncTank class CFuncTankLaser: public CFuncTank
@ -191,8 +178,8 @@ public:
virtual void KeyValue(KeyValueData *pkvd); virtual void KeyValue(KeyValueData *pkvd);
virtual int Save(CSave &save); virtual int Save(CSave &save);
virtual int Restore(CRestore &restore); virtual int Restore(CRestore &restore);
virtual void Activate(void); virtual void Activate();
virtual void Think(void); virtual void Think();
virtual void Fire(const Vector &barrelEnd, const Vector &forward, entvars_t *pevAttacker); virtual void Fire(const Vector &barrelEnd, const Vector &forward, entvars_t *pevAttacker);
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
@ -200,13 +187,13 @@ public:
void KeyValue_(KeyValueData *pkvd); void KeyValue_(KeyValueData *pkvd);
int Save_(CSave &save); int Save_(CSave &save);
int Restore_(CRestore &restore); int Restore_(CRestore &restore);
void Activate_(void); void Activate_();
void Think_(void); void Think_();
void Fire_(const Vector &barrelEnd, const Vector &forward, entvars_t *pevAttacker); void Fire_(const Vector &barrelEnd, const Vector &forward, entvars_t *pevAttacker);
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
CLaser *GetLaser(void); CLaser *GetLaser();
public: public:
static TYPEDESCRIPTION IMPL(m_SaveData)[2]; static TYPEDESCRIPTION IMPL(m_SaveData)[2];
@ -214,24 +201,23 @@ public:
private: private:
CLaser *m_pLaser; CLaser *m_pLaser;
float m_laserTime; float m_laserTime;
};
};/* size: 288, cachelines: 5, members: 4 */
/* <8c836> ../cstrike/dlls/func_tank.cpp:887 */ /* <8c836> ../cstrike/dlls/func_tank.cpp:887 */
class CFuncTankRocket: public CFuncTank class CFuncTankRocket: public CFuncTank
{ {
public: public:
virtual void Precache(void); virtual void Precache();
virtual void Fire(const Vector &barrelEnd, const Vector &forward, entvars_t *pevAttacker); virtual void Fire(const Vector &barrelEnd, const Vector &forward, entvars_t *pevAttacker);
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Precache_(void); void Precache_();
void Fire_(const Vector &barrelEnd, const Vector &forward, entvars_t *pevAttacker); void Fire_(const Vector &barrelEnd, const Vector &forward, entvars_t *pevAttacker);
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
};/* size: 280, cachelines: 5, members: 1 */ };
/* <8c884> ../cstrike/dlls/func_tank.cpp:924 */ /* <8c884> ../cstrike/dlls/func_tank.cpp:924 */
class CFuncTankMortar: public CFuncTank class CFuncTankMortar: public CFuncTank
@ -247,28 +233,25 @@ public:
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
};/* size: 280, cachelines: 5, members: 1 */ };
/* <8c8d2> ../cstrike/dlls/func_tank.cpp:974 */ /* <8c8d2> ../cstrike/dlls/func_tank.cpp:974 */
class CFuncTankControls: public CBaseEntity class CFuncTankControls: public CBaseEntity
{ {
public: public:
virtual void Spawn(void); virtual void Spawn();
virtual int Save(CSave &save); virtual int Save(CSave &save);
virtual int Restore(CRestore &restore); virtual int Restore(CRestore &restore);
virtual int ObjectCaps(void) virtual int ObjectCaps() { return (CBaseEntity::ObjectCaps() & ~FCAP_ACROSS_TRANSITION) | FCAP_IMPULSE_USE; }
{ virtual void Think();
return (CBaseEntity::ObjectCaps() & ~FCAP_ACROSS_TRANSITION) | FCAP_IMPULSE_USE;
}
virtual void Think(void);
virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value); virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Spawn_(void); void Spawn_();
int Save_(CSave &save); int Save_(CSave &save);
int Restore_(CRestore &restore); int Restore_(CRestore &restore);
void Think_(void); void Think_();
void Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value); void Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
@ -276,27 +259,7 @@ public:
public: public:
static TYPEDESCRIPTION IMPL(m_SaveData)[1]; static TYPEDESCRIPTION IMPL(m_SaveData)[1];
public:
CFuncTank *m_pTank; CFuncTank *m_pTank;
};
};/* size: 156, cachelines: 3, members: 3 */
#ifdef HOOK_GAMEDLL
#define gTankSpread (*pgTankSpread)
extern Vector gTankSpread[5];
#endif // HOOK_GAMEDLL
#ifdef HOOK_GAMEDLL
// linked objects
C_DLLEXPORT void func_tank(entvars_t *pev);
C_DLLEXPORT void func_tanklaser(entvars_t *pev);
C_DLLEXPORT void func_tankrocket(entvars_t *pev);
C_DLLEXPORT void func_tankmortar(entvars_t *pev);
C_DLLEXPORT void func_tankcontrols(entvars_t *pev);
#endif // HOOK_GAMEDLL
#endif // FUNC_TANK_H #endif // FUNC_TANK_H

View File

@ -91,316 +91,6 @@ cvar_t sk_scientist_heal1 = { "sk_scientist_heal1", "0", 0, 0.0f, NULL };
cvar_t sk_scientist_heal2 = { "sk_scientist_heal2", "0", 0, 0.0f, NULL }; cvar_t sk_scientist_heal2 = { "sk_scientist_heal2", "0", 0, 0.0f, NULL };
cvar_t sk_scientist_heal3 = { "sk_scientist_heal3", "0", 0, 0.0f, NULL }; cvar_t sk_scientist_heal3 = { "sk_scientist_heal3", "0", 0, 0.0f, NULL };
#else // HOOK_GAMEDLL
cvar_t *g_psv_gravity;
cvar_t *g_psv_aim;
cvar_t *g_footsteps;
cvar_t *g_psv_accelerate;
cvar_t *g_psv_friction;
cvar_t *g_psv_stopspeed;
cvar_t displaysoundlist;
cvar_t timelimit;
cvar_t flashlight;
cvar_t decalfrequency;
cvar_t fadetoblack;
cvar_t fragsleft;
cvar_t timeleft;
cvar_t friendlyfire;
cvar_t allowmonsters;
cvar_t roundtime;
cvar_t buytime;
cvar_t freezetime;
cvar_t c4timer;
cvar_t ghostfrequency;
cvar_t autokick;
cvar_t autokick_timeout;
cvar_t restartround;
cvar_t sv_restart;
cvar_t limitteams;
cvar_t autoteambalance;
cvar_t tkpunish;
cvar_t hostagepenalty;
cvar_t mirrordamage;
cvar_t logmessages;
cvar_t forcecamera;
cvar_t forcechasecam;
cvar_t mapvoteratio;
cvar_t logdetail;
cvar_t startmoney;
cvar_t maxrounds;
cvar_t winlimit;
cvar_t windifference;
cvar_t playerid;
cvar_t allow_spectators;
cvar_t mp_chattime;
cvar_t kick_percent;
cvar_t humans_join_team;
// NOXREF
//cvar_t sk_agrunt_health1;
//cvar_t sk_agrunt_health2;
//cvar_t sk_agrunt_health3;
//cvar_t sk_agrunt_dmg_punch1;
//cvar_t sk_agrunt_dmg_punch2;
//cvar_t sk_agrunt_dmg_punch3;
//cvar_t sk_apache_health1;
//cvar_t sk_apache_health2;
//cvar_t sk_apache_health3;
//cvar_t sk_barney_health1;
//cvar_t sk_barney_health2;
//cvar_t sk_barney_health3;
//cvar_t sk_bullsquid_health1;
//cvar_t sk_bullsquid_health2;
//cvar_t sk_bullsquid_health3;
//cvar_t sk_bullsquid_dmg_bite1;
//cvar_t sk_bullsquid_dmg_bite2;
//cvar_t sk_bullsquid_dmg_bite3;
//cvar_t sk_bullsquid_dmg_whip1;
//cvar_t sk_bullsquid_dmg_whip2;
//cvar_t sk_bullsquid_dmg_whip3;
//cvar_t sk_bullsquid_dmg_spit1;
//cvar_t sk_bullsquid_dmg_spit2;
//cvar_t sk_bullsquid_dmg_spit3;
//cvar_t sk_bigmomma_health_factor1;
//cvar_t sk_bigmomma_health_factor2;
//cvar_t sk_bigmomma_health_factor3;
//cvar_t sk_bigmomma_dmg_slash1;
//cvar_t sk_bigmomma_dmg_slash2;
//cvar_t sk_bigmomma_dmg_slash3;
//cvar_t sk_bigmomma_dmg_blast1;
//cvar_t sk_bigmomma_dmg_blast2;
//cvar_t sk_bigmomma_dmg_blast3;
//cvar_t sk_bigmomma_radius_blast1;
//cvar_t sk_bigmomma_radius_blast2;
//cvar_t sk_bigmomma_radius_blast3;
//cvar_t sk_gargantua_health1;
//cvar_t sk_gargantua_health2;
//cvar_t sk_gargantua_health3;
//cvar_t sk_gargantua_dmg_slash1;
//cvar_t sk_gargantua_dmg_slash2;
//cvar_t sk_gargantua_dmg_slash3;
//cvar_t sk_gargantua_dmg_fire1;
//cvar_t sk_gargantua_dmg_fire2;
//cvar_t sk_gargantua_dmg_fire3;
//cvar_t sk_gargantua_dmg_stomp1;
//cvar_t sk_gargantua_dmg_stomp2;
//cvar_t sk_gargantua_dmg_stomp3;
//cvar_t sk_hassassin_health1;
//cvar_t sk_hassassin_health2;
//cvar_t sk_hassassin_health3;
//cvar_t sk_headcrab_health1;
//cvar_t sk_headcrab_health2;
//cvar_t sk_headcrab_health3;
//cvar_t sk_headcrab_dmg_bite1;
//cvar_t sk_headcrab_dmg_bite2;
//cvar_t sk_headcrab_dmg_bite3;
//cvar_t sk_hgrunt_health1;
//cvar_t sk_hgrunt_health2;
//cvar_t sk_hgrunt_health3;
//cvar_t sk_hgrunt_kick1;
//cvar_t sk_hgrunt_kick2;
//cvar_t sk_hgrunt_kick3;
//cvar_t sk_hgrunt_pellets1;
//cvar_t sk_hgrunt_pellets2;
//cvar_t sk_hgrunt_pellets3;
//cvar_t sk_hgrunt_gspeed1;
//cvar_t sk_hgrunt_gspeed2;
//cvar_t sk_hgrunt_gspeed3;
//cvar_t sk_houndeye_health1;
//cvar_t sk_houndeye_health2;
//cvar_t sk_houndeye_health3;
//cvar_t sk_houndeye_dmg_blast1;
//cvar_t sk_houndeye_dmg_blast2;
//cvar_t sk_houndeye_dmg_blast3;
//cvar_t sk_islave_health1;
//cvar_t sk_islave_health2;
//cvar_t sk_islave_health3;
//cvar_t sk_islave_dmg_claw1;
//cvar_t sk_islave_dmg_claw2;
//cvar_t sk_islave_dmg_claw3;
//cvar_t sk_islave_dmg_clawrake1;
//cvar_t sk_islave_dmg_clawrake2;
//cvar_t sk_islave_dmg_clawrake3;
//cvar_t sk_islave_dmg_zap1;
//cvar_t sk_islave_dmg_zap2;
//cvar_t sk_islave_dmg_zap3;
//cvar_t sk_ichthyosaur_health1;
//cvar_t sk_ichthyosaur_health2;
//cvar_t sk_ichthyosaur_health3;
//cvar_t sk_ichthyosaur_shake1;
//cvar_t sk_ichthyosaur_shake2;
//cvar_t sk_ichthyosaur_shake3;
//cvar_t sk_leech_health1;
//cvar_t sk_leech_health2;
//cvar_t sk_leech_health3;
//cvar_t sk_leech_dmg_bite1;
//cvar_t sk_leech_dmg_bite2;
//cvar_t sk_leech_dmg_bite3;
//cvar_t sk_controller_health1;
//cvar_t sk_controller_health2;
//cvar_t sk_controller_health3;
//cvar_t sk_controller_dmgzap1;
//cvar_t sk_controller_dmgzap2;
//cvar_t sk_controller_dmgzap3;
//cvar_t sk_controller_speedball1;
//cvar_t sk_controller_speedball2;
//cvar_t sk_controller_speedball3;
//cvar_t sk_controller_dmgball1;
//cvar_t sk_controller_dmgball2;
//cvar_t sk_controller_dmgball3;
//cvar_t sk_nihilanth_health1;
//cvar_t sk_nihilanth_health2;
//cvar_t sk_nihilanth_health3;
//cvar_t sk_nihilanth_zap1;
//cvar_t sk_nihilanth_zap2;
//cvar_t sk_nihilanth_zap3;
//cvar_t sk_scientist_health1;
//cvar_t sk_scientist_health2;
//cvar_t sk_scientist_health3;
//cvar_t sk_snark_health1;
//cvar_t sk_snark_health2;
//cvar_t sk_snark_health3;
//cvar_t sk_snark_dmg_bite1;
//cvar_t sk_snark_dmg_bite2;
//cvar_t sk_snark_dmg_bite3;
//cvar_t sk_snark_dmg_pop1;
//cvar_t sk_snark_dmg_pop2;
//cvar_t sk_snark_dmg_pop3;
//cvar_t sk_zombie_health1;
//cvar_t sk_zombie_health2;
//cvar_t sk_zombie_health3;
//cvar_t sk_zombie_dmg_one_slash1;
//cvar_t sk_zombie_dmg_one_slash2;
//cvar_t sk_zombie_dmg_one_slash3;
//cvar_t sk_zombie_dmg_both_slash1;
//cvar_t sk_zombie_dmg_both_slash2;
//cvar_t sk_zombie_dmg_both_slash3;
//cvar_t sk_turret_health1;
//cvar_t sk_turret_health2;
//cvar_t sk_turret_health3;
//cvar_t sk_miniturret_health1;
//cvar_t sk_miniturret_health2;
//cvar_t sk_miniturret_health3;
//cvar_t sk_sentry_health1;
//cvar_t sk_sentry_health2;
//cvar_t sk_sentry_health3;
//cvar_t sk_plr_crowbar1;
//cvar_t sk_plr_crowbar2;
//cvar_t sk_plr_crowbar3;
cvar_t sk_plr_9mm_bullet1;
cvar_t sk_plr_9mm_bullet2;
cvar_t sk_plr_9mm_bullet3;
cvar_t sk_plr_357_bullet1;
cvar_t sk_plr_357_bullet2;
cvar_t sk_plr_357_bullet3;
cvar_t sk_plr_9mmAR_bullet1;
cvar_t sk_plr_9mmAR_bullet2;
cvar_t sk_plr_9mmAR_bullet3;
cvar_t sk_plr_9mmAR_grenade1;
cvar_t sk_plr_9mmAR_grenade2;
cvar_t sk_plr_9mmAR_grenade3;
cvar_t sk_plr_buckshot1;
cvar_t sk_plr_buckshot2;
cvar_t sk_plr_buckshot3;
// NOXREF
//cvar_t sk_plr_xbow_bolt_client1;
//cvar_t sk_plr_xbow_bolt_client2;
//cvar_t sk_plr_xbow_bolt_client3;
//cvar_t sk_plr_xbow_bolt_monster1;
//cvar_t sk_plr_xbow_bolt_monster2;
//cvar_t sk_plr_xbow_bolt_monster3;
cvar_t sk_plr_rpg1;
cvar_t sk_plr_rpg2;
cvar_t sk_plr_rpg3;
// NOXREF
//cvar_t sk_plr_gauss1;
//cvar_t sk_plr_gauss2;
//cvar_t sk_plr_gauss3;
//cvar_t sk_plr_egon_narrow1;
//cvar_t sk_plr_egon_narrow2;
//cvar_t sk_plr_egon_narrow3;
//cvar_t sk_plr_egon_wide1;
//cvar_t sk_plr_egon_wide2;
//cvar_t sk_plr_egon_wide3;
//cvar_t sk_plr_hand_grenade1;
//cvar_t sk_plr_hand_grenade2;
//cvar_t sk_plr_hand_grenade3;
//cvar_t sk_plr_satchel1;
//cvar_t sk_plr_satchel2;
//cvar_t sk_plr_satchel3;
//cvar_t sk_plr_tripmine1;
//cvar_t sk_plr_tripmine2;
//cvar_t sk_plr_tripmine3;
cvar_t sk_12mm_bullet1;
cvar_t sk_12mm_bullet2;
cvar_t sk_12mm_bullet3;
cvar_t sk_9mmAR_bullet1;
cvar_t sk_9mmAR_bullet2;
cvar_t sk_9mmAR_bullet3;
cvar_t sk_9mm_bullet1;
cvar_t sk_9mm_bullet2;
cvar_t sk_9mm_bullet3;
// NOXREF
//cvar_t sk_hornet_dmg1;
//cvar_t sk_hornet_dmg2;
//cvar_t sk_hornet_dmg3;
cvar_t sk_suitcharger1;
cvar_t sk_suitcharger2;
cvar_t sk_suitcharger3;
cvar_t sk_battery1;
cvar_t sk_battery2;
cvar_t sk_battery3;
cvar_t sk_healthcharger1;
cvar_t sk_healthcharger2;
cvar_t sk_healthcharger3;
cvar_t sk_healthkit1;
cvar_t sk_healthkit2;
cvar_t sk_healthkit3;
cvar_t sk_scientist_heal1;
cvar_t sk_scientist_heal2;
cvar_t sk_scientist_heal3;
// NOXREF
//cvar_t sk_monster_head1;
//cvar_t sk_monster_head2;
//cvar_t sk_monster_head3;
//cvar_t sk_monster_chest1;
//cvar_t sk_monster_chest2;
//cvar_t sk_monster_chest3;
//cvar_t sk_monster_stomach1;
//cvar_t sk_monster_stomach2;
//cvar_t sk_monster_stomach3;
//cvar_t sk_monster_arm1;
//cvar_t sk_monster_arm2;
//cvar_t sk_monster_arm3;
//cvar_t sk_monster_leg1;
//cvar_t sk_monster_leg2;
//cvar_t sk_monster_leg3;
//cvar_t sk_player_head1;
//cvar_t sk_player_head2;
//cvar_t sk_player_head3;
//cvar_t sk_player_chest1;
//cvar_t sk_player_chest2;
//cvar_t sk_player_chest3;
//cvar_t sk_player_stomach1;
//cvar_t sk_player_stomach2;
//cvar_t sk_player_stomach3;
//cvar_t sk_player_arm1;
//cvar_t sk_player_arm2;
//cvar_t sk_player_arm3;
//cvar_t sk_player_leg1;
//cvar_t sk_player_leg2;
//cvar_t sk_player_leg3;
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
#ifdef REGAMEDLL_ADD #ifdef REGAMEDLL_ADD
@ -411,7 +101,7 @@ cvar_t round_infinite = { "mp_round_infinite", "0", FCVAR_SERVER, 0.0f, NULL };
#endif // REGAMEDLL_ADD #endif // REGAMEDLL_ADD
void GameDLL_Version_f(void) void GameDLL_Version_f()
{ {
if (Q_stricmp(CMD_ARGV(1), "version") != 0) if (Q_stricmp(CMD_ARGV(1), "version") != 0)
return; return;
@ -422,8 +112,10 @@ void GameDLL_Version_f(void)
} }
/* <9c900> ../cstrike/dlls/game.cpp:500 */ /* <9c900> ../cstrike/dlls/game.cpp:500 */
void EXT_FUNC GameDLLInit(void) void EXT_FUNC GameDLLInit()
{ {
g_bIsCzeroGame = UTIL_IsGame("czero");
g_psv_gravity = CVAR_GET_POINTER("sv_gravity"); g_psv_gravity = CVAR_GET_POINTER("sv_gravity");
g_psv_aim = CVAR_GET_POINTER("sv_aim"); g_psv_aim = CVAR_GET_POINTER("sv_aim");
g_footsteps = CVAR_GET_POINTER("mp_footsteps"); g_footsteps = CVAR_GET_POINTER("mp_footsteps");
@ -468,6 +160,9 @@ void EXT_FUNC GameDLLInit(void)
CVAR_REGISTER(&fragsleft); CVAR_REGISTER(&fragsleft);
CVAR_REGISTER(&timeleft); CVAR_REGISTER(&timeleft);
CVAR_REGISTER(&humans_join_team); CVAR_REGISTER(&humans_join_team);
// Remove unused cvars
#ifndef REGAMEDLL_FIXES
CVAR_REGISTER(&sk_plr_9mm_bullet1); CVAR_REGISTER(&sk_plr_9mm_bullet1);
CVAR_REGISTER(&sk_plr_9mm_bullet2); CVAR_REGISTER(&sk_plr_9mm_bullet2);
CVAR_REGISTER(&sk_plr_9mm_bullet3); CVAR_REGISTER(&sk_plr_9mm_bullet3);
@ -510,6 +205,7 @@ void EXT_FUNC GameDLLInit(void)
CVAR_REGISTER(&sk_scientist_heal1); CVAR_REGISTER(&sk_scientist_heal1);
CVAR_REGISTER(&sk_scientist_heal2); CVAR_REGISTER(&sk_scientist_heal2);
CVAR_REGISTER(&sk_scientist_heal3); CVAR_REGISTER(&sk_scientist_heal3);
#endif // REGAMEDLL_FIXES
#ifdef REGAMEDLL_ADD #ifdef REGAMEDLL_ADD

View File

@ -44,96 +44,6 @@
#define PLAYERID_TEAMONLY 1 #define PLAYERID_TEAMONLY 1
#define PLAYERID_OFF 2 #define PLAYERID_OFF 2
#ifdef HOOK_GAMEDLL
#define g_psv_gravity (*pg_psv_gravity)
#define g_psv_aim (*pg_psv_aim)
#define g_footsteps (*pg_footsteps)
#define g_psv_accelerate (*pg_psv_accelerate)
#define g_psv_friction (*pg_psv_friction)
#define g_psv_stopspeed (*pg_psv_stopspeed)
#define displaysoundlist (*pdisplaysoundlist)
#define timelimit (*ptimelimit)
#define flashlight (*pflashlight)
#define decalfrequency (*pdecalfrequency)
#define fadetoblack (*pfadetoblack)
#define fragsleft (*pfragsleft)
#define timeleft (*ptimeleft)
#define friendlyfire (*pfriendlyfire)
#define allowmonsters (*pallowmonsters)
#define roundtime (*proundtime)
#define buytime (*pbuytime)
#define freezetime (*pfreezetime)
#define c4timer (*pc4timer)
#define ghostfrequency (*pghostfrequency)
#define autokick (*pautokick)
#define autokick_timeout (*pautokick_timeout)
#define restartround (*prestartround)
#define sv_restart (*psv_restart)
#define limitteams (*plimitteams)
#define autoteambalance (*pautoteambalance)
#define tkpunish (*ptkpunish)
#define hostagepenalty (*phostagepenalty)
#define mirrordamage (*pmirrordamage)
#define logmessages (*plogmessages)
#define forcecamera (*pforcecamera)
#define forcechasecam (*pforcechasecam)
#define mapvoteratio (*pmapvoteratio)
#define logdetail (*plogdetail)
#define startmoney (*pstartmoney)
#define maxrounds (*pmaxrounds)
#define winlimit (*pwinlimit)
#define windifference (*pwindifference)
#define playerid (*pplayerid)
#define allow_spectators (*pallow_spectators)
#define mp_chattime (*pmp_chattime)
#define kick_percent (*pkick_percent)
#define humans_join_team (*phumans_join_team)
#define sk_plr_9mm_bullet1 (*psk_plr_9mm_bullet1)
#define sk_plr_9mm_bullet2 (*psk_plr_9mm_bullet2)
#define sk_plr_9mm_bullet3 (*psk_plr_9mm_bullet3)
#define sk_plr_357_bullet1 (*psk_plr_357_bullet1)
#define sk_plr_357_bullet2 (*psk_plr_357_bullet2)
#define sk_plr_357_bullet3 (*psk_plr_357_bullet3)
#define sk_plr_9mmAR_bullet1 (*psk_plr_9mmAR_bullet1)
#define sk_plr_9mmAR_bullet2 (*psk_plr_9mmAR_bullet2)
#define sk_plr_9mmAR_bullet3 (*psk_plr_9mmAR_bullet3)
#define sk_plr_9mmAR_grenade1 (*psk_plr_9mmAR_grenade1)
#define sk_plr_9mmAR_grenade2 (*psk_plr_9mmAR_grenade2)
#define sk_plr_9mmAR_grenade3 (*psk_plr_9mmAR_grenade3)
#define sk_plr_buckshot1 (*psk_plr_buckshot1)
#define sk_plr_buckshot2 (*psk_plr_buckshot2)
#define sk_plr_buckshot3 (*psk_plr_buckshot3)
#define sk_plr_rpg1 (*psk_plr_rpg1)
#define sk_plr_rpg2 (*psk_plr_rpg2)
#define sk_plr_rpg3 (*psk_plr_rpg3)
#define sk_12mm_bullet1 (*psk_12mm_bullet1)
#define sk_12mm_bullet2 (*psk_12mm_bullet2)
#define sk_12mm_bullet3 (*psk_12mm_bullet3)
#define sk_9mmAR_bullet1 (*psk_9mmAR_bullet1)
#define sk_9mmAR_bullet2 (*psk_9mmAR_bullet2)
#define sk_9mmAR_bullet3 (*psk_9mmAR_bullet3)
#define sk_9mm_bullet1 (*psk_9mm_bullet1)
#define sk_9mm_bullet2 (*psk_9mm_bullet2)
#define sk_9mm_bullet3 (*psk_9mm_bullet3)
#define sk_suitcharger1 (*psk_suitcharger1)
#define sk_suitcharger2 (*psk_suitcharger2)
#define sk_suitcharger3 (*psk_suitcharger3)
#define sk_battery1 (*psk_battery1)
#define sk_battery2 (*psk_battery2)
#define sk_battery3 (*psk_battery3)
#define sk_healthcharger1 (*psk_healthcharger1)
#define sk_healthcharger2 (*psk_healthcharger2)
#define sk_healthcharger3 (*psk_healthcharger3)
#define sk_healthkit1 (*psk_healthkit1)
#define sk_healthkit2 (*psk_healthkit2)
#define sk_healthkit3 (*psk_healthkit3)
#define sk_scientist_heal1 (*psk_scientist_heal1)
#define sk_scientist_heal2 (*psk_scientist_heal2)
#define sk_scientist_heal3 (*psk_scientist_heal3)
#endif // HOOK_GAMEDLL
extern cvar_t *g_psv_gravity; extern cvar_t *g_psv_gravity;
extern cvar_t *g_psv_aim; extern cvar_t *g_psv_aim;
extern cvar_t *g_footsteps; extern cvar_t *g_footsteps;
@ -228,6 +138,6 @@ extern cvar_t round_infinite;
#endif // REGAMEDLL_ADD #endif // REGAMEDLL_ADD
void GameDLLInit(void); void GameDLLInit();
#endif // GAME_H #endif // GAME_H

View File

@ -7,10 +7,6 @@
CHalfLifeMultiplay *g_pGameRules = NULL; CHalfLifeMultiplay *g_pGameRules = NULL;
#else //HOOK_GAMEDLL
CHalfLifeMultiplay *g_pGameRules;
#endif //HOOK_GAMEDLL #endif //HOOK_GAMEDLL
/* <ad93d> ../cstrike/dlls/gamerules.cpp:36 */ /* <ad93d> ../cstrike/dlls/gamerules.cpp:36 */
@ -101,7 +97,7 @@ BOOL CGameRules::__MAKE_VHOOK(CanHavePlayerItem)(CBasePlayer *pPlayer, CBasePlay
} }
/* <ad85d> ../cstrike/dlls/gamerules.cpp:119 */ /* <ad85d> ../cstrike/dlls/gamerules.cpp:119 */
void CGameRules::__MAKE_VHOOK(RefreshSkillData)(void) void CGameRules::__MAKE_VHOOK(RefreshSkillData)()
{ {
int iSkill = (int)CVAR_GET_FLOAT("skill"); int iSkill = (int)CVAR_GET_FLOAT("skill");
@ -124,7 +120,7 @@ void CGameRules::__MAKE_VHOOK(RefreshSkillData)(void)
} }
/* <ada23> ../cstrike/dlls/gamerules.cpp:157 */ /* <ada23> ../cstrike/dlls/gamerules.cpp:157 */
CGameRules *InstallGameRules(void) CGameRules *InstallGameRules()
{ {
SERVER_COMMAND("exec game.cfg\n"); SERVER_COMMAND("exec game.cfg\n");
SERVER_EXECUTE(); SERVER_EXECUTE();
@ -134,27 +130,3 @@ CGameRules *InstallGameRules(void)
return new CHalfLifeMultiplay; return new CHalfLifeMultiplay;
} }
#ifdef HOOK_GAMEDLL
void CGameRules::RefreshSkillData(void)
{
RefreshSkillData_();
}
edict_t *CGameRules::GetPlayerSpawnSpot(CBasePlayer *pPlayer)
{
return GetPlayerSpawnSpot_(pPlayer);
}
BOOL CGameRules::CanHavePlayerItem(CBasePlayer *pPlayer, CBasePlayerItem *pWeapon)
{
return CanHavePlayerItem_(pPlayer, pWeapon);
}
BOOL CGameRules::CanHaveAmmo(CBasePlayer *pPlayer, const char *pszAmmoName, int iMaxCarry)
{
return CanHaveAmmo_(pPlayer, pszAmmoName, iMaxCarry);
}
#endif // HOOK_GAMEDLL

View File

@ -265,11 +265,9 @@ public:
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
public: public:
//int **_vptr.CGameRules;
BOOL m_bFreezePeriod; BOOL m_bFreezePeriod;
BOOL m_bBombDropped; BOOL m_bBombDropped;
};
};/* size: 12, cachelines: 1, members: 3 */
class CHalfLifeRules: public CGameRules class CHalfLifeRules: public CGameRules
{ {
@ -361,8 +359,7 @@ public:
BOOL FAllowMonsters_(); BOOL FAllowMonsters_();
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
};
};/* size: 12, cachelines: 1, members: 1 */
class CHalfLifeMultiplay: public CGameRules class CHalfLifeMultiplay: public CGameRules
{ {
@ -654,9 +651,8 @@ protected:
int m_iCareerMatchWins; int m_iCareerMatchWins;
int m_iRoundWinDifference; int m_iRoundWinDifference;
float m_fCareerMatchMenuTime; float m_fCareerMatchMenuTime;
bool m_bSkipSpawn;//712 bool m_bSkipSpawn;
};
};/* size: 708, cachelines: 12, members: 76 */
typedef struct mapcycle_item_s typedef struct mapcycle_item_s
{ {
@ -667,7 +663,6 @@ typedef struct mapcycle_item_s
char rulebuffer[MAX_RULE_BUFFER]; char rulebuffer[MAX_RULE_BUFFER];
} mapcycle_item_t; } mapcycle_item_t;
/* size: 1068, cachelines: 17, members: 5 */
typedef struct mapcycle_s typedef struct mapcycle_s
{ {
@ -675,7 +670,6 @@ typedef struct mapcycle_s
struct mapcycle_item_s *next_item; struct mapcycle_item_s *next_item;
} mapcycle_t; } mapcycle_t;
/* size: 8, cachelines: 1, members: 2 */
/* <11192b> ../cstrike/dlls/multiplay_gamerules.cpp:257 */ /* <11192b> ../cstrike/dlls/multiplay_gamerules.cpp:257 */
class CMapInfo: public CPointEntity class CMapInfo: public CPointEntity
@ -694,8 +688,7 @@ public:
public: public:
int m_iBuyingStatus; int m_iBuyingStatus;
float m_flBombRadius; float m_flBombRadius;
};
};/* size: 160, cachelines: 3, members: 3 */
/* <111732> ../cstrike/dlls/multiplay_gamerules.cpp:292 */ /* <111732> ../cstrike/dlls/multiplay_gamerules.cpp:292 */
class CCStrikeGameMgrHelper: public IVoiceGameMgrHelper class CCStrikeGameMgrHelper: public IVoiceGameMgrHelper
@ -709,30 +702,12 @@ public:
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
};/* size: 4, cachelines: 1, members: 1 */ };
#ifdef HOOK_GAMEDLL
#define g_pGameRules (*pg_pGameRules)
#define g_GameMgrHelper (*pg_GameMgrHelper)
#define sv_clienttrace (*psv_clienttrace)
#define g_pMPGameRules (*pg_pMPGameRules)
#define mp_com_token (*pmp_com_token)
#endif // HOOK_GAMEDLL
extern CHalfLifeMultiplay *g_pGameRules; extern CHalfLifeMultiplay *g_pGameRules;
extern CCStrikeGameMgrHelper g_GameMgrHelper;
extern cvar_t *sv_clienttrace;
extern CHalfLifeMultiplay *g_pMPGameRules;
extern char mp_com_token[ COM_TOKEN_LEN ];
CGameRules *InstallGameRules(); CGameRules *InstallGameRules();
/*
* Multiplay gamerules
*/
bool IsBotSpeaking(); bool IsBotSpeaking();
void SV_Continue_f(); void SV_Continue_f();
void SV_Tutor_Toggle_f(); void SV_Tutor_Toggle_f();
@ -755,11 +730,4 @@ int CountPlayers();
void ExtractCommandString(char *s, char *szCommand); void ExtractCommandString(char *s, char *szCommand);
int GetMapCount(); int GetMapCount();
#ifdef HOOK_GAMEDLL
// linked objects
C_DLLEXPORT void info_map_parameters(entvars_t *pev);
#endif // HOOK_GAMEDLL
#endif // GAMERULES_H #endif // GAMERULES_H

View File

@ -24,10 +24,6 @@ TYPEDESCRIPTION CGrenade::m_SaveData[] =
DEFINE_FIELD(CGrenade, m_usEvent, FIELD_INTEGER), DEFINE_FIELD(CGrenade, m_usEvent, FIELD_INTEGER),
}; };
#else // HOOK_GAMEDLL
TYPEDESCRIPTION IMPL_CLASS(CGrenade, m_SaveData)[15];
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
/* <b8dad> ../cstrike/dlls/ggrenade.cpp:52 */ /* <b8dad> ../cstrike/dlls/ggrenade.cpp:52 */
@ -55,7 +51,7 @@ void CGrenade::Explode(TraceResult *pTrace, int bitsDamageType)
// Pull out of the wall a bit // Pull out of the wall a bit
if (pTrace->flFraction != 1.0f) if (pTrace->flFraction != 1.0f)
{ {
pev->origin = pTrace->vecEndPos + (pTrace->vecPlaneNormal * (pev->dmg - 24) * 0.6); pev->origin = pTrace->vecEndPos + (pTrace->vecPlaneNormal * (pev->dmg - 24.0f) * 0.6f);
} }
int iContents = UTIL_PointContents(pev->origin); int iContents = UTIL_PointContents(pev->origin);
@ -77,7 +73,7 @@ void CGrenade::Explode(TraceResult *pTrace, int bitsDamageType)
RadiusFlash(pev->origin, pev, pevOwner, 4, CLASS_NONE, bitsDamageType); RadiusFlash(pev->origin, pev, pevOwner, 4, CLASS_NONE, bitsDamageType);
if (RANDOM_FLOAT(0, 1) < 0.5) if (RANDOM_FLOAT(0, 1) < 0.5f)
UTIL_DecalTrace(pTrace, DECAL_SCORCH1); UTIL_DecalTrace(pTrace, DECAL_SCORCH1);
else else
UTIL_DecalTrace(pTrace, DECAL_SCORCH2); UTIL_DecalTrace(pTrace, DECAL_SCORCH2);
@ -94,7 +90,7 @@ void CGrenade::Explode(TraceResult *pTrace, int bitsDamageType)
pev->effects |= EF_NODRAW; pev->effects |= EF_NODRAW;
SetThink(&CGrenade::Smoke); SetThink(&CGrenade::Smoke);
pev->velocity = g_vecZero; pev->velocity = g_vecZero;
pev->nextthink = gpGlobals->time + 0.3; pev->nextthink = gpGlobals->time + 0.3f;
if (iContents != CONTENTS_WATER) if (iContents != CONTENTS_WATER)
{ {
@ -133,7 +129,7 @@ void CGrenade::Explode2(TraceResult *pTrace, int bitsDamageType)
// Pull out of the wall a bit // Pull out of the wall a bit
if (pTrace->flFraction != 1.0f) if (pTrace->flFraction != 1.0f)
{ {
pev->origin = pTrace->vecEndPos + (pTrace->vecPlaneNormal * (pev->dmg - 24) * 0.6); pev->origin = pTrace->vecEndPos + (pTrace->vecPlaneNormal * (pev->dmg - 24.0f) * 0.6f);
} }
int iContents = UTIL_PointContents(pev->origin); int iContents = UTIL_PointContents(pev->origin);
@ -142,9 +138,9 @@ void CGrenade::Explode2(TraceResult *pTrace, int bitsDamageType)
WRITE_BYTE(TE_SPRITE); WRITE_BYTE(TE_SPRITE);
WRITE_COORD(pev->origin.x); WRITE_COORD(pev->origin.x);
WRITE_COORD(pev->origin.y); WRITE_COORD(pev->origin.y);
WRITE_COORD(pev->origin.z - 10); WRITE_COORD(pev->origin.z - 10.0f);
WRITE_SHORT(g_sModelIndexFireball3); WRITE_SHORT(g_sModelIndexFireball3);
WRITE_BYTE((pev->dmg - 275) * 0.6); WRITE_BYTE((pev->dmg - 275.0f) * 0.6f);
WRITE_BYTE(150); WRITE_BYTE(150);
MESSAGE_END(); MESSAGE_END();
@ -154,7 +150,7 @@ void CGrenade::Explode2(TraceResult *pTrace, int bitsDamageType)
WRITE_COORD(pev->origin.y + RANDOM_FLOAT(-512, 512)); WRITE_COORD(pev->origin.y + RANDOM_FLOAT(-512, 512));
WRITE_COORD(pev->origin.z + RANDOM_FLOAT(-10, 10)); WRITE_COORD(pev->origin.z + RANDOM_FLOAT(-10, 10));
WRITE_SHORT(g_sModelIndexFireball2); WRITE_SHORT(g_sModelIndexFireball2);
WRITE_BYTE((pev->dmg - 275) * 0.6); WRITE_BYTE((pev->dmg - 275.0f) * 0.6f);
WRITE_BYTE(150); WRITE_BYTE(150);
MESSAGE_END(); MESSAGE_END();
@ -164,7 +160,7 @@ void CGrenade::Explode2(TraceResult *pTrace, int bitsDamageType)
WRITE_COORD(pev->origin.y + RANDOM_FLOAT(-512, 512)); WRITE_COORD(pev->origin.y + RANDOM_FLOAT(-512, 512));
WRITE_COORD(pev->origin.z + RANDOM_FLOAT(-10, 10)); WRITE_COORD(pev->origin.z + RANDOM_FLOAT(-10, 10));
WRITE_SHORT(g_sModelIndexFireball3); WRITE_SHORT(g_sModelIndexFireball3);
WRITE_BYTE((pev->dmg - 275) * 0.6); WRITE_BYTE((pev->dmg - 275.0f) * 0.6f);
WRITE_BYTE(150); WRITE_BYTE(150);
MESSAGE_END(); MESSAGE_END();
@ -174,7 +170,7 @@ void CGrenade::Explode2(TraceResult *pTrace, int bitsDamageType)
WRITE_COORD(pev->origin.y + RANDOM_FLOAT(-512, 512)); WRITE_COORD(pev->origin.y + RANDOM_FLOAT(-512, 512));
WRITE_COORD(pev->origin.z + RANDOM_FLOAT(-10, 10)); WRITE_COORD(pev->origin.z + RANDOM_FLOAT(-10, 10));
WRITE_SHORT(g_sModelIndexFireball); WRITE_SHORT(g_sModelIndexFireball);
WRITE_BYTE((pev->dmg - 275) * 0.6); WRITE_BYTE((pev->dmg - 275.0f) * 0.6f);
WRITE_BYTE(17); WRITE_BYTE(17);
MESSAGE_END(); MESSAGE_END();
@ -210,7 +206,7 @@ void CGrenade::Explode2(TraceResult *pTrace, int bitsDamageType)
MESSAGE_END(); MESSAGE_END();
// Decal! // Decal!
if (RANDOM_FLOAT(0, 1) < 0.5) if (RANDOM_FLOAT(0, 1) < 0.5f)
UTIL_DecalTrace(pTrace, DECAL_SCORCH1); UTIL_DecalTrace(pTrace, DECAL_SCORCH1);
else else
UTIL_DecalTrace(pTrace, DECAL_SCORCH2); UTIL_DecalTrace(pTrace, DECAL_SCORCH2);
@ -228,7 +224,7 @@ void CGrenade::Explode2(TraceResult *pTrace, int bitsDamageType)
pev->effects |= EF_NODRAW; pev->effects |= EF_NODRAW;
SetThink(&CGrenade::Smoke2); SetThink(&CGrenade::Smoke2);
pev->velocity = g_vecZero; pev->velocity = g_vecZero;
pev->nextthink = gpGlobals->time + 0.85; pev->nextthink = gpGlobals->time + 0.85f;
if (iContents != CONTENTS_WATER) if (iContents != CONTENTS_WATER)
{ {
@ -251,14 +247,14 @@ void CGrenade::Explode3(TraceResult *pTrace, int bitsDamageType)
if (pTrace->flFraction != 1.0f) if (pTrace->flFraction != 1.0f)
{ {
pev->origin = pTrace->vecEndPos + (pTrace->vecPlaneNormal * (pev->dmg - 24) * 0.6); pev->origin = pTrace->vecEndPos + (pTrace->vecPlaneNormal * (pev->dmg - 24.0f) * 0.6f);
} }
MESSAGE_BEGIN(MSG_PAS, SVC_TEMPENTITY, pev->origin); MESSAGE_BEGIN(MSG_PAS, SVC_TEMPENTITY, pev->origin);
WRITE_BYTE(TE_EXPLOSION); // This makes a dynamic light and the explosion sprites/sound WRITE_BYTE(TE_EXPLOSION); // This makes a dynamic light and the explosion sprites/sound
WRITE_COORD(pev->origin.x); // Send to PAS because of the sound WRITE_COORD(pev->origin.x); // Send to PAS because of the sound
WRITE_COORD(pev->origin.y); WRITE_COORD(pev->origin.y);
WRITE_COORD(pev->origin.z + 20); WRITE_COORD(pev->origin.z + 20.0f);
WRITE_SHORT(g_sModelIndexFireball3); WRITE_SHORT(g_sModelIndexFireball3);
WRITE_BYTE(25); // scale * 10 WRITE_BYTE(25); // scale * 10
WRITE_BYTE(30); // framerate WRITE_BYTE(30); // framerate
@ -292,7 +288,7 @@ void CGrenade::Explode3(TraceResult *pTrace, int bitsDamageType)
pev->owner = NULL; pev->owner = NULL;
RadiusDamage(pev, pevOwner, pev->dmg, CLASS_NONE, bitsDamageType); RadiusDamage(pev, pevOwner, pev->dmg, CLASS_NONE, bitsDamageType);
if (RANDOM_FLOAT(0, 1) < 0.5) if (RANDOM_FLOAT(0, 1) < 0.5f)
UTIL_DecalTrace(pTrace, DECAL_SCORCH1); UTIL_DecalTrace(pTrace, DECAL_SCORCH1);
else else
UTIL_DecalTrace(pTrace, DECAL_SCORCH2); UTIL_DecalTrace(pTrace, DECAL_SCORCH2);
@ -310,7 +306,7 @@ void CGrenade::Explode3(TraceResult *pTrace, int bitsDamageType)
pev->effects |= EF_NODRAW; pev->effects |= EF_NODRAW;
SetThink(&CGrenade::Smoke3_C); SetThink(&CGrenade::Smoke3_C);
pev->velocity = g_vecZero; pev->velocity = g_vecZero;
pev->nextthink = gpGlobals->time + 0.55; pev->nextthink = gpGlobals->time + 0.55f;
int sparkCount = RANDOM_LONG(0, 3); int sparkCount = RANDOM_LONG(0, 3);
for (int i = 0; i < sparkCount; ++i) for (int i = 0; i < sparkCount; ++i)
@ -330,7 +326,7 @@ NOXREF void CGrenade::SG_Explode(TraceResult *pTrace, int bitsDamageType)
if (pTrace->flFraction != 1.0f) if (pTrace->flFraction != 1.0f)
{ {
pev->origin = pTrace->vecEndPos + (pTrace->vecPlaneNormal * (pev->dmg - 24) * 0.6); pev->origin = pTrace->vecEndPos + (pTrace->vecPlaneNormal * (pev->dmg - 24.0f) * 0.6f);
} }
int iContents = UTIL_PointContents(pev->origin); int iContents = UTIL_PointContents(pev->origin);
@ -339,7 +335,7 @@ NOXREF void CGrenade::SG_Explode(TraceResult *pTrace, int bitsDamageType)
// can't traceline attack owner if this is set // can't traceline attack owner if this is set
pev->owner = NULL; pev->owner = NULL;
if (RANDOM_FLOAT(0, 1) < 0.5) if (RANDOM_FLOAT(0, 1) < 0.5f)
UTIL_DecalTrace(pTrace, DECAL_SCORCH1); UTIL_DecalTrace(pTrace, DECAL_SCORCH1);
else else
UTIL_DecalTrace(pTrace, DECAL_SCORCH2); UTIL_DecalTrace(pTrace, DECAL_SCORCH2);
@ -356,7 +352,7 @@ NOXREF void CGrenade::SG_Explode(TraceResult *pTrace, int bitsDamageType)
pev->effects |= EF_NODRAW; pev->effects |= EF_NODRAW;
SetThink(&CGrenade::Smoke); SetThink(&CGrenade::Smoke);
pev->velocity = g_vecZero; pev->velocity = g_vecZero;
pev->nextthink = gpGlobals->time + 0.1; pev->nextthink = gpGlobals->time + 0.1f;
if (iContents != CONTENTS_WATER) if (iContents != CONTENTS_WATER)
{ {
@ -368,7 +364,7 @@ NOXREF void CGrenade::SG_Explode(TraceResult *pTrace, int bitsDamageType)
} }
/* <b6c26> ../cstrike/dlls/ggrenade.cpp:475 */ /* <b6c26> ../cstrike/dlls/ggrenade.cpp:475 */
void CGrenade::Smoke3_C(void) void CGrenade::Smoke3_C()
{ {
if (UTIL_PointContents(pev->origin) == CONTENTS_WATER) if (UTIL_PointContents(pev->origin) == CONTENTS_WATER)
{ {
@ -380,7 +376,7 @@ void CGrenade::Smoke3_C(void)
WRITE_BYTE(TE_SMOKE); WRITE_BYTE(TE_SMOKE);
WRITE_COORD(pev->origin.x); WRITE_COORD(pev->origin.x);
WRITE_COORD(pev->origin.y); WRITE_COORD(pev->origin.y);
WRITE_COORD(pev->origin.z - 5); WRITE_COORD(pev->origin.z - 5.0f);
WRITE_SHORT(g_sModelIndexSmoke); WRITE_SHORT(g_sModelIndexSmoke);
WRITE_BYTE(35 + RANDOM_FLOAT(0, 10)); // scale * 10 WRITE_BYTE(35 + RANDOM_FLOAT(0, 10)); // scale * 10
WRITE_BYTE(5); // framerate WRITE_BYTE(5); // framerate
@ -391,7 +387,7 @@ void CGrenade::Smoke3_C(void)
} }
/* <b995d> ../cstrike/dlls/ggrenade.cpp:497 */ /* <b995d> ../cstrike/dlls/ggrenade.cpp:497 */
void CGrenade::Smoke3_B(void) void CGrenade::Smoke3_B()
{ {
if (UTIL_PointContents(pev->origin) == CONTENTS_WATER) if (UTIL_PointContents(pev->origin) == CONTENTS_WATER)
{ {
@ -415,7 +411,7 @@ void CGrenade::Smoke3_B(void)
} }
/* <b6b2a> ../cstrike/dlls/ggrenade.cpp:520 */ /* <b6b2a> ../cstrike/dlls/ggrenade.cpp:520 */
void CGrenade::Smoke3_A(void) void CGrenade::Smoke3_A()
{ {
if (UTIL_PointContents(pev->origin) == CONTENTS_WATER) if (UTIL_PointContents(pev->origin) == CONTENTS_WATER)
{ {
@ -436,7 +432,7 @@ void CGrenade::Smoke3_A(void)
} }
/* <b6a2e> ../cstrike/dlls/ggrenade.cpp:544 */ /* <b6a2e> ../cstrike/dlls/ggrenade.cpp:544 */
void CGrenade::Smoke2(void) void CGrenade::Smoke2()
{ {
if (UTIL_PointContents(pev->origin) == CONTENTS_WATER) if (UTIL_PointContents(pev->origin) == CONTENTS_WATER)
{ {
@ -459,7 +455,7 @@ void CGrenade::Smoke2(void)
} }
/* <b6932> ../cstrike/dlls/ggrenade.cpp:567 */ /* <b6932> ../cstrike/dlls/ggrenade.cpp:567 */
void CGrenade::Smoke(void) void CGrenade::Smoke()
{ {
if (UTIL_PointContents(pev->origin) == CONTENTS_WATER) if (UTIL_PointContents(pev->origin) == CONTENTS_WATER)
{ {
@ -482,7 +478,7 @@ void CGrenade::Smoke(void)
} }
/* <b6d22> ../cstrike/dlls/ggrenade.cpp:591 */ /* <b6d22> ../cstrike/dlls/ggrenade.cpp:591 */
void CGrenade::SG_Smoke(void) void CGrenade::SG_Smoke()
{ {
int iMaxSmokePuffs = 100; int iMaxSmokePuffs = 100;
float flSmokeInterval; float flSmokeInterval;
@ -517,7 +513,7 @@ void CGrenade::SG_Smoke(void)
if (m_SGSmoke <= 20) if (m_SGSmoke <= 20)
{ {
pev->nextthink = gpGlobals->time + 1.0; pev->nextthink = gpGlobals->time + 1.0f;
SetThink(&CGrenade::SG_Smoke); SetThink(&CGrenade::SG_Smoke);
++m_SGSmoke; ++m_SGSmoke;
} }
@ -549,16 +545,16 @@ void CGrenade::DetonateUse(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TY
} }
/* <b9abf> ../cstrike/dlls/ggrenade.cpp:677 */ /* <b9abf> ../cstrike/dlls/ggrenade.cpp:677 */
void CGrenade::PreDetonate(void) void CGrenade::PreDetonate()
{ {
CSoundEnt::InsertSound(bits_SOUND_DANGER, pev->origin, 400, 0.3); CSoundEnt::InsertSound(bits_SOUND_DANGER, pev->origin, 400, 0.3);
SetThink(&CGrenade::Detonate); SetThink(&CGrenade::Detonate);
pev->nextthink = gpGlobals->time + 1; pev->nextthink = gpGlobals->time + 1.0f;
} }
/* <b789e> ../cstrike/dlls/ggrenade.cpp:686 */ /* <b789e> ../cstrike/dlls/ggrenade.cpp:686 */
void CGrenade::Detonate(void) void CGrenade::Detonate()
{ {
TraceResult tr; TraceResult tr;
Vector vecSpot; // trace starts here! Vector vecSpot; // trace starts here!
@ -569,7 +565,7 @@ void CGrenade::Detonate(void)
} }
/* <b7355> ../cstrike/dlls/ggrenade.cpp:698 */ /* <b7355> ../cstrike/dlls/ggrenade.cpp:698 */
void CGrenade::SG_Detonate(void) void CGrenade::SG_Detonate()
{ {
TraceResult tr; TraceResult tr;
Vector vecSpot; Vector vecSpot;
@ -617,12 +613,12 @@ void CGrenade::SG_Detonate(void)
pev->velocity.y = RANDOM_FLOAT(-175, 175); pev->velocity.y = RANDOM_FLOAT(-175, 175);
pev->velocity.z = RANDOM_FLOAT(250, 350); pev->velocity.z = RANDOM_FLOAT(250, 350);
pev->nextthink = gpGlobals->time + 0.1; pev->nextthink = gpGlobals->time + 0.1f;
SetThink(&CGrenade::SG_Smoke); SetThink(&CGrenade::SG_Smoke);
} }
/* <b8009> ../cstrike/dlls/ggrenade.cpp:752 */ /* <b8009> ../cstrike/dlls/ggrenade.cpp:752 */
void CGrenade::Detonate2(void) void CGrenade::Detonate2()
{ {
TraceResult tr; TraceResult tr;
Vector vecSpot;// trace starts here! Vector vecSpot;// trace starts here!
@ -634,7 +630,7 @@ void CGrenade::Detonate2(void)
} }
/* <b7c81> ../cstrike/dlls/ggrenade.cpp:764 */ /* <b7c81> ../cstrike/dlls/ggrenade.cpp:764 */
void CGrenade::Detonate3(void) void CGrenade::Detonate3()
{ {
TraceResult tr; TraceResult tr;
Vector vecSpot;// trace starts here! Vector vecSpot;// trace starts here!
@ -654,13 +650,13 @@ void CGrenade::ExplodeTouch(CBaseEntity *pOther)
pev->enemy = pOther->edict(); pev->enemy = pOther->edict();
vecSpot = pev->origin - pev->velocity.Normalize() * 32; vecSpot = pev->origin - pev->velocity.Normalize() * 32.0f;
UTIL_TraceLine(vecSpot, vecSpot + pev->velocity.Normalize() * 64, ignore_monsters, ENT(pev), &tr); UTIL_TraceLine(vecSpot, vecSpot + pev->velocity.Normalize() * 64, ignore_monsters, ENT(pev), &tr);
Explode(&tr, DMG_BLAST); Explode(&tr, DMG_BLAST);
} }
/* <b7101> ../cstrike/dlls/ggrenade.cpp:794 */ /* <b7101> ../cstrike/dlls/ggrenade.cpp:794 */
void CGrenade::DangerSoundThink(void) void CGrenade::DangerSoundThink()
{ {
if (!IsInWorld()) if (!IsInWorld())
{ {
@ -669,11 +665,11 @@ void CGrenade::DangerSoundThink(void)
} }
CSoundEnt::InsertSound(bits_SOUND_DANGER, pev->origin + pev->velocity * 0.5, pev->velocity.Length(), 0.2); CSoundEnt::InsertSound(bits_SOUND_DANGER, pev->origin + pev->velocity * 0.5, pev->velocity.Length(), 0.2);
pev->nextthink = gpGlobals->time + 0.2; pev->nextthink = gpGlobals->time + 0.2f;
if (pev->waterlevel != 0) if (pev->waterlevel != 0)
{ {
pev->velocity = pev->velocity * 0.5; pev->velocity = pev->velocity * 0.5f;
} }
} }
@ -686,7 +682,7 @@ void CGrenade::BounceTouch(CBaseEntity *pOther)
if (FClassnameIs(pOther->pev, "func_breakable") && pOther->pev->rendermode != kRenderNormal) if (FClassnameIs(pOther->pev, "func_breakable") && pOther->pev->rendermode != kRenderNormal)
{ {
pev->velocity = pev->velocity * -2; pev->velocity = pev->velocity * -2.0f;
return; return;
} }
@ -696,22 +692,22 @@ void CGrenade::BounceTouch(CBaseEntity *pOther)
// or thrown very far tend to slow down too quickly for me to always catch just by testing velocity. // or thrown very far tend to slow down too quickly for me to always catch just by testing velocity.
// trimming the Z velocity a bit seems to help quite a bit. // trimming the Z velocity a bit seems to help quite a bit.
vecTestVelocity = pev->velocity; vecTestVelocity = pev->velocity;
vecTestVelocity.z *= 0.7; vecTestVelocity.z *= 0.7f;
if (!m_fRegisteredSound && vecTestVelocity.Length() <= 60) if (!m_fRegisteredSound && vecTestVelocity.Length() <= 60.0f)
{ {
// grenade is moving really slow. It's probably very close to where it will ultimately stop moving. // grenade is moving really slow. It's probably very close to where it will ultimately stop moving.
// go ahead and emit the danger sound. // go ahead and emit the danger sound.
// register a radius louder than the explosion, so we make sure everyone gets out of the way // register a radius louder than the explosion, so we make sure everyone gets out of the way
CSoundEnt::InsertSound(bits_SOUND_DANGER, pev->origin, pev->dmg / 0.4, 0.3); CSoundEnt::InsertSound(bits_SOUND_DANGER, pev->origin, pev->dmg / 0.4f, 0.3);
m_fRegisteredSound = TRUE; m_fRegisteredSound = TRUE;
} }
if (pev->flags & FL_ONGROUND) if (pev->flags & FL_ONGROUND)
{ {
// add a bit of static friction // add a bit of static friction
pev->velocity = pev->velocity * 0.8; pev->velocity = pev->velocity * 0.8f;
pev->sequence = RANDOM_LONG(1, 1); // TODO: what? pev->sequence = RANDOM_LONG(1, 1); // TODO: what?
} }
else else
@ -732,15 +728,15 @@ void CGrenade::BounceTouch(CBaseEntity *pOther)
++m_iBounceCount; ++m_iBounceCount;
} }
pev->framerate = pev->velocity.Length() / 200; pev->framerate = pev->velocity.Length() / 200.0f;
if (pev->framerate > 1) if (pev->framerate > 1)
{ {
pev->framerate = 1; pev->framerate = 1.0f;
} }
else if (pev->framerate < 0.5) else if (pev->framerate < 0.5f)
{ {
pev->framerate = 0; pev->framerate = 0.0f;
} }
} }
@ -754,7 +750,7 @@ void CGrenade::SlideTouch(CBaseEntity *pOther)
if (pev->flags & FL_ONGROUND) if (pev->flags & FL_ONGROUND)
{ {
// add a bit of static friction // add a bit of static friction
pev->velocity = pev->velocity * 0.95; pev->velocity = pev->velocity * 0.95f;
} }
else else
{ {
@ -763,9 +759,9 @@ void CGrenade::SlideTouch(CBaseEntity *pOther)
} }
/* <b7b20> ../cstrike/dlls/ggrenade.cpp:904 */ /* <b7b20> ../cstrike/dlls/ggrenade.cpp:904 */
void CGrenade::__MAKE_VHOOK(BounceSound)(void) void CGrenade::__MAKE_VHOOK(BounceSound)()
{ {
if (pev->dmg > 50) if (pev->dmg > 50.0f)
{ {
EMIT_SOUND(ENT(pev), CHAN_VOICE, "weapons/he_bounce-1.wav", 0.25, ATTN_NORM); EMIT_SOUND(ENT(pev), CHAN_VOICE, "weapons/he_bounce-1.wav", 0.25, ATTN_NORM);
return; return;
@ -780,7 +776,7 @@ void CGrenade::__MAKE_VHOOK(BounceSound)(void)
} }
/* <b6f28> ../cstrike/dlls/ggrenade.cpp:919 */ /* <b6f28> ../cstrike/dlls/ggrenade.cpp:919 */
void CGrenade::TumbleThink(void) void CGrenade::TumbleThink()
{ {
if (!IsInWorld()) if (!IsInWorld())
{ {
@ -789,7 +785,7 @@ void CGrenade::TumbleThink(void)
} }
StudioFrameAdvance(); StudioFrameAdvance();
pev->nextthink = gpGlobals->time + 0.1; pev->nextthink = gpGlobals->time + 0.1f;
if (pev->dmgtime - 1 < gpGlobals->time) if (pev->dmgtime - 1 < gpGlobals->time)
{ {
@ -798,7 +794,7 @@ void CGrenade::TumbleThink(void)
if (pev->dmgtime <= gpGlobals->time) if (pev->dmgtime <= gpGlobals->time)
{ {
if (pev->dmg <= 40) if (pev->dmg <= 40.0f)
{ {
SetThink(&CGrenade::Detonate); SetThink(&CGrenade::Detonate);
} }
@ -808,13 +804,13 @@ void CGrenade::TumbleThink(void)
if (pev->waterlevel != 0) if (pev->waterlevel != 0)
{ {
pev->velocity = pev->velocity * 0.5; pev->velocity = pev->velocity * 0.5f;
pev->framerate = 0.2; pev->framerate = 0.2f;
} }
} }
/* <b67e7> ../cstrike/dlls/ggrenade.cpp:949 */ /* <b67e7> ../cstrike/dlls/ggrenade.cpp:949 */
void CGrenade::SG_TumbleThink(void) void CGrenade::SG_TumbleThink()
{ {
if (!IsInWorld()) if (!IsInWorld())
{ {
@ -824,11 +820,11 @@ void CGrenade::SG_TumbleThink(void)
if (pev->flags & FL_ONGROUND) if (pev->flags & FL_ONGROUND)
{ {
pev->velocity = pev->velocity * 0.95; pev->velocity = pev->velocity * 0.95f;
} }
StudioFrameAdvance(); StudioFrameAdvance();
pev->nextthink = gpGlobals->time + 0.1; pev->nextthink = gpGlobals->time + 0.1f;
if (pev->dmgtime - 1 < gpGlobals->time) if (pev->dmgtime - 1 < gpGlobals->time)
{ {
@ -845,13 +841,13 @@ void CGrenade::SG_TumbleThink(void)
if (pev->waterlevel != 0) if (pev->waterlevel != 0)
{ {
pev->velocity = pev->velocity * 0.5; pev->velocity = pev->velocity * 0.5f;
pev->framerate = 0.2; pev->framerate = 0.2f;
} }
} }
/* <b7010> ../cstrike/dlls/ggrenade.cpp:985 */ /* <b7010> ../cstrike/dlls/ggrenade.cpp:985 */
void CGrenade::__MAKE_VHOOK(Spawn)(void) void CGrenade::__MAKE_VHOOK(Spawn)()
{ {
m_iBounceCount = 0; m_iBounceCount = 0;
pev->movetype = MOVETYPE_BOUNCE; pev->movetype = MOVETYPE_BOUNCE;
@ -870,7 +866,7 @@ void CGrenade::__MAKE_VHOOK(Spawn)(void)
SET_MODEL(ENT(pev), "models/grenade.mdl"); SET_MODEL(ENT(pev), "models/grenade.mdl");
UTIL_SetSize(pev, Vector(0, 0, 0), Vector(0, 0, 0)); UTIL_SetSize(pev, Vector(0, 0, 0), Vector(0, 0, 0));
pev->dmg = 30; pev->dmg = 30.0f;
m_fRegisteredSound = FALSE; m_fRegisteredSound = FALSE;
} }
@ -881,7 +877,7 @@ NOXREF CGrenade *CGrenade::ShootContact(entvars_t *pevOwner, Vector vecStart, Ve
pGrenade->Spawn(); pGrenade->Spawn();
// contact grenades arc lower // contact grenades arc lower
pGrenade->pev->gravity = 0.5; // lower gravity since grenade is aerodynamic and engine doesn't know it. pGrenade->pev->gravity = 0.5f; // lower gravity since grenade is aerodynamic and engine doesn't know it.
UTIL_SetOrigin(pGrenade->pev, vecStart); UTIL_SetOrigin(pGrenade->pev, vecStart);
pGrenade->pev->velocity = vecVelocity; pGrenade->pev->velocity = vecVelocity;
@ -920,20 +916,20 @@ CGrenade *CGrenade::ShootTimed2(entvars_t *pevOwner, Vector vecStart, Vector vec
pGrenade->pev->dmgtime = gpGlobals->time + time; pGrenade->pev->dmgtime = gpGlobals->time + time;
pGrenade->SetThink(&CGrenade::TumbleThink); pGrenade->SetThink(&CGrenade::TumbleThink);
pGrenade->pev->nextthink = gpGlobals->time + 0.1; pGrenade->pev->nextthink = gpGlobals->time + 0.1f;
pGrenade->pev->sequence = RANDOM_LONG(3, 6); pGrenade->pev->sequence = RANDOM_LONG(3, 6);
pGrenade->pev->framerate = 1.0; pGrenade->pev->framerate = 1.0f;
pGrenade->m_bJustBlew = true; pGrenade->m_bJustBlew = true;
pGrenade->pev->gravity = 0.55; pGrenade->pev->gravity = 0.55f;
pGrenade->pev->friction = 0.7; pGrenade->pev->friction = 0.7f;
pGrenade->m_iTeam = iTeam; pGrenade->m_iTeam = iTeam;
SET_MODEL(ENT(pGrenade->pev), "models/w_hegrenade.mdl"); SET_MODEL(ENT(pGrenade->pev), "models/w_hegrenade.mdl");
pGrenade->pev->dmg = 100; pGrenade->pev->dmg = 100.0f;
return pGrenade; return pGrenade;
} }
@ -958,24 +954,24 @@ CGrenade *CGrenade::ShootTimed(entvars_t *pevOwner, Vector vecStart, Vector vecV
pGrenade->pev->dmgtime = gpGlobals->time + time; pGrenade->pev->dmgtime = gpGlobals->time + time;
pGrenade->SetThink(&CGrenade::TumbleThink); pGrenade->SetThink(&CGrenade::TumbleThink);
pGrenade->pev->nextthink = gpGlobals->time + 0.1; pGrenade->pev->nextthink = gpGlobals->time + 0.1f;
if (time < 0.1) if (time < 0.1f)
{ {
pGrenade->pev->nextthink = gpGlobals->time; pGrenade->pev->nextthink = gpGlobals->time;
pGrenade->pev->velocity = Vector(0, 0, 0); pGrenade->pev->velocity = Vector(0, 0, 0);
} }
pGrenade->pev->sequence = RANDOM_LONG(3, 6); pGrenade->pev->sequence = RANDOM_LONG(3, 6);
pGrenade->pev->framerate = 1.0; pGrenade->pev->framerate = 1.0f;
pGrenade->m_bJustBlew = true; pGrenade->m_bJustBlew = true;
pGrenade->pev->gravity = 0.5; pGrenade->pev->gravity = 0.5f;
pGrenade->pev->friction = 0.8; pGrenade->pev->friction = 0.8f;
SET_MODEL(ENT(pGrenade->pev), "models/w_flashbang.mdl"); SET_MODEL(ENT(pGrenade->pev), "models/w_flashbang.mdl");
pGrenade->pev->dmg = 35; pGrenade->pev->dmg = 35.0f;
return pGrenade; return pGrenade;
} }
@ -1030,8 +1026,8 @@ void CGrenade::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCaller,
player->m_bIsDefusing = true; player->m_bIsDefusing = true;
m_pBombDefuser = pActivator; m_pBombDefuser = pActivator;
m_bStartDefuse = true; m_bStartDefuse = true;
m_flDefuseCountDown = gpGlobals->time + 5; m_flDefuseCountDown = gpGlobals->time + 5.0f;
m_fNextDefuse = gpGlobals->time + 0.5; m_fNextDefuse = gpGlobals->time + 0.5f;
// start the progress bar // start the progress bar
player->SetProgressBarTime(5); player->SetProgressBarTime(5);
@ -1050,8 +1046,8 @@ void CGrenade::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCaller,
player->m_bIsDefusing = true; player->m_bIsDefusing = true;
m_pBombDefuser = pActivator; m_pBombDefuser = pActivator;
m_bStartDefuse = true; m_bStartDefuse = true;
m_flDefuseCountDown = gpGlobals->time + 10; m_flDefuseCountDown = gpGlobals->time + 10.0f;
m_fNextDefuse = gpGlobals->time + 0.5; m_fNextDefuse = gpGlobals->time + 0.5f;
// start the progress bar // start the progress bar
player->SetProgressBarTime(10); player->SetProgressBarTime(10);
@ -1077,7 +1073,7 @@ CGrenade *CGrenade::ShootSatchelCharge(entvars_t *pevOwner, Vector vecStart, Vec
UTIL_SetSize(pGrenade->pev, Vector(-3, -6, 0), Vector(3, 6, 8)); UTIL_SetSize(pGrenade->pev, Vector(-3, -6, 0), Vector(3, 6, 8));
pGrenade->pev->dmg = 100; pGrenade->pev->dmg = 100.0f;
UTIL_SetOrigin(pGrenade->pev, vecStart); UTIL_SetOrigin(pGrenade->pev, vecStart);
pGrenade->pev->velocity = g_vecZero; pGrenade->pev->velocity = g_vecZero;
pGrenade->pev->angles = vecAngles; pGrenade->pev->angles = vecAngles;
@ -1088,7 +1084,7 @@ CGrenade *CGrenade::ShootSatchelCharge(entvars_t *pevOwner, Vector vecStart, Vec
pGrenade->SetTouch(&CGrenade::C4Touch); pGrenade->SetTouch(&CGrenade::C4Touch);
pGrenade->pev->spawnflags = SF_DETONATE; pGrenade->pev->spawnflags = SF_DETONATE;
pGrenade->pev->nextthink = gpGlobals->time + 0.1; pGrenade->pev->nextthink = gpGlobals->time + 0.1f;
pGrenade->m_flC4Blow = gpGlobals->time + g_pGameRules->m_iC4Timer; pGrenade->m_flC4Blow = gpGlobals->time + g_pGameRules->m_iC4Timer;
pGrenade->m_flNextFreqInterval = (g_pGameRules->m_iC4Timer / 4); pGrenade->m_flNextFreqInterval = (g_pGameRules->m_iC4Timer / 4);
pGrenade->m_flNextFreq = gpGlobals->time; pGrenade->m_flNextFreq = gpGlobals->time;
@ -1096,18 +1092,18 @@ CGrenade *CGrenade::ShootSatchelCharge(entvars_t *pevOwner, Vector vecStart, Vec
pGrenade->m_iCurWave = 0; pGrenade->m_iCurWave = 0;
pGrenade->m_fAttenu = 0; pGrenade->m_fAttenu = 0;
pGrenade->m_sBeepName = NULL; pGrenade->m_sBeepName = NULL;
pGrenade->m_flNextBeep = gpGlobals->time + 0.5; pGrenade->m_flNextBeep = gpGlobals->time + 0.5f;
pGrenade->m_bIsC4 = true; pGrenade->m_bIsC4 = true;
pGrenade->m_fNextDefuse = 0; pGrenade->m_fNextDefuse = 0;
pGrenade->m_bStartDefuse = false; pGrenade->m_bStartDefuse = false;
pGrenade->m_flNextBlink = gpGlobals->time + 2; pGrenade->m_flNextBlink = gpGlobals->time + 2.0f;
pGrenade->pev->friction = 0.9; pGrenade->pev->friction = 0.9f;
pGrenade->m_bJustBlew = false; pGrenade->m_bJustBlew = false;
CBasePlayer *owner = reinterpret_cast<CBasePlayer *>(CBasePlayer::Instance(pevOwner)); CBasePlayer *owner = dynamic_cast<CBasePlayer *>(CBasePlayer::Instance(pevOwner));
if (owner && owner->IsPlayer()) if (owner != NULL && owner->IsPlayer())
{ {
pGrenade->m_pentCurBombTarget = owner->m_pentCurBombTarget; pGrenade->m_pentCurBombTarget = owner->m_pentCurBombTarget;
} }
@ -1133,7 +1129,7 @@ CGrenade *CGrenade::ShootSmokeGrenade(entvars_t *pevOwner, Vector vecStart, Vect
pGrenade->SetTouch(&CGrenade::BounceTouch); pGrenade->SetTouch(&CGrenade::BounceTouch);
pGrenade->pev->dmgtime = gpGlobals->time + time; pGrenade->pev->dmgtime = gpGlobals->time + time;
pGrenade->SetThink(&CGrenade::SG_TumbleThink); pGrenade->SetThink(&CGrenade::SG_TumbleThink);
pGrenade->pev->nextthink = gpGlobals->time + 0.1; pGrenade->pev->nextthink = gpGlobals->time + 0.1f;
if (time < 0.1) if (time < 0.1)
{ {
@ -1142,14 +1138,14 @@ CGrenade *CGrenade::ShootSmokeGrenade(entvars_t *pevOwner, Vector vecStart, Vect
} }
pGrenade->pev->sequence = RANDOM_LONG(3, 6); pGrenade->pev->sequence = RANDOM_LONG(3, 6);
pGrenade->pev->framerate = 1; pGrenade->pev->framerate = 1.0f;
pGrenade->m_bJustBlew = true; pGrenade->m_bJustBlew = true;
pGrenade->pev->gravity = 0.5; pGrenade->pev->gravity = 0.5f;
pGrenade->pev->friction = 0.8; pGrenade->pev->friction = 0.8f;
pGrenade->m_SGSmoke = 0; pGrenade->m_SGSmoke = 0;
SET_MODEL(ENT(pGrenade->pev), "models/w_smokegrenade.mdl"); SET_MODEL(ENT(pGrenade->pev), "models/w_smokegrenade.mdl");
pGrenade->pev->dmg = 35; pGrenade->pev->dmg = 35.0f;
return pGrenade; return pGrenade;
} }
@ -1157,7 +1153,7 @@ CGrenade *CGrenade::ShootSmokeGrenade(entvars_t *pevOwner, Vector vecStart, Vect
/* <b5701> ../cstrike/dlls/ggrenade.cpp:1284 */ /* <b5701> ../cstrike/dlls/ggrenade.cpp:1284 */
void AnnounceFlashInterval(float interval, float offset) void AnnounceFlashInterval(float interval, float offset)
{ {
if (!UTIL_IsGame("czero")) if (!g_bIsCzeroGame)
return; return;
MESSAGE_BEGIN(MSG_ALL, gmsgScenarioIcon); MESSAGE_BEGIN(MSG_ALL, gmsgScenarioIcon);
@ -1170,7 +1166,7 @@ void AnnounceFlashInterval(float interval, float offset)
} }
/* <b855a> ../cstrike/dlls/ggrenade.cpp:1300 */ /* <b855a> ../cstrike/dlls/ggrenade.cpp:1300 */
void CGrenade::C4Think(void) void CGrenade::C4Think()
{ {
if (!IsInWorld()) if (!IsInWorld())
{ {
@ -1178,42 +1174,42 @@ void CGrenade::C4Think(void)
return; return;
} }
pev->nextthink = gpGlobals->time + 0.12; pev->nextthink = gpGlobals->time + 0.12f;
if (gpGlobals->time >= m_flNextFreq) if (gpGlobals->time >= m_flNextFreq)
{ {
m_flNextFreq = gpGlobals->time + m_flNextFreqInterval; m_flNextFreq = gpGlobals->time + m_flNextFreqInterval;
m_flNextFreqInterval *= 0.9; m_flNextFreqInterval *= 0.9f;
switch (m_iCurWave) switch (m_iCurWave)
{ {
case 0: case 0:
m_sBeepName = "weapons/c4_beep1.wav"; m_sBeepName = "weapons/c4_beep1.wav";
m_fAttenu = 1.5; m_fAttenu = 1.5f;
AnnounceFlashInterval(139); AnnounceFlashInterval(139);
break; break;
case 1: case 1:
m_sBeepName = "weapons/c4_beep2.wav"; m_sBeepName = "weapons/c4_beep2.wav";
m_fAttenu = 1.0; m_fAttenu = 1.0f;
AnnounceFlashInterval(69, 10); AnnounceFlashInterval(69, 10);
break; break;
case 2: case 2:
m_sBeepName = "weapons/c4_beep3.wav"; m_sBeepName = "weapons/c4_beep3.wav";
m_fAttenu = 0.8; m_fAttenu = 0.8f;
AnnounceFlashInterval(40); AnnounceFlashInterval(40);
break; break;
case 3: case 3:
m_sBeepName = "weapons/c4_beep4.wav"; m_sBeepName = "weapons/c4_beep4.wav";
m_fAttenu = 0.5; m_fAttenu = 0.5f;
AnnounceFlashInterval(30); AnnounceFlashInterval(30);
break; break;
case 4: case 4:
m_sBeepName = "weapons/c4_beep5.wav"; m_sBeepName = "weapons/c4_beep5.wav";
m_fAttenu = 0.2; m_fAttenu = 0.2f;
AnnounceFlashInterval(20); AnnounceFlashInterval(20);
break; break;
@ -1237,13 +1233,13 @@ void CGrenade::C4Think(void)
if (gpGlobals->time >= m_flNextBlink) if (gpGlobals->time >= m_flNextBlink)
{ {
m_flNextBlink = gpGlobals->time + 2; m_flNextBlink = gpGlobals->time + 2.0f;
MESSAGE_BEGIN(MSG_PVS, SVC_TEMPENTITY, pev->origin); MESSAGE_BEGIN(MSG_PVS, SVC_TEMPENTITY, pev->origin);
WRITE_BYTE(TE_GLOWSPRITE); WRITE_BYTE(TE_GLOWSPRITE);
WRITE_COORD(pev->origin.x); WRITE_COORD(pev->origin.x);
WRITE_COORD(pev->origin.y); WRITE_COORD(pev->origin.y);
WRITE_COORD(pev->origin.z + 5); WRITE_COORD(pev->origin.z + 5.0f);
WRITE_SHORT(g_sModelIndexC4Glow); WRITE_SHORT(g_sModelIndexC4Glow);
WRITE_BYTE(1); WRITE_BYTE(1);
WRITE_BYTE(3); WRITE_BYTE(3);
@ -1273,10 +1269,10 @@ void CGrenade::C4Think(void)
} }
} }
CBasePlayer *pBombOwner = (CBasePlayer *)CBaseEntity::Instance(pev->owner); CBasePlayer *pBombOwner = dynamic_cast<CBasePlayer *>(CBaseEntity::Instance(pev->owner));
if (pBombOwner != NULL) if (pBombOwner != NULL)
{ {
pBombOwner->pev->frags += 3; pBombOwner->pev->frags += 3.0f;
} }
MESSAGE_BEGIN(MSG_ALL, gmsgBombPickup); MESSAGE_BEGIN(MSG_ALL, gmsgBombPickup);
@ -1374,7 +1370,7 @@ void CGrenade::C4Think(void)
g_pGameRules->CheckWinConditions(); g_pGameRules->CheckWinConditions();
// give the defuser credit for defusing the bomb // give the defuser credit for defusing the bomb
m_pBombDefuser->pev->frags += 3; m_pBombDefuser->pev->frags += 3.0f;
MESSAGE_BEGIN(MSG_ALL, gmsgBombPickup); MESSAGE_BEGIN(MSG_ALL, gmsgBombPickup);
MESSAGE_END(); MESSAGE_END();
@ -1445,37 +1441,3 @@ NOXREF void CGrenade::UseSatchelCharges(entvars_t *pevOwner, SATCHELCODE code)
/* <b6ed7> ../cstrike/dlls/ggrenade.cpp:1579 */ /* <b6ed7> ../cstrike/dlls/ggrenade.cpp:1579 */
IMPLEMENT_SAVERESTORE(CGrenade, CBaseMonster); IMPLEMENT_SAVERESTORE(CGrenade, CBaseMonster);
#ifdef HOOK_GAMEDLL
void CGrenade::Spawn(void)
{
Spawn_();
}
int CGrenade::Save(CSave &save)
{
Save_(save);
}
int CGrenade::Restore(CRestore &restore)
{
Restore_(restore);
}
void CGrenade::Killed(entvars_t *pevAttacker, int iGib)
{
Killed_(pevAttacker, iGib);
}
void CGrenade::Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
{
Use_(pActivator, pCaller, useType, value);
}
void CGrenade::BounceSound(void)
{
BounceSound_();
}
#endif // HOOK_GAMEDLL

View File

@ -8,11 +8,6 @@
const Vector g_vecZero = Vector(0, 0, 0); const Vector g_vecZero = Vector(0, 0, 0);
u_long g_ulFrameCount = 0; u_long g_ulFrameCount = 0;
#else // HOOK_GAMEDLL
const Vector g_vecZero;
u_long g_ulFrameCount;
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
int g_Language; int g_Language;
@ -22,3 +17,4 @@ Vector g_vecAttackDir;
int g_iSkillLevel; int g_iSkillLevel;
int gDisplayTitle; int gDisplayTitle;
BOOL g_fGameOver; BOOL g_fGameOver;
bool g_bIsCzeroGame = false;

View File

@ -32,21 +32,6 @@
#pragma once #pragma once
#endif #endif
#ifdef HOOK_GAMEDLL
#define g_vecZero (*pg_vecZero)
#define g_Language (*pg_Language)
#define g_ulFrameCount (*pg_ulFrameCount)
#define g_ulModelIndexEyes (*pg_ulModelIndexEyes)
#define g_vecAttackDir (*pg_vecAttackDir)
#define g_iSkillLevel (*pg_iSkillLevel)
#define gDisplayTitle (*pgDisplayTitle)
#define g_fGameOver (*pg_fGameOver)
#endif // HOOK_GAMEDLL
extern const Vector g_vecZero; extern const Vector g_vecZero;
extern int g_Language; extern int g_Language;
@ -57,5 +42,6 @@ extern Vector g_vecAttackDir;
extern int g_iSkillLevel; extern int g_iSkillLevel;
extern int gDisplayTitle; extern int gDisplayTitle;
extern BOOL g_fGameOver; extern BOOL g_fGameOver;
extern bool g_bIsCzeroGame;
#endif // GLOBALS_H #endif // GLOBALS_H

View File

@ -1,18 +1,7 @@
#include "precompiled.h" #include "precompiled.h"
/*
* Globals initialization
*/
#ifndef HOOK_GAMEDLL
BOOL g_fDrawLines = FALSE; BOOL g_fDrawLines = FALSE;
#else
BOOL g_fDrawLines;
#endif // HOOK_GAMEDLL
/* <c08f4> ../cstrike/dlls/h_ai.cpp:47 */ /* <c08f4> ../cstrike/dlls/h_ai.cpp:47 */
NOXREF BOOL FBoxVisible(entvars_t *pevLooker, entvars_t *pevTarget, Vector &vecTargetOrigin, float flSize) NOXREF BOOL FBoxVisible(entvars_t *pevLooker, entvars_t *pevTarget, Vector &vecTargetOrigin, float flSize)
{ {

View File

@ -14,10 +14,6 @@ TYPEDESCRIPTION CRecharge::m_SaveData[] =
DEFINE_FIELD(CRecharge, m_flSoundTime, FIELD_TIME), DEFINE_FIELD(CRecharge, m_flSoundTime, FIELD_TIME),
}; };
#else
TYPEDESCRIPTION IMPL_CLASS(CRecharge, m_SaveData)[5];
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
/* <c61e2> ../cstrike/dlls/h_battery.cpp:61 */ /* <c61e2> ../cstrike/dlls/h_battery.cpp:61 */
@ -47,7 +43,7 @@ void CRecharge::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
} }
/* <c616f> ../cstrike/dlls/h_battery.cpp:85 */ /* <c616f> ../cstrike/dlls/h_battery.cpp:85 */
void CRecharge::__MAKE_VHOOK(Spawn)(void) void CRecharge::__MAKE_VHOOK(Spawn)()
{ {
Precache(); Precache();
@ -64,7 +60,7 @@ void CRecharge::__MAKE_VHOOK(Spawn)(void)
} }
/* <c6122> ../cstrike/dlls/h_battery.cpp:99 */ /* <c6122> ../cstrike/dlls/h_battery.cpp:99 */
void CRecharge::__MAKE_VHOOK(Precache)(void) void CRecharge::__MAKE_VHOOK(Precache)()
{ {
PRECACHE_SOUND("items/suitcharge1.wav"); PRECACHE_SOUND("items/suitcharge1.wav");
PRECACHE_SOUND("items/suitchargeno1.wav"); PRECACHE_SOUND("items/suitchargeno1.wav");
@ -81,7 +77,7 @@ void CRecharge::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCaller,
// if there is no juice left, turn it off // if there is no juice left, turn it off
if (m_iJuice <= 0) if (m_iJuice <= 0)
{ {
pev->frame = 1; pev->frame = 1.0f;
Off(); Off();
} }
@ -90,14 +86,14 @@ void CRecharge::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCaller,
{ {
if (m_flSoundTime <= gpGlobals->time) if (m_flSoundTime <= gpGlobals->time)
{ {
m_flSoundTime = gpGlobals->time + 0.62; m_flSoundTime = gpGlobals->time + 0.62f;
EMIT_SOUND(ENT(pev), CHAN_ITEM, "items/suitchargeno1.wav", 0.85, ATTN_NORM); EMIT_SOUND(ENT(pev), CHAN_ITEM, "items/suitchargeno1.wav", 0.85, ATTN_NORM);
} }
return; return;
} }
pev->nextthink = pev->ltime + 0.25; pev->nextthink = pev->ltime + 0.25f;
SetThink(&CRecharge::Off); SetThink(&CRecharge::Off);
// Time to recharge yet? // Time to recharge yet?
@ -119,7 +115,7 @@ void CRecharge::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCaller,
{ {
m_iOn++; m_iOn++;
EMIT_SOUND(ENT(pev), CHAN_ITEM, "items/suitchargeok1.wav", 0.85, ATTN_NORM); EMIT_SOUND(ENT(pev), CHAN_ITEM, "items/suitchargeok1.wav", 0.85, ATTN_NORM);
m_flSoundTime = gpGlobals->time + 0.56; m_flSoundTime = gpGlobals->time + 0.56f;
} }
if (m_iOn == 1 && m_flSoundTime <= gpGlobals->time) if (m_iOn == 1 && m_flSoundTime <= gpGlobals->time)
@ -132,26 +128,26 @@ void CRecharge::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCaller,
if (m_hActivator->pev->armorvalue < 100) if (m_hActivator->pev->armorvalue < 100)
{ {
m_iJuice--; m_iJuice--;
m_hActivator->pev->armorvalue += 1; m_hActivator->pev->armorvalue += 1.0f;
if (m_hActivator->pev->armorvalue > 100) if (m_hActivator->pev->armorvalue > 100)
m_hActivator->pev->armorvalue = 100; m_hActivator->pev->armorvalue = 100;
} }
// govern the rate of charge // govern the rate of charge
m_flNextCharge = gpGlobals->time + 0.1; m_flNextCharge = gpGlobals->time + 0.1f;
} }
/* <c6149> ../cstrike/dlls/h_battery.cpp:178 */ /* <c6149> ../cstrike/dlls/h_battery.cpp:178 */
void CRecharge::Recharge(void) void CRecharge::Recharge()
{ {
m_iJuice = gSkillData.suitchargerCapacity; m_iJuice = gSkillData.suitchargerCapacity;
pev->frame = 0; pev->frame = 0;
SetThink(&CRecharge::SUB_DoNothing); SetThink(&CRecharge::SUB_DoNothing);
} }
/* <c622e> ../cstrike/dlls/h_battery.cpp:185 */ /* <c622e> ../cstrike/dlls/h_battery.cpp:185 */
void CRecharge::Off(void) void CRecharge::Off()
{ {
// Stop looping sound. // Stop looping sound.
if (m_iOn > 1) if (m_iOn > 1)
@ -159,7 +155,7 @@ void CRecharge::Off(void)
m_iOn = 0; m_iOn = 0;
if (!m_iJuice && (m_iReactivate = g_pGameRules->FlHEVChargerRechargeTime()) > 0) if (!m_iJuice && (m_iReactivate = g_pGameRules->FlHEVChargerRechargeTime()) > 0)
{ {
pev->nextthink = pev->ltime + m_iReactivate; pev->nextthink = pev->ltime + m_iReactivate;
SetThink(&CRecharge::Recharge); SetThink(&CRecharge::Recharge);
@ -167,37 +163,3 @@ void CRecharge::Off(void)
else else
SetThink(&CRecharge::SUB_DoNothing); SetThink(&CRecharge::SUB_DoNothing);
} }
#ifdef HOOK_GAMEDLL
void CRecharge::Spawn(void)
{
Spawn_();
}
void CRecharge::Precache(void)
{
Precache_();
}
void CRecharge::KeyValue(KeyValueData *pkvd)
{
KeyValue_(pkvd);
}
int CRecharge::Save(CSave &save)
{
return Save_(save);
}
int CRecharge::Restore(CRestore &restore)
{
return Restore_(restore);
}
void CRecharge::Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
{
Use_(pActivator, pCaller, useType, value);
}
#endif // HOOK_GAMEDLL

View File

@ -35,21 +35,18 @@
class CRecharge: public CBaseToggle class CRecharge: public CBaseToggle
{ {
public: public:
virtual void Spawn(void); virtual void Spawn();
virtual void Precache(void); virtual void Precache();
virtual void KeyValue(KeyValueData *pkvd); virtual void KeyValue(KeyValueData *pkvd);
virtual int Save(CSave &save); virtual int Save(CSave &save);
virtual int Restore(CRestore &restore); virtual int Restore(CRestore &restore);
virtual int ObjectCaps(void) virtual int ObjectCaps() { return ((CBaseToggle::ObjectCaps() | FCAP_CONTINUOUS_USE) & ~FCAP_ACROSS_TRANSITION); }
{
return ((CBaseToggle::ObjectCaps() | FCAP_CONTINUOUS_USE) & ~FCAP_ACROSS_TRANSITION);
}
virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value); virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
#ifdef HOOK_GAMEDLL #ifdef HOOK_GAMEDLL
void Spawn_(void); void Spawn_();
void Precache_(void); void Precache_();
void KeyValue_(KeyValueData *pkvd); void KeyValue_(KeyValueData *pkvd);
int Save_(CSave &save); int Save_(CSave &save);
int Restore_(CRestore &restore); int Restore_(CRestore &restore);
@ -58,8 +55,8 @@ public:
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
public: public:
void EXPORT Off(void); void EXPORT Off();
void EXPORT Recharge(void); void EXPORT Recharge();
public: public:
static TYPEDESCRIPTION IMPL(m_SaveData)[5]; static TYPEDESCRIPTION IMPL(m_SaveData)[5];
@ -69,7 +66,6 @@ public:
int m_iJuice; int m_iJuice;
int m_iOn; int m_iOn;
float m_flSoundTime; float m_flSoundTime;
};
};/* size: 332, cachelines: 6, members: 7 */
#endif // H_BATTERY_H #endif // H_BATTERY_H

View File

@ -22,19 +22,13 @@ TYPEDESCRIPTION CWreckage::m_SaveData[] =
DEFINE_FIELD(CWreckage, m_flStartTime, FIELD_TIME), DEFINE_FIELD(CWreckage, m_flStartTime, FIELD_TIME),
}; };
#else
TYPEDESCRIPTION IMPL_CLASS(CCycler, m_SaveData)[1];
TYPEDESCRIPTION IMPL_CLASS(CCyclerSprite, m_SaveData)[3];
TYPEDESCRIPTION IMPL_CLASS(CWreckage, m_SaveData)[1];
#endif // HOOK_GAMEDLL #endif // HOOK_GAMEDLL
/* <cce5f> ../cstrike/dlls/h_cycler.cpp:61 */ /* <cce5f> ../cstrike/dlls/h_cycler.cpp:61 */
IMPLEMENT_SAVERESTORE(CCycler, CBaseToggle); IMPLEMENT_SAVERESTORE(CCycler, CBaseToggle);
/* <cd01f> ../cstrike/dlls/h_cycler.cpp:70 */ /* <cd01f> ../cstrike/dlls/h_cycler.cpp:70 */
void CGenericCycler::__MAKE_VHOOK(Spawn)(void) void CGenericCycler::__MAKE_VHOOK(Spawn)()
{ {
GenericCyclerSpawn((char *)STRING(pev->model), Vector(-16, -16, 0), Vector(16, 16, 72)); GenericCyclerSpawn((char *)STRING(pev->model), Vector(-16, -16, 0), Vector(16, 16, 72));
} }
@ -46,7 +40,7 @@ LINK_ENTITY_TO_CLASS(cycler, CGenericCycler);
LINK_ENTITY_TO_CLASS(cycler_prdroid, CCyclerProbe); LINK_ENTITY_TO_CLASS(cycler_prdroid, CCyclerProbe);
/* <cd16d> ../cstrike/dlls/h_cycler.cpp:86 */ /* <cd16d> ../cstrike/dlls/h_cycler.cpp:86 */
void CCyclerProbe::__MAKE_VHOOK(Spawn)(void) void CCyclerProbe::__MAKE_VHOOK(Spawn)()
{ {
pev->origin = pev->origin + Vector(0, 0, 16); pev->origin = pev->origin + Vector(0, 0, 16);
GenericCyclerSpawn("models/prdroid.mdl", Vector(-16, -16, -16), Vector(16, 16, 16)); GenericCyclerSpawn("models/prdroid.mdl", Vector(-16, -16, -16), Vector(16, 16, 16));
@ -57,7 +51,7 @@ void CCyclerProbe::__MAKE_VHOOK(Spawn)(void)
/* <cd466> ../cstrike/dlls/h_cycler.cpp:96 */ /* <cd466> ../cstrike/dlls/h_cycler.cpp:96 */
void CCycler::GenericCyclerSpawn(char *szModel, Vector vecMin, Vector vecMax) void CCycler::GenericCyclerSpawn(char *szModel, Vector vecMin, Vector vecMax)
{ {
if (!szModel || !*szModel) if (!szModel || !szModel[0])
{ {
ALERT(at_error, "cycler at %.0f %.0f %0.f missing modelname", pev->origin.x, pev->origin.y, pev->origin.z); ALERT(at_error, "cycler at %.0f %.0f %0.f missing modelname", pev->origin.x, pev->origin.y, pev->origin.z);
REMOVE_ENTITY(ENT(pev)); REMOVE_ENTITY(ENT(pev));
@ -81,7 +75,7 @@ void CCycler::GenericCyclerSpawn(char *szModel, Vector vecMin, Vector vecMax)
} }
/* <ccc91> ../cstrike/dlls/h_cycler.cpp:115 */ /* <ccc91> ../cstrike/dlls/h_cycler.cpp:115 */
void CCycler::__MAKE_VHOOK(Spawn)(void) void CCycler::__MAKE_VHOOK(Spawn)()
{ {
InitBoneControllers(); InitBoneControllers();
@ -100,11 +94,11 @@ void CCycler::__MAKE_VHOOK(Spawn)(void)
m_flFrameRate = 75; m_flFrameRate = 75;
m_flGroundSpeed = 0; m_flGroundSpeed = 0;
pev->nextthink += 1.0; pev->nextthink += 1.0f;
ResetSequenceInfo(); ResetSequenceInfo();
if (pev->sequence != 0 || pev->frame != 0) if (pev->sequence != 0 || pev->frame != 0.0f)
{ {
m_animate = 0; m_animate = 0;
pev->framerate = 0; pev->framerate = 0;
@ -118,7 +112,7 @@ void CCycler::__MAKE_VHOOK(Spawn)(void)
// cycler think // cycler think
/* <ccd3e> ../cstrike/dlls/h_cycler.cpp:151 */ /* <ccd3e> ../cstrike/dlls/h_cycler.cpp:151 */
void CCycler::__MAKE_VHOOK(Think)(void) void CCycler::__MAKE_VHOOK(Think)()
{ {
pev->nextthink = gpGlobals->time + 0.1f; pev->nextthink = gpGlobals->time + 0.1f;
@ -132,7 +126,7 @@ void CCycler::__MAKE_VHOOK(Think)(void)
// ResetSequenceInfo(); // ResetSequenceInfo();
// hack to avoid reloading model every frame // hack to avoid reloading model every frame
pev->animtime = gpGlobals->time; pev->animtime = gpGlobals->time;
pev->framerate = 1.0; pev->framerate = 1.0f;
m_fSequenceFinished = FALSE; m_fSequenceFinished = FALSE;
m_flLastEventCheck = gpGlobals->time; m_flLastEventCheck = gpGlobals->time;
pev->frame = 0; pev->frame = 0;
@ -140,7 +134,7 @@ void CCycler::__MAKE_VHOOK(Think)(void)
if (!m_animate) if (!m_animate)
{ {
// FIX: don't reset framerate // FIX: don't reset framerate
pev->framerate = 0.0; pev->framerate = 0.0f;
} }
} }
} }
@ -153,9 +147,9 @@ void CCycler::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCaller, U
m_animate = !m_animate; m_animate = !m_animate;
if (m_animate) if (m_animate)
pev->framerate = 1.0; pev->framerate = 1.0f;
else else
pev->framerate = 0.0; pev->framerate = 0.0f;
} }
// CyclerPain , changes sequences when shot // CyclerPain , changes sequences when shot
@ -195,7 +189,7 @@ LINK_ENTITY_TO_CLASS(cycler_sprite, CCyclerSprite);
IMPLEMENT_SAVERESTORE(CCyclerSprite, CBaseEntity); IMPLEMENT_SAVERESTORE(CCyclerSprite, CBaseEntity);
/* <cc943> ../cstrike/dlls/h_cycler.cpp:258 */ /* <cc943> ../cstrike/dlls/h_cycler.cpp:258 */
void CCyclerSprite::__MAKE_VHOOK(Spawn)(void) void CCyclerSprite::__MAKE_VHOOK(Spawn)()
{ {
pev->solid = SOLID_SLIDEBOX; pev->solid = SOLID_SLIDEBOX;
pev->movetype = MOVETYPE_NONE; pev->movetype = MOVETYPE_NONE;
@ -223,7 +217,7 @@ void CCyclerSprite::__MAKE_VHOOK(Spawn)(void)
} }
/* <cc982> ../cstrike/dlls/h_cycler.cpp:284 */ /* <cc982> ../cstrike/dlls/h_cycler.cpp:284 */
void CCyclerSprite::__MAKE_VHOOK(Restart)(void) void CCyclerSprite::__MAKE_VHOOK(Restart)()
{ {
pev->solid = SOLID_SLIDEBOX; pev->solid = SOLID_SLIDEBOX;
pev->movetype = MOVETYPE_NONE; pev->movetype = MOVETYPE_NONE;
@ -246,7 +240,7 @@ void CCyclerSprite::__MAKE_VHOOK(Restart)(void)
} }
/* <cd0ef> ../cstrike/dlls/h_cycler.cpp:305 */ /* <cd0ef> ../cstrike/dlls/h_cycler.cpp:305 */
void CCyclerSprite::__MAKE_VHOOK(Think)(void) void CCyclerSprite::__MAKE_VHOOK(Think)()
{ {
if (ShouldAnimate()) if (ShouldAnimate())
{ {
@ -290,7 +284,7 @@ void CCyclerSprite::Animate(float frames)
LINK_ENTITY_TO_CLASS(cycler_weapon, CWeaponCycler); LINK_ENTITY_TO_CLASS(cycler_weapon, CWeaponCycler);
/* <ccbf6> ../cstrike/dlls/h_cycler.cpp:361 */ /* <ccbf6> ../cstrike/dlls/h_cycler.cpp:361 */
void CWeaponCycler::__MAKE_VHOOK(Spawn)(void) void CWeaponCycler::__MAKE_VHOOK(Spawn)()
{ {
pev->solid = SOLID_SLIDEBOX; pev->solid = SOLID_SLIDEBOX;
pev->movetype = MOVETYPE_NONE; pev->movetype = MOVETYPE_NONE;
@ -307,10 +301,10 @@ void CWeaponCycler::__MAKE_VHOOK(Spawn)(void)
} }
/* <cca7c> ../cstrike/dlls/h_cycler.cpp:378 */ /* <cca7c> ../cstrike/dlls/h_cycler.cpp:378 */
BOOL CWeaponCycler::__MAKE_VHOOK(Deploy)(void) BOOL CWeaponCycler::__MAKE_VHOOK(Deploy)()
{ {
m_pPlayer->pev->viewmodel = m_iszModel; m_pPlayer->pev->viewmodel = m_iszModel;
m_pPlayer->m_flNextAttack = UTIL_WeaponTimeBase() + 1.0; m_pPlayer->m_flNextAttack = UTIL_WeaponTimeBase() + 1.0f;
SendWeaponAnim(0); SendWeaponAnim(0);
m_iClip = 0; m_iClip = 0;
@ -321,18 +315,18 @@ BOOL CWeaponCycler::__MAKE_VHOOK(Deploy)(void)
/* <ccaa3> ../cstrike/dlls/h_cycler.cpp:388 */ /* <ccaa3> ../cstrike/dlls/h_cycler.cpp:388 */
void CWeaponCycler::__MAKE_VHOOK(Holster)(int skiplocal) void CWeaponCycler::__MAKE_VHOOK(Holster)(int skiplocal)
{ {
m_pPlayer->m_flNextAttack = UTIL_WeaponTimeBase() + 0.5; m_pPlayer->m_flNextAttack = UTIL_WeaponTimeBase() + 0.5f;
} }
/* <ccad8> ../cstrike/dlls/h_cycler.cpp:394 */ /* <ccad8> ../cstrike/dlls/h_cycler.cpp:394 */
void CWeaponCycler::__MAKE_VHOOK(PrimaryAttack)(void) void CWeaponCycler::__MAKE_VHOOK(PrimaryAttack)()
{ {
SendWeaponAnim(pev->sequence); SendWeaponAnim(pev->sequence);
m_flNextPrimaryAttack = gpGlobals->time + 0.3; m_flNextPrimaryAttack = gpGlobals->time + 0.3f;
} }
/* <ccb97> ../cstrike/dlls/h_cycler.cpp:403 */ /* <ccb97> ../cstrike/dlls/h_cycler.cpp:403 */
void CWeaponCycler::__MAKE_VHOOK(SecondaryAttack)(void) void CWeaponCycler::__MAKE_VHOOK(SecondaryAttack)()
{ {
float flFrameRate, flGroundSpeed; float flFrameRate, flGroundSpeed;
@ -349,7 +343,7 @@ void CWeaponCycler::__MAKE_VHOOK(SecondaryAttack)(void)
} }
SendWeaponAnim(pev->sequence); SendWeaponAnim(pev->sequence);
m_flNextSecondaryAttack = gpGlobals->time + 0.3; m_flNextSecondaryAttack = gpGlobals->time + 0.3f;
} }
/* <cce12> ../cstrike/dlls/h_cycler.cpp:443 */ /* <cce12> ../cstrike/dlls/h_cycler.cpp:443 */
@ -359,7 +353,7 @@ IMPLEMENT_SAVERESTORE(CWreckage, CBaseToggle);
LINK_ENTITY_TO_CLASS(cycler_wreckage, CWreckage); LINK_ENTITY_TO_CLASS(cycler_wreckage, CWreckage);
/* <ccaff> ../cstrike/dlls/h_cycler.cpp:448 */ /* <ccaff> ../cstrike/dlls/h_cycler.cpp:448 */
void CWreckage::__MAKE_VHOOK(Spawn)(void) void CWreckage::__MAKE_VHOOK(Spawn)()
{ {
pev->solid = SOLID_NOT; pev->solid = SOLID_NOT;
pev->movetype = MOVETYPE_NONE; pev->movetype = MOVETYPE_NONE;
@ -380,7 +374,7 @@ void CWreckage::__MAKE_VHOOK(Spawn)(void)
} }
/* <ccd07> ../cstrike/dlls/h_cycler.cpp:468 */ /* <ccd07> ../cstrike/dlls/h_cycler.cpp:468 */
void CWreckage::__MAKE_VHOOK(Precache)(void) void CWreckage::__MAKE_VHOOK(Precache)()
{ {
if (!FStringNull(pev->model)) if (!FStringNull(pev->model))
{ {
@ -389,10 +383,10 @@ void CWreckage::__MAKE_VHOOK(Precache)(void)
} }
/* <ccb26> ../cstrike/dlls/h_cycler.cpp:474 */ /* <ccb26> ../cstrike/dlls/h_cycler.cpp:474 */
void CWreckage::__MAKE_VHOOK(Think)(void) void CWreckage::__MAKE_VHOOK(Think)()
{ {
StudioFrameAdvance(); StudioFrameAdvance();
pev->nextthink = gpGlobals->time + 0.2; pev->nextthink = gpGlobals->time + 0.2f;
if (pev->dmgtime) if (pev->dmgtime)
{ {
@ -423,132 +417,3 @@ void CWreckage::__MAKE_VHOOK(Think)(void)
WRITE_BYTE(RANDOM_LONG(0, 3) + 8); // framerate WRITE_BYTE(RANDOM_LONG(0, 3) + 8); // framerate
MESSAGE_END(); MESSAGE_END();
} }
#ifdef HOOK_GAMEDLL
void CWreckage::Spawn(void)
{
Spawn_();
}
void CWreckage::Precache(void)
{
Precache_();
}
int CWreckage::Save(CSave &save)
{
return Save_(save);
}
int CWreckage::Restore(CRestore &restore)
{
return Restore_(restore);
}
void CWreckage::Think(void)
{
Think_();
}
void CWeaponCycler::Spawn(void)
{
Spawn_();
}
BOOL CWeaponCycler::Deploy(void)
{
return Deploy_();
}
void CWeaponCycler::Holster(int skiplocal)
{
Holster_(skiplocal);
}
void CWeaponCycler::PrimaryAttack(void)
{
PrimaryAttack_();
}
void CWeaponCycler::SecondaryAttack(void)
{
SecondaryAttack_();
}
void CCyclerSprite::Spawn(void)
{
Spawn_();
}
void CCyclerSprite::Restart(void)
{
Restart_();
}
int CCyclerSprite::Save(CSave &save)
{
return Save_(save);
}
int CCyclerSprite::Restore(CRestore &restore)
{
return Restore_(restore);
}
int CCyclerSprite::TakeDamage(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType)
{
return TakeDamage_(pevInflictor,pevAttacker,flDamage,bitsDamageType);
}
void CCyclerSprite::Think(void)
{
Think_();
}
void CCyclerSprite::Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
{
Use_(pActivator,pCaller,useType,value);
}
void CCycler::Spawn(void)
{
Spawn_();
}
int CCycler::Save(CSave &save)
{
return Save_(save);
}
int CCycler::Restore(CRestore &restore)
{
return Restore_(restore);
}
int CCycler::TakeDamage(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType)
{
return TakeDamage_(pevInflictor,pevAttacker,flDamage,bitsDamageType);
}
void CCycler::Think(void)
{
Think_();
}
void CCycler::Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
{
Use_(pActivator,pCaller,useType,value);
}
void CGenericCycler::Spawn(void)
{
Spawn_();
}
void CCyclerProbe::Spawn(void)
{
Spawn_();
}
#endif // HOOK_GAMEDLL

Some files were not shown because too many files have changed in this diff Show More