zdoom/raze-gles
0
0
Fork 0
mirror of https://github.com/ZDoom/raze-gles.git synced 2024-12-24 02:30:46 +00:00
Code Issues Projects Releases Packages Wiki Activity

Ball-busting true client-server multiplayer prototype/alpha/whatever

Browse source 
git-svn-id: https://svn.eduke32.com/eduke32@1552 1a8010ca-5511-0410-912e-c29ae57300e0
This commit is contained in:
terminx 2009-12-05 09:22:43 +00:00
parent 0bd458fa42
commit 44575d7e2c
64 changed files with 7858 additions and 2771 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

24
polymer/eduke32/Makefile
View file

@ -51,6 +51,9 @@ endif
JAUDIOLIBDIR=$(SRC)/jaudiolib
JAUDIOLIB=libjfaudiolib.a
ENETDIR=$(SRC)/enet
ENETLIB=libenet.a
CC=gcc
CXX=g++
AS=nasm
@ -73,7 +76,7 @@ endif
OURCFLAGS=$(debug) -W -Wall -Wimplicit -Werror-implicit-function-declaration \
-funsigned-char -fno-strict-aliasing -DNO_GCC_BUILTINS \
-I$(INC) -I$(EINC) -I$(SRC)/jmact -I$(JAUDIOLIBDIR)/include -D_FORTIFY_SOURCE=2 \
-I$(INC) -I$(EINC) -I$(SRC)/jmact -I$(JAUDIOLIBDIR)/include -I$(ENETDIR)/include -D_FORTIFY_SOURCE=2 \
-fjump-tables -fno-stack-protector
# -march=pentium3 -mtune=generic -mmmx -m3dnow -msse -mfpmath=sse
OURCXXFLAGS=-fno-exceptions -fno-rtti
@ -168,6 +171,7 @@ ifeq ($(PLATFORM),WINDOWS)
GAMEOBJS+= $(OBJ)/gameres.$o $(OBJ)/winbits.$o $(OBJ)/startwin.game.$o $(OBJ)/music.$o $(OBJ)/midi.$o $(OBJ)/mpu401.$o
EDITOROBJS+= $(OBJ)/buildres.$o
JAUDIOLIB=libjfaudiolib_win32.a
ENETLIB=libenet_win32.a
else
ifeq ($(RENDERTYPE),SDL)
ifeq (0,$(SDL_FRAMEWORK))
@ -198,7 +202,7 @@ OURCXXFLAGS+= $(BUILDCFLAGS)
ifeq ($(PRETTY_OUTPUT),1)
.SILENT:
endif
.PHONY: clean all engine $(EOBJ)/$(ENGINELIB) $(EOBJ)/$(EDITORLIB) $(JAUDIOLIBDIR)/$(JAUDIOLIB)
.PHONY: clean all engine $(EOBJ)/$(ENGINELIB) $(EOBJ)/$(EDITORLIB) $(JAUDIOLIBDIR)/$(JAUDIOLIB) $(ENETDIR)/$(ENETLIB)
# TARGETS
@ -212,7 +216,7 @@ all:
notice:
$(BUILD_STARTED)
eduke32$(EXESUFFIX): $(GAMEOBJS) $(EOBJ)/$(ENGINELIB) $(JAUDIOLIBDIR)/$(JAUDIOLIB)
eduke32$(EXESUFFIX): $(GAMEOBJS) $(EOBJ)/$(ENGINELIB) $(JAUDIOLIBDIR)/$(JAUDIOLIB) $(ENETDIR)/$(ENETLIB)
$(LINK_STATUS)
if $(CC) -o $@ $^ $(LIBS) $(STDCPPLIB); then $(LINK_OK); else $(LINK_FAILED); fi
ifeq (1,$(RELEASE))
@ -221,7 +225,7 @@ ifeq (1,$(RELEASE))
endif
endif
mapster32$(EXESUFFIX): $(EDITOROBJS) $(EOBJ)/$(EDITORLIB) $(EOBJ)/$(ENGINELIB) $(JAUDIOLIBDIR)/$(JAUDIOLIB)
mapster32$(EXESUFFIX): $(EDITOROBJS) $(EOBJ)/$(EDITORLIB) $(EOBJ)/$(ENGINELIB) $(JAUDIOLIBDIR)/$(JAUDIOLIB) $(ENETDIR)/$(ENETLIB)
$(LINK_STATUS)
if $(CC) $(CFLAGS) $(OURCFLAGS) -o $@ $^ $(LIBS) $(STDCPPLIB); then $(LINK_OK); else $(LINK_FAILED); fi
ifeq (1,$(RELEASE))
@ -268,6 +272,16 @@ ifeq ($(PRETTY_OUTPUT),1)
printf "\033[K\033[0;35mChanging dir to \033[1;35m$(CURDIR)\033[0;35m \033[0m\n"
endif
$(ENETDIR)/$(ENETLIB):
ifeq ($(PRETTY_OUTPUT),1)
printf "\033[K\033[0;35mChanging dir to \033[1;35m$(CURDIR)/$(ENETDIR)\033[0;35m \033[0m\n"
endif
$(MAKE) -C $(ENETDIR) PRETTY_OUTPUT=$(PRETTY_OUTPUT) EROOT=$(EROOT) RELEASE=$(RELEASE) OPTLEVEL=$(OPTLEVEL)
ifeq ($(PRETTY_OUTPUT),1)
printf "\033[K\033[0;35mChanging dir to \033[1;35m$(CURDIR)\033[0;35m \033[0m\n"
endif
# RULES
$(OBJ)/%.$o: $(SRC)/%.nasm
$(COMPILE_STATUS)
@ -309,7 +323,7 @@ $(RSRC)/editor_banner.c: $(RSRC)/build.bmp
# PHONIES
clean:
-rm -f $(OBJ)/* eduke32$(EXESUFFIX) mapster32$(EXESUFFIX) core* duke3d_w32$(EXESUFFIX) && $(MAKE) -C $(JAUDIOLIBDIR) clean
-rm -f $(OBJ)/* eduke32$(EXESUFFIX) mapster32$(EXESUFFIX) core* duke3d_w32$(EXESUFFIX) && $(MAKE) -C $(JAUDIOLIBDIR) clean && $(MAKE) -C $(ENETDIR) clean
veryclean: clean
-rm -f $(EOBJ)/* $(RSRC)/*banner*

14
polymer/eduke32/Makefile.msvc
View file

@ -12,6 +12,9 @@ o=obj
JAUDIOLIBDIR=$(SRC)\jaudiolib
JAUDIOLIB=libjfaudiolib.lib
ENETDIR=$(SRC)\enet
ENETLIB=libenet.lib
ENGINELIB=engine.lib
EDITORLIB=build.lib
@ -37,7 +40,7 @@ AS=ml
LINK=link /nologo /opt:ref
MT=mt
CFLAGS= /MT /J /nologo $(flags_cl) \
/I$(INC) /I$(EINC)\msvc /I$(EINC)\ /I$(SRC)\jmact /I$(JAUDIOLIBDIR)\include /I$(MSSDKROOT)\include" /I$(PLATFORMSDK)\include" \
/I$(INC) /I$(EINC)\msvc /I$(EINC)\ /I$(SRC)\jmact /I$(JAUDIOLIBDIR)\include /I$(ENETDIR)\include /I$(MSSDKROOT)\include" /I$(PLATFORMSDK)\include" \
/D "_CRT_SECURE_NO_DEPRECATE" /W2 $(ENGINEOPTS) \
/I$(DXROOT)\include" /DRENDERTYPEWIN=1
LIBS=user32.lib gdi32.lib shell32.lib dxguid.lib winmm.lib wsock32.lib comctl32.lib \
@ -131,7 +134,7 @@ EDITOROBJS=$(OBJ)\astub.$o \
# TARGETS
all: eduke32$(EXESUFFIX) mapster32$(EXESUFFIX) # duke3d_w32$(EXESUFFIX);
eduke32$(EXESUFFIX): $(GAMEOBJS) $(EOBJ)\$(ENGINELIB) $(JAUDIOLIBDIR)\$(JAUDIOLIB)
eduke32$(EXESUFFIX): $(GAMEOBJS) $(EOBJ)\$(ENGINELIB) $(JAUDIOLIBDIR)\$(JAUDIOLIB) $(ENETDIR)\$(ENETLIB)
$(LINK) /OUT:$@ /SUBSYSTEM:WINDOWS /LIBPATH:$(DXROOT)\lib\x86" /LIBPATH:$(PLATFORMSDK)\lib" /LIBPATH:$(MSSDKROOT)\lib" $(flags_link) /MAP $** $(LIBS)
$(MT) -manifest $(RSRC)\manifest.game.xml -hashupdate -outputresource:$@ -out:$@.manifest
@ -158,11 +161,16 @@ jaudiolib:
nmake /f Makefile.msvc
cd $(MAKEDIR)
enet:
cd $(ENETDIR)
nmake /f Makefile.msvc
cd $(MAKEDIR)
AlwaysBuild: ;
$(EOBJ)\$(EDITORLIB): editorlib ;
$(EOBJ)\$(ENGINELIB): enginelib ;
$(JAUDIOLIBDIR)\$(JAUDIOLIB): jaudiolib ;
$(ENETDIR)\$(ENETLIB): enet ;
# PHONIES
clean:
@ -170,6 +178,8 @@ clean:
*.pdb *.map *.manifest
cd $(JAUDIOLIBDIR)
nmake /f Makefile.msvc clean
cd $(MAKEDIR)\$(ENETDIR)
nmake /f Makefile.msvc clean
cd $(MAKEDIR)
veryclean: clean

2
polymer/eduke32/build/Makefile
View file

@ -127,7 +127,7 @@ ENGINEOBJS+= \
$(OBJ)/textfont.$o \
$(OBJ)/smalltextfont.$o \
$(OBJ)/kplib.$o \
$(OBJ)/fastlz.$o \
$(OBJ)/quicklz.$o \
$(OBJ)/md4.$o \
$(OBJ)/osd.$o \
$(OBJ)/pragmas.$o \

4
polymer/eduke32/build/Makefile.deps
View file

@ -10,14 +10,14 @@ $(OBJ)/config.$o: $(SRC)/config.c $(INC)/compat.h $(INC)/osd.h $(INC)/editor.h
$(OBJ)/crc32.$o: $(SRC)/crc32.c $(INC)/crc32.h
$(OBJ)/defs.$o: $(SRC)/defs.c $(INC)/build.h $(INC)/baselayer.h $(INC)/scriptfile.h $(INC)/compat.h
$(OBJ)/engine.$o: $(SRC)/engine.c $(INC)/compat.h $(INC)/build.h $(INC)/pragmas.h $(INC)/cache1d.h $(INC)/a.h $(INC)/osd.h $(INC)/baselayer.h $(SRC)/engine_priv.h $(INC)/polymost.h $(INC)/hightile.h $(INC)/mdsprite.h $(INC)/polymer.h
$(OBJ)/polymost.$o: $(SRC)/polymost.c $(INC)/md4.h $(INC)/fastlz.h $(INC)/lzwnew.h $(SRC)/engine_priv.h $(INC)/polymost.h $(INC)/hightile.h $(INC)/mdsprite.h
$(OBJ)/polymost.$o: $(SRC)/polymost.c $(INC)/md4.h $(INC)/quicklz.h $(INC)/lzwnew.h $(SRC)/engine_priv.h $(INC)/polymost.h $(INC)/hightile.h $(INC)/mdsprite.h
$(OBJ)/hightile.$o: $(SRC)/hightile.c $(INC)/kplib.h $(INC)/hightile.h
$(OBJ)/mdsprite.$o: $(SRC)/mdsprite.c $(SRC)/engine_priv.h $(INC)/polymost.h $(INC)/hightile.h $(INC)/mdsprite.h
$(OBJ)/textfont.$o: $(SRC)/textfont.c
$(OBJ)/smalltextfont.$o: $(SRC)/smalltextfont.c
$(OBJ)/glbuild.$o: $(SRC)/glbuild.c $(INC)/glbuild.h $(INC)/baselayer.h
$(OBJ)/kplib.$o: $(SRC)/kplib.c $(INC)/compat.h
$(OBJ)/fastlz.$o: $(SRC)/fastlz.c $(INC)/fastlz.h
$(OBJ)/quicklz.$o: $(SRC)/quicklz.c $(INC)/quicklz.h
$(OBJ)/lzwnew.$o: $(SRC)/lzwnew.c
$(OBJ)/md4.$o: $(SRC)/md4.c $(INC)/md4.h $(INC)/compat.h
$(OBJ)/mmulti_unstable.$o: $(SRC)/mmulti_unstable.c $(INC)/mmulti_unstable.h

2
polymer/eduke32/build/Makefile.msvc
View file

@ -72,7 +72,7 @@ ENGINEOBJS= \
$(OBJ)\smalltextfont.$o \
$(OBJ)\glbuild.$o \
$(OBJ)\kplib.$o \
$(OBJ)\fastlz.$o \
$(OBJ)\quicklz.$o \
$(OBJ)\lzwnew.$o \
$(OBJ)\md4.$o \
$(OBJ)\mmulti_unstable.$o \

4
polymer/eduke32/build/Makefile.shared
View file

@ -3,8 +3,8 @@
ENGINELIB=libengine.a
EDITORLIB=libbuild.a
SDLCONFIG = /usr/local/bin/sdl-config
# SDLCONFIG = sdl-config
# SDLCONFIG = /usr/local/bin/sdl-config
SDLCONFIG = sdl-config
ifeq ($(wildcard $(SDLCONFIG)),$(SDLCONFIG))
SDLROOT = /usr/local

2
polymer/eduke32/build/include/build.h
View file

@ -40,7 +40,7 @@ extern "C" {
#define MAXSPRITESONSCREEN 4096
#define MAXUNIQHUDID 256 //Extra slots so HUD models can store animation state without messing game sprites
#define RESERVEDPALS 2 // don't forget to increment this when adding reserved pals
#define RESERVEDPALS 4 // don't forget to increment this when adding reserved pals
#define DETAILPAL (MAXPALOOKUPS - 1)
#define GLOWPAL (MAXPALOOKUPS - 2)
#define SPECULARPAL (MAXPALOOKUPS - 3)

5
polymer/eduke32/build/include/compat.h
View file

@ -36,8 +36,9 @@
#endif
#define USE_ALLOCATOR 1
// #define REPLACE_SYSTEM_ALLOCATOR
#define USE_MAGIC_HEADERS 0
#define USE_MAGIC_HEADERS 1
#define ENABLE_FAST_HEAP_DETECTION 1
#include "nedmalloc.h"
#ifndef TRUE

100
polymer/eduke32/build/include/fastlz.h
View file

@ -1,100 +0,0 @@
/*
FastLZ - lightning-fast lossless compression library
Copyright (C) 2007 Ariya Hidayat (ariya@kde.org)
Copyright (C) 2006 Ariya Hidayat (ariya@kde.org)
Copyright (C) 2005 Ariya Hidayat (ariya@kde.org)
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
#ifndef FASTLZ_H
#define FASTLZ_H
#define FASTLZ_VERSION 0x000100
#define FASTLZ_VERSION_MAJOR 0
#define FASTLZ_VERSION_MINOR 0
#define FASTLZ_VERSION_REVISION 0
#define FASTLZ_VERSION_STRING "0.1.0"
#if defined (__cplusplus)
extern "C" {
#endif
/**
Compress a block of data in the input buffer and returns the size of
compressed block. The size of input buffer is specified by length. The
minimum input buffer size is 16.
The output buffer must be at least 5% larger than the input buffer
and can not be smaller than 66 bytes.
If the input is not compressible, the return value might be larger than
length (input buffer size).
The input buffer and the output buffer can not overlap.
*/
int fastlz_compress(const void* input, int length, void* output);
/**
Decompress a block of compressed data and returns the size of the
decompressed block. If error occurs, e.g. the compressed data is
corrupted or the output buffer is not large enough, then 0 (zero)
will be returned instead.
The input buffer and the output buffer can not overlap.
Decompression is memory safe and guaranteed not to write the output buffer
more than what is specified in maxout.
*/
int fastlz_decompress(const void* input, int length, void* output, int maxout);
/**
Compress a block of data in the input buffer and returns the size of
compressed block. The size of input buffer is specified by length. The
minimum input buffer size is 16.
The output buffer must be at least 5% larger than the input buffer
and can not be smaller than 66 bytes.
If the input is not compressible, the return value might be larger than
length (input buffer size).
The input buffer and the output buffer can not overlap.
Compression level can be specified in parameter level. At the moment,
only level 1 and level 2 are supported.
Level 1 is the fastest compression and generally useful for short data.
Level 2 is slightly slower but it gives better compression ratio.
Note that the compressed data, regardless of the level, can always be
decompressed using the function fastlz_decompress above.
*/
int fastlz_compress_level(int level, const void* input, int length, void* output);
#if defined (__cplusplus)
}
#endif
#endif /* FASTLZ_H */

21
polymer/eduke32/build/include/malloc.c.h
View file

@ -502,7 +502,6 @@ MAX_RELEASE_CHECK_RATE default: 4095 unless not HAVE_MMAP
*/
/* Version identifier to allow people to support multiple versions */
#ifndef DLMALLOC_VERSION
#define DLMALLOC_VERSION 20804
#endif /* DLMALLOC_VERSION */
@ -1543,9 +1542,7 @@ unsigned char _BitScanReverse(unsigned long *index, unsigned long mask);
initialized in init_mparams. Note that the non-zeroness of "magic"
also serves as an initialization flag.
*/
typedef unsigned int flag_t; /* The type of various bit flag sets */
typedef unsigned int flag_t;
struct malloc_params {
volatile size_t magic;
size_t page_size;
@ -1634,16 +1631,14 @@ static void* lastWin32mmap; /* Used as a hint */
#endif /* DEFAULT_GRANULARITY_ALIGNED */
#ifdef ENABLE_LARGE_PAGES
int largepagesavailable = 1;
#ifndef MEM_LARGE_PAGES
#define MEM_LARGE_PAGES 0x20000000
#endif
#endif /* ENABLE_LARGE_PAGES */
static FORCEINLINE void* win32mmap(size_t size) {
void* baseaddress = 0;
void* ptr = 0;
#ifdef ENABLE_LARGE_PAGES
#ifndef MEM_LARGE_PAGES
#define MEM_LARGE_PAGES 0x20000000
#endif
/* Note that large pages are *always* allocated on a large page boundary.
If however granularity is small then don't waste a kernel call if size
isn't around the size of a large page */
@ -1677,7 +1672,11 @@ static FORCEINLINE void* win32mmap(size_t size) {
#endif
}
#if DEBUG
#ifdef ENABLE_LARGE_PAGES
printf("VirtualAlloc returns %p size %u. LargePagesAvailable=%d\n", ptr, size, largepagesavailable);
#else
printf("VirtualAlloc returns %p size %u\n", ptr, size);
#endif
#endif
return (ptr != 0)? ptr: MFAIL;
}
@ -1825,6 +1824,7 @@ static FORCEINLINE int win32munmap(void* ptr, size_t size) {
/* Custom pthread-style spin locks on x86 and x64 for gcc */
struct pthread_mlock_t {
volatile unsigned int l;
char cachelinepadding[64];
unsigned int c;
pthread_t threadid;
};
@ -1836,7 +1836,7 @@ struct pthread_mlock_t {
#define TRY_LOCK(sl) pthread_try_lock(sl)
#define SPINS_PER_YIELD 63
static MLOCK_T malloc_global_mutex = { 0, 0, 0};
static MLOCK_T malloc_global_mutex = { 0, "", 0, 0};
static FORCEINLINE int pthread_acquire_lock (MLOCK_T *sl) {
int spins = 0;
@ -1924,6 +1924,7 @@ static FORCEINLINE int pthread_try_lock (MLOCK_T *sl) {
/* Custom win32-style spin locks on x86 and x64 for MSC */
struct win32_mlock_t {
volatile long l;
char cachelinepadding[64];
unsigned int c;
long threadid;
};

65
polymer/eduke32/build/include/mmultimsgs.h
View file

@ -1,65 +0,0 @@
#ifndef __MMULTIMSGS_H__
#define __MMULTIMSGS_H__
/*
* Ok, so this header file defines the message bytes and outlines the basic
* message descriptions for out-of-band messages that are common to all games
* that utilize my net code. Once a game determines that it is indeed talking
* to another peer of the same genus, the rest is up to the game itself to
* decide, but for basic stuff, the interfaces will be identical.
*
* Why am I not choosing to implement all this engine-side? Because all the
* games are different and about the only thing they are guaranteed to use in
* common that I can be certain of is the services my net code will provide.
* So, since I can't code anything in particular with every Build game in mind,
* I'm putting handling all the game-visible messages into the game's domain.
* The engine will still handle its own internal messages because the game
* never sees them. Ever.
*
* CMDs are messages sent by a peer to another, and RSPs are the replies.
*
* The master of the network game, regardless if the eventual game is talking
* with a peer-to-peer design or not, shall enumerate each peer as it joins
* and the master will always assign itself peer number 0. This simplifies
* things all-round because each peer that joins automatically knows that
* id 0 is its master and it already knows the master's address. Technically
* every other peer who joins may get a sequential number for its id so maybe
* even transmitting the peer unique ids is unnecessary and we'd be easier
* just sending a number of players, but the less craftiness at this point
* in time, the better.
*
* -- Jonathon
*/
#define MSGPROTOVER 0x00
// 0x00 20031209
#define MSG_CMD_GETGAMEINFO 0x10
// char MSG_CMD_GETGAMEINFO
// char MSGPROTOVER
#define MSG_RSP_BADPROTO 0x11
// char MSG_RSP_BADPROTO
#define MSG_RSP_NOGAME 0x12
// char MSG_RSP_NOGAME
// char[8] gamename
#define MSG_RSP_GAMEINFO 0x13
// char MSG_RSP_GAMEINFO
// char[8] gamename eg. DUKE3DSW/DUKE3D\x00\x00/DUKE3DAT
// ... other information particular to the game
#define MSG_CMD_JOINGAME 0x20
// char MSG_CMD_JOINGAME
#define MSG_RSP_GAMEINPROG 0x21
// char MSG_RSP_GAMEINPROG
#define MSG_RSP_JOINACCEPTED 0x22
// char MSG_RSP_JOINACCEPTED
// short uniqueid
// char numtofollow
// short[numtofollow] peeruid
// ... other information particular to the game
#define MSG_RSP_GAMEFULL 0x23
// char MSG_RSP_GAMEFULL
#endif

106
polymer/eduke32/build/include/nedmalloc.h
View file

@ -32,8 +32,10 @@ DEALINGS IN THE SOFTWARE.
/* See malloc.c.h for what each function does.
REPLACE_SYSTEM_ALLOCATOR causes nedalloc's functions to be called malloc,
free etc. instead of nedmalloc, nedfree etc. You may or may not want this.
REPLACE_SYSTEM_ALLOCATOR on POSIX causes nedalloc's functions to be called
malloc, free etc. instead of nedmalloc, nedfree etc. You may or may not want
this. On Windows it causes nedmalloc to patch all loaded DLLs and binaries
to replace usage of the system allocator.
NO_NED_NAMESPACE prevents the functions from being defined in the nedalloc
namespace when in C++ (uses the global namespace instead).
@ -51,25 +53,62 @@ to each block. nedpfree() and nedprealloc() can then automagically know when
to free a system allocated block. Enabling this typically adds 20-50% to
application memory usage.
USE_ALLOCATOR can be one of these settings:
ENABLE_TOLERANT_NEDMALLOC is automatically turned on if REPLACE_SYSTEM_ALLOCATOR
is set or the Windows DLL is being built. This causes nedmalloc to detect when a
system allocator block is passed to it and to handle it appropriately. Note that
without USE_MAGIC_HEADERS there is a very tiny chance that nedmalloc will segfault
on non-Windows builds (it uses Win32 SEH to trap segfaults on Windows and there
is no comparable system on POSIX).
USE_ALLOCATOR can be one of these settings (it defaults to 1):
0: System allocator (nedmalloc now simply acts as a threadcache).
WARNING: Intended for DEBUG USE ONLY - not all functions work correctly.
1: dlmalloc
ENABLE_LARGE_PAGES enables support for requesting memory from the system in large
(typically >=2Mb) pages if the host OS supports this. These occupy just a single
TLB entry and can significantly improve performance in large working set applications.
ENABLE_FAST_HEAP_DETECTION enables special logic to detect blocks allocated
by the system heap. This avoids 1.5%-2% overhead when checking for non-nedmalloc
blocks, but it assumes that the NT and glibc heaps function in a very specific
fashion which may not hold true across OS upgrades.
*/
#include <stddef.h> /* for size_t */
#ifndef NEDMALLOCEXTSPEC
#ifdef NEDMALLOC_DLL_EXPORTS
#define NEDMALLOCEXTSPEC extern __declspec(dllexport)
#ifdef WIN32
#define NEDMALLOCEXTSPEC extern __declspec(dllexport)
#elif defined(__GNUC__)
#define NEDMALLOCEXTSPEC extern __attribute__ ((visibility("default")))
#endif
#ifndef ENABLE_TOLERANT_NEDMALLOC
#define ENABLE_TOLERANT_NEDMALLOC 1
#endif
#else
#define NEDMALLOCEXTSPEC extern
#endif
#endif
#if __STDC_VERSION__ >= 199901L /* C99 or better */
#define RESTRICT restrict
#else
#if defined(_MSC_VER) && _MSC_VER>=1400
#define RESTRICT __restrict
#endif
#ifdef __GNUC__
#define RESTRICT __restrict
#endif
#endif
#ifndef RESTRICT
#define RESTRICT
#endif
#if defined(_MSC_VER) && _MSC_VER>=1400
#define NEDMALLOCPTRATTR __declspec(restrict)
#define NEDMALLOCNOALIASATTR __declspec(noalias)
#endif
#ifdef __GNUC__
#define NEDMALLOCPTRATTR __attribute__ ((malloc))
@ -77,6 +116,9 @@ USE_ALLOCATOR can be one of these settings:
#ifndef NEDMALLOCPTRATTR
#define NEDMALLOCPTRATTR
#endif
#ifndef NEDMALLOCNOALIASATTR
#define NEDMALLOCNOALIASATTR
#endif
#ifndef USE_MAGIC_HEADERS
#define USE_MAGIC_HEADERS 0
@ -94,7 +136,10 @@ USE_ALLOCATOR can be one of these settings:
#if USE_ALLOCATOR==0
#error Cannot combine using the system allocator with replacing the system allocator
#endif
#ifndef _WIN32 /* We have a dedidicated patcher for Windows */
#ifndef ENABLE_TOLERANT_NEDMALLOC
#define ENABLE_TOLERANT_NEDMALLOC 1
#endif
#ifndef WIN32 /* We have a dedicated patcher for Windows */
#define nedmalloc malloc
#define nedcalloc calloc
#define nedrealloc realloc
@ -107,23 +152,30 @@ USE_ALLOCATOR can be one of these settings:
#define nedmalloc_footprint malloc_footprint
#define nedindependent_calloc independent_calloc
#define nedindependent_comalloc independent_comalloc
#ifdef _MSC_VER
#define nedblksize _msize
#endif
#endif
#endif
#ifndef NO_MALLINFO
#define NO_MALLINFO 0
#endif
#if !NO_MALLINFO
#if defined(__cplusplus)
extern "C" {
#endif
struct mallinfo;
struct nedmallinfo {
size_t arena; /* non-mmapped space allocated from system */
size_t ordblks; /* number of free chunks */
size_t smblks; /* always 0 */
size_t hblks; /* always 0 */
size_t hblkhd; /* space in mmapped regions */
size_t usmblks; /* maximum total allocated space */
size_t fsmblks; /* always 0 */
size_t uordblks; /* total allocated space */
size_t fordblks; /* total free space */
size_t keepcost; /* releasable (via malloc_trim) space */
};
#if defined(__cplusplus)
}
#endif
#endif
#if defined(__cplusplus)
#if !defined(NO_NED_NAMESPACE)
@ -139,11 +191,11 @@ extern "C" {
/* These are the global functions */
/* Gets the usable size of an allocated block. Note this will always be bigger than what was
asked for due to rounding etc. Tries to return zero if this is not a nedmalloc block (though
one could see a segfault up to 6.25% of the time). On Win32 SEH is used to guarantee that a
segfault never happens.
asked for due to rounding etc. Optionally returns 1 in isforeign if the block came from the
system allocator - note that there is a small (>0.01%) but real chance of segfault on non-Windows
systems when passing non-nedmalloc blocks if you don't use USE_MAGIC_HEADERS.
*/
NEDMALLOCEXTSPEC size_t nedblksize(void *mem) THROWSPEC;
NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR size_t nedblksize(int *RESTRICT isforeign, void *RESTRICT mem) THROWSPEC;
NEDMALLOCEXTSPEC void nedsetvalue(void *v) THROWSPEC;
@ -152,9 +204,7 @@ NEDMALLOCEXTSPEC NEDMALLOCPTRATTR void * nedcalloc(size_t no, size_t size) THROW
NEDMALLOCEXTSPEC NEDMALLOCPTRATTR void * nedrealloc(void *mem, size_t size) THROWSPEC;
NEDMALLOCEXTSPEC void nedfree(void *mem) THROWSPEC;
NEDMALLOCEXTSPEC NEDMALLOCPTRATTR void * nedmemalign(size_t alignment, size_t bytes) THROWSPEC;
#if !NO_MALLINFO
NEDMALLOCEXTSPEC struct mallinfo nedmallinfo(void) THROWSPEC;
#endif
NEDMALLOCEXTSPEC struct nedmallinfo nedmallinfo(void) THROWSPEC;
NEDMALLOCEXTSPEC int nedmallopt(int parno, int value) THROWSPEC;
NEDMALLOCEXTSPEC void* nedmalloc_internals(size_t *granularity, size_t *magic) THROWSPEC;
NEDMALLOCEXTSPEC int nedmalloc_trim(size_t pad) THROWSPEC;
@ -187,12 +237,20 @@ NEDMALLOCEXTSPEC NEDMALLOCPTRATTR nedpool *nedcreatepool(size_t capacity, int th
*/
NEDMALLOCEXTSPEC void neddestroypool(nedpool *p) THROWSPEC;
/* Returns a zero terminated snapshot of threadpools existing at the time of call. Call
nedfree() on the returned list when you are done. Returns zero if there is only the
system pool in existence.
*/
NEDMALLOCEXTSPEC nedpool **nedpoollist() THROWSPEC;
/* Sets a value to be associated with a pool. You can retrieve this value by passing
any memory block allocated from that pool.
*/
NEDMALLOCEXTSPEC void nedpsetvalue(nedpool *p, void *v) THROWSPEC;
/* Gets a previously set value using nedpsetvalue() or zero if memory is unknown.
Optionally can also retrieve pool.
Optionally can also retrieve pool. You can detect an unknown block by the return
being zero and *p being unmodifed.
*/
NEDMALLOCEXTSPEC void *nedgetvalue(nedpool **p, void *mem) THROWSPEC;
@ -208,14 +266,13 @@ system pool.
*/
NEDMALLOCEXTSPEC void neddisablethreadcache(nedpool *p) THROWSPEC;
NEDMALLOCEXTSPEC NEDMALLOCPTRATTR void * nedpmalloc(nedpool *p, size_t size) THROWSPEC;
NEDMALLOCEXTSPEC NEDMALLOCPTRATTR void * nedpcalloc(nedpool *p, size_t no, size_t size) THROWSPEC;
NEDMALLOCEXTSPEC NEDMALLOCPTRATTR void * nedprealloc(nedpool *p, void *mem, size_t size) THROWSPEC;
NEDMALLOCEXTSPEC void nedpfree(nedpool *p, void *mem) THROWSPEC;
NEDMALLOCEXTSPEC NEDMALLOCPTRATTR void * nedpmemalign(nedpool *p, size_t alignment, size_t bytes) THROWSPEC;
#if !NO_MALLINFO
NEDMALLOCEXTSPEC struct mallinfo nedpmallinfo(nedpool *p) THROWSPEC;
#endif
NEDMALLOCEXTSPEC struct nedmallinfo nedpmallinfo(nedpool *p) THROWSPEC;
NEDMALLOCEXTSPEC int nedpmallopt(nedpool *p, int parno, int value) THROWSPEC;
NEDMALLOCEXTSPEC int nedpmalloc_trim(nedpool *p, size_t pad) THROWSPEC;
NEDMALLOCEXTSPEC void nedpmalloc_stats(nedpool *p) THROWSPEC;
@ -223,6 +280,7 @@ NEDMALLOCEXTSPEC size_t nedpmalloc_footprint(nedpool *p) THROWSPEC;
NEDMALLOCEXTSPEC NEDMALLOCPTRATTR void **nedpindependent_calloc(nedpool *p, size_t elemsno, size_t elemsize, void **chunks) THROWSPEC;
NEDMALLOCEXTSPEC NEDMALLOCPTRATTR void **nedpindependent_comalloc(nedpool *p, size_t elems, size_t *sizes, void **chunks) THROWSPEC;
NEDMALLOCEXTSPEC NEDMALLOCPTRATTR char * nedstrdup(const char *str) THROWSPEC;
#if defined(__cplusplus)
}
#endif

150
polymer/eduke32/build/include/quicklz.h Normal file
View file

@ -0,0 +1,150 @@
#ifndef QLZ_HEADER
#define QLZ_HEADER
// Fast data compression library
// Copyright (C) 2006-2009 Lasse Mikkel Reinhold
// lar@quicklz.com
//
// QuickLZ can be used for free under the GPL-1 or GPL-2 license (where anything
// released into public must be open source) or under a commercial license if such
// has been acquired (see http://www.quicklz.com/order.html). The commercial license
// does not cover derived or ported versions created by third parties under GPL.
// You can edit following user settings. Data must be decompressed with the same
// setting of QLZ_COMPRESSION_LEVEL and QLZ_STREAMING_BUFFER as it was compressed
// (see manual). If QLZ_STREAMING_BUFFER > 0, scratch buffers must be initially
// zeroed out (see manual). First #ifndef makes it possible to define settings from
// the outside like the compiler command line.
// BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION
// BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION
// BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION
// BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION
// BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION
// 1.5.0 BETA 2
#ifndef QLZ_COMPRESSION_LEVEL
#define QLZ_COMPRESSION_LEVEL 1
//#define QLZ_COMPRESSION_LEVEL 2
//#define QLZ_COMPRESSION_LEVEL 3
#define QLZ_STREAMING_BUFFER 0
//#define QLZ_STREAMING_BUFFER 100000
//#define QLZ_STREAMING_BUFFER 1000000
//#define QLZ_MEMORY_SAFE
#endif
#define QLZ_VERSION_MAJOR 1
#define QLZ_VERSION_MINOR 5
#define QLZ_VERSION_REVISION 0
// Using size_t, memset() and memcpy()
#include <string.h>
// Verify compression level
#if QLZ_COMPRESSION_LEVEL != 1 && QLZ_COMPRESSION_LEVEL != 2 && QLZ_COMPRESSION_LEVEL != 3
#error QLZ_COMPRESSION_LEVEL must be 1, 2 or 3
#endif
typedef unsigned int ui32;
typedef unsigned short int ui16;
// Decrease QLZ_POINTERS for level 3 to increase compression speed. Do not touch any other values!
#if QLZ_COMPRESSION_LEVEL == 1
#define QLZ_POINTERS 1
#define QLZ_HASH_VALUES 4096
#elif QLZ_COMPRESSION_LEVEL == 2
#define QLZ_POINTERS 4
#define QLZ_HASH_VALUES 2048
#elif QLZ_COMPRESSION_LEVEL == 3
#define QLZ_POINTERS 16
#define QLZ_HASH_VALUES 4096
#endif
// Detect if pointer size is 64-bit. It's not fatal if some 64-bit target is not detected because this is only for adding an optional 64-bit optimization.
#if defined _LP64 || defined __LP64__ || defined __64BIT__ || _ADDR64 || defined _WIN64 || defined __arch64__ || __WORDSIZE == 64 || (defined __sparc && defined __sparcv9) || defined __x86_64 || defined __amd64 || defined __x86_64__ || defined _M_X64 || defined _M_IA64 || defined __ia64 || defined __IA64__
#define QLZ_PTR_64
#endif
// hash entry
typedef struct
{
#if QLZ_COMPRESSION_LEVEL == 1
ui32 cache;
#if defined QLZ_PTR_64 && QLZ_STREAMING_BUFFER == 0
unsigned int offset;
#else
const unsigned char *offset;
#endif
#else
const unsigned char *offset[QLZ_POINTERS];
#endif
} qlz_hash_compress;
typedef struct
{
#if QLZ_COMPRESSION_LEVEL == 1
const unsigned char *offset;
#else
const unsigned char *offset[QLZ_POINTERS];
#endif
} qlz_hash_decompress;
// states
typedef struct
{
#if QLZ_STREAMING_BUFFER > 0
unsigned char stream_buffer[QLZ_STREAMING_BUFFER];
#endif
size_t stream_counter;
qlz_hash_compress hash[QLZ_HASH_VALUES];
unsigned char hash_counter[QLZ_HASH_VALUES];
} qlz_state_compress;
#if QLZ_COMPRESSION_LEVEL == 1 || QLZ_COMPRESSION_LEVEL == 2
typedef struct
{
#if QLZ_STREAMING_BUFFER > 0
unsigned char stream_buffer[QLZ_STREAMING_BUFFER];
#endif
qlz_hash_decompress hash[QLZ_HASH_VALUES];
unsigned char hash_counter[QLZ_HASH_VALUES];
size_t stream_counter;
} qlz_state_decompress;
#elif QLZ_COMPRESSION_LEVEL == 3
typedef struct
{
#if QLZ_STREAMING_BUFFER > 0
unsigned char stream_buffer[QLZ_STREAMING_BUFFER];
#endif
qlz_hash_decompress hash[QLZ_HASH_VALUES];
size_t stream_counter;
} qlz_state_decompress;
#endif
#if defined (__cplusplus)
extern "C" {
#endif
// Public functions of QuickLZ
size_t qlz_size_decompressed(const char *source);
size_t qlz_size_compressed(const char *source);
size_t qlz_compress(const void *source, char *destination, size_t size, qlz_state_compress *state);
size_t qlz_decompress(const char *source, void *destination, qlz_state_decompress *state);
int qlz_get_setting(int setting);
extern qlz_state_compress *state_compress;
extern qlz_state_decompress *state_decompress;
#if defined (__cplusplus)
}
#endif
#endif

6
polymer/eduke32/build/src/defs.c
View file

@ -11,7 +11,7 @@
#include "scriptfile.h"
#include "cache1d.h"
#include "kplib.h"
#include "fastlz.h"
#include "quicklz.h"
enum
{
@ -677,7 +677,7 @@ static int32_t defsparser(scriptfile *script)
tilesizx[tile] = xsiz;
tilesizy[tile] = ysiz;
faketilesiz[tile] = fastlz_compress(ftd, xsiz*ysiz, faketiledata[tile]);
faketilesiz[tile] = qlz_compress(ftd, faketiledata[tile], xsiz*ysiz, state_compress);
xoffset = clamp(xoffset, -128, 127);
picanm[tile] = (picanm[tile]&0xffff00ff)+((xoffset&255)<<8);
@ -728,7 +728,7 @@ static int32_t defsparser(scriptfile *script)
{
tilesizx[tile] = xsiz;
tilesizy[tile] = ysiz;
faketilesiz[tile] = fastlz_compress(ftd, xsiz*ysiz, faketiledata[tile]);
faketilesiz[tile] = qlz_compress(ftd, faketiledata[tile], xsiz*ysiz, state_compress);
picanm[tile] = 0;
j = 15; while ((j > 1) && (pow2long[j] > xsiz)) j--;

13
polymer/eduke32/build/src/engine.c
View file

@ -17,7 +17,7 @@
#include "a.h"
#include "osd.h"
#include "crc32.h"
#include "fastlz.h"
#include "quicklz.h"
#include "baselayer.h"
#include "scriptfile.h"
@ -132,6 +132,9 @@ int32_t circlewall=-1;
char cachedebug = 0;
qlz_state_compress *state_compress = NULL;
qlz_state_decompress *state_decompress = NULL;
#if defined(_MSC_VER) && !defined(NOASM)
//
@ -5493,6 +5496,9 @@ int32_t preinitengine(void)
// this shite is to help get around data segment size limits on some platforms
state_compress = (qlz_state_compress *)Bmalloc(sizeof(qlz_state_compress));
state_decompress = (qlz_state_decompress *)Bmalloc(sizeof(qlz_state_decompress));
#ifdef DYNALLOC_ARRAYS
sector = Bcalloc(MAXSECTORS,sizeof(sectortype));
wall = Bcalloc(MAXWALLS,sizeof(walltype));
@ -5657,6 +5663,9 @@ void uninitengine(void)
if (spritesmooth != NULL)
Bfree(spritesmooth);
#endif
if (state_compress) Bfree(state_compress);
if (state_decompress) Bfree(state_decompress);
}
@ -7967,7 +7976,7 @@ void loadtile(int16_t tilenume)
if (faketilesiz[tilenume] == -1)
Bmemset((char *)waloff[tilenume],0,dasiz);
else if (faketiledata[tilenume] != NULL)
fastlz_decompress(faketiledata[tilenume], faketilesiz[tilenume], (char *)waloff[tilenume], dasiz);
qlz_decompress(faketiledata[tilenume], (char *)waloff[tilenume], state_decompress);
faketimerhandler();
return;
}

551
polymer/eduke32/build/src/fastlz.c
View file

@ -1,551 +0,0 @@
/*
FastLZ - lightning-fast lossless compression library
Copyright (C) 2007 Ariya Hidayat (ariya@kde.org)
Copyright (C) 2006 Ariya Hidayat (ariya@kde.org)
Copyright (C) 2005 Ariya Hidayat (ariya@kde.org)
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
#if !defined(FASTLZ__COMPRESSOR) && !defined(FASTLZ_DECOMPRESSOR)
/*
* Always check for bound when decompressing.
* Generally it is best to leave it defined.
*/
#define FASTLZ_SAFE
/*
* Give hints to the compiler for branch prediction optimization.
*/
#if defined(__GNUC__) && (__GNUC__ > 2)
#define FASTLZ_EXPECT_CONDITIONAL(c) (__builtin_expect((c), 1))
#define FASTLZ_UNEXPECT_CONDITIONAL(c) (__builtin_expect((c), 0))
#else
#define FASTLZ_EXPECT_CONDITIONAL(c) (c)
#define FASTLZ_UNEXPECT_CONDITIONAL(c) (c)
#endif
/*
* Use inlined functions for supported systems.
*/
#if defined(__GNUC__) || defined(__DMC__) || defined(__POCC__) || defined(__WATCOMC__) || defined(__SUNPRO_C)
#define FASTLZ_INLINE inline
#elif defined(__BORLANDC__) || defined(_MSC_VER) || defined(__LCC__)
#define FASTLZ_INLINE __inline
#else
#define FASTLZ_INLINE
#endif
/*
* Prevent accessing more than 8-bit at once, except on x86 architectures.
*/
#if !defined(FASTLZ_STRICT_ALIGN)
#define FASTLZ_STRICT_ALIGN
#if defined(__i386__) || defined(__386) /* GNU C, Sun Studio */
#undef FASTLZ_STRICT_ALIGN
#elif defined(__i486__) || defined(__i586__) || defined(__i686__) /* GNU C */
#undef FASTLZ_STRICT_ALIGN
#elif defined(_M_IX86) /* Intel, MSVC */
#undef FASTLZ_STRICT_ALIGN
#elif defined(__386)
#undef FASTLZ_STRICT_ALIGN
#elif defined(_X86_) /* MinGW */
#undef FASTLZ_STRICT_ALIGN
#elif defined(__I86__) /* Digital Mars */
#undef FASTLZ_STRICT_ALIGN
#endif
#endif
/*
* FIXME: use preprocessor magic to set this on different platforms!
*/
typedef unsigned char flzuint8;
typedef unsigned short flzuint16;
typedef unsigned int flzuint32;
/* prototypes */
int fastlz_compress(const void* input, int length, void* output);
int fastlz_compress_level(int level, const void* input, int length, void* output);
int fastlz_decompress(const void* input, int length, void* output, int maxout);
#define MAX_COPY 32
#define MAX_LEN 264 /* 256 + 8 */
#define MAX_DISTANCE 8192
#if !defined(FASTLZ_STRICT_ALIGN)
#define FASTLZ_READU16(p) *((const flzuint16*)(p))
#else
#define FASTLZ_READU16(p) ((p)[0] | (p)[1]<<8)
#endif
#define HASH_LOG 13
#define HASH_SIZE (1<< HASH_LOG)
#define HASH_MASK (HASH_SIZE-1)
#define HASH_FUNCTION(v,p) { v = FASTLZ_READU16(p); v ^= FASTLZ_READU16(p+1)^(v>>(16-HASH_LOG));v &= HASH_MASK; }
#undef FASTLZ_LEVEL
#define FASTLZ_LEVEL 1
#undef FASTLZ_COMPRESSOR
#undef FASTLZ_DECOMPRESSOR
#define FASTLZ_COMPRESSOR fastlz1_compress
#define FASTLZ_DECOMPRESSOR fastlz1_decompress
static FASTLZ_INLINE int FASTLZ_COMPRESSOR(const void* input, int length, void* output);
static FASTLZ_INLINE int FASTLZ_DECOMPRESSOR(const void* input, int length, void* output, int maxout);
#include "fastlz.c"
#undef FASTLZ_LEVEL
#define FASTLZ_LEVEL 2
#undef MAX_DISTANCE
#define MAX_DISTANCE 8191
#define MAX_FARDISTANCE (65535+MAX_DISTANCE-1)
#undef FASTLZ_COMPRESSOR
#undef FASTLZ_DECOMPRESSOR
#define FASTLZ_COMPRESSOR fastlz2_compress
#define FASTLZ_DECOMPRESSOR fastlz2_decompress
static FASTLZ_INLINE int FASTLZ_COMPRESSOR(const void* input, int length, void* output);
static FASTLZ_INLINE int FASTLZ_DECOMPRESSOR(const void* input, int length, void* output, int maxout);
#include "fastlz.c"
int fastlz_compress(const void* input, int length, void* output)
{
/* for short block, choose fastlz1 */
if(length < 65536)
return fastlz1_compress(input, length, output);
/* else... */
return fastlz2_compress(input, length, output);
}
int fastlz_decompress(const void* input, int length, void* output, int maxout)
{
/* magic identifier for compression level */
int level = ((*(const flzuint8*)input) >> 5) + 1;
if(level == 1)
return fastlz1_decompress(input, length, output, maxout);
if(level == 2)
return fastlz2_decompress(input, length, output, maxout);
/* unknown level, trigger error */
return 0;
}
int fastlz_compress_level(int level, const void* input, int length, void* output)
{
if(level == 1)
return fastlz1_compress(input, length, output);
if(level == 2)
return fastlz2_compress(input, length, output);
return 0;
}
#else /* !defined(FASTLZ_COMPRESSOR) && !defined(FASTLZ_DECOMPRESSOR) */
static FASTLZ_INLINE int FASTLZ_COMPRESSOR(const void* input, int length, void* output)
{
const flzuint8* ip = (const flzuint8*) input;
const flzuint8* ip_bound = ip + length - 2;
const flzuint8* ip_limit = ip + length - 12;
flzuint8* op = (flzuint8*) output;
const flzuint8* htab[HASH_SIZE];
const flzuint8** hslot;
flzuint32 hval;
flzuint32 copy;
/* sanity check */
if(FASTLZ_UNEXPECT_CONDITIONAL(length < 4))
{
if(length)
{
/* create literal copy only */
*op++ = length-1;
ip_bound++;
while(ip <= ip_bound)
*op++ = *ip++;
return length+1;
}
else
return 0;
}
/* initializes hash table */
for (hslot = htab; hslot < htab + HASH_SIZE; hslot++)
*hslot = ip;
/* we start with literal copy */
copy = 2;
*op++ = MAX_COPY-1;
*op++ = *ip++;
*op++ = *ip++;
/* main loop */
while(FASTLZ_EXPECT_CONDITIONAL(ip < ip_limit))
{
const flzuint8* ref;
flzuint32 distance;
/* minimum match length */
flzuint32 len = 3;
/* comparison starting-point */
const flzuint8* anchor = ip;
/* check for a run */
#if FASTLZ_LEVEL==2
if(ip[0] == ip[-1] && FASTLZ_READU16(ip-1)==FASTLZ_READU16(ip+1))
{
distance = 1;
ip += 3;
ref = anchor - 1 + 3;
goto match;
}
#endif
/* find potential match */
HASH_FUNCTION(hval,ip);
hslot = htab + hval;
ref = htab[hval];
/* calculate distance to the match */
distance = anchor - ref;
/* update hash table */
*hslot = anchor;
/* is this a match? check the first 3 bytes */
if(distance==0 ||
#if FASTLZ_LEVEL==1
(distance >= MAX_DISTANCE) ||
#else
(distance >= MAX_FARDISTANCE) ||
#endif
*ref++ != *ip++ || *ref++!=*ip++ || *ref++!=*ip++)
goto literal;
#if FASTLZ_LEVEL==2
/* far, needs at least 5-byte match */
if(distance >= MAX_DISTANCE)
{
if(*ip++ != *ref++ || *ip++!= *ref++)
goto literal;
len += 2;
}
match:
#endif
/* last matched byte */
ip = anchor + len;
/* distance is biased */
distance--;
if(!distance)
{
/* zero distance means a run */
flzuint8 x = ip[-1];
while(ip < ip_bound)
if(*ref++ != x) break; else ip++;
}
else
for(;;)
{
/* safe because the outer check against ip limit */
if(*ref++ != *ip++) break;
if(*ref++ != *ip++) break;
if(*ref++ != *ip++) break;
if(*ref++ != *ip++) break;
if(*ref++ != *ip++) break;
if(*ref++ != *ip++) break;
if(*ref++ != *ip++) break;
if(*ref++ != *ip++) break;
while(ip < ip_bound)
if(*ref++ != *ip++) break;
break;
}
/* if we have copied something, adjust the copy count */
if(copy)
/* copy is biased, '0' means 1 byte copy */
*(op-copy-1) = copy-1;
else
/* back, to overwrite the copy count */
op--;
/* reset literal counter */
copy = 0;
/* length is biased, '1' means a match of 3 bytes */
ip -= 3;
len = ip - anchor;
/* encode the match */
#if FASTLZ_LEVEL==2
if(distance < MAX_DISTANCE)
{
if(len < 7)
{
*op++ = (len << 5) + (distance >> 8);
*op++ = (distance & 255);
}
else
{
*op++ = (7 << 5) + (distance >> 8);
for(len-=7; len >= 255; len-= 255)
*op++ = 255;
*op++ = len;
*op++ = (distance & 255);
}
}
else
{
/* far away, but not yet in the another galaxy... */
if(len < 7)
{
distance -= MAX_DISTANCE;
*op++ = (len << 5) + 31;
*op++ = 255;
*op++ = distance >> 8;
*op++ = distance & 255;
}
else
{
distance -= MAX_DISTANCE;
*op++ = (7 << 5) + 31;
for(len-=7; len >= 255; len-= 255)
*op++ = 255;
*op++ = len;
*op++ = 255;
*op++ = distance >> 8;
*op++ = distance & 255;
}
}
#else
if(FASTLZ_UNEXPECT_CONDITIONAL(len > MAX_LEN-2))
while(len > MAX_LEN-2)
{
*op++ = (7 << 5) + (distance >> 8);
*op++ = MAX_LEN - 2 - 7 -2;
*op++ = (distance & 255);
len -= MAX_LEN-2;
}
if(len < 7)
{
*op++ = (len << 5) + (distance >> 8);
*op++ = (distance & 255);
}
else
{
*op++ = (7 << 5) + (distance >> 8);
*op++ = len - 7;
*op++ = (distance & 255);
}
#endif
/* update the hash at match boundary */
HASH_FUNCTION(hval,ip);
htab[hval] = ip++;
HASH_FUNCTION(hval,ip);
htab[hval] = ip++;
/* assuming literal copy */
*op++ = MAX_COPY-1;
continue;
literal:
*op++ = *anchor++;
ip = anchor;
copy++;
if(FASTLZ_UNEXPECT_CONDITIONAL(copy == MAX_COPY))
{
copy = 0;
*op++ = MAX_COPY-1;
}
}
/* left-over as literal copy */
ip_bound++;
while(ip <= ip_bound)
{
*op++ = *ip++;
copy++;
if(copy == MAX_COPY)
{
copy = 0;
*op++ = MAX_COPY-1;
}
}
/* if we have copied something, adjust the copy length */
if(copy)
*(op-copy-1) = copy-1;
else
op--;
#if FASTLZ_LEVEL==2
/* marker for fastlz2 */
*(flzuint8*)output |= (1 << 5);
#endif
return op - (flzuint8*)output;
}
static FASTLZ_INLINE int FASTLZ_DECOMPRESSOR(const void* input, int length, void* output, int maxout)
{
const flzuint8* ip = (const flzuint8*) input;
const flzuint8* ip_limit = ip + length;
flzuint8* op = (flzuint8*) output;
flzuint8* op_limit = op + maxout;
flzuint32 ctrl = (*ip++) & 31;
int loop = 1;
do
{
const flzuint8* ref = op;
flzuint32 len = ctrl >> 5;
flzuint32 ofs = (ctrl & 31) << 8;
if(ctrl >= 32)
{
#if FASTLZ_LEVEL==2
flzuint8 code;
#endif
len--;
ref -= ofs;
if (len == 7-1)
#if FASTLZ_LEVEL==1
len += *ip++;
ref -= *ip++;
#else
do
{
code = *ip++;
len += code;
} while (code==255);
code = *ip++;
ref -= code;
/* match from 16-bit distance */
if(FASTLZ_UNEXPECT_CONDITIONAL(code==255))
if(FASTLZ_EXPECT_CONDITIONAL(ofs==(31 << 8)))
{
ofs = (*ip++) << 8;
ofs += *ip++;
ref = op - ofs - MAX_DISTANCE;
}
#endif
#ifdef FASTLZ_SAFE
if (FASTLZ_UNEXPECT_CONDITIONAL(op + len + 3 > op_limit))
return 0;
if (FASTLZ_UNEXPECT_CONDITIONAL(ref-1 < (flzuint8 *)output))
return 0;
#endif
if(FASTLZ_EXPECT_CONDITIONAL(ip < ip_limit))
ctrl = *ip++;
else
loop = 0;
if(ref == op)
{
/* optimize copy for a run */
flzuint8 b = ref[-1];
*op++ = b;
*op++ = b;
*op++ = b;
for(; len; --len)
*op++ = b;
}
else
{
#if !defined(FASTLZ_STRICT_ALIGN)
const flzuint16* p;
flzuint16* q;
#endif
/* copy from reference */
ref--;
*op++ = *ref++;
*op++ = *ref++;
*op++ = *ref++;
#if !defined(FASTLZ_STRICT_ALIGN)
/* copy a byte, so that now it's word aligned */
if(len & 1)
{
*op++ = *ref++;
len--;
}
/* copy 16-bit at once */
q = (flzuint16*) op;
op += len;
p = (const flzuint16*) ref;
for(len>>=1; len > 4; len-=4)
{
*q++ = *p++;
*q++ = *p++;
*q++ = *p++;
*q++ = *p++;
}
for(; len; --len)
*q++ = *p++;
#else
for(; len; --len)
*op++ = *ref++;
#endif
}
}
else
{
ctrl++;
#ifdef FASTLZ_SAFE
if (FASTLZ_UNEXPECT_CONDITIONAL(op + ctrl > op_limit))
return 0;
if (FASTLZ_UNEXPECT_CONDITIONAL(ip + ctrl > ip_limit))
return 0;
#endif
*op++ = *ip++;
for(--ctrl; ctrl; ctrl--)
*op++ = *ip++;
loop = FASTLZ_EXPECT_CONDITIONAL(ip < ip_limit);
if(loop)
ctrl = *ip++;
}
}
while(FASTLZ_EXPECT_CONDITIONAL(loop));
return op - (flzuint8*)output;
}
#endif /* !defined(FASTLZ_COMPRESSOR) && !defined(FASTLZ_DECOMPRESSOR) */

29
polymer/eduke32/build/src/hightile.c
View file

@ -22,26 +22,23 @@ char hicfirstinit = 0;
//
hicreplctyp * hicfindsubst(int32_t picnum, int32_t palnum, int32_t skybox)
{
hicreplctyp *hr;
if (!hicfirstinit) return NULL;
if ((uint32_t)picnum >= (uint32_t)MAXTILES) return NULL;
if (!hicfirstinit || (uint32_t)picnum >= (uint32_t)MAXTILES) return NULL;
do
{
for (hr = hicreplc[picnum]; hr; hr = hr->next)
if (skybox)
{
if (hr->palnum == palnum)
{
if (skybox)
{
if (hr->skybox && !hr->skybox->ignore) return hr;
}
else
{
if (!hr->ignore) return hr;
}
}
hicreplctyp *hr = hicreplc[picnum];
for (; hr; hr = hr->next)
if (hr->palnum == palnum && hr->skybox && !hr->skybox->ignore)
return hr;
}
else
{
hicreplctyp *hr = hicreplc[picnum];
for (; hr; hr = hr->next)
if (hr->palnum == palnum && !hr->ignore)
return hr;
}
if (!palnum || palnum >= (MAXPALOOKUPS - RESERVEDPALS)) break;

553
polymer/eduke32/build/src/nedmalloc.c
View file

@ -35,20 +35,25 @@ DEALINGS IN THE SOFTWARE.
#pragma warning(disable:4706) /* assignment within conditional expression */
#endif
/*#define FULLSANITYCHECKS*/
#define USE_ALLOCATOR 1
// #define REPLACE_SYSTEM_ALLOCATOR
#define USE_MAGIC_HEADERS 0
#define USE_MAGIC_HEADERS 1
#define MAXTHREADSINPOOL 1
#define FINEGRAINEDBINS 1
#define ENABLE_LARGE_PAGES
#define ENABLE_LARGE_PAGES 1
#define ENABLE_FAST_HEAP_DETECTION 1
#ifndef UNREFERENCED_PARAMETER
#define UNREFERENCED_PARAMETER(x) x=x
/*#define ENABLE_TOLERANT_NEDMALLOC 1*/
/*#define ENABLE_FAST_HEAP_DETECTION 1*/
/*#define FULLSANITYCHECKS*/
/* If link time code generation is on, don't force or prevent inlining */
#if defined(_MSC_VER) && defined(NEDMALLOC_DLL_EXPORTS)
#define FORCEINLINE
#define NOINLINE
#endif
#include "nedmalloc.h"
#ifdef _WIN32
#ifdef WIN32
#include <malloc.h>
#include <stddef.h>
#endif
@ -85,7 +90,6 @@ DEALINGS IN THE SOFTWARE.
/*#define USE_SPIN_LOCKS 0*/
/*#define FORCEINLINE*/
#include "malloc.c.h"
#ifdef NDEBUG /* Disable assert checking on release builds */
#undef DEBUG
@ -118,7 +122,8 @@ DEALINGS IN THE SOFTWARE.
#define THREADCACHEMAXFREESPACE (512*1024*4)
#endif
#ifdef _WIN32
#ifdef WIN32
#define TLSVAR DWORD
#define TLSALLOC(k) (*(k)=TlsAlloc(), TLS_OUT_OF_INDEXES==*(k))
#define TLSFREE(k) (!TlsFree(k))
@ -159,11 +164,14 @@ static void *unsupported_operation(const char *opname) THROWSPEC
}
static size_t mspacecounter=(size_t) 0xdeadbeef;
#endif
#ifndef ENABLE_FAST_HEAP_DETECTION
static void *RESTRICT leastusedaddress;
static size_t largestusedblock;
#endif
static FORCEINLINE void *CallMalloc(void *mspace, size_t size, size_t alignment) THROWSPEC
static FORCEINLINE void *CallMalloc(void *RESTRICT mspace, size_t size, size_t alignment) THROWSPEC
{
void *ret=0;
UNREFERENCED_PARAMETER(alignment);
void *RESTRICT ret=0;
#if USE_MAGIC_HEADERS
size_t *_ret=0;
size+=alignment+3*sizeof(size_t);
@ -172,6 +180,14 @@ static FORCEINLINE void *CallMalloc(void *mspace, size_t size, size_t alignment)
ret=malloc(size);
#elif USE_ALLOCATOR==1
ret=mspace_malloc((mstate) mspace, size);
#ifndef ENABLE_FAST_HEAP_DETECTION
if(ret)
{
size_t truesize=chunksize(mem2chunk(ret));
if(!leastusedaddress || (void *)((mstate) mspace)->least_addr<leastusedaddress) leastusedaddress=(void *)((mstate) mspace)->least_addr;
if(!largestusedblock || truesize>largestusedblock) largestusedblock=(truesize+mparams.page_size) & ~(mparams.page_size-1);
}
#endif
#endif
if(!ret) return 0;
#if USE_MAGIC_HEADERS
@ -180,23 +196,30 @@ static FORCEINLINE void *CallMalloc(void *mspace, size_t size, size_t alignment)
if(alignment) ret=(void *)(((size_t) ret+alignment-1)&~(alignment-1));
for(; _ret<(size_t *)ret-2; _ret++) *_ret=*(size_t *)"NEDMALOC";
_ret[0]=(size_t) mspace;
_ret[1]=size;
_ret[1]=size-3*sizeof(size_t);
#endif
return ret;
}
static FORCEINLINE void *CallCalloc(void *mspace, size_t no, size_t size, size_t alignment) THROWSPEC
static FORCEINLINE void *CallCalloc(void *RESTRICT mspace, size_t size, size_t alignment) THROWSPEC
{
void *ret=0;
UNREFERENCED_PARAMETER(alignment);
void *RESTRICT ret=0;
#if USE_MAGIC_HEADERS
size_t *_ret=0;
size+=alignment+3*sizeof(size_t);
#endif
#if USE_ALLOCATOR==0
ret=calloc(no, size);
ret=calloc(1, size);
#elif USE_ALLOCATOR==1
ret=mspace_calloc((mstate) mspace, no, size);
ret=mspace_calloc((mstate) mspace, 1, size);
#ifndef ENABLE_FAST_HEAP_DETECTION
if(ret)
{
size_t truesize=chunksize(mem2chunk(ret));
if(!leastusedaddress || (void *)((mstate) mspace)->least_addr<leastusedaddress) leastusedaddress=(void *)((mstate) mspace)->least_addr;
if(!largestusedblock || truesize>largestusedblock) largestusedblock=(truesize+mparams.page_size) & ~(mparams.page_size-1);
}
#endif
#endif
if(!ret) return 0;
#if USE_MAGIC_HEADERS
@ -205,39 +228,52 @@ static FORCEINLINE void *CallCalloc(void *mspace, size_t no, size_t size, size_t
if(alignment) ret=(void *)(((size_t) ret+alignment-1)&~(alignment-1));
for(; _ret<(size_t *)ret-2; _ret++) *_ret=*(size_t *) "NEDMALOC";
_ret[0]=(size_t) mspace;
_ret[1]=size;
_ret[1]=size-3*sizeof(size_t);
#endif
return ret;
}
static FORCEINLINE void *CallRealloc(void *mspace, void *mem, size_t size) THROWSPEC
static FORCEINLINE void *CallRealloc(void *RESTRICT mspace, void *RESTRICT mem, int isforeign, size_t oldsize, size_t newsize) THROWSPEC
{
void *ret=0;
void *RESTRICT ret=0;
#if USE_MAGIC_HEADERS
mstate oldmspace=0;
size_t *_ret=0, *_mem=(size_t *) mem-3, oldsize=0;
if(_mem[0]!=*(size_t *) "NEDMALOC")
size_t *_ret=0, *_mem=(size_t *) mem-3;
#endif
if(isforeign)
{ /* Transfer */
if((ret=CallMalloc(mspace, size, 0)))
{ /* It's probably safe to copy size bytes from mem - can't do much different */
#if USE_MAGIC_HEADERS
assert(_mem[0]!=*(size_t *) "NEDMALOC");
#endif
if((ret=CallMalloc(mspace, newsize, 0)))
{
#if defined(DEBUG)
printf("*** nedmalloc frees system allocated block %p\n", mem);
#endif
memcpy(ret, mem, size);
memcpy(ret, mem, oldsize<newsize ? oldsize : newsize);
free(mem);
}
return ret;
}
size+=3*sizeof(size_t);
#if USE_MAGIC_HEADERS
assert(_mem[0]==*(size_t *) "NEDMALOC");
newsize+=3*sizeof(size_t);
oldmspace=(mstate) _mem[1];
oldsize=_mem[2];
for(; *_mem==*(size_t *) "NEDMALOC"; *_mem--=0);
assert(oldsize>=_mem[2]);
for(; *_mem==*(size_t *) "NEDMALOC"; *_mem--=*(size_t *) "nedmaloc");
mem=(void *)(++_mem);
#endif
#if USE_ALLOCATOR==0
ret=realloc(mem, size);
ret=realloc(mem, newsize);
#elif USE_ALLOCATOR==1
ret=mspace_realloc((mstate) mspace, mem, size);
ret=mspace_realloc((mstate) mspace, mem, newsize);
#ifndef ENABLE_FAST_HEAP_DETECTION
if(ret)
{
size_t truesize=chunksize(mem2chunk(ret));
if(!largestusedblock || truesize>largestusedblock) largestusedblock=(truesize+mparams.page_size) & ~(mparams.page_size-1);
}
#endif
#endif
if(!ret)
{ /* Put it back the way it was */
@ -251,27 +287,33 @@ static FORCEINLINE void *CallRealloc(void *mspace, void *mem, size_t size) THROW
ret=(void *)(_ret+3);
for(; _ret<(size_t *)ret-2; _ret++) *_ret=*(size_t *) "NEDMALOC";
_ret[0]=(size_t) mspace;
_ret[1]=size;
_ret[1]=newsize-3*sizeof(size_t);
#endif
return ret;
}
static FORCEINLINE void CallFree(void *mspace, void *mem) THROWSPEC
static FORCEINLINE void CallFree(void *RESTRICT mspace, void *RESTRICT mem, int isforeign) THROWSPEC
{
#if USE_MAGIC_HEADERS
mstate oldmspace=0;
size_t *_mem=(size_t *) mem-3, oldsize=0;
if(_mem[0]!=*(size_t *) "NEDMALOC")
#endif
if(isforeign)
{
#if USE_MAGIC_HEADERS
assert(_mem[0]!=*(size_t *) "NEDMALOC");
#endif
#if defined(DEBUG)
printf("*** nedmalloc frees system allocated block %p\n", mem);
#endif
free(mem);
return;
}
#if USE_MAGIC_HEADERS
assert(_mem[0]==*(size_t *) "NEDMALOC");
oldmspace=(mstate) _mem[1];
oldsize=_mem[2];
for(; *_mem==*(size_t *) "NEDMALOC"; *_mem--=0);
for(; *_mem==*(size_t *) "NEDMALOC"; *_mem--=*(size_t *) "nedmaloc");
mem=(void *)(++_mem);
#endif
#if USE_ALLOCATOR==0
@ -281,7 +323,7 @@ static FORCEINLINE void CallFree(void *mspace, void *mem) THROWSPEC
#endif
}
size_t nedblksize(void *mem) THROWSPEC
static NEDMALLOCNOALIASATTR mstate nedblkmstate(void *RESTRICT mem) THROWSPEC
{
if(mem)
{
@ -289,9 +331,7 @@ size_t nedblksize(void *mem) THROWSPEC
size_t *_mem=(size_t *) mem-3;
if(_mem[0]==*(size_t *) "NEDMALOC")
{
// mstate mspace=(mstate) _mem[1];
size_t size=_mem[2];
return size-3*sizeof(size_t);
return (mstate) _mem[1];
}
else return 0;
#else
@ -299,6 +339,58 @@ size_t nedblksize(void *mem) THROWSPEC
/* Fail everything */
return 0;
#elif USE_ALLOCATOR==1
#ifdef ENABLE_FAST_HEAP_DETECTION
#ifdef WIN32
/* On Windows for RELEASE both x86 and x64 the NT heap precedes each block with an eight byte header
which looks like:
normal: 4 bytes of size, 4 bytes of [char < 64, char < 64, char < 64 bit 0 always set, char random ]
mmaped: 4 bytes of size 4 bytes of [zero, zero, 0xb, zero ]
On Windows for DEBUG both x86 and x64 the preceding four bytes is always 0xfdfdfdfd (no man's land).
*/
#pragma pack(push, 1)
struct _HEAP_ENTRY
{
USHORT Size;
USHORT PreviousSize;
UCHAR Cookie; /* SegmentIndex */
UCHAR Flags; /* always bit 0 (HEAP_ENTRY_BUSY). bit 1=(HEAP_ENTRY_EXTRA_PRESENT), bit 2=normal block (HEAP_ENTRY_FILL_PATTERN), bit 3=mmap block (HEAP_ENTRY_VIRTUAL_ALLOC). Bit 4 (HEAP_ENTRY_LAST_ENTRY) could be set */
UCHAR UnusedBytes;
UCHAR SmallTagIndex; /* fastbin index. Always one of 0x02, 0x03, 0x04 < 0x80 */
} *RESTRICT he=((struct _HEAP_ENTRY *) mem)-1;
#pragma pack(pop)
unsigned int header=((unsigned int *)mem)[-1], mask1=0x8080E100, result1, mask2=0xFFFFFF06, result2;
result1=header & mask1; /* Positive testing for NT heap */
result2=header & mask2; /* Positive testing for dlmalloc */
if(result1==0x00000100 && result2!=0x00000102)
{ /* This is likely a NT heap block */
return 0;
}
#endif
#ifdef __linux__
/* On Linux glibc uses ptmalloc2 (really dlmalloc) just as we do, but prev_foot contains rubbish
when the preceding block is allocated because ptmalloc2 finds the local mstate by rounding the ptr
down to the nearest megabyte. It's like dlmalloc with FOOTERS disabled. */
mchunkptr p=mem2chunk(mem);
mstate fm=get_mstate_for(p);
/* If it's a ptmalloc2 block, fm is likely to be some crazy value */
if(!is_aligned(fm)) return 0;
if((size_t)mem-(size_t)fm>=(size_t)1<<(SIZE_T_BITSIZE-1)) return 0;
if(ok_magic(fm))
return fm;
else
return 0;
if(1) { }
#endif
else
{
mchunkptr p=mem2chunk(mem);
mstate fm=get_mstate_for(p);
assert(ok_magic(fm)); /* If this fails, someone tried to free a block twice */
if(ok_magic(fm))
return fm;
}
#else
#ifdef _MSC_VER
__try
#endif
@ -309,44 +401,109 @@ size_t nedblksize(void *mem) THROWSPEC
mchunkptr->prev_foot = mem-(2*size_t) = mstate ^ mparams.magic for PRECEDING block;
mchunkptr->head = mem-(1*size_t) = 8 multiple size of this block with bottom three bits = FLAG_BITS
FLAG_BITS = bit 0 is CINUSE (currently in use unless is mmap), bit 1 is PINUSE (previous block currently
in use unless mmap), bit 2 is UNUSED and currently is always zero.
*/
mchunkptr p=mem2chunk(mem);
mstate fm=0;
if(!is_inuse(p)) return 0;
/* The following isn't safe but is probably true: unlikely to allocate
a 2Gb block on a 32bit system or a 8Eb block on a 64 bit system */
if(p->head & ((size_t)1)<<(SIZE_T_BITSIZE-SIZE_T_ONE)) return 0;
/* We have now reduced our chances of being wrong to 0.5^4 = 6.25%.
We could start comparing prev_foot's for similarity but it starts getting slow. */
fm = get_mstate_for(p);
assert(ok_magic(fm)); /* If this fails, someone tried to free a block twice */
if(ok_magic(fm))
return chunksize(p)-overhead_for(p);
register void *RESTRICT leastusedaddress_=leastusedaddress; /* Cache these to avoid register reloading */
register size_t largestusedblock_=largestusedblock;
if(!is_aligned(mem)) return 0; /* Would fail very rarely as all allocators return aligned blocks */
if(mem<leastusedaddress_) return 0; /* Simple but effective */
{
mchunkptr p=mem2chunk(mem);
mstate fm=0;
int ismmapped=is_mmapped(p);
if((!ismmapped && !is_inuse(p)) || (p->head & FLAG4_BIT)) return 0;
/* Reduced uncertainty by 0.5^2 = 25.0% */
/* size should never exceed largestusedblock */
if(chunksize(p)>largestusedblock_) return 0;
/* Reduced uncertainty by a minimum of 0.5^3 = 12.5%, maximum 0.5^16 = 0.0015% */
/* Having sanity checked prev_foot and head, check next block */
if(!ismmapped && (!next_pinuse(p) || (next_chunk(p)->head & FLAG4_BIT))) return 0;
/* Reduced uncertainty by 0.5^5 = 3.13% or 0.5^18 = 0.00038% */
#if 0
/* If previous block is free, check that its next block pointer equals us */
if(!ismmapped && !pinuse(p))
if(next_chunk(prev_chunk(p))!=p) return 0;
/* We could start comparing prev_foot's for similarity but it starts getting slow. */
#endif
fm = get_mstate_for(p);
if(!is_aligned(fm) || (void *)fm<leastusedaddress_) return 0;
if((size_t)mem-(size_t)fm>=(size_t)1<<(SIZE_T_BITSIZE-1)) return 0;
assert(ok_magic(fm)); /* If this fails, someone tried to free a block twice */
if(ok_magic(fm))
return fm;
}
}
#ifdef _MSC_VER
__except(1) { }
#endif
#endif
#endif
#endif
}
return 0;
}
NEDMALLOCNOALIASATTR size_t nedblksize(int *RESTRICT isforeign, void *RESTRICT mem) THROWSPEC
{
if(mem)
{
if(isforeign) *isforeign=1;
#if USE_MAGIC_HEADERS
{
size_t *_mem=(size_t *) mem-3;
if(_mem[0]==*(size_t *) "NEDMALOC")
{
mstate mspace=(mstate) _mem[1];
size_t size=_mem[2];
if(isforeign) *isforeign=0;
return size;
}
}
#elif USE_ALLOCATOR==1
if(nedblkmstate(mem))
{
mchunkptr p=mem2chunk(mem);
if(isforeign) *isforeign=0;
return chunksize(p)-overhead_for(p);
}
#ifdef DEBUG
else
{
int a=1; /* Set breakpoints here if needed */
}
#endif
#endif
#if defined(ENABLE_TOLERANT_NEDMALLOC) || USE_ALLOCATOR==0
#ifdef WIN32
/* This is the MSVCRT equivalent */
return _msize(mem);
#elif defined(__linux__)
/* This is the glibc/ptmalloc2/dlmalloc equivalent. */
return malloc_usable_size(mem);
#elif defined(__FreeBSD__) || defined(__APPLE__)
/* This is the BSD libc equivalent. */
return malloc_size(mem);
#else
#error Cannot tolerate the memory allocator of an unknown system!
#endif
#endif
}
return 0;
}
void nedsetvalue(void *v) THROWSPEC { nedpsetvalue((nedpool *) 0, v); }
NEDMALLOCPTRATTR void * nedmalloc(size_t size) THROWSPEC { return nedpmalloc((nedpool *) 0, size); }
NEDMALLOCPTRATTR void * nedcalloc(size_t no, size_t size) THROWSPEC { return nedpcalloc((nedpool *) 0, no, size); }
NEDMALLOCPTRATTR void * nedrealloc(void *mem, size_t size) THROWSPEC { return nedprealloc((nedpool *) 0, mem, size); }
void nedfree(void *mem) THROWSPEC { nedpfree((nedpool *) 0, mem); }
NEDMALLOCPTRATTR void * nedmemalign(size_t alignment, size_t bytes) THROWSPEC { return nedpmemalign((nedpool *) 0, alignment, bytes); }
#if !NO_MALLINFO
struct mallinfo nedmallinfo(void) THROWSPEC { return nedpmallinfo((nedpool *) 0); }
#endif
int nedmallopt(int parno, int value) THROWSPEC { return nedpmallopt((nedpool *) 0, parno, value); }
int nedmalloc_trim(size_t pad) THROWSPEC { return nedpmalloc_trim((nedpool *) 0, pad); }
void nedmalloc_stats() THROWSPEC { nedpmalloc_stats((nedpool *) 0); }
size_t nedmalloc_footprint() THROWSPEC { return nedpmalloc_footprint((nedpool *) 0); }
void nedsetvalue(void *v) THROWSPEC { nedpsetvalue((nedpool *) 0, v); }
NEDMALLOCPTRATTR void * nedmalloc(size_t size) THROWSPEC { return nedpmalloc((nedpool *) 0, size); }
NEDMALLOCPTRATTR void * nedcalloc(size_t no, size_t size) THROWSPEC { return nedpcalloc((nedpool *) 0, no, size); }
NEDMALLOCPTRATTR void * nedrealloc(void *mem, size_t size) THROWSPEC { return nedprealloc((nedpool *) 0, mem, size); }
void nedfree(void *mem) THROWSPEC { nedpfree((nedpool *) 0, mem); }
NEDMALLOCPTRATTR void * nedmemalign(size_t alignment, size_t bytes) THROWSPEC { return nedpmemalign((nedpool *) 0, alignment, bytes); }
struct nedmallinfo nedmallinfo(void) THROWSPEC { return nedpmallinfo((nedpool *) 0); }
int nedmallopt(int parno, int value) THROWSPEC { return nedpmallopt((nedpool *) 0, parno, value); }
int nedmalloc_trim(size_t pad) THROWSPEC { return nedpmalloc_trim((nedpool *) 0, pad); }
void nedmalloc_stats() THROWSPEC { nedpmalloc_stats((nedpool *) 0); }
size_t nedmalloc_footprint() THROWSPEC { return nedpmalloc_footprint((nedpool *) 0); }
NEDMALLOCPTRATTR void **nedindependent_calloc(size_t elemsno, size_t elemsize, void **chunks) THROWSPEC { return nedpindependent_calloc((nedpool *) 0, elemsno, elemsize, chunks); }
NEDMALLOCPTRATTR void **nedindependent_comalloc(size_t elems, size_t *sizes, void **chunks) THROWSPEC { return nedpindependent_comalloc((nedpool *) 0, elems, sizes, chunks); }
// NEDMALLOCPTRATTR void **nedindependent_comalloc(size_t elems, size_t *sizes, void **chunks) THROWSPEC { return nedpindependent_comalloc((nedpool *) 0, elems, sizes, chunks); }
struct threadcacheblk_t;
typedef struct threadcacheblk_t threadcacheblk;
@ -383,7 +540,7 @@ struct nedpool_t
};
static nedpool syspool;
static FORCEINLINE unsigned int size2binidx(size_t _size) THROWSPEC
static FORCEINLINE NEDMALLOCNOALIASATTR unsigned int size2binidx(size_t _size) THROWSPEC
{ /* 8=1000 16=10000 20=10100 24=11000 32=100000 48=110000 4096=1000000000000 */
unsigned int topbit, size=(unsigned int)(_size>>4);
/* 16=1 20=1 24=1 32=10 48=11 64=100 96=110 128=1000 4096=100000000 */
@ -467,9 +624,8 @@ static void tcfullsanitycheck(threadcache *tc) THROWSPEC
}
#endif
static NOINLINE void RemoveCacheEntries(nedpool *p, threadcache *tc, unsigned int age) THROWSPEC
static NOINLINE void RemoveCacheEntries(nedpool *RESTRICT p, threadcache *RESTRICT tc, unsigned int age) THROWSPEC
{
UNREFERENCED_PARAMETER(p);
#ifdef FULLSANITYCHECKS
tcfullsanitycheck(tc);
#endif
@ -485,7 +641,7 @@ static NOINLINE void RemoveCacheEntries(nedpool *p, threadcache *tc, unsigned in
{
threadcacheblk *f=*tcb;
size_t blksize=f->size; /*nedblksize(f);*/
assert(blksize<=nedblksize(f));
assert(blksize<=nedblksize(0, f));
assert(blksize);
#ifdef FULLSANITYCHECKS
assert(*(unsigned int *) "NEDN"==(*tcb)->magic);
@ -497,7 +653,7 @@ static NOINLINE void RemoveCacheEntries(nedpool *p, threadcache *tc, unsigned in
*tcbptr=0;
tc->freeInCache-=blksize;
assert((long) tc->freeInCache>=0);
CallFree(0, f);
CallFree(0, f, 0);
/*tcsanitycheck(tcbptr);*/
}
}
@ -506,7 +662,7 @@ static NOINLINE void RemoveCacheEntries(nedpool *p, threadcache *tc, unsigned in
tcfullsanitycheck(tc);
#endif
}
static void DestroyCaches(nedpool *p) THROWSPEC
static void DestroyCaches(nedpool *RESTRICT p) THROWSPEC
{
if(p->caches)
{
@ -521,14 +677,14 @@ static void DestroyCaches(nedpool *p) THROWSPEC
assert(!tc->freeInCache);
tc->mymspace=-1;
tc->threadid=0;
CallFree(0, tc);
CallFree(0, tc, 0);
p->caches[n]=0;
}
}
}
}
static NOINLINE threadcache *AllocCache(nedpool *p) THROWSPEC
static NOINLINE threadcache *AllocCache(nedpool *RESTRICT p) THROWSPEC
{
threadcache *tc=0;
int n, end;
@ -539,7 +695,7 @@ static NOINLINE threadcache *AllocCache(nedpool *p) THROWSPEC
RELEASE_LOCK(&p->mutex);
return 0;
}
tc=p->caches[n]=(threadcache *) CallCalloc(p->m[0], 1, sizeof(threadcache), 0);
tc=p->caches[n]=(threadcache *) CallCalloc(p->m[0], sizeof(threadcache), 0);
if(!tc)
{
RELEASE_LOCK(&p->mutex);
@ -557,14 +713,13 @@ static NOINLINE threadcache *AllocCache(nedpool *p) THROWSPEC
return tc;
}
static void *threadcache_malloc(nedpool *p, threadcache *tc, size_t *size) THROWSPEC
static void *threadcache_malloc(nedpool *RESTRICT p, threadcache *RESTRICT tc, size_t *RESTRICT _size) THROWSPEC
{
void *ret=0;
void *RESTRICT ret=0;
size_t size=*_size, blksize=0;
unsigned int bestsize;
unsigned int idx=size2binidx(*size);
size_t blksize=0;
threadcacheblk *blk, **binsptr;
UNREFERENCED_PARAMETER(p);
unsigned int idx=size2binidx(size);
threadcacheblk *RESTRICT blk, **RESTRICT binsptr;
#ifdef FULLSANITYCHECKS
tcfullsanitycheck(tc);
#endif
@ -573,31 +728,31 @@ static void *threadcache_malloc(nedpool *p, threadcache *tc, size_t *size) THROW
#ifdef FINEGRAINEDBINS
/* Finer grained bin fit */
idx<<=1;
if(*size>bestsize)
if(size>bestsize)
{
idx++;
bestsize+=bestsize>>1;
}
if(*size>bestsize)
if(size>bestsize)
{
idx++;
bestsize=1<<(4+(idx>>1));
}
#else
if(*size>bestsize)
if(size>bestsize)
{
idx++;
bestsize<<=1;
}
#endif
assert(bestsize>=*size);
if(*size<bestsize) *size=bestsize;
assert(*size<=THREADCACHEMAX);
assert(bestsize>=size);
if(size<bestsize) size=bestsize;
assert(size<=THREADCACHEMAX);
assert(idx<=THREADCACHEMAXBINS);
binsptr=&tc->bins[idx*2];
/* Try to match close, but move up a bin if necessary */
blk=*binsptr;
if(!blk || blk->size<*size)
if(!blk || blk->size<size)
{ /* Bump it up a bin */
if(idx<THREADCACHEMAXBINS)
{
@ -609,8 +764,8 @@ static void *threadcache_malloc(nedpool *p, threadcache *tc, size_t *size) THROW
if(blk)
{
blksize=blk->size; /*nedblksize(blk);*/
assert(nedblksize(blk)>=blksize);
assert(blksize>=*size);
assert(nedblksize(0, blk)>=blksize);
assert(blksize>=size);
if(blk->next)
blk->next->prev=0;
*binsptr=blk->next;
@ -620,14 +775,14 @@ static void *threadcache_malloc(nedpool *p, threadcache *tc, size_t *size) THROW
blk->magic=0;
#endif
assert(binsptr[0]!=blk && binsptr[1]!=blk);
assert(nedblksize(blk)>=sizeof(threadcacheblk) && nedblksize(blk)<=THREADCACHEMAX+CHUNK_OVERHEAD);
/*printf("malloc: %p, %p, %p, %lu\n", p, tc, blk, (long) size);*/
assert(nedblksize(0, blk)>=sizeof(threadcacheblk) && nedblksize(0, blk)<=THREADCACHEMAX+CHUNK_OVERHEAD);
/*printf("malloc: %p, %p, %p, %lu\n", p, tc, blk, (long) _size);*/
ret=(void *) blk;
}
++tc->mallocs;
if(ret)
{
assert(blksize>=*size);
assert(blksize>=size);
++tc->successes;
tc->freeInCache-=blksize;
assert((long) tc->freeInCache>=0);
@ -642,13 +797,13 @@ static void *threadcache_malloc(nedpool *p, threadcache *tc, size_t *size) THROW
#ifdef FULLSANITYCHECKS
tcfullsanitycheck(tc);
#endif
*_size=size;
return ret;
}
static NOINLINE void ReleaseFreeInCache(nedpool *p, threadcache *tc, int mymspace) THROWSPEC
static NOINLINE void ReleaseFreeInCache(nedpool *RESTRICT p, threadcache *RESTRICT tc, int mymspace) THROWSPEC
{
unsigned int age=THREADCACHEMAXFREESPACE/8192;
/*ACQUIRE_LOCK(&p->m[mymspace]->mutex);*/
UNREFERENCED_PARAMETER(mymspace);
while(age && tc->freeInCache>=THREADCACHEMAXFREESPACE)
{
RemoveCacheEntries(p, tc, age);
@ -657,15 +812,15 @@ static NOINLINE void ReleaseFreeInCache(nedpool *p, threadcache *tc, int mymspac
}
/*RELEASE_LOCK(&p->m[mymspace]->mutex);*/
}
static void threadcache_free(nedpool *p, threadcache *tc, int mymspace, void *mem, size_t size) THROWSPEC
static void threadcache_free(nedpool *RESTRICT p, threadcache *RESTRICT tc, int mymspace, void *RESTRICT mem, size_t size) THROWSPEC
{
unsigned int bestsize;
unsigned int idx=size2binidx(size);
threadcacheblk **binsptr, *tck=(threadcacheblk *) mem;
threadcacheblk **RESTRICT binsptr, *RESTRICT tck=(threadcacheblk *) mem;
assert(size>=sizeof(threadcacheblk) && size<=THREADCACHEMAX+CHUNK_OVERHEAD);
#ifdef DEBUG
/* Make sure this is a valid memory block */
assert(nedblksize(mem));
assert(nedblksize(0, mem));
#endif
#ifdef FULLSANITYCHECKS
tcfullsanitycheck(tc);
@ -677,7 +832,7 @@ static void threadcache_free(nedpool *p, threadcache *tc, int mymspace, void *me
idx<<=1;
if(size>bestsize)
{
unsigned int biggerbestsize=bestsize+(bestsize<<1);
unsigned int biggerbestsize=bestsize+bestsize<<1;
if(size>=biggerbestsize)
{
idx++;
@ -723,7 +878,7 @@ static void threadcache_free(nedpool *p, threadcache *tc, int mymspace, void *me
static NOINLINE int InitPool(nedpool *p, size_t capacity, int threads) THROWSPEC
static NOINLINE int InitPool(nedpool *RESTRICT p, size_t capacity, int threads) THROWSPEC
{ /* threads is -1 for system pool */
ensure_initialization();
ACQUIRE_MALLOC_GLOBAL_LOCK();
@ -759,7 +914,7 @@ err:
RELEASE_MALLOC_GLOBAL_LOCK();
return 0;
}
static NOINLINE mstate FindMSpace(nedpool *p, threadcache *tc, int *lastUsed, size_t size) THROWSPEC
static NOINLINE mstate FindMSpace(nedpool *RESTRICT p, threadcache *RESTRICT tc, int *RESTRICT lastUsed, size_t size) THROWSPEC
{ /* Gets called when thread's last used mspace is in use. The strategy
is to run through the list of all available mspaces looking for an
unlocked one and if we fail, we create a new one so long as we don't
@ -818,20 +973,57 @@ found:
return p->m[n];
}
typedef struct PoolList_t
{
size_t size; /* Size of list */
size_t length; /* Actual entries in list */
#ifdef DEBUG
nedpool *list[1]; /* Force testing of list expansion */
#else
nedpool *list[16];
#endif
} PoolList;
static MLOCK_T poollistlock;
static PoolList *poollist;
NEDMALLOCPTRATTR nedpool *nedcreatepool(size_t capacity, int threads) THROWSPEC
{
nedpool *ret;
if(!(ret=(nedpool *) nedpcalloc(0, 1, sizeof(nedpool)))) return 0;
nedpool *ret=0;
if(!poollist)
{
PoolList *newpoollist=0;
if(!(newpoollist=(PoolList *) nedpcalloc(0, 1, sizeof(PoolList)+sizeof(nedpool *)))) return 0;
INITIAL_LOCK(&poollistlock);
ACQUIRE_LOCK(&poollistlock);
poollist=newpoollist;
poollist->size=sizeof(poollist->list)/sizeof(nedpool *);
}
else
ACQUIRE_LOCK(&poollistlock);
if(poollist->length==poollist->size)
{
PoolList *newpoollist=0;
size_t newsize=0;
newsize=sizeof(PoolList)+(poollist->size+1)*sizeof(nedpool *);
if(!(newpoollist=(PoolList *) nedprealloc(0, poollist, newsize))) goto badexit;
poollist=newpoollist;
memset(&poollist->list[poollist->size], 0, newsize-((size_t)&poollist->list[poollist->size]-(size_t)&poollist->list[0]));
poollist->size=((newsize-((char *)&poollist->list[0]-(char *)poollist))/sizeof(nedpool *))-1;
assert(poollist->size>poollist->length);
}
if(!(ret=(nedpool *) nedpcalloc(0, 1, sizeof(nedpool)))) goto badexit;
if(!InitPool(ret, capacity, threads))
{
nedpfree(0, ret);
return 0;
goto badexit;
}
poollist->list[poollist->length++]=ret;
badexit:
RELEASE_LOCK(&poollistlock);
return ret;
}
void neddestroypool(nedpool *p) THROWSPEC
{
int n;
unsigned int n;
ACQUIRE_LOCK(&p->mutex);
DestroyCaches(p);
for(n=0; p->m[n]; n++)
@ -844,6 +1036,18 @@ void neddestroypool(nedpool *p) THROWSPEC
RELEASE_LOCK(&p->mutex);
if(TLSFREE(p->mycache)) abort();
nedpfree(0, p);
ACQUIRE_LOCK(&poollistlock);
assert(poollist);
for(n=0; n<poollist->length && poollist->list[n]!=p; n++);
assert(n!=poollist->length);
memmove(&poollist->list[n], &poollist->list[n+1], (size_t)&poollist->list[poollist->length]-(size_t)&poollist->list[n]);
if(!--poollist->length)
{
assert(!poollist->list[0]);
nedpfree(0, poollist);
poollist=0;
}
RELEASE_LOCK(&poollistlock);
}
void neddestroysyspool() THROWSPEC
{
@ -860,35 +1064,36 @@ void neddestroysyspool() THROWSPEC
}
/* Render syspool unusable */
for(n=0; n<THREADCACHEMAXCACHES; n++)
p->caches[n]=(threadcache *)0xdeadbeef;
p->caches[n]=(threadcache *)(size_t)(sizeof(size_t)>4 ? 0xdeadbeefdeadbeefULL : 0xdeadbeefUL);
for(n=0; n<MAXTHREADSINPOOL+1; n++)
p->m[n]=(mstate)0xdeadbeef;
p->m[n]=(mstate)(size_t)(sizeof(size_t)>4 ? 0xdeadbeefdeadbeefULL : 0xdeadbeefUL);
if(TLSFREE(p->mycache)) abort();
RELEASE_LOCK(&p->mutex);
}
nedpool **nedpoollist() THROWSPEC
{
nedpool **ret=0;
if(poollist)
{
ACQUIRE_LOCK(&poollistlock);
if(!(ret=(nedpool **) nedmalloc((poollist->length+1)*sizeof(nedpool *)))) goto badexit;
memcpy(ret, poollist->list, (poollist->length+1)*sizeof(nedpool *));
badexit:
RELEASE_LOCK(&poollistlock);
}
return ret;
}
void nedpsetvalue(nedpool *p, void *v) THROWSPEC
{
if(!p) { p=&syspool; if(!syspool.threads) InitPool(&syspool, 0, -1); }
p->uservalue=v;
}
void *nedgetvalue(nedpool **p, void *mem) THROWSPEC
{
nedpool *np=0;
mchunkptr mcp=mem2chunk(mem);
mstate fm;
if(!(is_aligned(chunk2mem(mcp))) && mcp->head != FENCEPOST_HEAD) return 0;
if(!cinuse(mcp)) return 0;
if(!next_pinuse(mcp)) return 0;
if(!is_mmapped(mcp) && !pinuse(mcp))
{
if(next_chunk(prev_chunk(mcp))!=mcp) return 0;
}
fm=get_mstate_for(mcp);
if(!ok_magic(fm)) return 0;
if(!ok_address(fm, mcp)) return 0;
if(!fm->extp) return 0;
mstate fm=nedblkmstate(mem);
if(!fm || !fm->extp) return 0;
np=(nedpool *) fm->extp;
if(p) *p=np;
return np->uservalue;
@ -922,7 +1127,7 @@ void nedtrimthreadcache(nedpool *p, int disable) THROWSPEC
{
tc->mymspace=-1;
tc->threadid=0;
CallFree(0, p->caches[mycache-1]);
CallFree(0, p->caches[mycache-1], 0);
p->caches[mycache-1]=0;
}
}
@ -940,7 +1145,7 @@ void neddisablethreadcache(nedpool *p) THROWSPEC
if(USE_ALLOCATOR==1) { RELEASE_LOCK(&m->mutex); } \
} while (0)
static FORCEINLINE mstate GetMSpace(nedpool *p, threadcache *tc, int mymspace, size_t size) THROWSPEC
static FORCEINLINE mstate GetMSpace(nedpool *RESTRICT p, threadcache *RESTRICT tc, int mymspace, size_t size) THROWSPEC
{ /* Returns a locked and ready for use mspace */
mstate m=p->m[mymspace];
assert(m);
@ -950,22 +1155,14 @@ static FORCEINLINE mstate GetMSpace(nedpool *p, threadcache *tc, int mymspace, s
#endif
return m;
}
static FORCEINLINE void GetThreadCache(nedpool **p, threadcache **tc, int *mymspace, size_t *size) THROWSPEC
static NOINLINE void GetThreadCache_cold1(nedpool *RESTRICT *RESTRICT p) THROWSPEC
{
int mycache;
if(size && *size<sizeof(threadcacheblk)) *size=sizeof(threadcacheblk);
if(!*p)
{
*p=&syspool;
if(!syspool.threads) InitPool(&syspool, 0, -1);
}
mycache=(int)(size_t) TLSGET((*p)->mycache);
if(mycache>0)
{ /* Already have a cache */
*tc=(*p)->caches[mycache-1];
*mymspace=(*tc)->mymspace;
}
else if(!mycache)
*p=&syspool;
if(!syspool.threads) InitPool(&syspool, 0, -1);
}
static NOINLINE void GetThreadCache_cold2(nedpool *RESTRICT *RESTRICT p, threadcache *RESTRICT *RESTRICT tc, int *RESTRICT mymspace, int mycache) THROWSPEC
{
if(!mycache)
{ /* Need to allocate a new cache */
*tc=AllocCache(*p);
if(!*tc)
@ -981,6 +1178,20 @@ static FORCEINLINE void GetThreadCache(nedpool **p, threadcache **tc, int *mymsp
*tc=0;
*mymspace=-mycache-1;
}
}
static FORCEINLINE void GetThreadCache(nedpool *RESTRICT *RESTRICT p, threadcache *RESTRICT *RESTRICT tc, int *RESTRICT mymspace, size_t *RESTRICT size) THROWSPEC
{
int mycache;
if(size && *size<sizeof(threadcacheblk)) *size=sizeof(threadcacheblk);
if(!*p)
GetThreadCache_cold1(p);
mycache=(int)(size_t) TLSGET((*p)->mycache);
if(mycache>0)
{ /* Already have a cache */
*tc=(*p)->caches[mycache-1];
*mymspace=(*tc)->mymspace;
}
else GetThreadCache_cold2(p, tc, mymspace, mycache);
assert(*mymspace>=0);
assert(!(*tc) || (long)(size_t)CURRENT_THREAD==(*tc)->threadid);
#ifdef FULLSANITYCHECKS
@ -1030,7 +1241,7 @@ NEDMALLOCPTRATTR void * nedpcalloc(nedpool *p, size_t no, size_t size) THROWSPEC
if(!ret)
{ /* Use this thread's mspace */
GETMSPACE(m, p, tc, mymspace, rsize,
ret=CallCalloc(m, 1, rsize, 0));
ret=CallCalloc(m, rsize, 0));
}
return ret;
}
@ -1038,35 +1249,42 @@ NEDMALLOCPTRATTR void * nedprealloc(nedpool *p, void *mem, size_t size) THROWSPE
{
void *ret=0;
threadcache *tc;
int mymspace;
int mymspace, isforeign=1;
size_t memsize;
if(!mem) return nedpmalloc(p, size);
memsize=nedblksize(&isforeign, mem);
assert(memsize);
if(!memsize)
{
fprintf(stderr, "nedmalloc: nedprealloc() called with a block not created by nedmalloc!\n");
abort();
}
else if(size<=memsize && memsize-size<
#ifdef DEBUG
32
#else
1024
#endif
) /* If realloc size is within 1Kb smaller than existing, noop it */
return mem;
GetThreadCache(&p, &tc, &mymspace, &size);
#if THREADCACHEMAX
if(tc && size && size<=THREADCACHEMAX)
{ /* Use the thread cache */
size_t memsize=nedblksize(mem);
#if !USE_MAGIC_HEADERS
assert(memsize);
if(!memsize)
{
fprintf(stderr, "nedmalloc: nedprealloc() called with a block not created by nedmalloc!\n");
abort();
}
#endif
if((ret=threadcache_malloc(p, tc, &size)))
{
memcpy(ret, mem, memsize<size ? memsize : size);
if(memsize && memsize<=THREADCACHEMAX)
if(memsize>=sizeof(threadcacheblk) && memsize<=(THREADCACHEMAX+CHUNK_OVERHEAD))
threadcache_free(p, tc, mymspace, mem, memsize);
else
CallFree(0, mem);
CallFree(0, mem, isforeign);
}
}
#endif
if(!ret)
{ /* Reallocs always happen in the mspace they happened in, so skip
locking the preferred mspace for this thread */
ret=CallRealloc(0, mem, size);
ret=CallRealloc(p->m[mymspace], mem, isforeign, memsize, size);
}
return ret;
}
@ -1074,30 +1292,29 @@ void nedpfree(nedpool *p, void *mem) THROWSPEC
{ /* Frees always happen in the mspace they happened in, so skip
locking the preferred mspace for this thread */
threadcache *tc;
int mymspace;
int mymspace, isforeign=1;
size_t memsize;
if(!mem)
{ /* You'd be surprised the number of times this happens as so many
allocators are non-conformant here */
// fprintf(stderr, "nedmalloc: WARNING nedpfree() called with zero. This is not portable behaviour!\n");
{ /* If you tried this on FreeBSD you'd be sorry! */
#ifdef DEBUG
fprintf(stderr, "nedmalloc: WARNING nedpfree() called with zero. This is not portable behaviour!\n");
#endif
return;
}
GetThreadCache(&p, &tc, &mymspace, 0);
#if THREADCACHEMAX
memsize=nedblksize(mem);
#if !USE_MAGIC_HEADERS
memsize=nedblksize(&isforeign, mem);
assert(memsize);
if(!memsize)
{
fprintf(stderr, "nedmalloc: nedpfree() called with a block not created by nedmalloc!\n");
abort();
}
#endif
if(mem && tc && memsize && memsize<=(THREADCACHEMAX+CHUNK_OVERHEAD))
GetThreadCache(&p, &tc, &mymspace, 0);
#if THREADCACHEMAX
if(mem && tc && memsize>=sizeof(threadcacheblk) && memsize<=(THREADCACHEMAX+CHUNK_OVERHEAD))
threadcache_free(p, tc, mymspace, mem, memsize);
else
#endif
CallFree(0, mem);
CallFree(0, mem, isforeign);
}
NEDMALLOCPTRATTR void * nedpmemalign(nedpool *p, size_t alignment, size_t bytes) THROWSPEC
{
@ -1111,15 +1328,14 @@ NEDMALLOCPTRATTR void * nedpmemalign(nedpool *p, size_t alignment, size_t bytes)
}
return ret;
}
#if !NO_MALLINFO
struct mallinfo nedpmallinfo(nedpool *p) THROWSPEC
struct nedmallinfo nedpmallinfo(nedpool *p) THROWSPEC
{
int n;
struct mallinfo ret={0,0,0,0,0,0,0,0,0,0};
struct nedmallinfo ret={0};
if(!p) { p=&syspool; if(!syspool.threads) InitPool(&syspool, 0, -1); }
for(n=0; p->m[n]; n++)
{
#if USE_ALLOCATOR==1
#if USE_ALLOCATOR==1 && !NO_MALLINFO
struct mallinfo t=mspace_mallinfo(p->m[n]);
ret.arena+=t.arena;
ret.ordblks+=t.ordblks;
@ -1132,10 +1348,8 @@ struct mallinfo nedpmallinfo(nedpool *p) THROWSPEC
}
return ret;
}
#endif
int nedpmallopt(nedpool *p, int parno, int value) THROWSPEC
{
UNREFERENCED_PARAMETER(p);
#if USE_ALLOCATOR==1
return mspace_mallopt(parno, value);
#else
@ -1205,6 +1419,8 @@ NEDMALLOCPTRATTR void **nedpindependent_calloc(nedpool *p, size_t elemsno, size_
#endif
return ret;
}
#if 0
NEDMALLOCPTRATTR void **nedpindependent_comalloc(nedpool *p, size_t elems, size_t *sizes, void **chunks) THROWSPEC
{
void **ret;
@ -1224,6 +1440,7 @@ NEDMALLOCPTRATTR void **nedpindependent_comalloc(nedpool *p, size_t elems, size_
#endif
return ret;
}
#endif // 0
// cheap replacement for strdup so we aren't feeding system allocated blocks into nedmalloc

151
polymer/eduke32/build/src/polymer.c
View file

@ -4290,109 +4290,84 @@ static void polymer_getscratchmaterial(_prmaterial* material)
static void polymer_getbuildmaterial(_prmaterial* material, int16_t tilenum, char pal, int8_t shade)
{
pthtyp* pth;
pthtyp* detailpth;
pthtyp* glowpth;
polymer_getscratchmaterial(material);
// PR_BIT_NORMAL_MAP
if (hicfindsubst(tilenum, NORMALPAL, 0))
{
glowpth = NULL;
glowpth = gltexcache(tilenum, NORMALPAL, 0);
if (glowpth && glowpth->hicr && (glowpth->hicr->palnum == NORMALPAL)) {
material->normalmap = glowpth->glpic;
material->normalbias[0] = glowpth->hicr->specpower;
material->normalbias[1] = glowpth->hicr->specfactor;
}
}
// PR_BIT_DIFFUSE_MAP
if (!waloff[tilenum])
loadtile(tilenum);
pth = NULL;
pth = gltexcache(tilenum, pal, (material == &spriteplane.material) ? 4 : 0);
if (pth)
if ((pth = gltexcache(tilenum, pal, (material == &spriteplane.material) ? 4 : 0)))
{
material->diffusemap = pth->glpic;
if (pth->hicr)
{
material->diffusescale[0] = pth->hicr->xscale;
material->diffusescale[1] = pth->hicr->yscale;
}
// PR_BIT_DIFFUSE_DETAIL_MAP
if (hicfindsubst(tilenum, DETAILPAL, 0))
{
detailpth = NULL;
detailpth = gltexcache(tilenum, DETAILPAL, 0);
if (detailpth && detailpth->hicr && (detailpth->hicr->palnum == DETAILPAL))
if (pth->hicr)
{
material->detailmap = detailpth->glpic;
material->detailscale[0] = detailpth->hicr->xscale;
material->detailscale[1] = detailpth->hicr->yscale;
material->diffusescale[0] = pth->hicr->xscale;
material->diffusescale[1] = pth->hicr->yscale;
// PR_BIT_SPECULAR_MATERIAL
if (pth->hicr->specpower != 1.0f)
material->specmaterial[0] = pth->hicr->specpower;
material->specmaterial[1] = pth->hicr->specfactor;
}
}
// PR_BIT_DIFFUSE_MODULATION
material->diffusemodulation[0] =
// PR_BIT_DIFFUSE_MODULATION
material->diffusemodulation[0] =
material->diffusemodulation[1] =
material->diffusemodulation[2] =
((float)(numpalookups-min(max(shade*shadescale,0),numpalookups)))/((float)numpalookups);
if (pth->flags & 2)
{
if (pth->palnum != pal)
{
material->diffusemodulation[0] *= (float)hictinting[pal].r / 255.0;
material->diffusemodulation[1] *= (float)hictinting[pal].g / 255.0;
material->diffusemodulation[2] *= (float)hictinting[pal].b / 255.0;
}
if (pth && (pth->flags & 2))
{
if (pth->palnum != pal)
{
material->diffusemodulation[0] *= (float)hictinting[pal].r / 255.0;
material->diffusemodulation[1] *= (float)hictinting[pal].g / 255.0;
material->diffusemodulation[2] *= (float)hictinting[pal].b / 255.0;
}
// fullscreen tint on global palette change
if (hictinting[MAXPALOOKUPS-1].r != 255 ||
hictinting[MAXPALOOKUPS-1].g != 255 ||
hictinting[MAXPALOOKUPS-1].b != 255)
{
material->diffusemodulation[0] *= hictinting[MAXPALOOKUPS-1].r / 255.0;
material->diffusemodulation[1] *= hictinting[MAXPALOOKUPS-1].g / 255.0;
material->diffusemodulation[2] *= hictinting[MAXPALOOKUPS-1].b / 255.0;
// fullscreen tint on global palette change... this is used for nightvision and underwater tinting
// if ((hictinting[MAXPALOOKUPS-1].r + hictinting[MAXPALOOKUPS-1].g + hictinting[MAXPALOOKUPS-1].b) != 0x2FD)
if (((uint32_t)hictinting[MAXPALOOKUPS-1].r & 0xFFFFFF00) != 0xFFFFFF00)
{
material->diffusemodulation[0] *= hictinting[MAXPALOOKUPS-1].r / 255.0;
material->diffusemodulation[1] *= hictinting[MAXPALOOKUPS-1].g / 255.0;
material->diffusemodulation[2] *= hictinting[MAXPALOOKUPS-1].b / 255.0;
}
}
// PR_BIT_GLOW_MAP
if (r_fullbrights && pth->flags & 16)
material->glowmap = pth->ofb->glpic;
}
// PR_BIT_DIFFUSE_DETAIL_MAP
if (hicfindsubst(tilenum, DETAILPAL, 0) && (pth = gltexcache(tilenum, DETAILPAL, 0)) &&
pth->hicr && (pth->hicr->palnum == DETAILPAL))
{
material->detailmap = pth->glpic;
material->detailscale[0] = pth->hicr->xscale;
material->detailscale[1] = pth->hicr->yscale;
}
// PR_BIT_GLOW_MAP
if (hicfindsubst(tilenum, GLOWPAL, 0) && (pth = gltexcache(tilenum, GLOWPAL, 0)) &&
pth->hicr && (pth->hicr->palnum == GLOWPAL))
material->glowmap = pth->glpic;
// PR_BIT_SPECULAR_MAP
if (hicfindsubst(tilenum, SPECULARPAL, 0))
if (hicfindsubst(tilenum, SPECULARPAL, 0) && (pth = gltexcache(tilenum, SPECULARPAL, 0)) &&
pth->hicr && (pth->hicr->palnum == SPECULARPAL))
material->specmap = pth->glpic;
// PR_BIT_NORMAL_MAP
if (hicfindsubst(tilenum, NORMALPAL, 0) && (pth = gltexcache(tilenum, NORMALPAL, 0)) &&
pth->hicr && (pth->hicr->palnum == NORMALPAL))
{
glowpth = NULL;
glowpth = gltexcache(tilenum, SPECULARPAL, 0);
if (glowpth && glowpth->hicr && (glowpth->hicr->palnum == SPECULARPAL))
material->specmap = glowpth->glpic;
}
// PR_BIT_SPECULAR_MATERIAL
if (pth->hicr)
{
if (pth->hicr->specpower != 1.0f)
material->specmaterial[0] = pth->hicr->specpower;
material->specmaterial[1] = pth->hicr->specfactor;
}
// PR_BIT_GLOW_MAP
if (r_fullbrights && pth && pth->flags & 16)
material->glowmap = pth->ofb->glpic;
if (hicfindsubst(tilenum, GLOWPAL, 0))
{
glowpth = NULL;
glowpth = gltexcache(tilenum, GLOWPAL, 0);
if (glowpth && glowpth->hicr && (glowpth->hicr->palnum == GLOWPAL))
material->glowmap = glowpth->glpic;
material->normalmap = pth->glpic;
material->normalbias[0] = pth->hicr->specpower;
material->normalbias[1] = pth->hicr->specfactor;
}
}

22
polymer/eduke32/build/src/polymost.c
View file

@ -247,7 +247,7 @@ void drawline2d(float x0, float y0, float x1, float y1, char col)
#define USEKENFILTER 1
#ifdef USELZF
# include "fastlz.h"
# include "quicklz.h"
#else
# include "lzwnew.h"
#endif
@ -4283,8 +4283,8 @@ void polymost_drawrooms()
w2d = -w2d;
if ((w1d==0 && w2d==0) || (w1d<0 || w2d<0))
continue;
ptonline[0] = w2[0]+(w2d/(w1d+w2d))*w21[0];
ptonline[1] = w2[1]+(w2d/(w1d+w2d))*w21[1];
ptonline[0] = (int32_t)(w2[0]+(w2d/(w1d+w2d))*w21[0]);
ptonline[1] = (int32_t)(w2[1]+(w2d/(w1d+w2d))*w21[1]);
scrp[0] = ptonline[0]-vect.x;
scrp[1] = ptonline[1]-vect.y;
if (scrv[0]*scrp[0] + scrv[1]*scrp[1] <= 0)
@ -6096,7 +6096,7 @@ int32_t dxtfilter(int32_t fil, texcachepicture *pict, char *pic, void *midbuf, c
if (glusetexcache == 2)
{
#ifdef USELZF
cleng = fastlz_compress(pic, miplen, packbuf/*, miplen-1*/);
cleng = qlz_compress(pic, packbuf, miplen, state_compress);
if (cleng == 0 || cleng > j-1)
{
// failed to compress
@ -6138,7 +6138,7 @@ int32_t dxtfilter(int32_t fil, texcachepicture *pict, char *pic, void *midbuf, c
{
#ifdef USELZF
j = (miplen/stride)<<3;
cleng = fastlz_compress(midbuf,j,packbuf/*,j-1*/);
cleng = qlz_compress(midbuf,packbuf,j,state_compress);
if (cleng == 0 || cleng > j-1)
{
cleng = j;
@ -6169,7 +6169,7 @@ int32_t dxtfilter(int32_t fil, texcachepicture *pict, char *pic, void *midbuf, c
{
#ifdef USELZF
j = (miplen/stride)<<2;
cleng = fastlz_compress(midbuf,j,packbuf/*,j-1*/);
cleng = qlz_compress(midbuf,packbuf,j,state_compress);
if (cleng == 0 || cleng > j-1)
{
cleng = j;
@ -6205,7 +6205,7 @@ int32_t dxtfilter(int32_t fil, texcachepicture *pict, char *pic, void *midbuf, c
{
#ifdef USELZF
j = (miplen/stride)<<2;
cleng = fastlz_compress(midbuf,j,packbuf/*,j-1*/);
cleng = qlz_compress(midbuf,packbuf,j,state_compress);
if (cleng == 0 || cleng > j-1)
{
cleng = j;
@ -6239,7 +6239,7 @@ int32_t dedxtfilter(int32_t fil, texcachepicture *pict, char *pic, void *midbuf,
if (ispacked && cleng < pict->size) inbuf = packbuf; else inbuf = pic;
if (kread(fil, inbuf, cleng) != cleng) return -1;
if (ispacked && cleng < pict->size)
if (fastlz_decompress(packbuf, cleng, pic, pict->size) == 0) return -1;
if (qlz_decompress(packbuf, pic, state_decompress) == 0) return -1;
#else
if (ispacked) inbuf = packbuf; else inbuf = pic;
if (kread(fil, inbuf, cleng) != cleng) return -1;
@ -6266,7 +6266,7 @@ int32_t dedxtfilter(int32_t fil, texcachepicture *pict, char *pic, void *midbuf,
if (ispacked && cleng < j) inbuf = packbuf; else inbuf = midbuf;
if (Bread(fil,inbuf,cleng) < cleng) return -1;
if (ispacked && cleng < j)
if (fastlz_decompress(packbuf,cleng,midbuf,j) == 0) return -1;
if (qlz_decompress(packbuf,midbuf,state_decompress) == 0) return -1;
#else
if (Bread(fil,inbuf,cleng) < cleng) return -1;
if (ispacked && lzwuncompress(packbuf,cleng,midbuf,j) != j) return -1;
@ -6284,7 +6284,7 @@ int32_t dedxtfilter(int32_t fil, texcachepicture *pict, char *pic, void *midbuf,
if (ispacked && cleng < j) inbuf = packbuf; else inbuf = midbuf;
if (Bread(fil,inbuf,cleng) < cleng) return -1;
if (ispacked && cleng < j)
if (fastlz_decompress(packbuf,cleng,midbuf,j) == 0) return -1;
if (qlz_decompress(packbuf,midbuf,state_decompress) == 0) return -1;
#else
if (Bread(fil,inbuf,cleng) < cleng) return -1;
if (ispacked && lzwuncompress(packbuf,cleng,midbuf,j) != j) return -1;
@ -6304,7 +6304,7 @@ int32_t dedxtfilter(int32_t fil, texcachepicture *pict, char *pic, void *midbuf,
if (ispacked && cleng < j) inbuf = packbuf; else inbuf = midbuf;
if (Bread(fil,inbuf,cleng) < cleng) return -1;
if (ispacked && cleng < j)
if (fastlz_decompress(packbuf,cleng,midbuf,j) == 0) return -1;
if (qlz_decompress(packbuf,midbuf,state_decompress) == 0) return -1;
#else
if (Bread(fil,inbuf,cleng) < cleng) return -1;
if (ispacked && lzwuncompress(packbuf,cleng,midbuf,j) != j) return -1;

854
polymer/eduke32/build/src/quicklz.c Normal file
View file

@ -0,0 +1,854 @@
// Fast data compression library
// Copyright (C) 2006-2009 Lasse Mikkel Reinhold
// lar@quicklz.com
//
// QuickLZ can be used for free under the GPL-1 or GPL-2 license (where anything
// released into public must be open source) or under a commercial license if such
// has been acquired (see http://www.quicklz.com/order.html). The commercial license
// does not cover derived or ported versions created by third parties under GPL.
// BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION
// BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION
// BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION
// BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION
// BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION BETA VERSION
// 1.5.0 BETA 2
#include "quicklz.h"
#if QLZ_VERSION_MAJOR != 1 || QLZ_VERSION_MINOR != 5 || QLZ_VERSION_REVISION != 0
#error quicklz.c and quicklz.h have different versions
#endif
#if (defined(__X86__) || defined(__i386__) || defined(i386) || defined(_M_IX86) || defined(__386__) || defined(__x86_64__) || defined(_M_X64))
#define X86X64
#endif
#define MINOFFSET 2
#define UNCONDITIONAL_MATCHLEN 6
#define UNCOMPRESSED_END 4
#define CWORD_LEN 4
#if QLZ_COMPRESSION_LEVEL == 1 && defined QLZ_PTR_64 && QLZ_STREAMING_BUFFER == 0
#define OFFSET_BASE source
#define CAST (ui32)(size_t)
#else
#define OFFSET_BASE 0
#define CAST
#endif
int qlz_get_setting(int setting)
{
switch (setting)
{
case 0: return QLZ_COMPRESSION_LEVEL;
case 1: return sizeof(qlz_state_compress);
case 2: return sizeof(qlz_state_decompress);
case 3: return QLZ_STREAMING_BUFFER;
#ifdef QLZ_MEMORY_SAFE
case 6: return 1;
#else
case 6: return 0;
#endif
case 7: return QLZ_VERSION_MAJOR;
case 8: return QLZ_VERSION_MINOR;
case 9: return QLZ_VERSION_REVISION;
}
return -1;
}
#if QLZ_COMPRESSION_LEVEL == 1
static int same(const unsigned char *src, size_t n)
{
while(n > 0 && *(src + n) == *src)
n--;
return n == 0 ? 1 : 0;
}
#endif
static void reset_table_compress(qlz_state_compress *state)
{
int i;
for(i = 0; i < QLZ_HASH_VALUES; i++)
{
#if QLZ_COMPRESSION_LEVEL == 1
state->hash[i].offset = 0;
#else
state->hash_counter[i] = 0;
#endif
}
}
static void reset_table_decompress(qlz_state_decompress *state)
{
int i;
(void)state;
(void)i;
#if QLZ_COMPRESSION_LEVEL == 2
for(i = 0; i < QLZ_HASH_VALUES; i++)
{
state->hash_counter[i] = 0;
}
#endif
}
static __inline ui32 hash_func(ui32 i)
{
#if QLZ_COMPRESSION_LEVEL == 2
return ((i >> 9) ^ (i >> 13) ^ i) & (QLZ_HASH_VALUES - 1);
#else
return ((i >> 12) ^ i) & (QLZ_HASH_VALUES - 1);
#endif
}
static __inline ui32 fast_read(void const *src, ui32 bytes)
{
#ifndef X86X64
unsigned char *p = (unsigned char*)src;
switch (bytes)
{
case 4:
return(*p | *(p + 1) << 8 | *(p + 2) << 16 | *(p + 3) << 24);
case 3:
return(*p | *(p + 1) << 8 | *(p + 2) << 16);
case 2:
return(*p | *(p + 1) << 8);
case 1:
return(*p);
}
return 0;
#else
if (bytes >= 1 && bytes <= 4)
return *((ui32*)src);
else
return 0;
#endif
}
static __inline ui32 hashat(const unsigned char *src)
{
ui32 fetch, hash;
fetch = fast_read(src, 3);
hash = hash_func(fetch);
return hash;
}
static __inline void fast_write(ui32 f, void *dst, size_t bytes)
{
#ifndef X86X64
unsigned char *p = (unsigned char*)dst;
switch (bytes)
{
case 4:
*p = (unsigned char)f;
*(p + 1) = (unsigned char)(f >> 8);
*(p + 2) = (unsigned char)(f >> 16);
*(p + 3) = (unsigned char)(f >> 24);
return;
case 3:
*p = (unsigned char)f;
*(p + 1) = (unsigned char)(f >> 8);
*(p + 2) = (unsigned char)(f >> 16);
return;
case 2:
*p = (unsigned char)f;
*(p + 1) = (unsigned char)(f >> 8);
return;
case 1:
*p = (unsigned char)f;
return;
}
#else
switch (bytes)
{
case 4:
*((ui32*)dst) = f;
return;
case 3:
*((ui32*)dst) = f;
return;
case 2:
*((ui16 *)dst) = (ui16)f;
return;
case 1:
*((unsigned char*)dst) = (unsigned char)f;
return;
}
#endif
}
size_t qlz_size_decompressed(const char *source)
{
ui32 n, r;
n = (((*source) & 2) == 2) ? 4 : 1;
r = fast_read(source + 1 + n, n);
r = r & (0xffffffff >> ((4 - n)*8));
return r;
}
size_t qlz_size_compressed(const char *source)
{
ui32 n, r;
n = (((*source) & 2) == 2) ? 4 : 1;
r = fast_read(source + 1, n);
r = r & (0xffffffff >> ((4 - n)*8));
return r;
}
size_t qlz_size_header(const char *source)
{
size_t n = 2*((((*source) & 2) == 2) ? 4 : 1) + 1;
return n;
}
static __inline void memcpy_up(unsigned char *dst, const unsigned char *src, ui32 n)
{
// Caution if modifying memcpy_up! Overlap of dst and src must be special handled.
#ifndef X86X64
unsigned char *end = dst + n;
while(dst < end)
{
*dst = *src;
dst++;
src++;
}
#else
ui32 f = 0;
do
{
*(ui32 *)(dst + f) = *(ui32 *)(src + f);
f += MINOFFSET + 1;
}
while (f < n);
#endif
}
static __inline void update_hash(qlz_state_decompress *state, const unsigned char *s)
{
#if QLZ_COMPRESSION_LEVEL == 1
ui32 hash;
hash = hashat(s);
state->hash[hash].offset = s;
state->hash_counter[hash] = 1;
#elif QLZ_COMPRESSION_LEVEL == 2
ui32 hash;
unsigned char c;
hash = hashat(s);
c = state->hash_counter[hash];
state->hash[hash].offset[c & (QLZ_POINTERS - 1)] = s;
c++;
state->hash_counter[hash] = c;
#endif
(void)state;
(void)s;
}
#if QLZ_COMPRESSION_LEVEL <= 2
static void update_hash_upto(qlz_state_decompress *state, unsigned char **lh, const unsigned char *max)
{
while(*lh < max)
{
(*lh)++;
update_hash(state, *lh);
}
}
#endif
static size_t qlz_compress_core(const unsigned char *source, unsigned char *destination, size_t size, qlz_state_compress *state)
{
const unsigned char *last_byte = source + size - 1;
const unsigned char *src = source;
unsigned char *cword_ptr = destination;
unsigned char *dst = destination + CWORD_LEN;
ui32 cword_val = 1U << 31;
const unsigned char *last_matchstart = last_byte - UNCONDITIONAL_MATCHLEN - UNCOMPRESSED_END;
ui32 fetch = 0;
unsigned int lits = 0;
(void) lits;
if(src <= last_matchstart)
fetch = fast_read(src, 3);
while(src <= last_matchstart)
{
if ((cword_val & 1) == 1)
{
// store uncompressed if compression ratio is too low
if (src > source + (size >> 1) && dst - destination > src - source - ((src - source) >> 5))
return 0;
fast_write((cword_val >> 1) | (1U << 31), cword_ptr, CWORD_LEN);
cword_ptr = dst;
dst += CWORD_LEN;
cword_val = 1U << 31;
fetch = fast_read(src, 3);
}
#if QLZ_COMPRESSION_LEVEL == 1
{
const unsigned char *o;
ui32 hash, cached;
hash = hash_func(fetch);
cached = fetch ^ state->hash[hash].cache;
state->hash[hash].cache = fetch;
o = state->hash[hash].offset + OFFSET_BASE;
state->hash[hash].offset = CAST(src - OFFSET_BASE);
#ifdef X86X64
if ((cached & 0xffffff) == 0 && o != OFFSET_BASE && (src - o > MINOFFSET || (src == o + 1 && lits >= 3 && src > source + 3 && same(src - 3, 6))))
{
if(cached != 0)
{
#else
if (cached == 0 && o != OFFSET_BASE && (src - o > MINOFFSET || (src == o + 1 && lits >= 3 && src > source + 3 && same(src - 3, 6))))
{
if (*(o + 3) != *(src + 3))
{
#endif
hash <<= 4;
cword_val = (cword_val >> 1) | (1U << 31);
fast_write((3 - 2) | hash, dst, 2);
src += 3;
dst += 2;
}
else
{
const unsigned char *old_src = src;
size_t matchlen;
hash <<= 4;
cword_val = (cword_val >> 1) | (1U << 31);
src += 4;
if(*(o + (src - old_src)) == *src)
{
src++;
if(*(o + (src - old_src)) == *src)
{
size_t q = last_byte - UNCOMPRESSED_END - (src - 5) + 1;
size_t remaining = q > 255 ? 255 : q;
src++;
while(*(o + (src - old_src)) == *src && (size_t)(src - old_src) < remaining)
src++;
}
}
matchlen = src - old_src;
if (matchlen < 18)
{
fast_write((ui32)(matchlen - 2) | hash, dst, 2);
dst += 2;
}
else
{
fast_write((ui32)(matchlen << 16) | hash, dst, 3);
dst += 3;
}
}
fetch = fast_read(src, 3);
lits = 0;
}
else
{
lits++;
*dst = *src;
src++;
dst++;
cword_val = (cword_val >> 1);
#ifdef X86X64
fetch = fast_read(src, 3);
#else
fetch = (fetch >> 8 & 0xffff) | (*(src + 2) << 16);
#endif
}
}
#elif QLZ_COMPRESSION_LEVEL >= 2
{
const unsigned char *o, *offset2;
ui32 hash, matchlen, k, m, best_k = 0;
unsigned char c;
size_t remaining = (last_byte - UNCOMPRESSED_END - src + 1) > 255 ? 255 : (last_byte - UNCOMPRESSED_END - src + 1);
(void)best_k;
//hash = hashat(src);
fetch = fast_read(src, 3);
hash = hash_func(fetch);
c = state->hash_counter[hash];
offset2 = state->hash[hash].offset[0];
if(offset2 < src - MINOFFSET && c > 0 && ((fast_read(offset2, 3) ^ fetch) & 0xffffff) == 0)
{
matchlen = 3;
if(*(offset2 + matchlen) == *(src + matchlen))
{
matchlen = 4;
while(*(offset2 + matchlen) == *(src + matchlen) && matchlen < remaining)
matchlen++;
}
}
else
matchlen = 0;
for(k = 1; k < QLZ_POINTERS && c > k; k++)
{
o = state->hash[hash].offset[k];
#if QLZ_COMPRESSION_LEVEL == 3
if(((fast_read(o, 3) ^ fetch) & 0xffffff) == 0 && o < src - MINOFFSET)
#elif QLZ_COMPRESSION_LEVEL == 2
if(*(src + matchlen) == *(o + matchlen) && ((fast_read(o, 3) ^ fetch) & 0xffffff) == 0 && o < src - MINOFFSET)
#endif
{
m = 3;
while(*(o + m) == *(src + m) && m < remaining)
m++;
#if QLZ_COMPRESSION_LEVEL == 3
if ((m > matchlen) || (m == matchlen && o > offset2))
#elif QLZ_COMPRESSION_LEVEL == 2
if (m > matchlen)
#endif
{
offset2 = o;
matchlen = m;
best_k = k;
}
}
}
o = offset2;
state->hash[hash].offset[c & (QLZ_POINTERS - 1)] = src;
c++;
state->hash_counter[hash] = c;
#if QLZ_COMPRESSION_LEVEL == 3
if(matchlen > 2 && src - o < 131071)
{
ui32 u;
size_t offset = src - o;
for(u = 1; u < matchlen; u++)
{
hash = hashat(src + u);
c = state->hash_counter[hash]++;
state->hash[hash].offset[c & (QLZ_POINTERS - 1)] = src + u;
}
cword_val = (cword_val >> 1) | (1U << 31);
src += matchlen;
if(matchlen == 3 && offset <= 63)
{
*dst = (unsigned char)(offset << 2);
dst++;
}
else if (matchlen == 3 && offset <= 16383)
{
ui32 f = (ui32)((offset << 2) | 1);
fast_write(f, dst, 2);
dst += 2;
}
else if (matchlen <= 18 && offset <= 1023)
{
ui32 f = ((matchlen - 3) << 2) | ((ui32)offset << 6) | 2;
fast_write(f, dst, 2);
dst += 2;
}
else if(matchlen <= 33)
{
ui32 f = ((matchlen - 2) << 2) | ((ui32)offset << 7) | 3;
fast_write(f, dst, 3);
dst += 3;
}
else
{
ui32 f = ((matchlen - 3) << 7) | ((ui32)offset << 15) | 3;
fast_write(f, dst, 4);
dst += 4;
}
}
else
{
*dst = *src;
src++;
dst++;
cword_val = (cword_val >> 1);
}
#elif QLZ_COMPRESSION_LEVEL == 2
if(matchlen > 2)
{
cword_val = (cword_val >> 1) | (1U << 31);
src += matchlen;
if (matchlen < 10)
{
ui32 f = best_k | ((matchlen - 2) << 2) | (hash << 5);
fast_write(f, dst, 2);
dst += 2;
}
else
{
ui32 f = best_k | (matchlen << 16) | (hash << 5);
fast_write(f, dst, 3);
dst += 3;
}
}
else
{
*dst = *src;
src++;
dst++;
cword_val = (cword_val >> 1);
}
#endif
}
#endif
}
while (src <= last_byte)
{
if ((cword_val & 1) == 1)
{
fast_write((cword_val >> 1) | (1U << 31), cword_ptr, CWORD_LEN);
cword_ptr = dst;
dst += CWORD_LEN;
cword_val = 1U << 31;
}
#if QLZ_COMPRESSION_LEVEL < 3
if (src <= last_byte - 3)
{
#if QLZ_COMPRESSION_LEVEL == 1
ui32 hash, fetch;
fetch = fast_read(src, 3);
hash = hash_func(fetch);
state->hash[hash].offset = CAST(src - OFFSET_BASE);
state->hash[hash].cache = fetch;
#elif QLZ_COMPRESSION_LEVEL == 2
ui32 hash;
unsigned char c;
hash = hashat(src);
c = state->hash_counter[hash];
state->hash[hash].offset[c & (QLZ_POINTERS - 1)] = src;
c++;
state->hash_counter[hash] = c;
#endif
}
#endif
*dst = *src;
src++;
dst++;
cword_val = (cword_val >> 1);
}
while((cword_val & 1) != 1)
cword_val = (cword_val >> 1);
fast_write((cword_val >> 1) | (1U << 31), cword_ptr, CWORD_LEN);
// min. size must be 9 bytes so that the qlz_size functions can take 9 bytes as argument
return dst - destination < 9 ? 9 : dst - destination;
}
static size_t qlz_decompress_core(const unsigned char *source, unsigned char *destination, size_t size, qlz_state_decompress *state, const unsigned char *history)
{
const unsigned char *src = source + qlz_size_header((const char *)source);
unsigned char *dst = destination;
const unsigned char *last_destination_byte = destination + size - 1;
ui32 cword_val = 1;
const unsigned char *last_matchstart = last_destination_byte - UNCONDITIONAL_MATCHLEN - UNCOMPRESSED_END;
unsigned char *last_hashed = destination - 1;
const unsigned char *last_source_byte = source + qlz_size_compressed((const char *)source) - 1;
static const ui32 bitlut[16] = {4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0};
(void) last_source_byte;
(void) last_hashed;
(void) state;
(void) history;
for(;;)
{
ui32 fetch;
if (cword_val == 1)
{
#ifdef QLZ_MEMORY_SAFE
if(src + CWORD_LEN - 1 > last_source_byte)
return 0;
#endif
cword_val = fast_read(src, CWORD_LEN);
src += CWORD_LEN;
}
#ifdef QLZ_MEMORY_SAFE
if(src + 4 - 1 > last_source_byte)
return 0;
#endif
fetch = fast_read(src, 4);
if ((cword_val & 1) == 1)
{
ui32 matchlen;
const unsigned char *offset2;
#if QLZ_COMPRESSION_LEVEL == 1
ui32 hash;
cword_val = cword_val >> 1;
hash = (fetch >> 4) & 0xfff;
offset2 = (const unsigned char *)(size_t)state->hash[hash].offset;
if((fetch & 0xf) != 0)
{
matchlen = (fetch & 0xf) + 2;
src += 2;
}
else
{
matchlen = *(src + 2);
src += 3;
}
#elif QLZ_COMPRESSION_LEVEL == 2
ui32 hash;
unsigned char c;
cword_val = cword_val >> 1;
hash = (fetch >> 5) & 0x7ff;
c = (unsigned char)(fetch & 0x3);
offset2 = state->hash[hash].offset[c];
if((fetch & (28)) != 0)
{
matchlen = ((fetch >> 2) & 0x7) + 2;
src += 2;
}
else
{
matchlen = *(src + 2);
src += 3;
}
#elif QLZ_COMPRESSION_LEVEL == 3
ui32 offset;
cword_val = cword_val >> 1;
if ((fetch & 3) == 0)
{
offset = (fetch & 0xff) >> 2;
matchlen = 3;
src++;
}
else if ((fetch & 2) == 0)
{
offset = (fetch & 0xffff) >> 2;
matchlen = 3;
src += 2;
}
else if ((fetch & 1) == 0)
{
offset = (fetch & 0xffff) >> 6;
matchlen = ((fetch >> 2) & 15) + 3;
src += 2;
}
else if ((fetch & 127) != 3)
{
offset = (fetch >> 7) & 0x1ffff;
matchlen = ((fetch >> 2) & 0x1f) + 2;
src += 3;
}
else
{
offset = (fetch >> 15);
matchlen = ((fetch >> 7) & 255) + 3;
src += 4;
}
offset2 = dst - offset;
#endif
#ifdef QLZ_MEMORY_SAFE
if(offset2 < history || offset2 > dst - MINOFFSET - 1)
return 0;
if(matchlen > (ui32)(last_destination_byte - dst - UNCOMPRESSED_END + 1))
return 0;
#endif
memcpy_up(dst, offset2, matchlen);
dst += matchlen;
#if QLZ_COMPRESSION_LEVEL <= 2
update_hash_upto(state, &last_hashed, dst - matchlen);
last_hashed = dst - 1;
#endif
}
else
{
if (dst < last_matchstart)
{
unsigned int n = bitlut[cword_val & 0xf];
#ifdef X86X64
*(ui32 *)dst = *(ui32 *)src;
#else
memcpy_up(dst, src, 4);
#endif
cword_val = cword_val >> n;
dst += n;
src += n;
#if QLZ_COMPRESSION_LEVEL <= 2
update_hash_upto(state, &last_hashed, dst - 3);
#endif
}
else
{
while(dst <= last_destination_byte)
{
if (cword_val == 1)
{
src += CWORD_LEN;
cword_val = 1U << 31;
}
#ifdef QLZ_MEMORY_SAFE
if(src >= last_source_byte + 1)
return 0;
#endif
*dst = *src;
dst++;
src++;
cword_val = cword_val >> 1;
}
#if QLZ_COMPRESSION_LEVEL <= 2
update_hash_upto(state, &last_hashed, last_destination_byte - 3); // todo, use constant
#endif
return size;
}
}
}
}
size_t qlz_compress(const void *source, char *destination, size_t size, qlz_state_compress *state)
{
size_t r;
ui32 compressed;
size_t base;
if(size == 0 || size > 0xffffffff - 400)
return 0;
if(size < 216)
base = 3;
else
base = 9;
#if QLZ_STREAMING_BUFFER > 0
if (state->stream_counter + size - 1 >= QLZ_STREAMING_BUFFER)
#endif
{
reset_table_compress(state);
r = base + qlz_compress_core((const unsigned char *)source, (unsigned char*)destination + base, size, state);
#if QLZ_STREAMING_BUFFER > 0
reset_table_compress(state);
#endif
if(r == base)
{
memcpy(destination + base, source, size);
r = size + base;
compressed = 0;
}
else
{
compressed = 1;
}
state->stream_counter = 0;
}
#if QLZ_STREAMING_BUFFER > 0
else
{
unsigned char *src = state->stream_buffer + state->stream_counter;
memcpy(src, source, size);
r = base + qlz_compress_core(src, (unsigned char*)destination + base, size, state);
if(r == base)
{
memcpy(destination + base, src, size);
r = size + base;
compressed = 0;
reset_table_compress(state);
}
else
{
compressed = 1;
}
state->stream_counter += size;
}
#endif
if(base == 3)
{
*destination = (unsigned char)(0 | compressed);
*(destination + 1) = (unsigned char)r;
*(destination + 2) = (unsigned char)size;
}
else
{
*destination = (unsigned char)(2 | compressed);
fast_write((ui32)r, destination + 1, 4);
fast_write((ui32)size, destination + 5, 4);
}
*destination |= (QLZ_COMPRESSION_LEVEL << 2);
*destination |= (1 << 6);
*destination |= ((QLZ_STREAMING_BUFFER == 0 ? 0 : (QLZ_STREAMING_BUFFER == 100000 ? 1 : (QLZ_STREAMING_BUFFER == 1000000 ? 2 : 3))) << 4);
// 76543210
// 01SSLLHC
return r;
}
size_t qlz_decompress(const char *source, void *destination, qlz_state_decompress *state)
{
size_t dsiz = qlz_size_decompressed(source);
#if QLZ_STREAMING_BUFFER > 0
if (state->stream_counter + qlz_size_decompressed(source) - 1 >= QLZ_STREAMING_BUFFER)
#endif
{
if((*source & 1) == 1)
{
reset_table_decompress(state);
dsiz = qlz_decompress_core((const unsigned char *)source, (unsigned char *)destination, dsiz, state, (const unsigned char *)destination);
}
else
{
memcpy(destination, source + qlz_size_header(source), dsiz);
}
state->stream_counter = 0;
reset_table_decompress(state);
}
#if QLZ_STREAMING_BUFFER > 0
else
{
unsigned char *dst = state->stream_buffer + state->stream_counter;
if((*source & 1) == 1)
{
dsiz = qlz_decompress_core((const unsigned char *)source, dst, dsiz, state, (const unsigned char *)state->stream_buffer);
}
else
{
memcpy(dst, source + qlz_size_header(source), dsiz);
reset_table_decompress(state);
}
memcpy(destination, dst, dsiz);
state->stream_counter += dsiz;
}
#endif
return dsiz;
}

5
polymer/eduke32/build/src/sdlayer.c
View file

@ -89,7 +89,7 @@ static char keytranslation[SDL_NUM_SCANCODES];
static int32_t buildkeytranslationtable(void);
//static SDL_Surface * loadtarga(const char *fn); // for loading the icon
static SDL_Surface * appicon;
static SDL_Surface * appicon = NULL;
static SDL_Surface * loadappicon(void);
int32_t wm_msgbox(char *name, char *fmt, ...)
@ -337,7 +337,10 @@ void uninitsystem(void)
uninittimer();
if (appicon)
{
SDL_FreeSurface(appicon);
appicon = NULL;
}
SDL_Quit();

2
polymer/eduke32/build/src/winlayer.c
View file

@ -3405,6 +3405,8 @@ static int32_t SetupOpenGL(int32_t width, int32_t height, int32_t bitspp)
{
if (!Bstrcmp(glinfo.renderer,"Intel 865G"))
err = 0;
else if (!Bstrcmp(glinfo.renderer,"Intel 915G"))
err = 0;
else if (!Bstrcmp(glinfo.renderer,"Intel 945GM"))
err = 0;
else if (!Bstrcmp(glinfo.renderer,"Intel 965/963 Graphics Media Accelerator"))

100
polymer/eduke32/eduke32.vcproj
View file

@ -108,10 +108,6 @@
RelativePath=".\build\include\enet_mmulti.h"
>
</File>
<File
RelativePath=".\build\include\fastlz.h"
>
</File>
<File
RelativePath=".\build\include\glbuild.h"
>
@ -152,10 +148,6 @@
RelativePath=".\build\include\mmulti_unstable.h"
>
</File>
<File
RelativePath=".\build\include\mmultimsgs.h"
>
</File>
<File
RelativePath=".\build\include\nedmalloc.h"
>
@ -184,6 +176,10 @@
RelativePath=".\build\include\pragmas.h"
>
</File>
<File
RelativePath=".\build\include\quicklz.h"
>
</File>
<File
RelativePath=".\build\include\scriptfile.h"
>
@ -260,10 +256,6 @@
RelativePath=".\build\src\engine_priv.h"
>
</File>
<File
RelativePath=".\build\src\fastlz.c"
>
</File>
<File
RelativePath=".\build\src\glbuild.c"
>
@ -316,6 +308,10 @@
RelativePath=".\build\src\pragmas.c"
>
</File>
<File
RelativePath=".\build\src\quicklz.c"
>
</File>
<File
RelativePath=".\build\src\scriptfile.c"
>
@ -778,6 +774,86 @@
Name="Misc"
>
</Filter>
<Filter
Name="enet"
>
<Filter
Name="source"
>
<File
RelativePath=".\source\enet\src\callbacks.c"
>
</File>
<File
RelativePath=".\source\enet\src\host.c"
>
</File>
<File
RelativePath=".\source\enet\src\list.c"
>
</File>
<File
RelativePath=".\source\enet\src\packet.c"
>
</File>
<File
RelativePath=".\source\enet\src\peer.c"
>
</File>
<File
RelativePath=".\source\enet\src\protocol.c"
>
</File>
<File
RelativePath=".\source\enet\src\unix.c"
>
</File>
<File
RelativePath=".\source\enet\src\win32.c"
>
</File>
</Filter>
<Filter
Name="headers"
>
<File
RelativePath=".\source\enet\include\enet\callbacks.h"
>
</File>
<File
RelativePath=".\source\enet\include\enet\enet.h"
>
</File>
<File
RelativePath=".\source\enet\include\enet\list.h"
>
</File>
<File
RelativePath=".\source\enet\include\enet\protocol.h"
>
</File>
<File
RelativePath=".\source\enet\include\enet\time.h"
>
</File>
<File
RelativePath=".\source\enet\include\enet\types.h"
>
</File>
<File
RelativePath=".\source\enet\include\enet\unix.h"
>
</File>
<File
RelativePath=".\source\enet\include\enet\utility.h"
>
</File>
<File
RelativePath=".\source\enet\include\enet\win32.h"
>
</File>
</Filter>
</Filter>
</Files>
<Globals>
</Globals>

10
polymer/eduke32/source/actors.c
View file

@ -29,6 +29,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
extern int32_t g_numEnvSoundsPlaying;
extern int32_t g_noEnemies;
extern int32_t ticrandomseed;
inline void G_UpdateInterpolations(void) //Stick at beginning of G_DoMoveThings
{
@ -4832,6 +4833,9 @@ static void G_MoveMisc(void) // STATNUM 5
ActorExtra[i].floorz = s->z = getflorzofslope(s->sectnum,s->x,s->y);
else switch (DynamicTileMap[switchpicnum])
{
case APLAYER__STATIC:
s->cstat = 32768;
goto BOLT;
case NEON1__STATIC:
case NEON2__STATIC:
case NEON3__STATIC:
@ -5670,7 +5674,7 @@ static void G_MoveEffectors(void) //STATNUM 3
m = (s->xvel*sintable[(s->ang+512)&2047])>>14;
x = (s->xvel*sintable[s->ang&2047])>>14;
for (p = connecthead; p >= 0; p=connectpoint2[p])
TRAVERSE_CONNECT(p)
if (sector[g_player[p].ps->cursectnum].lotag != 2)
{
if (g_playerSpawnPoints[p].os == s->sectnum)
@ -5849,7 +5853,7 @@ static void G_MoveEffectors(void) //STATNUM 3
}
}
for (p = connecthead; p >= 0; p = connectpoint2[p])
TRAVERSE_CONNECT(p)
{
if (sprite[g_player[p].ps->i].sectnum == s->sectnum)
{
@ -7135,7 +7139,7 @@ static void G_MoveEffectors(void) //STATNUM 3
fricyv += x<<5;
}
for (p = connecthead; p >= 0; p = connectpoint2[p])
TRAVERSE_CONNECT(p)
if (sprite[g_player[p].ps->i].sectnum == s->sectnum && g_player[p].ps->on_ground)
g_player[p].ps->posz += s->zvel;

20
polymer/eduke32/source/astub.c
View file

@ -42,7 +42,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#include "fx_man.h"
#include "macros.h"
#include "fastlz.h"
#include "quicklz.h"
#include "m32script.h"
#include "m32def.h"
@ -244,8 +244,8 @@ void create_map_snapshot(void)
else
{
mapstate->sectors = (sectortype *)Bcalloc(1, sizeof(sectortype) * numsectors);
mapstate->sectsiz = j = fastlz_compress(&sector[0], sizeof(sectortype) * numsectors,
&mapstate->sectors[0]/*, sizeof(sectortype) * numsectors*/);
mapstate->sectsiz = j = qlz_compress(&sector[0], (char *)&mapstate->sectors[0],
sizeof(sectortype) * numsectors, state_compress);
mapstate->sectors = (sectortype *)Brealloc(mapstate->sectors, j);
mapstate->sectcrc = tempcrc;
}
@ -265,8 +265,8 @@ void create_map_snapshot(void)
else
{
mapstate->walls = (walltype *)Bcalloc(1, sizeof(walltype) * numwalls);
mapstate->wallsiz = j = fastlz_compress(&wall[0], sizeof(walltype) * numwalls,
&mapstate->walls[0]/*, sizeof(walltype) * numwalls*/);
mapstate->wallsiz = j = qlz_compress(&wall[0], (char *)&mapstate->walls[0],
sizeof(walltype) * numwalls, state_compress);
mapstate->walls = (walltype *)Brealloc(mapstate->walls, j);
mapstate->wallcrc = tempcrc;
}
@ -298,8 +298,8 @@ void create_map_snapshot(void)
i++;
}
}
mapstate->spritesiz = j = fastlz_compress(&tspri[0], sizeof(spritetype) * numsprites,
&mapstate->sprites[0]/*, sizeof(spritetype) * numsprites*/);
mapstate->spritesiz = j = qlz_compress(&tspri[0], (char *)&mapstate->sprites[0],
sizeof(spritetype) * numsprites, state_compress);
mapstate->sprites = (spritetype *)Brealloc(mapstate->sprites, j);
mapstate->spritecrc = tempcrc;
Bfree(tspri);
@ -370,13 +370,13 @@ int32_t map_undoredo(int32_t dir)
if (mapstate->numsectors)
{
fastlz_decompress(&mapstate->sectors[0], mapstate->sectsiz, &sector[0], sizeof(sectortype) * numsectors);
qlz_decompress((const char *)&mapstate->sectors[0], &sector[0], state_decompress);
if (mapstate->numwalls)
fastlz_decompress(&mapstate->walls[0], mapstate->wallsiz, &wall[0], sizeof(walltype) * numwalls);
qlz_decompress((const char *)&mapstate->walls[0], &wall[0], state_decompress);
if (mapstate->numsprites)
fastlz_decompress(&mapstate->sprites[0], mapstate->spritesiz, &sprite[0], sizeof(spritetype) * numsprites);
qlz_decompress((const char *)&mapstate->sprites[0], &sprite[0], state_decompress);
}
updatenumsprites();

32
polymer/eduke32/source/duke3d.h
View file

@ -47,6 +47,12 @@ extern "C" {
#include "macros.h"
#include "enet/enet.h"
extern ENetHost * net_server;
extern ENetHost * net_client;
extern ENetPeer * net_peer;
#define APPNAME "EDuke32"
#define VERSION " 2.0.0devel"
// this is checked against http://eduke32.com/VERSION
@ -83,7 +89,7 @@ extern int32_t g_scriptVersion, g_Shareware, g_gameType;
#define AUTO_AIM_ANGLE 48
#define RECSYNCBUFSIZ 2520 //2520 is the (LCM of 1-8)*3
#define MOVEFIFOSIZ 256
#define MOVEFIFOSIZ 2
#define FOURSLEIGHT (1<<8)
@ -422,9 +428,9 @@ extern int32_t fricxv,fricyv;
// mywhatever type globals
typedef struct {
int32_t posx, posy, posz, horiz, ohoriz, ohorizoff, invdisptime;
int32_t bobposx, bobposy, oposx, oposy, oposz, pyoff, opyoff;
int32_t posxv, posyv, poszv, last_pissed_time, truefz, truecz;
int32_t posx, posy, posz, oposx, oposy, oposz, posxv, posyv, poszv;
int32_t bobposx, bobposy, pyoff, opyoff, horiz, ohoriz, ohorizoff, invdisptime;
int32_t last_pissed_time, truefz, truecz;
int32_t player_par, visibility;
int32_t bobcounter, weapon_sway;
int32_t pals_time, randomflamex, crack_time;
@ -485,7 +491,7 @@ typedef struct {
char name[32];
} DukePlayer_t;
extern char tempbuf[2048], packbuf[576], menutextbuf[128];
extern char tempbuf[2048], packbuf[4096], menutextbuf[128];
extern int32_t g_spriteGravity;
@ -559,9 +565,9 @@ typedef struct {
void *lightptr;
#endif
int8_t filler[16]; // pad struct to 128 bytes
projectile_t *projectile; //4b/8b
int8_t filler[16]; // pad struct to 128 bytes
} ActorData_t;
extern ActorData_t ActorExtra[MAXSPRITES];
@ -638,8 +644,6 @@ extern char boardfilename[BMAX_PATH];
extern uint8_t waterpal[768],slimepal[768],titlepal[768],drealms[768],endingpal[768],animpal[768];
extern char currentboardfilename[BMAX_PATH];
extern char cachedebug,g_earthquakeTime;
// 0: master/slave, 1: peer-to-peer
extern int32_t g_networkBroadcastMode;
extern char lumplockbyte[11];
//DUKE3D.H - replace the end "my's" with this
@ -670,7 +674,6 @@ typedef struct {
extern DukeStatus_t sbar;
extern int32_t g_cameraDistance, g_cameraClock, g_playerFriction,g_showShareware;
extern int32_t g_networkBroadcastMode, g_movesPerPacket;
extern int32_t g_gameQuit;
extern int32_t playerswhenstarted;
@ -1042,6 +1045,9 @@ typedef struct {
walltype wall[MAXWALLS];
} mapstate_t;
extern void G_SaveMapState(mapstate_t *save);
extern void G_RestoreMapState(mapstate_t *save);
typedef struct {
int32_t partime, designertime;
char *name, *filename, *musicfn, *alt_musicfn;
@ -1088,12 +1094,13 @@ enum DukePacket_t
{
PACKET_MASTER_TO_SLAVE,
PACKET_SLAVE_TO_MASTER,
PACKET_BROADCAST,
SERVER_GENERATED_BROADCAST,
PACKET_VERSION,
/* don't change anything above this line */
PACKET_NUM_PLAYERS,
PACKET_PLAYER_INDEX,
PACKET_PLAYER_DISCONNECTED,
PACKET_MESSAGE,
PACKET_NEW_GAME,
@ -1103,6 +1110,7 @@ enum DukePacket_t
PACKET_PLAYER_OPTIONS,
PACKET_PLAYER_NAME,
PACKET_REQUEST_GAMESTATE,
PACKET_USER_MAP,
PACKET_MAP_VOTE,

60
polymer/eduke32/source/enet/Makefile Normal file
View file

@ -0,0 +1,60 @@
CC=gcc
OBJ=obj
OBJNAME?=libenet.a
PRETTY_OUTPUT?=1
EROOT?=build
RELEASE?=1
OPTLEVEL?=2
SRC=src
include ../../$(EROOT)/Makefile.shared
ifneq (0,$(RELEASE))
# Debugging disabled
debug=-fomit-frame-pointer -funswitch-loops -O$(OPTLEVEL)
else
# Debugging enabled
debug=-ggdb -O0 -DDEBUGGINGAIDS
endif
ifneq (0,$(DEBUGANYWAY))
debug+=-ggdb
endif
CFLAGS=$(debug) -W -Wall -Wimplicit -Werror-implicit-function-declaration \
-funsigned-char -fno-strict-aliasing -DNO_GCC_BUILTINS -D_FORTIFY_SOURCE=2 \
-fjump-tables -fno-stack-protector
CPPFLAGS=-Iinclude -Isrc -DHAVE_VORBIS
OBJECTS=$(OBJ)/callbacks.o \
$(OBJ)/host.o \
$(OBJ)/list.o \
$(OBJ)/packet.o \
$(OBJ)/peer.o \
$(OBJ)/protocol.o
ifeq ($(PLATFORM),WINDOWS)
OBJECTS+= $(OBJ)/win32.o
OBJNAME=libenet_win32.a
OBJ=obj_win
else
OBJECTS+= $(OBJ)/unix.o
endif
# OBJECTS=$(SOURCES:%.c=$(OBJ)/%.o)
$(OBJNAME): $(OBJECTS)
$(AR) cr $@ $^
$(OBJECTS): $(OBJ)/%.o: $(SRC)/%.c
-mkdir -p $(OBJ)
$(COMPILE_STATUS)
if $(CC) $(CPPFLAGS) $(CFLAGS) -c $< -o $@; then $(COMPILE_OK); else $(COMPILE_FAILED); fi
ifeq ($(PRETTY_OUTPUT),1)
.SILENT:
endif
.PHONY: clean
clean:
-rm -f $(OBJECTS) $(OBJNAME)

45
polymer/eduke32/source/enet/Makefile.msvc Normal file
View file

@ -0,0 +1,45 @@
OBJ=obj.msc
INC=include
SRC=src
ENETLIB=libenet.lib
!ifdef DEBUG
# debugging options
flags_cl=/Od /Zi
flags_link=/DEBUG
flags_lib=
!else
# release options
flags_cl=/Ox /GL /arch:SSE
flags_link=/RELEASE /LTCG
flags_lib=/LTCG
!endif
CC=cl
LINK=link /opt:ref /nologo
CFLAGS=$(CFLAGS) /nologo /MT /J $(flags_cl) $(TARGETOPTS) /I$(INC) /I$(SRC)
!ifdef DEBUG
CFLAGS=$(CFLAGS) /DDEBUGGINGAIDS
!endif
CFLAGS=$(CFLAGS) /DRENDERTYPE$(RENDERTYPE)=1 /D "_CRT_SECURE_NO_DEPRECATE" /W2 /DHAVE_VORBIS /Iinclude/msvc /DWIN32
OBJECTS=$(OBJ)\callbacks.o \
$(OBJ)\host.o \
$(OBJ)\list.o \
$(OBJ)\packet.o \
$(OBJ)\peer.o \
$(OBJ)\protocol.o \
$(OBJ)\win32.o
{$(SRC)}.c{$(OBJ)}.o:
$(CC) /c $(CFLAGS) /Fo$@ $<
enet: $(ENETLIB)
$(ENETLIB): $(OBJECTS)
lib $(flags_lib) /out:$@ /nologo $**
clean:
-del /Q $(OBJ)\* $(ENETLIB)

28
polymer/eduke32/source/enet/include/enet/callbacks.h Normal file
View file

@ -0,0 +1,28 @@
/**
@file callbacks.h
@brief ENet callbacks
*/
#ifndef __ENET_CALLBACKS_H__
#define __ENET_CALLBACKS_H__
#include <stdlib.h>
typedef struct
{
void * (ENET_CALLBACK * malloc) (size_t size);
void (ENET_CALLBACK * free) (void * memory);
int (ENET_CALLBACK * rand) (void);
} ENetCallbacks;
/** @defgroup callbacks ENet internal callbacks
@{
@ingroup private
*/
extern void * enet_malloc (size_t);
extern void enet_free (void *);
extern int enet_rand (void);
/** @} */
#endif /* __ENET_CALLBACKS_H__ */

492
polymer/eduke32/source/enet/include/enet/enet.h Normal file
View file

@ -0,0 +1,492 @@
/**
@file enet.h
@brief ENet public header file
*/
#ifndef __ENET_ENET_H__
#define __ENET_ENET_H__
#ifdef __cplusplus
extern "C"
{
#endif
#include <stdlib.h>
#ifdef WIN32
#include "enet/win32.h"
#else
#include "enet/unix.h"
#endif
#include "enet/types.h"
#include "enet/protocol.h"
#include "enet/list.h"
#include "enet/callbacks.h"
typedef enum
{
ENET_VERSION = 1
} ENetVersion;
typedef enum
{
ENET_SOCKET_TYPE_STREAM = 1,
ENET_SOCKET_TYPE_DATAGRAM = 2
} ENetSocketType;
typedef enum
{
ENET_SOCKET_WAIT_NONE = 0,
ENET_SOCKET_WAIT_SEND = (1 << 0),
ENET_SOCKET_WAIT_RECEIVE = (1 << 1)
} ENetSocketWait;
typedef enum
{
ENET_SOCKOPT_NONBLOCK = 1,
ENET_SOCKOPT_BROADCAST = 2,
ENET_SOCKOPT_RCVBUF = 3,
ENET_SOCKOPT_SNDBUF = 4,
ENET_SOCKOPT_REUSEADDR = 5
} ENetSocketOption;
enum
{
ENET_HOST_ANY = 0, /**< specifies the default server host */
ENET_HOST_BROADCAST = 0xFFFFFFFF, /**< specifies a subnet-wide broadcast */
ENET_PORT_ANY = 0 /**< specifies that a port should be automatically chosen */
};
/**
* Portable internet address structure.
*
* The host must be specified in network byte-order, and the port must be in host
* byte-order. The constant ENET_HOST_ANY may be used to specify the default
* server host. The constant ENET_HOST_BROADCAST may be used to specify the
* broadcast address (255.255.255.255). This makes sense for enet_host_connect,
* but not for enet_host_create. Once a server responds to a broadcast, the
* address is updated from ENET_HOST_BROADCAST to the server's actual IP address.
*/
typedef struct _ENetAddress
{
enet_uint32 host;
enet_uint16 port;
} ENetAddress;
/**
* Packet flag bit constants.
*
* The host must be specified in network byte-order, and the port must be in
* host byte-order. The constant ENET_HOST_ANY may be used to specify the
* default server host.
@sa ENetPacket
*/
typedef enum
{
/** packet must be received by the target peer and resend attempts should be
* made until the packet is delivered */
ENET_PACKET_FLAG_RELIABLE = (1 << 0),
/** packet will not be sequenced with other packets
* not supported for reliable packets
*/
ENET_PACKET_FLAG_UNSEQUENCED = (1 << 1),
/** packet will not allocate data, and user must supply it instead */
ENET_PACKET_FLAG_NO_ALLOCATE = (1 << 2)
} ENetPacketFlag;
struct _ENetPacket;
typedef void (ENET_CALLBACK * ENetPacketFreeCallback) (struct _ENetPacket *);
/**
* ENet packet structure.
*
* An ENet data packet that may be sent to or received from a peer. The shown
* fields should only be read and never modified. The data field contains the
* allocated data for the packet. The dataLength fields specifies the length
* of the allocated data. The flags field is either 0 (specifying no flags),
* or a bitwise-or of any combination of the following flags:
*
* ENET_PACKET_FLAG_RELIABLE - packet must be received by the target peer
* and resend attempts should be made until the packet is delivered
*
* ENET_PACKET_FLAG_UNSEQUENCED - packet will not be sequenced with other packets
* (not supported for reliable packets)
*
* ENET_PACKET_FLAG_NO_ALLOCATE - packet will not allocate data, and user must supply it instead
@sa ENetPacketFlag
*/
typedef struct _ENetPacket
{
size_t referenceCount; /**< internal use only */
enet_uint32 flags; /**< bitwise-or of ENetPacketFlag constants */
enet_uint8 * data; /**< allocated data for packet */
size_t dataLength; /**< length of data */
ENetPacketFreeCallback freeCallback; /**< function to be called when the packet is no longer in use */
} ENetPacket;
typedef struct _ENetAcknowledgement
{
ENetListNode acknowledgementList;
enet_uint32 sentTime;
ENetProtocol command;
} ENetAcknowledgement;
typedef struct _ENetOutgoingCommand
{
ENetListNode outgoingCommandList;
enet_uint16 reliableSequenceNumber;
enet_uint16 unreliableSequenceNumber;
enet_uint32 sentTime;
enet_uint32 roundTripTimeout;
enet_uint32 roundTripTimeoutLimit;
enet_uint32 fragmentOffset;
enet_uint16 fragmentLength;
enet_uint16 sendAttempts;
ENetProtocol command;
ENetPacket * packet;
} ENetOutgoingCommand;
typedef struct _ENetIncomingCommand
{
ENetListNode incomingCommandList;
enet_uint16 reliableSequenceNumber;
enet_uint16 unreliableSequenceNumber;
ENetProtocol command;
enet_uint32 fragmentCount;
enet_uint32 fragmentsRemaining;
enet_uint32 * fragments;
ENetPacket * packet;
} ENetIncomingCommand;
typedef enum
{
ENET_PEER_STATE_DISCONNECTED = 0,
ENET_PEER_STATE_CONNECTING = 1,
ENET_PEER_STATE_ACKNOWLEDGING_CONNECT = 2,
ENET_PEER_STATE_CONNECTION_PENDING = 3,
ENET_PEER_STATE_CONNECTION_SUCCEEDED = 4,
ENET_PEER_STATE_CONNECTED = 5,
ENET_PEER_STATE_DISCONNECT_LATER = 6,
ENET_PEER_STATE_DISCONNECTING = 7,
ENET_PEER_STATE_ACKNOWLEDGING_DISCONNECT = 8,
ENET_PEER_STATE_ZOMBIE = 9
} ENetPeerState;
#ifndef ENET_BUFFER_MAXIMUM
#define ENET_BUFFER_MAXIMUM (1 + 2 * ENET_PROTOCOL_MAXIMUM_PACKET_COMMANDS)
#endif
enum
{
ENET_HOST_RECEIVE_BUFFER_SIZE = 256 * 1024,
ENET_HOST_SEND_BUFFER_SIZE = 256 * 1024,
ENET_HOST_BANDWIDTH_THROTTLE_INTERVAL = 1000,
ENET_HOST_DEFAULT_MTU = 1400,
ENET_PEER_DEFAULT_ROUND_TRIP_TIME = 500,
ENET_PEER_DEFAULT_PACKET_THROTTLE = 32,
ENET_PEER_PACKET_THROTTLE_SCALE = 32,
ENET_PEER_PACKET_THROTTLE_COUNTER = 7,
ENET_PEER_PACKET_THROTTLE_ACCELERATION = 2,
ENET_PEER_PACKET_THROTTLE_DECELERATION = 2,
ENET_PEER_PACKET_THROTTLE_INTERVAL = 5000,
ENET_PEER_PACKET_LOSS_SCALE = (1 << 16),
ENET_PEER_PACKET_LOSS_INTERVAL = 10000,
ENET_PEER_WINDOW_SIZE_SCALE = 64 * 1024,
ENET_PEER_TIMEOUT_LIMIT = 32,
ENET_PEER_TIMEOUT_MINIMUM = 5000,
ENET_PEER_TIMEOUT_MAXIMUM = 30000,
ENET_PEER_PING_INTERVAL = 500,
ENET_PEER_UNSEQUENCED_WINDOWS = 64,
ENET_PEER_UNSEQUENCED_WINDOW_SIZE = 1024,
ENET_PEER_FREE_UNSEQUENCED_WINDOWS = 32,
ENET_PEER_RELIABLE_WINDOWS = 16,
ENET_PEER_RELIABLE_WINDOW_SIZE = 0x1000,
ENET_PEER_FREE_RELIABLE_WINDOWS = 8
};
typedef struct _ENetChannel
{
enet_uint16 outgoingReliableSequenceNumber;
enet_uint16 outgoingUnreliableSequenceNumber;
enet_uint16 usedReliableWindows;
enet_uint16 reliableWindows [ENET_PEER_RELIABLE_WINDOWS];
enet_uint16 incomingReliableSequenceNumber;
ENetList incomingReliableCommands;
ENetList incomingUnreliableCommands;
} ENetChannel;
/**
* An ENet peer which data packets may be sent or received from.
*
* No fields should be modified unless otherwise specified.
*/
typedef struct _ENetPeer
{
struct _ENetHost * host;
enet_uint16 outgoingPeerID;
enet_uint16 incomingPeerID;
enet_uint32 sessionID;
ENetAddress address; /**< Internet address of the peer */
void * data; /**< Application private data, may be freely modified */
ENetPeerState state;
ENetChannel * channels;
size_t channelCount; /**< Number of channels allocated for communication with peer */
enet_uint32 incomingBandwidth; /**< Downstream bandwidth of the client in bytes/second */
enet_uint32 outgoingBandwidth; /**< Upstream bandwidth of the client in bytes/second */
enet_uint32 incomingBandwidthThrottleEpoch;
enet_uint32 outgoingBandwidthThrottleEpoch;
enet_uint32 incomingDataTotal;
enet_uint32 outgoingDataTotal;
enet_uint32 lastSendTime;
enet_uint32 lastReceiveTime;
enet_uint32 nextTimeout;
enet_uint32 earliestTimeout;
enet_uint32 packetLossEpoch;
enet_uint32 packetsSent;
enet_uint32 packetsLost;
enet_uint32 packetLoss; /**< mean packet loss of reliable packets as a ratio with respect to the constant ENET_PEER_PACKET_LOSS_SCALE */
enet_uint32 packetLossVariance;
enet_uint32 packetThrottle;
enet_uint32 packetThrottleLimit;
enet_uint32 packetThrottleCounter;
enet_uint32 packetThrottleEpoch;
enet_uint32 packetThrottleAcceleration;
enet_uint32 packetThrottleDeceleration;
enet_uint32 packetThrottleInterval;
enet_uint32 lastRoundTripTime;
enet_uint32 lowestRoundTripTime;
enet_uint32 lastRoundTripTimeVariance;
enet_uint32 highestRoundTripTimeVariance;
enet_uint32 roundTripTime; /**< mean round trip time (RTT), in milliseconds, between sending a reliable packet and receiving its acknowledgement */
enet_uint32 roundTripTimeVariance;
enet_uint16 mtu;
enet_uint32 windowSize;
enet_uint32 reliableDataInTransit;
enet_uint16 outgoingReliableSequenceNumber;
ENetList acknowledgements;
ENetList sentReliableCommands;
ENetList sentUnreliableCommands;
ENetList outgoingReliableCommands;
ENetList outgoingUnreliableCommands;
enet_uint16 incomingUnsequencedGroup;
enet_uint16 outgoingUnsequencedGroup;
enet_uint32 unsequencedWindow [ENET_PEER_UNSEQUENCED_WINDOW_SIZE / 32];
enet_uint32 disconnectData;
} ENetPeer;
/** An ENet host for communicating with peers.
*
* No fields should be modified.
@sa enet_host_create()
@sa enet_host_destroy()
@sa enet_host_connect()
@sa enet_host_service()
@sa enet_host_flush()
@sa enet_host_broadcast()
@sa enet_host_bandwidth_limit()
@sa enet_host_bandwidth_throttle()
*/
typedef struct _ENetHost
{
ENetSocket socket;
ENetAddress address; /**< Internet address of the host */
enet_uint32 incomingBandwidth; /**< downstream bandwidth of the host */
enet_uint32 outgoingBandwidth; /**< upstream bandwidth of the host */
enet_uint32 bandwidthThrottleEpoch;
enet_uint32 mtu;
int recalculateBandwidthLimits;
ENetPeer * peers; /**< array of peers allocated for this host */
size_t peerCount; /**< number of peers allocated for this host */
enet_uint32 serviceTime;
ENetPeer * lastServicedPeer;
int continueSending;
size_t packetSize;
enet_uint16 headerFlags;
ENetProtocol commands [ENET_PROTOCOL_MAXIMUM_PACKET_COMMANDS];
size_t commandCount;
ENetBuffer buffers [ENET_BUFFER_MAXIMUM];
size_t bufferCount;
ENetAddress receivedAddress;
enet_uint8 receivedData [ENET_PROTOCOL_MAXIMUM_MTU];
size_t receivedDataLength;
} ENetHost;
/**
* An ENet event type, as specified in @ref ENetEvent.
*/
typedef enum
{
/** no event occurred within the specified time limit */
ENET_EVENT_TYPE_NONE = 0,
/** a connection request initiated by enet_host_connect has completed.
* The peer field contains the peer which successfully connected.
*/
ENET_EVENT_TYPE_CONNECT = 1,
/** a peer has disconnected. This event is generated on a successful
* completion of a disconnect initiated by enet_pper_disconnect, if
* a peer has timed out, or if a connection request intialized by
* enet_host_connect has timed out. The peer field contains the peer
* which disconnected. The data field contains user supplied data
* describing the disconnection, or 0, if none is available.
*/
ENET_EVENT_TYPE_DISCONNECT = 2,
/** a packet has been received from a peer. The peer field specifies the
* peer which sent the packet. The channelID field specifies the channel
* number upon which the packet was received. The packet field contains
* the packet that was received; this packet must be destroyed with
* enet_packet_destroy after use.
*/
ENET_EVENT_TYPE_RECEIVE = 3
} ENetEventType;
/**
* An ENet event as returned by enet_host_service().
@sa enet_host_service
*/
typedef struct _ENetEvent
{
ENetEventType type; /**< type of the event */
ENetPeer * peer; /**< peer that generated a connect, disconnect or receive event */
enet_uint8 channelID; /**< channel on the peer that generated the event, if appropriate */
enet_uint32 data; /**< data associated with the event, if appropriate */
ENetPacket * packet; /**< packet associated with the event, if appropriate */
} ENetEvent;
/** @defgroup global ENet global functions
@{
*/
/**
Initializes ENet globally. Must be called prior to using any functions in
ENet.
@returns 0 on success, < 0 on failure
*/
ENET_API int enet_initialize (void);
/**
Initializes ENet globally and supplies user-overridden callbacks. Must be called prior to using any functions in ENet. Do not use enet_initialize() if you use this variant.
@param version the constant ENET_VERSION should be supplied so ENet knows which version of ENetCallbacks struct to use
@param inits user-overriden callbacks where any NULL callbacks will use ENet's defaults
@returns 0 on success, < 0 on failure
*/
ENET_API int enet_initialize_with_callbacks (ENetVersion version, const ENetCallbacks * inits);
/**
Shuts down ENet globally. Should be called when a program that has
initialized ENet exits.
*/
ENET_API void enet_deinitialize (void);
/** @} */
/** @defgroup private ENet private implementation functions */
/**
Returns the wall-time in milliseconds. Its initial value is unspecified
unless otherwise set.
*/
ENET_API enet_uint32 enet_time_get (void);
/**
Sets the current wall-time in milliseconds.
*/
ENET_API void enet_time_set (enet_uint32);
/** @defgroup socket ENet socket functions
@{
*/
ENET_API ENetSocket enet_socket_create (ENetSocketType);
ENET_API int enet_socket_bind (ENetSocket, const ENetAddress *);
ENET_API int enet_socket_listen (ENetSocket, int);
ENET_API ENetSocket enet_socket_accept (ENetSocket, ENetAddress *);
ENET_API int enet_socket_connect (ENetSocket, const ENetAddress *);
ENET_API int enet_socket_send (ENetSocket, const ENetAddress *, const ENetBuffer *, size_t);
ENET_API int enet_socket_receive (ENetSocket, ENetAddress *, ENetBuffer *, size_t);
ENET_API int enet_socket_wait (ENetSocket, enet_uint32 *, enet_uint32);
ENET_API int enet_socket_set_option (ENetSocket, ENetSocketOption, int);
ENET_API void enet_socket_destroy (ENetSocket);
ENET_API int enet_socketset_select (ENetSocket, ENetSocketSet *, ENetSocketSet *, enet_uint32);
/** @} */
/** @defgroup Address ENet address functions
@{
*/
/** Attempts to resolve the host named by the parameter hostName and sets
the host field in the address parameter if successful.
@param address destination to store resolved address
@param hostName host name to lookup
@retval 0 on success
@retval < 0 on failure
@returns the address of the given hostName in address on success
*/
ENET_API int enet_address_set_host (ENetAddress * address, const char * hostName);
/** Gives the printable form of the ip address specified in the address parameter.
@param address address printed
@param hostName destination for name, must not be NULL
@param nameLength maximum length of hostName.
@returns the null-terminated name of the host in hostName on success
@retval 0 on success
@retval < 0 on failure
*/
ENET_API int enet_address_get_host_ip (const ENetAddress * address, char * hostName, size_t nameLength);
/** Attempts to do a reverse lookup of the host field in the address parameter.
@param address address used for reverse lookup
@param hostName destination for name, must not be NULL
@param nameLength maximum length of hostName.
@returns the null-terminated name of the host in hostName on success
@retval 0 on success
@retval < 0 on failure
*/
ENET_API int enet_address_get_host (const ENetAddress * address, char * hostName, size_t nameLength);
/** @} */
ENET_API ENetPacket * enet_packet_create (const void *, size_t, enet_uint32);
ENET_API void enet_packet_destroy (ENetPacket *);
ENET_API int enet_packet_resize (ENetPacket *, size_t);
extern enet_uint32 enet_crc32 (const ENetBuffer *, size_t);
ENET_API ENetHost * enet_host_create (const ENetAddress *, size_t, enet_uint32, enet_uint32);
ENET_API void enet_host_destroy (ENetHost *);
ENET_API ENetPeer * enet_host_connect (ENetHost *, const ENetAddress *, size_t);
ENET_API int enet_host_check_events (ENetHost *, ENetEvent *);
ENET_API int enet_host_service (ENetHost *, ENetEvent *, enet_uint32);
ENET_API void enet_host_flush (ENetHost *);
ENET_API void enet_host_broadcast (ENetHost *, enet_uint8, ENetPacket *);
ENET_API void enet_host_bandwidth_limit (ENetHost *, enet_uint32, enet_uint32);
extern void enet_host_bandwidth_throttle (ENetHost *);
ENET_API int enet_peer_send (ENetPeer *, enet_uint8, ENetPacket *);
ENET_API ENetPacket * enet_peer_receive (ENetPeer *, enet_uint8);
ENET_API void enet_peer_ping (ENetPeer *);
ENET_API void enet_peer_reset (ENetPeer *);
ENET_API void enet_peer_disconnect (ENetPeer *, enet_uint32);
ENET_API void enet_peer_disconnect_now (ENetPeer *, enet_uint32);
ENET_API void enet_peer_disconnect_later (ENetPeer *, enet_uint32);
ENET_API void enet_peer_throttle_configure (ENetPeer *, enet_uint32, enet_uint32, enet_uint32);
extern int enet_peer_throttle (ENetPeer *, enet_uint32);
extern void enet_peer_reset_queues (ENetPeer *);
extern ENetOutgoingCommand * enet_peer_queue_outgoing_command (ENetPeer *, const ENetProtocol *, ENetPacket *, enet_uint32, enet_uint16);
extern ENetIncomingCommand * enet_peer_queue_incoming_command (ENetPeer *, const ENetProtocol *, ENetPacket *, enet_uint32);
extern ENetAcknowledgement * enet_peer_queue_acknowledgement (ENetPeer *, const ENetProtocol *, enet_uint16);
extern size_t enet_protocol_command_size (enet_uint8);
#ifdef __cplusplus
}
#endif
#endif /* __ENET_ENET_H__ */

42
polymer/eduke32/source/enet/include/enet/list.h Normal file
View file

@ -0,0 +1,42 @@
/**
@file list.h
@brief ENet list management
*/
#ifndef __ENET_LIST_H__
#define __ENET_LIST_H__
#include <stdlib.h>
typedef struct _ENetListNode
{
struct _ENetListNode * next;
struct _ENetListNode * previous;
} ENetListNode;
typedef ENetListNode * ENetListIterator;
typedef struct _ENetList
{
ENetListNode sentinel;
} ENetList;
extern void enet_list_clear (ENetList *);
extern ENetListIterator enet_list_insert (ENetListIterator, void *);
extern void * enet_list_remove (ENetListIterator);
extern size_t enet_list_size (ENetList *);
#define enet_list_begin(list) ((list) -> sentinel.next)
#define enet_list_end(list) (& (list) -> sentinel)
#define enet_list_empty(list) (enet_list_begin (list) == enet_list_end (list))
#define enet_list_next(iterator) ((iterator) -> next)
#define enet_list_previous(iterator) ((iterator) -> previous)
#define enet_list_front(list) ((void *) (list) -> sentinel.next)
#define enet_list_back(list) ((void *) (list) -> sentinel.previous)
#endif /* __ENET_LIST_H__ */

174
polymer/eduke32/source/enet/include/enet/protocol.h Normal file
View file

@ -0,0 +1,174 @@
/**
@file protocol.h
@brief ENet protocol
*/
#ifndef __ENET_PROTOCOL_H__
#define __ENET_PROTOCOL_H__
#include "enet/types.h"
enum
{
ENET_PROTOCOL_MINIMUM_MTU = 576,
ENET_PROTOCOL_MAXIMUM_MTU = 4096,
ENET_PROTOCOL_MAXIMUM_PACKET_COMMANDS = 32,
ENET_PROTOCOL_MINIMUM_WINDOW_SIZE = 4096,
ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE = 32768,
ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT = 1,
ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT = 255,
ENET_PROTOCOL_MAXIMUM_PEER_ID = 0x7FFF
};
typedef enum
{
ENET_PROTOCOL_COMMAND_NONE = 0,
ENET_PROTOCOL_COMMAND_ACKNOWLEDGE = 1,
ENET_PROTOCOL_COMMAND_CONNECT = 2,
ENET_PROTOCOL_COMMAND_VERIFY_CONNECT = 3,
ENET_PROTOCOL_COMMAND_DISCONNECT = 4,
ENET_PROTOCOL_COMMAND_PING = 5,
ENET_PROTOCOL_COMMAND_SEND_RELIABLE = 6,
ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE = 7,
ENET_PROTOCOL_COMMAND_SEND_FRAGMENT = 8,
ENET_PROTOCOL_COMMAND_SEND_UNSEQUENCED = 9,
ENET_PROTOCOL_COMMAND_BANDWIDTH_LIMIT = 10,
ENET_PROTOCOL_COMMAND_THROTTLE_CONFIGURE = 11,
ENET_PROTOCOL_COMMAND_COUNT = 12,
ENET_PROTOCOL_COMMAND_MASK = 0x0F
} ENetProtocolCommand;
typedef enum
{
ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE = (1 << 7),
ENET_PROTOCOL_COMMAND_FLAG_UNSEQUENCED = (1 << 6),
ENET_PROTOCOL_HEADER_FLAG_SENT_TIME = (1 << 15),
ENET_PROTOCOL_HEADER_FLAG_MASK = 0x8000
} ENetProtocolFlag;
typedef struct
{
enet_uint32 checksum;
enet_uint16 peerID;
enet_uint16 sentTime;
} ENetProtocolHeader;
typedef struct
{
enet_uint8 command;
enet_uint8 channelID;
enet_uint16 reliableSequenceNumber;
} ENetProtocolCommandHeader;
typedef struct
{
ENetProtocolCommandHeader header;
enet_uint16 receivedReliableSequenceNumber;
enet_uint16 receivedSentTime;
} ENetProtocolAcknowledge;
typedef struct
{
ENetProtocolCommandHeader header;
enet_uint16 outgoingPeerID;
enet_uint16 mtu;
enet_uint32 windowSize;
enet_uint32 channelCount;
enet_uint32 incomingBandwidth;
enet_uint32 outgoingBandwidth;
enet_uint32 packetThrottleInterval;
enet_uint32 packetThrottleAcceleration;
enet_uint32 packetThrottleDeceleration;
enet_uint32 sessionID;
} ENetProtocolConnect;
typedef struct
{
ENetProtocolCommandHeader header;
enet_uint16 outgoingPeerID;
enet_uint16 mtu;
enet_uint32 windowSize;
enet_uint32 channelCount;
enet_uint32 incomingBandwidth;
enet_uint32 outgoingBandwidth;
enet_uint32 packetThrottleInterval;
enet_uint32 packetThrottleAcceleration;
enet_uint32 packetThrottleDeceleration;
} ENetProtocolVerifyConnect;
typedef struct
{
ENetProtocolCommandHeader header;
enet_uint32 incomingBandwidth;
enet_uint32 outgoingBandwidth;
} ENetProtocolBandwidthLimit;
typedef struct
{
ENetProtocolCommandHeader header;
enet_uint32 packetThrottleInterval;
enet_uint32 packetThrottleAcceleration;
enet_uint32 packetThrottleDeceleration;
} ENetProtocolThrottleConfigure;
typedef struct
{
ENetProtocolCommandHeader header;
enet_uint32 data;
} ENetProtocolDisconnect;
typedef struct
{
ENetProtocolCommandHeader header;
} ENetProtocolPing;
typedef struct
{
ENetProtocolCommandHeader header;
enet_uint16 dataLength;
} ENetProtocolSendReliable;
typedef struct
{
ENetProtocolCommandHeader header;
enet_uint16 unreliableSequenceNumber;
enet_uint16 dataLength;
} ENetProtocolSendUnreliable;
typedef struct
{
ENetProtocolCommandHeader header;
enet_uint16 unsequencedGroup;
enet_uint16 dataLength;
} ENetProtocolSendUnsequenced;
typedef struct
{
ENetProtocolCommandHeader header;
enet_uint16 startSequenceNumber;
enet_uint16 dataLength;
enet_uint32 fragmentCount;
enet_uint32 fragmentNumber;
enet_uint32 totalLength;
enet_uint32 fragmentOffset;
} ENetProtocolSendFragment;
typedef union
{
ENetProtocolCommandHeader header;
ENetProtocolAcknowledge acknowledge;
ENetProtocolConnect connect;
ENetProtocolVerifyConnect verifyConnect;
ENetProtocolDisconnect disconnect;
ENetProtocolPing ping;
ENetProtocolSendReliable sendReliable;
ENetProtocolSendUnreliable sendUnreliable;
ENetProtocolSendUnsequenced sendUnsequenced;
ENetProtocolSendFragment sendFragment;
ENetProtocolBandwidthLimit bandwidthLimit;
ENetProtocolThrottleConfigure throttleConfigure;
} ENetProtocol;
#endif /* __ENET_PROTOCOL_H__ */

18
polymer/eduke32/source/enet/include/enet/time.h Normal file
View file

@ -0,0 +1,18 @@
/**
@file time.h
@brief ENet time constants and macros
*/
#ifndef __ENET_TIME_H__
#define __ENET_TIME_H__
#define ENET_TIME_OVERFLOW 86400000
#define ENET_TIME_LESS(a, b) ((a) - (b) >= ENET_TIME_OVERFLOW)
#define ENET_TIME_GREATER(a, b) ((b) - (a) >= ENET_TIME_OVERFLOW)
#define ENET_TIME_LESS_EQUAL(a, b) (! ENET_TIME_GREATER (a, b))
#define ENET_TIME_GREATER_EQUAL(a, b) (! ENET_TIME_LESS (a, b))
#define ENET_TIME_DIFFERENCE(a, b) ((a) - (b) >= ENET_TIME_OVERFLOW ? (b) - (a) : (a) - (b))
#endif /* __ENET_TIME_H__ */

13
polymer/eduke32/source/enet/include/enet/types.h Normal file
View file

@ -0,0 +1,13 @@
/**
@file types.h
@brief type definitions for ENet
*/
#ifndef __ENET_TYPES_H__
#define __ENET_TYPES_H__
typedef unsigned char enet_uint8; /**< unsigned 8-bit type */
typedef unsigned short enet_uint16; /**< unsigned 16-bit type */
typedef unsigned int enet_uint32; /**< unsigned 32-bit type */
#endif /* __ENET_TYPES_H__ */

45
polymer/eduke32/source/enet/include/enet/unix.h Normal file
View file

@ -0,0 +1,45 @@
/**
@file unix.h
@brief ENet Unix header
*/
#ifndef __ENET_UNIX_H__
#define __ENET_UNIX_H__
#include <stdlib.h>
#include <sys/time.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <unistd.h>
typedef int ENetSocket;
enum
{
ENET_SOCKET_NULL = -1
};
#define ENET_HOST_TO_NET_16(value) (htons (value)) /**< macro that converts host to net byte-order of a 16-bit value */
#define ENET_HOST_TO_NET_32(value) (htonl (value)) /**< macro that converts host to net byte-order of a 32-bit value */
#define ENET_NET_TO_HOST_16(value) (ntohs (value)) /**< macro that converts net to host byte-order of a 16-bit value */
#define ENET_NET_TO_HOST_32(value) (ntohl (value)) /**< macro that converts net to host byte-order of a 32-bit value */
typedef struct
{
void * data;
size_t dataLength;
} ENetBuffer;
#define ENET_CALLBACK
#define ENET_API extern
typedef fd_set ENetSocketSet;
#define ENET_SOCKETSET_EMPTY(sockset) FD_ZERO (& (sockset))
#define ENET_SOCKETSET_ADD(sockset, socket) FD_SET (socket, & (sockset))
#define ENET_SOCKETSET_REMOVE(sockset, socket) FD_CLEAR (socket, & (sockset))
#define ENET_SOCKETSET_CHECK(sockset, socket) FD_ISSET (socket, & (sockset))
#endif /* __ENET_UNIX_H__ */

12
polymer/eduke32/source/enet/include/enet/utility.h Normal file
View file

@ -0,0 +1,12 @@
/**
@file utility.h
@brief ENet utility header
*/
#ifndef __ENET_UTILITY_H__
#define __ENET_UTILITY_H__
#define ENET_MAX(x, y) ((x) > (y) ? (x) : (y))
#define ENET_MIN(x, y) ((x) < (y) ? (x) : (y))
#endif /* __ENET_UTILITY_H__ */

58
polymer/eduke32/source/enet/include/enet/win32.h Normal file
View file

@ -0,0 +1,58 @@
/**
@file win32.h
@brief ENet Win32 header
*/
#ifndef __ENET_WIN32_H__
#define __ENET_WIN32_H__
#ifdef ENET_BUILDING_LIB
#pragma warning (disable: 4996) // 'strncpy' was declared deprecated
#pragma warning (disable: 4267) // size_t to int conversion
#pragma warning (disable: 4244) // 64bit to 32bit int
#pragma warning (disable: 4018) // signed/unsigned mismatch
#endif
#include <stdlib.h>
#include <winsock2.h>
typedef SOCKET ENetSocket;
enum
{
ENET_SOCKET_NULL = INVALID_SOCKET
};
#define ENET_HOST_TO_NET_16(value) (htons (value))
#define ENET_HOST_TO_NET_32(value) (htonl (value))
#define ENET_NET_TO_HOST_16(value) (ntohs (value))
#define ENET_NET_TO_HOST_32(value) (ntohl (value))
typedef struct
{
size_t dataLength;
void * data;
} ENetBuffer;
#define ENET_CALLBACK __cdecl
#if defined ENET_DLL
#if defined ENET_BUILDING_LIB
#define ENET_API __declspec( dllexport )
#else
#define ENET_API __declspec( dllimport )
#endif /* ENET_BUILDING_LIB */
#else /* !ENET_DLL */
#define ENET_API extern
#endif /* ENET_DLL */
typedef fd_set ENetSocketSet;
#define ENET_SOCKETSET_EMPTY(sockset) FD_ZERO (& (sockset))
#define ENET_SOCKETSET_ADD(sockset, socket) FD_SET (socket, & (sockset))
#define ENET_SOCKETSET_REMOVE(sockset, socket) FD_CLEAR (socket, & (sockset))
#define ENET_SOCKETSET_CHECK(sockset, socket) FD_ISSET (socket, & (sockset))
#endif /* __ENET_WIN32_H__ */

53
polymer/eduke32/source/enet/src/callbacks.c Normal file
View file

@ -0,0 +1,53 @@
/**
@file callbacks.c
@brief ENet callback functions
*/
#define ENET_BUILDING_LIB 1
#include "enet/enet.h"
static ENetCallbacks callbacks = { malloc, free, rand };
int
enet_initialize_with_callbacks (ENetVersion version, const ENetCallbacks * inits)
{
if (version != ENET_VERSION)
return -1;
if (inits -> malloc != NULL || inits -> free != NULL)
{
if (inits -> malloc == NULL || inits -> free == NULL)
return -1;
callbacks.malloc = inits -> malloc;
callbacks.free = inits -> free;
}
if (inits -> rand != NULL)
callbacks.rand = inits -> rand;
return enet_initialize ();
}
void *
enet_malloc (size_t size)
{
void * memory = callbacks.malloc (size);
if (memory == NULL)
abort ();
return memory;
}
void
enet_free (void * memory)
{
callbacks.free (memory);
}
int
enet_rand (void)
{
return callbacks.rand ();
}

401
polymer/eduke32/source/enet/src/host.c Normal file
View file

@ -0,0 +1,401 @@
/**
@file host.c
@brief ENet host management functions
*/
#define ENET_BUILDING_LIB 1
#include <string.h>
#include "enet/enet.h"
/** @defgroup host ENet host functions
@{
*/
/** Creates a host for communicating to peers.
@param address the address at which other peers may connect to this host. If NULL, then no peers may connect to the host.
@param peerCount the maximum number of peers that should be allocated for the host.
@param incomingBandwidth downstream bandwidth of the host in bytes/second; if 0, ENet will assume unlimited bandwidth.
@param outgoingBandwidth upstream bandwidth of the host in bytes/second; if 0, ENet will assume unlimited bandwidth.
@returns the host on success and NULL on failure
@remarks ENet will strategically drop packets on specific sides of a connection between hosts
to ensure the host's bandwidth is not overwhelmed. The bandwidth parameters also determine
the window size of a connection which limits the amount of reliable packets that may be in transit
at any given time.
*/
ENetHost *
enet_host_create (const ENetAddress * address, size_t peerCount, enet_uint32 incomingBandwidth, enet_uint32 outgoingBandwidth)
{
ENetHost * host = (ENetHost *) enet_malloc (sizeof (ENetHost));
ENetPeer * currentPeer;
if (peerCount > ENET_PROTOCOL_MAXIMUM_PEER_ID)
return NULL;
host -> peers = (ENetPeer *) enet_malloc (peerCount * sizeof (ENetPeer));
memset (host -> peers, 0, peerCount * sizeof (ENetPeer));
host -> socket = enet_socket_create (ENET_SOCKET_TYPE_DATAGRAM);
if (host -> socket == ENET_SOCKET_NULL || (address != NULL && enet_socket_bind (host -> socket, address) < 0))
{
if (host -> socket != ENET_SOCKET_NULL)
enet_socket_destroy (host -> socket);
enet_free (host -> peers);
enet_free (host);
return NULL;
}
enet_socket_set_option (host -> socket, ENET_SOCKOPT_NONBLOCK, 1);
enet_socket_set_option (host -> socket, ENET_SOCKOPT_BROADCAST, 1);
enet_socket_set_option (host -> socket, ENET_SOCKOPT_RCVBUF, ENET_HOST_RECEIVE_BUFFER_SIZE);
enet_socket_set_option (host -> socket, ENET_SOCKOPT_SNDBUF, ENET_HOST_SEND_BUFFER_SIZE);
if (address != NULL)
host -> address = * address;
host -> incomingBandwidth = incomingBandwidth;
host -> outgoingBandwidth = outgoingBandwidth;
host -> bandwidthThrottleEpoch = 0;
host -> recalculateBandwidthLimits = 0;
host -> mtu = ENET_HOST_DEFAULT_MTU;
host -> peerCount = peerCount;
host -> lastServicedPeer = host -> peers;
host -> commandCount = 0;
host -> bufferCount = 0;
host -> receivedAddress.host = ENET_HOST_ANY;
host -> receivedAddress.port = 0;
host -> receivedDataLength = 0;
for (currentPeer = host -> peers;
currentPeer < & host -> peers [host -> peerCount];
++ currentPeer)
{
currentPeer -> host = host;
currentPeer -> incomingPeerID = currentPeer - host -> peers;
currentPeer -> data = NULL;
enet_list_clear (& currentPeer -> acknowledgements);
enet_list_clear (& currentPeer -> sentReliableCommands);
enet_list_clear (& currentPeer -> sentUnreliableCommands);
enet_list_clear (& currentPeer -> outgoingReliableCommands);
enet_list_clear (& currentPeer -> outgoingUnreliableCommands);
enet_peer_reset (currentPeer);
}
return host;
}
/** Destroys the host and all resources associated with it.
@param host pointer to the host to destroy
*/
void
enet_host_destroy (ENetHost * host)
{
ENetPeer * currentPeer;
enet_socket_destroy (host -> socket);
for (currentPeer = host -> peers;
currentPeer < & host -> peers [host -> peerCount];
++ currentPeer)
{
enet_peer_reset (currentPeer);
}
enet_free (host -> peers);
enet_free (host);
}
/** Initiates a connection to a foreign host.
@param host host seeking the connection
@param address destination for the connection
@param channelCount number of channels to allocate
@returns a peer representing the foreign host on success, NULL on failure
@remarks The peer returned will have not completed the connection until enet_host_service()
notifies of an ENET_EVENT_TYPE_CONNECT event for the peer.
*/
ENetPeer *
enet_host_connect (ENetHost * host, const ENetAddress * address, size_t channelCount)
{
ENetPeer * currentPeer;
ENetChannel * channel;
ENetProtocol command;
if (channelCount < ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT)
channelCount = ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT;
else
if (channelCount > ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT)
channelCount = ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT;
for (currentPeer = host -> peers;
currentPeer < & host -> peers [host -> peerCount];
++ currentPeer)
{
if (currentPeer -> state == ENET_PEER_STATE_DISCONNECTED)
break;
}
if (currentPeer >= & host -> peers [host -> peerCount])
return NULL;
currentPeer -> state = ENET_PEER_STATE_CONNECTING;
currentPeer -> address = * address;
currentPeer -> channels = (ENetChannel *) enet_malloc (channelCount * sizeof (ENetChannel));
currentPeer -> channelCount = channelCount;
currentPeer -> sessionID = (enet_uint32) enet_rand ();
if (host -> outgoingBandwidth == 0)
currentPeer -> windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
else
currentPeer -> windowSize = (host -> outgoingBandwidth /
ENET_PEER_WINDOW_SIZE_SCALE) *
ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
if (currentPeer -> windowSize < ENET_PROTOCOL_MINIMUM_WINDOW_SIZE)
currentPeer -> windowSize = ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
else
if (currentPeer -> windowSize > ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE)
currentPeer -> windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
for (channel = currentPeer -> channels;
channel < & currentPeer -> channels [channelCount];
++ channel)
{
channel -> outgoingReliableSequenceNumber = 0;
channel -> outgoingUnreliableSequenceNumber = 0;
channel -> incomingReliableSequenceNumber = 0;
enet_list_clear (& channel -> incomingReliableCommands);
enet_list_clear (& channel -> incomingUnreliableCommands);
channel -> usedReliableWindows = 0;
memset (channel -> reliableWindows, 0, sizeof (channel -> reliableWindows));
}
command.header.command = ENET_PROTOCOL_COMMAND_CONNECT | ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE;
command.header.channelID = 0xFF;
command.connect.outgoingPeerID = ENET_HOST_TO_NET_16 (currentPeer -> incomingPeerID);
command.connect.mtu = ENET_HOST_TO_NET_16 (currentPeer -> mtu);
command.connect.windowSize = ENET_HOST_TO_NET_32 (currentPeer -> windowSize);
command.connect.channelCount = ENET_HOST_TO_NET_32 (channelCount);
command.connect.incomingBandwidth = ENET_HOST_TO_NET_32 (host -> incomingBandwidth);
command.connect.outgoingBandwidth = ENET_HOST_TO_NET_32 (host -> outgoingBandwidth);
command.connect.packetThrottleInterval = ENET_HOST_TO_NET_32 (currentPeer -> packetThrottleInterval);
command.connect.packetThrottleAcceleration = ENET_HOST_TO_NET_32 (currentPeer -> packetThrottleAcceleration);
command.connect.packetThrottleDeceleration = ENET_HOST_TO_NET_32 (currentPeer -> packetThrottleDeceleration);
command.connect.sessionID = currentPeer -> sessionID;
enet_peer_queue_outgoing_command (currentPeer, & command, NULL, 0, 0);
return currentPeer;
}
/** Queues a packet to be sent to all peers associated with the host.
@param host host on which to broadcast the packet
@param channelID channel on which to broadcast
@param packet packet to broadcast
*/
void
enet_host_broadcast (ENetHost * host, enet_uint8 channelID, ENetPacket * packet)
{
ENetPeer * currentPeer;
for (currentPeer = host -> peers;
currentPeer < & host -> peers [host -> peerCount];
++ currentPeer)
{
if (currentPeer -> state != ENET_PEER_STATE_CONNECTED)
continue;
enet_peer_send (currentPeer, channelID, packet);
}
if (packet -> referenceCount == 0)
enet_packet_destroy (packet);
}
/** Adjusts the bandwidth limits of a host.
@param host host to adjust
@param incomingBandwidth new incoming bandwidth
@param outgoingBandwidth new outgoing bandwidth
@remarks the incoming and outgoing bandwidth parameters are identical in function to those
specified in enet_host_create().
*/
void
enet_host_bandwidth_limit (ENetHost * host, enet_uint32 incomingBandwidth, enet_uint32 outgoingBandwidth)
{
host -> incomingBandwidth = incomingBandwidth;
host -> outgoingBandwidth = outgoingBandwidth;
host -> recalculateBandwidthLimits = 1;
}
void
enet_host_bandwidth_throttle (ENetHost * host)
{
enet_uint32 timeCurrent = enet_time_get (),
elapsedTime = timeCurrent - host -> bandwidthThrottleEpoch,
peersTotal = 0,
dataTotal = 0,
peersRemaining,
bandwidth,
throttle = 0,
bandwidthLimit = 0;
int needsAdjustment;
ENetPeer * peer;
ENetProtocol command;
if (elapsedTime < ENET_HOST_BANDWIDTH_THROTTLE_INTERVAL)
return;
for (peer = host -> peers;
peer < & host -> peers [host -> peerCount];
++ peer)
{
if (peer -> state != ENET_PEER_STATE_CONNECTED && peer -> state != ENET_PEER_STATE_DISCONNECT_LATER)
continue;
++ peersTotal;
dataTotal += peer -> outgoingDataTotal;
}
if (peersTotal == 0)
return;
peersRemaining = peersTotal;
needsAdjustment = 1;
if (host -> outgoingBandwidth == 0)
bandwidth = ~0;
else
bandwidth = (host -> outgoingBandwidth * elapsedTime) / 1000;
while (peersRemaining > 0 && needsAdjustment != 0)
{
needsAdjustment = 0;
if (dataTotal < bandwidth)
throttle = ENET_PEER_PACKET_THROTTLE_SCALE;
else
throttle = (bandwidth * ENET_PEER_PACKET_THROTTLE_SCALE) / dataTotal;
for (peer = host -> peers;
peer < & host -> peers [host -> peerCount];
++ peer)
{
enet_uint32 peerBandwidth;
if ((peer -> state != ENET_PEER_STATE_CONNECTED && peer -> state != ENET_PEER_STATE_DISCONNECT_LATER) ||
peer -> incomingBandwidth == 0 ||
peer -> outgoingBandwidthThrottleEpoch == timeCurrent)
continue;
peerBandwidth = (peer -> incomingBandwidth * elapsedTime) / 1000;
if ((throttle * peer -> outgoingDataTotal) / ENET_PEER_PACKET_THROTTLE_SCALE <= peerBandwidth)
continue;
peer -> packetThrottleLimit = (peerBandwidth *
ENET_PEER_PACKET_THROTTLE_SCALE) / peer -> outgoingDataTotal;
if (peer -> packetThrottleLimit == 0)
peer -> packetThrottleLimit = 1;
if (peer -> packetThrottle > peer -> packetThrottleLimit)
peer -> packetThrottle = peer -> packetThrottleLimit;
peer -> outgoingBandwidthThrottleEpoch = timeCurrent;
needsAdjustment = 1;
-- peersRemaining;
bandwidth -= peerBandwidth;
dataTotal -= peerBandwidth;
}
}
if (peersRemaining > 0)
for (peer = host -> peers;
peer < & host -> peers [host -> peerCount];
++ peer)
{
if ((peer -> state != ENET_PEER_STATE_CONNECTED && peer -> state != ENET_PEER_STATE_DISCONNECT_LATER) ||
peer -> outgoingBandwidthThrottleEpoch == timeCurrent)
continue;
peer -> packetThrottleLimit = throttle;
if (peer -> packetThrottle > peer -> packetThrottleLimit)
peer -> packetThrottle = peer -> packetThrottleLimit;
}
if (host -> recalculateBandwidthLimits)
{
host -> recalculateBandwidthLimits = 0;
peersRemaining = peersTotal;
bandwidth = host -> incomingBandwidth;
needsAdjustment = 1;
if (bandwidth == 0)
bandwidthLimit = 0;
else
while (peersRemaining > 0 && needsAdjustment != 0)
{
needsAdjustment = 0;
bandwidthLimit = bandwidth / peersRemaining;
for (peer = host -> peers;
peer < & host -> peers [host -> peerCount];
++ peer)
{
if ((peer -> state != ENET_PEER_STATE_CONNECTED && peer -> state != ENET_PEER_STATE_DISCONNECT_LATER) ||
peer -> incomingBandwidthThrottleEpoch == timeCurrent)
continue;
if (peer -> outgoingBandwidth > 0 &&
peer -> outgoingBandwidth >= bandwidthLimit)
continue;
peer -> incomingBandwidthThrottleEpoch = timeCurrent;
needsAdjustment = 1;
-- peersRemaining;
bandwidth -= peer -> outgoingBandwidth;
}
}
for (peer = host -> peers;
peer < & host -> peers [host -> peerCount];
++ peer)
{
if (peer -> state != ENET_PEER_STATE_CONNECTED && peer -> state != ENET_PEER_STATE_DISCONNECT_LATER)
continue;
command.header.command = ENET_PROTOCOL_COMMAND_BANDWIDTH_LIMIT | ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE;
command.header.channelID = 0xFF;
command.bandwidthLimit.outgoingBandwidth = ENET_HOST_TO_NET_32 (host -> outgoingBandwidth);
if (peer -> incomingBandwidthThrottleEpoch == timeCurrent)
command.bandwidthLimit.incomingBandwidth = ENET_HOST_TO_NET_32 (peer -> outgoingBandwidth);
else
command.bandwidthLimit.incomingBandwidth = ENET_HOST_TO_NET_32 (bandwidthLimit);
enet_peer_queue_outgoing_command (peer, & command, NULL, 0, 0);
}
}
host -> bandwidthThrottleEpoch = timeCurrent;
for (peer = host -> peers;
peer < & host -> peers [host -> peerCount];
++ peer)
{
peer -> incomingDataTotal = 0;
peer -> outgoingDataTotal = 0;
}
}
/** @} */

57
polymer/eduke32/source/enet/src/list.c Normal file
View file

@ -0,0 +1,57 @@
/**
@file list.c
@brief ENet linked list functions
*/
#define ENET_BUILDING_LIB 1
#include "enet/list.h"
/**
@defgroup list ENet linked list utility functions
@ingroup private
@{
*/
void
enet_list_clear (ENetList * list)
{
list -> sentinel.next = & list -> sentinel;
list -> sentinel.previous = & list -> sentinel;
}
ENetListIterator
enet_list_insert (ENetListIterator position, void * data)
{
ENetListIterator result = (ENetListIterator) data;
result -> previous = position -> previous;
result -> next = position;
result -> previous -> next = result;
position -> previous = result;
return result;
}
void *
enet_list_remove (ENetListIterator position)
{
position -> previous -> next = position -> next;
position -> next -> previous = position -> previous;
return position;
}
size_t
enet_list_size (ENetList * list)
{
size_t size = 0;
ENetListIterator position;
for (position = enet_list_begin (list);
position != enet_list_end (list);
position = enet_list_next (position))
++ size;
return size;
}
/** @} */

155
polymer/eduke32/source/enet/src/packet.c Normal file
View file

@ -0,0 +1,155 @@
/**
@file packet.c
@brief ENet packet management functions
*/
#include <string.h>
#define ENET_BUILDING_LIB 1
#include "enet/enet.h"
/** @defgroup Packet ENet packet functions
@{
*/
/** Creates a packet that may be sent to a peer.
@param dataContents initial contents of the packet's data; the packet's data will remain uninitialized if dataContents is NULL.
@param dataLength size of the data allocated for this packet
@param flags flags for this packet as described for the ENetPacket structure.
@returns the packet on success, NULL on failure
*/
ENetPacket *
enet_packet_create (const void * data, size_t dataLength, enet_uint32 flags)
{
ENetPacket * packet = (ENetPacket *) enet_malloc (sizeof (ENetPacket));
if (flags & ENET_PACKET_FLAG_NO_ALLOCATE)
packet -> data = (enet_uint8 *) data;
else
{
packet -> data = (enet_uint8 *) enet_malloc (dataLength);
if (packet -> data == NULL)
{
enet_free (packet);
return NULL;
}
if (data != NULL)
memcpy (packet -> data, data, dataLength);
}
packet -> referenceCount = 0;
packet -> flags = flags;
packet -> dataLength = dataLength;
packet -> freeCallback = NULL;
return packet;
}
/** Destroys the packet and deallocates its data.
@param packet packet to be destroyed
*/
void
enet_packet_destroy (ENetPacket * packet)
{
if (packet -> freeCallback != NULL)
(* packet -> freeCallback) (packet);
if (! (packet -> flags & ENET_PACKET_FLAG_NO_ALLOCATE))
enet_free (packet -> data);
enet_free (packet);
}
/** Attempts to resize the data in the packet to length specified in the
dataLength parameter
@param packet packet to resize
@param dataLength new size for the packet data
@returns 0 on success, < 0 on failure
*/
int
enet_packet_resize (ENetPacket * packet, size_t dataLength)
{
enet_uint8 * newData;
if (dataLength <= packet -> dataLength || (packet -> flags & ENET_PACKET_FLAG_NO_ALLOCATE))
{
packet -> dataLength = dataLength;
return 0;
}
newData = (enet_uint8 *) enet_malloc (dataLength);
if (newData == NULL)
return -1;
memcpy (newData, packet -> data, packet -> dataLength);
enet_free (packet -> data);
packet -> data = newData;
packet -> dataLength = dataLength;
return 0;
}
static int initializedCRC32 = 0;
static enet_uint32 crcTable [256];
static enet_uint32
reflect_crc (int val, int bits)
{
int result = 0, bit;
for (bit = 0; bit < bits; bit ++)
{
if(val & 1) result |= 1 << (bits - 1 - bit);
val >>= 1;
}
return result;
}
static void
initialize_crc32 ()
{
int byte;
for (byte = 0; byte < 256; ++ byte)
{
enet_uint32 crc = reflect_crc (byte, 8) << 24;
int offset;
for(offset = 0; offset < 8; ++ offset)
{
if (crc & 0x80000000)
crc = (crc << 1) ^ 0x04c11db7;
else
crc <<= 1;
}
crcTable [byte] = reflect_crc (crc, 32);
}
initializedCRC32 = 1;
}
enet_uint32
enet_crc32 (const ENetBuffer * buffers, size_t bufferCount)
{
enet_uint32 crc = 0xFFFFFFFF;
if (! initializedCRC32) initialize_crc32 ();
while (bufferCount -- > 0)
{
const enet_uint8 * data = (const enet_uint8 *) buffers -> data,
* dataEnd = & data [buffers -> dataLength];
while (data < dataEnd)
{
crc = (crc >> 8) ^ crcTable [(crc & 0xFF) ^ *data++];
}
++ buffers;
}
return ENET_HOST_TO_NET_32 (~ crc);
}
/** @} */

700
polymer/eduke32/source/enet/src/peer.c Normal file
View file

@ -0,0 +1,700 @@
/**
@file peer.c
@brief ENet peer management functions
*/
#include <string.h>
#define ENET_BUILDING_LIB 1
#include "enet/enet.h"
/** @defgroup peer ENet peer functions
@{
*/
/** Configures throttle parameter for a peer.
Unreliable packets are dropped by ENet in response to the varying conditions
of the Internet connection to the peer. The throttle represents a probability
that an unreliable packet should not be dropped and thus sent by ENet to the peer.
The lowest mean round trip time from the sending of a reliable packet to the
receipt of its acknowledgement is measured over an amount of time specified by
the interval parameter in milliseconds. If a measured round trip time happens to
be significantly less than the mean round trip time measured over the interval,
then the throttle probability is increased to allow more traffic by an amount
specified in the acceleration parameter, which is a ratio to the ENET_PEER_PACKET_THROTTLE_SCALE
constant. If a measured round trip time happens to be significantly greater than
the mean round trip time measured over the interval, then the throttle probability
is decreased to limit traffic by an amount specified in the deceleration parameter, which
is a ratio to the ENET_PEER_PACKET_THROTTLE_SCALE constant. When the throttle has
a value of ENET_PEER_PACKET_THROTTLE_SCALE, on unreliable packets are dropped by
ENet, and so 100% of all unreliable packets will be sent. When the throttle has a
value of 0, all unreliable packets are dropped by ENet, and so 0% of all unreliable
packets will be sent. Intermediate values for the throttle represent intermediate
probabilities between 0% and 100% of unreliable packets being sent. The bandwidth
limits of the local and foreign hosts are taken into account to determine a
sensible limit for the throttle probability above which it should not raise even in
the best of conditions.
@param peer peer to configure
@param interval interval, in milliseconds, over which to measure lowest mean RTT; the default value is ENET_PEER_PACKET_THROTTLE_INTERVAL.
@param acceleration rate at which to increase the throttle probability as mean RTT declines
@param deceleration rate at which to decrease the throttle probability as mean RTT increases
*/
void
enet_peer_throttle_configure (ENetPeer * peer, enet_uint32 interval, enet_uint32 acceleration, enet_uint32 deceleration)
{
ENetProtocol command;
peer -> packetThrottleInterval = interval;
peer -> packetThrottleAcceleration = acceleration;
peer -> packetThrottleDeceleration = deceleration;
command.header.command = ENET_PROTOCOL_COMMAND_THROTTLE_CONFIGURE | ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE;
command.header.channelID = 0xFF;
command.throttleConfigure.packetThrottleInterval = ENET_HOST_TO_NET_32 (interval);
command.throttleConfigure.packetThrottleAcceleration = ENET_HOST_TO_NET_32 (acceleration);
command.throttleConfigure.packetThrottleDeceleration = ENET_HOST_TO_NET_32 (deceleration);
enet_peer_queue_outgoing_command (peer, & command, NULL, 0, 0);
}
int
enet_peer_throttle (ENetPeer * peer, enet_uint32 rtt)
{
if (peer -> lastRoundTripTime <= peer -> lastRoundTripTimeVariance)
{
peer -> packetThrottle = peer -> packetThrottleLimit;
}
else
if (rtt < peer -> lastRoundTripTime)
{
peer -> packetThrottle += peer -> packetThrottleAcceleration;
if (peer -> packetThrottle > peer -> packetThrottleLimit)
peer -> packetThrottle = peer -> packetThrottleLimit;
return 1;
}
else
if (rtt > peer -> lastRoundTripTime + 2 * peer -> lastRoundTripTimeVariance)
{
if (peer -> packetThrottle > peer -> packetThrottleDeceleration)
peer -> packetThrottle -= peer -> packetThrottleDeceleration;
else
peer -> packetThrottle = 0;
return -1;
}
return 0;
}
/** Queues a packet to be sent.
@param peer destination for the packet
@param channelID channel on which to send
@param packet packet to send
@retval 0 on success
@retval < 0 on failure
*/
int
enet_peer_send (ENetPeer * peer, enet_uint8 channelID, ENetPacket * packet)
{
ENetChannel * channel = & peer -> channels [channelID];
ENetProtocol command;
size_t fragmentLength;
if (peer -> state != ENET_PEER_STATE_CONNECTED ||
channelID >= peer -> channelCount)
return -1;
fragmentLength = peer -> mtu - sizeof (ENetProtocolHeader) - sizeof (ENetProtocolSendFragment);
if (packet -> dataLength > fragmentLength)
{
enet_uint16 startSequenceNumber = ENET_HOST_TO_NET_16 (channel -> outgoingReliableSequenceNumber + 1);
enet_uint32 fragmentCount = ENET_HOST_TO_NET_32 ((packet -> dataLength + fragmentLength - 1) / fragmentLength),
fragmentNumber,
fragmentOffset;
packet -> flags |= ENET_PACKET_FLAG_RELIABLE;
packet -> flags &= ~ENET_PACKET_FLAG_UNSEQUENCED;
for (fragmentNumber = 0,
fragmentOffset = 0;
fragmentOffset < packet -> dataLength;
++ fragmentNumber,
fragmentOffset += fragmentLength)
{
if (packet -> dataLength - fragmentOffset < fragmentLength)
fragmentLength = packet -> dataLength - fragmentOffset;
command.header.command = ENET_PROTOCOL_COMMAND_SEND_FRAGMENT | ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE;
command.header.channelID = channelID;
command.sendFragment.startSequenceNumber = startSequenceNumber;
command.sendFragment.dataLength = ENET_HOST_TO_NET_16 (fragmentLength);
command.sendFragment.fragmentCount = fragmentCount;
command.sendFragment.fragmentNumber = ENET_HOST_TO_NET_32 (fragmentNumber);
command.sendFragment.totalLength = ENET_HOST_TO_NET_32 (packet -> dataLength);
command.sendFragment.fragmentOffset = ENET_NET_TO_HOST_32 (fragmentOffset);
enet_peer_queue_outgoing_command (peer, & command, packet, fragmentOffset, fragmentLength);
}
return 0;
}
command.header.channelID = channelID;
if (! (packet -> flags & (ENET_PACKET_FLAG_RELIABLE | ENET_PACKET_FLAG_UNSEQUENCED)) && channel -> outgoingUnreliableSequenceNumber >= 0xFFFF)
packet -> flags |= ENET_PACKET_FLAG_RELIABLE;
if (packet -> flags & ENET_PACKET_FLAG_RELIABLE)
{
command.header.command = ENET_PROTOCOL_COMMAND_SEND_RELIABLE | ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE;
command.sendReliable.dataLength = ENET_HOST_TO_NET_16 (packet -> dataLength);
}
else
if (packet -> flags & ENET_PACKET_FLAG_UNSEQUENCED)
{
command.header.command = ENET_PROTOCOL_COMMAND_SEND_UNSEQUENCED | ENET_PROTOCOL_COMMAND_FLAG_UNSEQUENCED;
command.sendUnsequenced.unsequencedGroup = ENET_HOST_TO_NET_16 (peer -> outgoingUnsequencedGroup + 1);
command.sendUnsequenced.dataLength = ENET_HOST_TO_NET_16 (packet -> dataLength);
}
else
{
command.header.command = ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE;
command.sendUnreliable.unreliableSequenceNumber = ENET_HOST_TO_NET_16 (channel -> outgoingUnreliableSequenceNumber + 1);
command.sendUnreliable.dataLength = ENET_HOST_TO_NET_16 (packet -> dataLength);
}
enet_peer_queue_outgoing_command (peer, & command, packet, 0, packet -> dataLength);
return 0;
}
/** Attempts to dequeue any incoming queued packet.
@param peer peer to dequeue packets from
@param channelID channel on which to receive
@returns a pointer to the packet, or NULL if there are no available incoming queued packets
*/
ENetPacket *
enet_peer_receive (ENetPeer * peer, enet_uint8 channelID)
{
ENetChannel * channel = & peer -> channels [channelID];
ENetIncomingCommand * incomingCommand = NULL;
ENetPacket * packet;
if (! enet_list_empty (& channel -> incomingUnreliableCommands))
{
incomingCommand = (ENetIncomingCommand *) enet_list_front (& channel -> incomingUnreliableCommands);
if ((incomingCommand -> command.header.command & ENET_PROTOCOL_COMMAND_MASK) == ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE)
{
if (incomingCommand -> reliableSequenceNumber != channel -> incomingReliableSequenceNumber)
incomingCommand = NULL;
}
}
if (incomingCommand == NULL &&
! enet_list_empty (& channel -> incomingReliableCommands))
{
incomingCommand = (ENetIncomingCommand *) enet_list_front (& channel -> incomingReliableCommands);
if (incomingCommand -> fragmentsRemaining > 0 ||
incomingCommand -> reliableSequenceNumber != (enet_uint16) (channel -> incomingReliableSequenceNumber + 1))
return NULL;
channel -> incomingReliableSequenceNumber = incomingCommand -> reliableSequenceNumber;
if (incomingCommand -> fragmentCount > 0)
channel -> incomingReliableSequenceNumber += incomingCommand -> fragmentCount - 1;
}
if (incomingCommand == NULL)
return NULL;
enet_list_remove (& incomingCommand -> incomingCommandList);
packet = incomingCommand -> packet;
-- packet -> referenceCount;
if (incomingCommand -> fragments != NULL)
enet_free (incomingCommand -> fragments);
enet_free (incomingCommand);
return packet;
}
static void
enet_peer_reset_outgoing_commands (ENetList * queue)
{
ENetOutgoingCommand * outgoingCommand;
while (! enet_list_empty (queue))
{
outgoingCommand = (ENetOutgoingCommand *) enet_list_remove (enet_list_begin (queue));
if (outgoingCommand -> packet != NULL)
{
-- outgoingCommand -> packet -> referenceCount;
if (outgoingCommand -> packet -> referenceCount == 0)
enet_packet_destroy (outgoingCommand -> packet);
}
enet_free (outgoingCommand);
}
}
static void
enet_peer_reset_incoming_commands (ENetList * queue)
{
ENetIncomingCommand * incomingCommand;
while (! enet_list_empty (queue))
{
incomingCommand = (ENetIncomingCommand *) enet_list_remove (enet_list_begin (queue));
if (incomingCommand -> packet != NULL)
{
-- incomingCommand -> packet -> referenceCount;
if (incomingCommand -> packet -> referenceCount == 0)
enet_packet_destroy (incomingCommand -> packet);
}
if (incomingCommand -> fragments != NULL)
enet_free (incomingCommand -> fragments);
enet_free (incomingCommand);
}
}
void
enet_peer_reset_queues (ENetPeer * peer)
{
ENetChannel * channel;
while (! enet_list_empty (& peer -> acknowledgements))
enet_free (enet_list_remove (enet_list_begin (& peer -> acknowledgements)));
enet_peer_reset_outgoing_commands (& peer -> sentReliableCommands);
enet_peer_reset_outgoing_commands (& peer -> sentUnreliableCommands);
enet_peer_reset_outgoing_commands (& peer -> outgoingReliableCommands);
enet_peer_reset_outgoing_commands (& peer -> outgoingUnreliableCommands);
if (peer -> channels != NULL && peer -> channelCount > 0)
{
for (channel = peer -> channels;
channel < & peer -> channels [peer -> channelCount];
++ channel)
{
enet_peer_reset_incoming_commands (& channel -> incomingReliableCommands);
enet_peer_reset_incoming_commands (& channel -> incomingUnreliableCommands);
}
enet_free (peer -> channels);
}
peer -> channels = NULL;
peer -> channelCount = 0;
}
/** Forcefully disconnects a peer.
@param peer peer to forcefully disconnect
@remarks The foreign host represented by the peer is not notified of the disconnection and will timeout
on its connection to the local host.
*/
void
enet_peer_reset (ENetPeer * peer)
{
peer -> outgoingPeerID = ENET_PROTOCOL_MAXIMUM_PEER_ID;
peer -> sessionID = 0;
peer -> state = ENET_PEER_STATE_DISCONNECTED;
peer -> incomingBandwidth = 0;
peer -> outgoingBandwidth = 0;
peer -> incomingBandwidthThrottleEpoch = 0;
peer -> outgoingBandwidthThrottleEpoch = 0;
peer -> incomingDataTotal = 0;
peer -> outgoingDataTotal = 0;
peer -> lastSendTime = 0;
peer -> lastReceiveTime = 0;
peer -> nextTimeout = 0;
peer -> earliestTimeout = 0;
peer -> packetLossEpoch = 0;
peer -> packetsSent = 0;
peer -> packetsLost = 0;
peer -> packetLoss = 0;
peer -> packetLossVariance = 0;
peer -> packetThrottle = ENET_PEER_DEFAULT_PACKET_THROTTLE;
peer -> packetThrottleLimit = ENET_PEER_PACKET_THROTTLE_SCALE;
peer -> packetThrottleCounter = 0;
peer -> packetThrottleEpoch = 0;
peer -> packetThrottleAcceleration = ENET_PEER_PACKET_THROTTLE_ACCELERATION;
peer -> packetThrottleDeceleration = ENET_PEER_PACKET_THROTTLE_DECELERATION;
peer -> packetThrottleInterval = ENET_PEER_PACKET_THROTTLE_INTERVAL;
peer -> lastRoundTripTime = ENET_PEER_DEFAULT_ROUND_TRIP_TIME;
peer -> lowestRoundTripTime = ENET_PEER_DEFAULT_ROUND_TRIP_TIME;
peer -> lastRoundTripTimeVariance = 0;
peer -> highestRoundTripTimeVariance = 0;
peer -> roundTripTime = ENET_PEER_DEFAULT_ROUND_TRIP_TIME;
peer -> roundTripTimeVariance = 0;
peer -> mtu = peer -> host -> mtu;
peer -> reliableDataInTransit = 0;
peer -> outgoingReliableSequenceNumber = 0;
peer -> windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
peer -> incomingUnsequencedGroup = 0;
peer -> outgoingUnsequencedGroup = 0;
peer -> disconnectData = 0;
memset (peer -> unsequencedWindow, 0, sizeof (peer -> unsequencedWindow));
enet_peer_reset_queues (peer);
}
/** Sends a ping request to a peer.
@param peer destination for the ping request
@remarks ping requests factor into the mean round trip time as designated by the
roundTripTime field in the ENetPeer structure. Enet automatically pings all connected
peers at regular intervals, however, this function may be called to ensure more
frequent ping requests.
*/
void
enet_peer_ping (ENetPeer * peer)
{
ENetProtocol command;
if (peer -> state != ENET_PEER_STATE_CONNECTED)
return;
command.header.command = ENET_PROTOCOL_COMMAND_PING | ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE;
command.header.channelID = 0xFF;
enet_peer_queue_outgoing_command (peer, & command, NULL, 0, 0);
}
/** Force an immediate disconnection from a peer.
@param peer peer to disconnect
@param data data describing the disconnection
@remarks No ENET_EVENT_DISCONNECT event will be generated. The foreign peer is not
guarenteed to receive the disconnect notification, and is reset immediately upon
return from this function.
*/
void
enet_peer_disconnect_now (ENetPeer * peer, enet_uint32 data)
{
ENetProtocol command;
if (peer -> state == ENET_PEER_STATE_DISCONNECTED)
return;
if (peer -> state != ENET_PEER_STATE_ZOMBIE &&
peer -> state != ENET_PEER_STATE_DISCONNECTING)
{
enet_peer_reset_queues (peer);
command.header.command = ENET_PROTOCOL_COMMAND_DISCONNECT | ENET_PROTOCOL_COMMAND_FLAG_UNSEQUENCED;
command.header.channelID = 0xFF;
command.disconnect.data = ENET_HOST_TO_NET_32 (data);
enet_peer_queue_outgoing_command (peer, & command, NULL, 0, 0);
enet_host_flush (peer -> host);
}
enet_peer_reset (peer);
}
/** Request a disconnection from a peer.
@param peer peer to request a disconnection
@param data data describing the disconnection
@remarks An ENET_EVENT_DISCONNECT event will be generated by enet_host_service()
once the disconnection is complete.
*/
void
enet_peer_disconnect (ENetPeer * peer, enet_uint32 data)
{
ENetProtocol command;
if (peer -> state == ENET_PEER_STATE_DISCONNECTING ||
peer -> state == ENET_PEER_STATE_DISCONNECTED ||
peer -> state == ENET_PEER_STATE_ACKNOWLEDGING_DISCONNECT ||
peer -> state == ENET_PEER_STATE_ZOMBIE)
return;
enet_peer_reset_queues (peer);
command.header.command = ENET_PROTOCOL_COMMAND_DISCONNECT;
command.header.channelID = 0xFF;
command.disconnect.data = ENET_HOST_TO_NET_32 (data);
if (peer -> state == ENET_PEER_STATE_CONNECTED || peer -> state == ENET_PEER_STATE_DISCONNECT_LATER)
command.header.command |= ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE;
else
command.header.command |= ENET_PROTOCOL_COMMAND_FLAG_UNSEQUENCED;
enet_peer_queue_outgoing_command (peer, & command, NULL, 0, 0);
if (peer -> state == ENET_PEER_STATE_CONNECTED || peer -> state == ENET_PEER_STATE_DISCONNECT_LATER)
peer -> state = ENET_PEER_STATE_DISCONNECTING;
else
{
enet_host_flush (peer -> host);
enet_peer_reset (peer);
}
}
/** Request a disconnection from a peer, but only after all queued outgoing packets are sent.
@param peer peer to request a disconnection
@param data data describing the disconnection
@remarks An ENET_EVENT_DISCONNECT event will be generated by enet_host_service()
once the disconnection is complete.
*/
void
enet_peer_disconnect_later (ENetPeer * peer, enet_uint32 data)
{
if ((peer -> state == ENET_PEER_STATE_CONNECTED || peer -> state == ENET_PEER_STATE_DISCONNECT_LATER) &&
! (enet_list_empty (& peer -> outgoingReliableCommands) &&
enet_list_empty (& peer -> outgoingUnreliableCommands) &&
enet_list_empty (& peer -> sentReliableCommands)))
{
peer -> state = ENET_PEER_STATE_DISCONNECT_LATER;
peer -> disconnectData = data;
}
else
enet_peer_disconnect (peer, data);
}
ENetAcknowledgement *
enet_peer_queue_acknowledgement (ENetPeer * peer, const ENetProtocol * command, enet_uint16 sentTime)
{
ENetAcknowledgement * acknowledgement;
if (command -> header.channelID < peer -> channelCount)
{
ENetChannel * channel = & peer -> channels [command -> header.channelID];
enet_uint16 reliableWindow = command -> header.reliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE,
currentWindow = channel -> incomingReliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE;
if (command -> header.reliableSequenceNumber < channel -> incomingReliableSequenceNumber)
reliableWindow += ENET_PEER_RELIABLE_WINDOWS;
if (reliableWindow >= currentWindow + ENET_PEER_FREE_RELIABLE_WINDOWS - 1 && reliableWindow <= currentWindow + ENET_PEER_FREE_RELIABLE_WINDOWS)
return NULL;
}
peer -> outgoingDataTotal += sizeof (ENetProtocolAcknowledge);
acknowledgement = (ENetAcknowledgement *) enet_malloc (sizeof (ENetAcknowledgement));
acknowledgement -> sentTime = sentTime;
acknowledgement -> command = * command;
enet_list_insert (enet_list_end (& peer -> acknowledgements), acknowledgement);
return acknowledgement;
}
ENetOutgoingCommand *
enet_peer_queue_outgoing_command (ENetPeer * peer, const ENetProtocol * command, ENetPacket * packet, enet_uint32 offset, enet_uint16 length)
{
ENetChannel * channel = & peer -> channels [command -> header.channelID];
ENetOutgoingCommand * outgoingCommand;
peer -> outgoingDataTotal += enet_protocol_command_size (command -> header.command) + length;
outgoingCommand = (ENetOutgoingCommand *) enet_malloc (sizeof (ENetOutgoingCommand));
if (command -> header.channelID == 0xFF)
{
++ peer -> outgoingReliableSequenceNumber;
outgoingCommand -> reliableSequenceNumber = peer -> outgoingReliableSequenceNumber;
outgoingCommand -> unreliableSequenceNumber = 0;
}
else
if (command -> header.command & ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE)
{
++ channel -> outgoingReliableSequenceNumber;
channel -> outgoingUnreliableSequenceNumber = 0;
outgoingCommand -> reliableSequenceNumber = channel -> outgoingReliableSequenceNumber;
outgoingCommand -> unreliableSequenceNumber = 0;
}
else
if (command -> header.command & ENET_PROTOCOL_COMMAND_FLAG_UNSEQUENCED)
{
++ peer -> outgoingUnsequencedGroup;
outgoingCommand -> reliableSequenceNumber = 0;
outgoingCommand -> unreliableSequenceNumber = 0;
}
else
{
++ channel -> outgoingUnreliableSequenceNumber;
outgoingCommand -> reliableSequenceNumber = channel -> outgoingReliableSequenceNumber;
outgoingCommand -> unreliableSequenceNumber = channel -> outgoingUnreliableSequenceNumber;
}
outgoingCommand -> sendAttempts = 0;
outgoingCommand -> sentTime = 0;
outgoingCommand -> roundTripTimeout = 0;
outgoingCommand -> roundTripTimeoutLimit = 0;
outgoingCommand -> fragmentOffset = offset;
outgoingCommand -> fragmentLength = length;
outgoingCommand -> packet = packet;
outgoingCommand -> command = * command;
outgoingCommand -> command.header.reliableSequenceNumber = ENET_HOST_TO_NET_16 (outgoingCommand -> reliableSequenceNumber);
if (packet != NULL)
++ packet -> referenceCount;
if (command -> header.command & ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE)
enet_list_insert (enet_list_end (& peer -> outgoingReliableCommands), outgoingCommand);
else
enet_list_insert (enet_list_end (& peer -> outgoingUnreliableCommands), outgoingCommand);
return outgoingCommand;
}
ENetIncomingCommand *
enet_peer_queue_incoming_command (ENetPeer * peer, const ENetProtocol * command, ENetPacket * packet, enet_uint32 fragmentCount)
{
ENetChannel * channel = & peer -> channels [command -> header.channelID];
enet_uint32 unreliableSequenceNumber = 0, reliableSequenceNumber;
enet_uint16 reliableWindow, currentWindow;
ENetIncomingCommand * incomingCommand;
ENetListIterator currentCommand;
if (peer -> state == ENET_PEER_STATE_DISCONNECT_LATER)
goto freePacket;
if ((command -> header.command & ENET_PROTOCOL_COMMAND_MASK) != ENET_PROTOCOL_COMMAND_SEND_UNSEQUENCED)
{
reliableSequenceNumber = command -> header.reliableSequenceNumber;
reliableWindow = reliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE;
currentWindow = channel -> incomingReliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE;
if (reliableSequenceNumber < channel -> incomingReliableSequenceNumber)
reliableWindow += ENET_PEER_RELIABLE_WINDOWS;
if (reliableWindow < currentWindow || reliableWindow >= currentWindow + ENET_PEER_FREE_RELIABLE_WINDOWS - 1)
goto freePacket;
}
switch (command -> header.command & ENET_PROTOCOL_COMMAND_MASK)
{
case ENET_PROTOCOL_COMMAND_SEND_FRAGMENT:
case ENET_PROTOCOL_COMMAND_SEND_RELIABLE:
if (reliableSequenceNumber == channel -> incomingReliableSequenceNumber)
goto freePacket;
for (currentCommand = enet_list_previous (enet_list_end (& channel -> incomingReliableCommands));
currentCommand != enet_list_end (& channel -> incomingReliableCommands);
currentCommand = enet_list_previous (currentCommand))
{
incomingCommand = (ENetIncomingCommand *) currentCommand;
if (reliableSequenceNumber >= channel -> incomingReliableSequenceNumber)
{
if (incomingCommand -> reliableSequenceNumber < channel -> incomingReliableSequenceNumber)
continue;
}
else
if (incomingCommand -> reliableSequenceNumber >= channel -> incomingReliableSequenceNumber)
break;
if (incomingCommand -> reliableSequenceNumber <= reliableSequenceNumber)
{
if (incomingCommand -> reliableSequenceNumber < reliableSequenceNumber)
break;
goto freePacket;
}
}
break;
case ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE:
unreliableSequenceNumber = ENET_NET_TO_HOST_16 (command -> sendUnreliable.unreliableSequenceNumber);
for (currentCommand = enet_list_previous (enet_list_end (& channel -> incomingUnreliableCommands));
currentCommand != enet_list_end (& channel -> incomingUnreliableCommands);
currentCommand = enet_list_previous (currentCommand))
{
incomingCommand = (ENetIncomingCommand *) currentCommand;
if ((incomingCommand -> command.header.command & ENET_PROTOCOL_COMMAND_MASK) != ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE)
continue;
if (reliableSequenceNumber >= channel -> incomingReliableSequenceNumber)
{
if (incomingCommand -> reliableSequenceNumber < channel -> incomingReliableSequenceNumber)
continue;
}
else
if (incomingCommand -> reliableSequenceNumber >= channel -> incomingReliableSequenceNumber)
break;
if (incomingCommand -> reliableSequenceNumber < reliableSequenceNumber)
break;
if (incomingCommand -> reliableSequenceNumber > reliableSequenceNumber)
continue;
if (incomingCommand -> unreliableSequenceNumber <= unreliableSequenceNumber)
{
if (incomingCommand -> unreliableSequenceNumber < unreliableSequenceNumber)
break;
goto freePacket;
}
}
break;
case ENET_PROTOCOL_COMMAND_SEND_UNSEQUENCED:
currentCommand = enet_list_end (& channel -> incomingUnreliableCommands);
break;
default:
goto freePacket;
}
incomingCommand = (ENetIncomingCommand *) enet_malloc (sizeof (ENetIncomingCommand));
incomingCommand -> reliableSequenceNumber = command -> header.reliableSequenceNumber;
incomingCommand -> unreliableSequenceNumber = unreliableSequenceNumber & 0xFFFF;
incomingCommand -> command = * command;
incomingCommand -> fragmentCount = fragmentCount;
incomingCommand -> fragmentsRemaining = fragmentCount;
incomingCommand -> packet = packet;
incomingCommand -> fragments = NULL;
if (fragmentCount > 0)
{
incomingCommand -> fragments = (enet_uint32 *) enet_malloc ((fragmentCount + 31) / 32 * sizeof (enet_uint32));
memset (incomingCommand -> fragments, 0, (fragmentCount + 31) / 32 * sizeof (enet_uint32));
}
if (packet != NULL)
++ packet -> referenceCount;
enet_list_insert (enet_list_next (currentCommand), incomingCommand);
return incomingCommand;
freePacket:
if (packet != NULL)
{
if (packet -> referenceCount == 0)
enet_packet_destroy (packet);
}
return NULL;
}
/** @} */

1577
polymer/eduke32/source/enet/src/protocol.c Normal file
View file

File diff suppressed because it is too large Load diff

438
polymer/eduke32/source/enet/src/unix.c Normal file
View file

@ -0,0 +1,438 @@
/**
@file unix.c
@brief ENet Unix system specific functions
*/
#ifndef WIN32
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <sys/time.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <time.h>
#define ENET_BUILDING_LIB 1
#include "enet/enet.h"
#ifdef HAS_FCNTL
#include <fcntl.h>
#endif
#ifdef __APPLE__
#undef HAS_POLL
#endif
#ifdef HAS_POLL
#include <sys/poll.h>
#endif
#ifndef HAS_SOCKLEN_T
// typedef int socklen_t;
#endif
#ifndef MSG_NOSIGNAL
#define MSG_NOSIGNAL 0
#endif
static enet_uint32 timeBase = 0;
int
enet_initialize (void)
{
return 0;
}
void
enet_deinitialize (void)
{
}
enet_uint32
enet_time_get (void)
{
struct timeval timeVal;
gettimeofday (& timeVal, NULL);
return timeVal.tv_sec * 1000 + timeVal.tv_usec / 1000 - timeBase;
}
void
enet_time_set (enet_uint32 newTimeBase)
{
struct timeval timeVal;
gettimeofday (& timeVal, NULL);
timeBase = timeVal.tv_sec * 1000 + timeVal.tv_usec / 1000 - newTimeBase;
}
int
enet_address_set_host (ENetAddress * address, const char * name)
{
struct hostent * hostEntry = NULL;
#ifdef HAS_GETHOSTBYNAME_R
struct hostent hostData;
char buffer [2048];
int errnum;
#if defined(linux) || defined(__linux) || defined(__linux__) || defined(__FreeBSD__)
gethostbyname_r (name, & hostData, buffer, sizeof (buffer), & hostEntry, & errnum);
#else
hostEntry = gethostbyname_r (name, & hostData, buffer, sizeof (buffer), & errnum);
#endif
#else
hostEntry = gethostbyname (name);
#endif
if (hostEntry == NULL ||
hostEntry -> h_addrtype != AF_INET)
{
#ifdef HAS_INET_PTON
if (! inet_pton (AF_INET, name, & address -> host))
#else
if (! inet_aton (name, (struct in_addr *) & address -> host))
#endif
return -1;
return 0;
}
address -> host = * (enet_uint32 *) hostEntry -> h_addr_list [0];
return 0;
}
int
enet_address_get_host_ip (const ENetAddress * address, char * name, size_t nameLength)
{
#ifdef HAS_INET_NTOP
if (inet_ntop (AF_INET, & address -> host, name, nameLength) == NULL)
#else
char * addr = inet_ntoa (* (struct in_addr *) & address -> host);
if (addr != NULL)
strncpy (name, addr, nameLength);
else
#endif
return -1;
return 0;
}
int
enet_address_get_host (const ENetAddress * address, char * name, size_t nameLength)
{
struct in_addr in;
struct hostent * hostEntry = NULL;
#ifdef HAS_GETHOSTBYADDR_R
struct hostent hostData;
char buffer [2048];
int errnum;
in.s_addr = address -> host;
#if defined(linux) || defined(__linux) || defined(__linux__) || defined(__FreeBSD__)
gethostbyaddr_r ((char *) & in, sizeof (struct in_addr), AF_INET, & hostData, buffer, sizeof (buffer), & hostEntry, & errnum);
#else
hostEntry = gethostbyaddr_r ((char *) & in, sizeof (struct in_addr), AF_INET, & hostData, buffer, sizeof (buffer), & errnum);
#endif
#else
in.s_addr = address -> host;
hostEntry = gethostbyaddr ((char *) & in, sizeof (struct in_addr), AF_INET);
#endif
if (hostEntry == NULL)
return enet_address_get_host_ip (address, name, nameLength);
strncpy (name, hostEntry -> h_name, nameLength);
return 0;
}
int
enet_socket_bind (ENetSocket socket, const ENetAddress * address)
{
struct sockaddr_in sin;
memset (& sin, 0, sizeof (struct sockaddr_in));
sin.sin_family = AF_INET;
if (address != NULL)
{
sin.sin_port = ENET_HOST_TO_NET_16 (address -> port);
sin.sin_addr.s_addr = address -> host;
}
else
{
sin.sin_port = 0;
sin.sin_addr.s_addr = INADDR_ANY;
}
return bind (socket,
(struct sockaddr *) & sin,
sizeof (struct sockaddr_in));
}
int
enet_socket_listen (ENetSocket socket, int backlog)
{
return listen (socket, backlog < 0 ? SOMAXCONN : backlog);
}
ENetSocket
enet_socket_create (ENetSocketType type)
{
return socket (PF_INET, type == ENET_SOCKET_TYPE_DATAGRAM ? SOCK_DGRAM : SOCK_STREAM, 0);
}
int
enet_socket_set_option (ENetSocket socket, ENetSocketOption option, int value)
{
int result = -1;
switch (option)
{
case ENET_SOCKOPT_NONBLOCK:
#ifdef HAS_FCNTL
result = fcntl (socket, F_SETFL, O_NONBLOCK | fcntl (socket, F_GETFL));
#else
result = ioctl (socket, FIONBIO, & value);
#endif
break;
case ENET_SOCKOPT_BROADCAST:
result = setsockopt (socket, SOL_SOCKET, SO_BROADCAST, (char *) & value, sizeof (int));
break;
case ENET_SOCKOPT_REUSEADDR:
result = setsockopt (socket, SOL_SOCKET, SO_REUSEADDR, (char *) & value, sizeof (int));
break;
case ENET_SOCKOPT_RCVBUF:
result = setsockopt (socket, SOL_SOCKET, SO_RCVBUF, (char *) & value, sizeof (int));
break;
case ENET_SOCKOPT_SNDBUF:
result = setsockopt (socket, SOL_SOCKET, SO_SNDBUF, (char *) & value, sizeof (int));
break;
default:
break;
}
return result == -1 ? -1 : 0;
}
int
enet_socket_connect (ENetSocket socket, const ENetAddress * address)
{
struct sockaddr_in sin;
memset (& sin, 0, sizeof (struct sockaddr_in));
sin.sin_family = AF_INET;
sin.sin_port = ENET_HOST_TO_NET_16 (address -> port);
sin.sin_addr.s_addr = address -> host;
return connect (socket, (struct sockaddr *) & sin, sizeof (struct sockaddr_in));
}
ENetSocket
enet_socket_accept (ENetSocket socket, ENetAddress * address)
{
int result;
struct sockaddr_in sin;
socklen_t sinLength = sizeof (struct sockaddr_in);
result = accept (socket,
address != NULL ? (struct sockaddr *) & sin : NULL,
address != NULL ? & sinLength : NULL);
if (result == -1)
return ENET_SOCKET_NULL;
if (address != NULL)
{
address -> host = (enet_uint32) sin.sin_addr.s_addr;
address -> port = ENET_NET_TO_HOST_16 (sin.sin_port);
}
return result;
}
void
enet_socket_destroy (ENetSocket socket)
{
close (socket);
}
int
enet_socket_send (ENetSocket socket,
const ENetAddress * address,
const ENetBuffer * buffers,
size_t bufferCount)
{
struct msghdr msgHdr;
struct sockaddr_in sin;
int sentLength;
memset (& msgHdr, 0, sizeof (struct msghdr));
if (address != NULL)
{
memset (& sin, 0, sizeof (struct sockaddr_in));
sin.sin_family = AF_INET;
sin.sin_port = ENET_HOST_TO_NET_16 (address -> port);
sin.sin_addr.s_addr = address -> host;
msgHdr.msg_name = & sin;
msgHdr.msg_namelen = sizeof (struct sockaddr_in);
}
msgHdr.msg_iov = (struct iovec *) buffers;
msgHdr.msg_iovlen = bufferCount;
sentLength = sendmsg (socket, & msgHdr, MSG_NOSIGNAL);
if (sentLength == -1)
{
if (errno == EWOULDBLOCK)
return 0;
return -1;
}
return sentLength;
}
int
enet_socket_receive (ENetSocket socket,
ENetAddress * address,
ENetBuffer * buffers,
size_t bufferCount)
{
struct msghdr msgHdr;
struct sockaddr_in sin;
int recvLength;
memset (& msgHdr, 0, sizeof (struct msghdr));
if (address != NULL)
{
msgHdr.msg_name = & sin;
msgHdr.msg_namelen = sizeof (struct sockaddr_in);
}
msgHdr.msg_iov = (struct iovec *) buffers;
msgHdr.msg_iovlen = bufferCount;
recvLength = recvmsg (socket, & msgHdr, MSG_NOSIGNAL);
if (recvLength == -1)
{
if (errno == EWOULDBLOCK)
return 0;
return -1;
}
#ifdef HAS_MSGHDR_FLAGS
if (msgHdr.msg_flags & MSG_TRUNC)
return -1;
#endif
if (address != NULL)
{
address -> host = (enet_uint32) sin.sin_addr.s_addr;
address -> port = ENET_NET_TO_HOST_16 (sin.sin_port);
}
return recvLength;
}
int
enet_socketset_select (ENetSocket maxSocket, ENetSocketSet * readSet, ENetSocketSet * writeSet, enet_uint32 timeout)
{
struct timeval timeVal;
timeVal.tv_sec = timeout / 1000;
timeVal.tv_usec = (timeout % 1000) * 1000;
return select (maxSocket + 1, readSet, writeSet, NULL, & timeVal);
}
int
enet_socket_wait (ENetSocket socket, enet_uint32 * condition, enet_uint32 timeout)
{
#ifdef HAS_POLL
struct pollfd pollSocket;
int pollCount;
pollSocket.fd = socket;
pollSocket.events = 0;
if (* condition & ENET_SOCKET_WAIT_SEND)
pollSocket.events |= POLLOUT;
if (* condition & ENET_SOCKET_WAIT_RECEIVE)
pollSocket.events |= POLLIN;
pollCount = poll (& pollSocket, 1, timeout);
if (pollCount < 0)
return -1;
* condition = ENET_SOCKET_WAIT_NONE;
if (pollCount == 0)
return 0;
if (pollSocket.revents & POLLOUT)
* condition |= ENET_SOCKET_WAIT_SEND;
if (pollSocket.revents & POLLIN)
* condition |= ENET_SOCKET_WAIT_RECEIVE;
return 0;
#else
fd_set readSet, writeSet;
struct timeval timeVal;
int selectCount;
timeVal.tv_sec = timeout / 1000;
timeVal.tv_usec = (timeout % 1000) * 1000;
FD_ZERO (& readSet);
FD_ZERO (& writeSet);
if (* condition & ENET_SOCKET_WAIT_SEND)
FD_SET (socket, & writeSet);
if (* condition & ENET_SOCKET_WAIT_RECEIVE)
FD_SET (socket, & readSet);
selectCount = select (socket + 1, & readSet, & writeSet, NULL, & timeVal);
if (selectCount < 0)
return -1;
* condition = ENET_SOCKET_WAIT_NONE;
if (selectCount == 0)
return 0;
if (FD_ISSET (socket, & writeSet))
* condition |= ENET_SOCKET_WAIT_SEND;
if (FD_ISSET (socket, & readSet))
* condition |= ENET_SOCKET_WAIT_RECEIVE;
return 0;
#endif
}
#endif

348
polymer/eduke32/source/enet/src/win32.c Normal file
View file

@ -0,0 +1,348 @@
/**
@file win32.c
@brief ENet Win32 system specific functions
*/
#ifdef WIN32
#include <time.h>
#define ENET_BUILDING_LIB 1
#include "enet/enet.h"
static enet_uint32 timeBase = 0;
int
enet_initialize (void)
{
WORD versionRequested = MAKEWORD (1, 1);
WSADATA wsaData;
if (WSAStartup (versionRequested, & wsaData))
return -1;
if (LOBYTE (wsaData.wVersion) != 1||
HIBYTE (wsaData.wVersion) != 1)
{
WSACleanup ();
return -1;
}
timeBeginPeriod (1);
return 0;
}
void
enet_deinitialize (void)
{
timeEndPeriod (1);
WSACleanup ();
}
enet_uint32
enet_time_get (void)
{
return (enet_uint32) timeGetTime () - timeBase;
}
void
enet_time_set (enet_uint32 newTimeBase)
{
timeBase = (enet_uint32) timeGetTime () - newTimeBase;
}
int
enet_address_set_host (ENetAddress * address, const char * name)
{
struct hostent * hostEntry;
hostEntry = gethostbyname (name);
if (hostEntry == NULL ||
hostEntry -> h_addrtype != AF_INET)
{
unsigned long host = inet_addr (name);
if (host == INADDR_NONE)
return -1;
address -> host = host;
return 0;
}
address -> host = * (enet_uint32 *) hostEntry -> h_addr_list [0];
return 0;
}
int
enet_address_get_host_ip (const ENetAddress * address, char * name, size_t nameLength)
{
char * addr = inet_ntoa (* (struct in_addr *) & address -> host);
if (addr == NULL)
return -1;
strncpy (name, addr, nameLength);
return 0;
}
int
enet_address_get_host (const ENetAddress * address, char * name, size_t nameLength)
{
struct in_addr in;
struct hostent * hostEntry;
in.s_addr = address -> host;
hostEntry = gethostbyaddr ((char *) & in, sizeof (struct in_addr), AF_INET);
if (hostEntry == NULL)
return enet_address_get_host_ip (address, name, nameLength);
strncpy (name, hostEntry -> h_name, nameLength);
return 0;
}
int
enet_socket_bind (ENetSocket socket, const ENetAddress * address)
{
struct sockaddr_in sin;
memset (& sin, 0, sizeof (struct sockaddr_in));
sin.sin_family = AF_INET;
if (address != NULL)
{
sin.sin_port = ENET_HOST_TO_NET_16 (address -> port);
sin.sin_addr.s_addr = address -> host;
}
else
{
sin.sin_port = 0;
sin.sin_addr.s_addr = INADDR_ANY;
}
return bind (socket,
(struct sockaddr *) & sin,
sizeof (struct sockaddr_in)) == SOCKET_ERROR ? -1 : 0;
}
int
enet_socket_listen (ENetSocket socket, int backlog)
{
return listen (socket, backlog < 0 ? SOMAXCONN : backlog) == SOCKET_ERROR ? -1 : 0;
}
ENetSocket
enet_socket_create (ENetSocketType type)
{
return socket (PF_INET, type == ENET_SOCKET_TYPE_DATAGRAM ? SOCK_DGRAM : SOCK_STREAM, 0);
}
int
enet_socket_set_option (ENetSocket socket, ENetSocketOption option, int value)
{
int result = SOCKET_ERROR;
switch (option)
{
case ENET_SOCKOPT_NONBLOCK:
{
u_long nonBlocking = (u_long) value;
result = ioctlsocket (socket, FIONBIO, & nonBlocking);
break;
}
case ENET_SOCKOPT_BROADCAST:
result = setsockopt (socket, SOL_SOCKET, SO_BROADCAST, (char *) & value, sizeof (int));
break;
case ENET_SOCKOPT_REUSEADDR:
result = setsockopt (socket, SOL_SOCKET, SO_REUSEADDR, (char *) & value, sizeof (int));
break;
case ENET_SOCKOPT_RCVBUF:
result = setsockopt (socket, SOL_SOCKET, SO_RCVBUF, (char *) & value, sizeof (int));
break;
case ENET_SOCKOPT_SNDBUF:
result = setsockopt (socket, SOL_SOCKET, SO_SNDBUF, (char *) & value, sizeof (int));
break;
default:
break;
}
return result == SOCKET_ERROR ? -1 : 0;
}
int
enet_socket_connect (ENetSocket socket, const ENetAddress * address)
{
struct sockaddr_in sin;
memset (& sin, 0, sizeof (struct sockaddr_in));
sin.sin_family = AF_INET;
sin.sin_port = ENET_HOST_TO_NET_16 (address -> port);
sin.sin_addr.s_addr = address -> host;
return connect (socket, (struct sockaddr *) & sin, sizeof (struct sockaddr_in)) == SOCKET_ERROR ? -1 : 0;
}
ENetSocket
enet_socket_accept (ENetSocket socket, ENetAddress * address)
{
SOCKET result;
struct sockaddr_in sin;
int sinLength = sizeof (struct sockaddr_in);
result = accept (socket,
address != NULL ? (struct sockaddr *) & sin : NULL,
address != NULL ? & sinLength : NULL);
if (result == INVALID_SOCKET)
return ENET_SOCKET_NULL;
if (address != NULL)
{
address -> host = (enet_uint32) sin.sin_addr.s_addr;
address -> port = ENET_NET_TO_HOST_16 (sin.sin_port);
}
return result;
}
void
enet_socket_destroy (ENetSocket socket)
{
closesocket (socket);
}
int
enet_socket_send (ENetSocket socket,
const ENetAddress * address,
const ENetBuffer * buffers,
size_t bufferCount)
{
struct sockaddr_in sin;
DWORD sentLength;
if (address != NULL)
{
memset (& sin, 0, sizeof (struct sockaddr_in));
sin.sin_family = AF_INET;
sin.sin_port = ENET_HOST_TO_NET_16 (address -> port);
sin.sin_addr.s_addr = address -> host;
}
if (WSASendTo (socket,
(LPWSABUF) buffers,
(DWORD) bufferCount,
& sentLength,
0,
address != NULL ? (struct sockaddr *) & sin : 0,
address != NULL ? sizeof (struct sockaddr_in) : 0,
NULL,
NULL) == SOCKET_ERROR)
{
if (WSAGetLastError () == WSAEWOULDBLOCK)
return 0;
return -1;
}
return (int) sentLength;
}
int
enet_socket_receive (ENetSocket socket,
ENetAddress * address,
ENetBuffer * buffers,
size_t bufferCount)
{
INT sinLength = sizeof (struct sockaddr_in);
DWORD flags = 0,
recvLength;
struct sockaddr_in sin;
if (WSARecvFrom (socket,
(LPWSABUF) buffers,
(DWORD) bufferCount,
& recvLength,
& flags,
address != NULL ? (struct sockaddr *) & sin : NULL,
address != NULL ? & sinLength : NULL,
NULL,
NULL) == SOCKET_ERROR)
{
switch (WSAGetLastError ())
{
case WSAEWOULDBLOCK:
case WSAECONNRESET:
return 0;
}
return -1;
}
if (flags & MSG_PARTIAL)
return -1;
if (address != NULL)
{
address -> host = (enet_uint32) sin.sin_addr.s_addr;
address -> port = ENET_NET_TO_HOST_16 (sin.sin_port);
}
return (int) recvLength;
}
int
enet_socketset_select (ENetSocket maxSocket, ENetSocketSet * readSet, ENetSocketSet * writeSet, enet_uint32 timeout)
{
struct timeval timeVal;
timeVal.tv_sec = timeout / 1000;
timeVal.tv_usec = (timeout % 1000) * 1000;
return select (maxSocket + 1, readSet, writeSet, NULL, & timeVal);
}
int
enet_socket_wait (ENetSocket socket, enet_uint32 * condition, enet_uint32 timeout)
{
fd_set readSet, writeSet;
struct timeval timeVal;
int selectCount;
timeVal.tv_sec = timeout / 1000;
timeVal.tv_usec = (timeout % 1000) * 1000;
FD_ZERO (& readSet);
FD_ZERO (& writeSet);
if (* condition & ENET_SOCKET_WAIT_SEND)
FD_SET (socket, & writeSet);
if (* condition & ENET_SOCKET_WAIT_RECEIVE)
FD_SET (socket, & readSet);
selectCount = select (socket + 1, & readSet, & writeSet, NULL, & timeVal);
if (selectCount < 0)
return -1;
* condition = ENET_SOCKET_WAIT_NONE;
if (selectCount == 0)
return 0;
if (FD_ISSET (socket, & writeSet))
* condition |= ENET_SOCKET_WAIT_SEND;
if (FD_ISSET (socket, & readSet))
* condition |= ENET_SOCKET_WAIT_RECEIVE;
return 0;
}
#endif

1
polymer/eduke32/source/funct.h
View file

@ -183,6 +183,7 @@ extern int32_t A_IncurDamage(int32_t sn);
extern void G_MoveWorld(void);
extern void A_MoveCyclers(void);
extern void A_MoveDummyPlayers(void);
extern void P_ResetStatus(int32_t snum);
// game.c
extern inline void G_SetStatusBarScale(int32_t sc);

2543
polymer/eduke32/source/game.c
View file

File diff suppressed because it is too large Load diff

11
polymer/eduke32/source/gamedef.c
View file

@ -5358,8 +5358,6 @@ repeatcase:
else if ((Bstrlen(tempbuf)+1) > sizeof(MapInfo[j*MAXLEVELS+k].filename))
MapInfo[j*MAXLEVELS+k].filename = Brealloc(MapInfo[j*MAXLEVELS+k].filename,(Bstrlen(tempbuf)+1));
/* initprintf("level file name string len: %d\n",Bstrlen(tempbuf)); */
Bstrcpy(MapInfo[j*MAXLEVELS+k].filename,tempbuf);
C_SkipComments();
@ -5581,19 +5579,15 @@ repeatcase:
C_GetNextValue(LABEL_DEFINE);
g_sounds[k].ps = *(g_scriptPtr-1);
g_scriptPtr--;
C_GetNextValue(LABEL_DEFINE);
g_sounds[k].pe = *(g_scriptPtr-1);
g_scriptPtr--;
C_GetNextValue(LABEL_DEFINE);
g_sounds[k].pr = *(g_scriptPtr-1);
g_scriptPtr--;
C_GetNextValue(LABEL_DEFINE);
g_sounds[k].m = *(g_scriptPtr-1);
g_scriptPtr--;
C_GetNextValue(LABEL_DEFINE);
g_sounds[k].vo = *(g_scriptPtr-1);
g_scriptPtr--;
g_scriptPtr -= 5;
if (k > g_maxSoundPos)
g_maxSoundPos = k;
@ -5627,8 +5621,7 @@ repeatcase:
*(g_scriptPtr++) = CON_ENDEVENT;
previous_event = NULL;
}
g_parsingEventPtr = 0;
g_parsingActorPtr = 0;
g_parsingEventPtr = g_parsingActorPtr = 0;
g_currentEvent = -1;
Bsprintf(g_szCurrentBlockName,"(none)");
return 0;

4
polymer/eduke32/source/gamedefs.h
View file

@ -105,10 +105,6 @@ extern "C" {
#define MAXJOYAXES 8
// Number of GAMEPAD axes
#define MAXGAMEPADAXES 2
// MIN/MAX scale value for controller scales
#define MAXCONTROLSCALEVALUE (1<<19)

15
polymer/eduke32/source/gameexec.c
View file

@ -39,6 +39,7 @@ vmstate_t vm;
int32_t g_errorLineNum;
int32_t g_tw;
extern int32_t ticrandomseed;
static int32_t X_DoExecute(int32_t once);
@ -1824,7 +1825,7 @@ nullquote:
ud.m_volume_number = ud.volume_number = volnume;
ud.m_level_number = ud.level_number = levnume;
if (numplayers > 1 && myconnectindex == connecthead)
if (numplayers > 1 && net_server)
Net_NewGame(volnume,levnume);
else
{
@ -2712,7 +2713,7 @@ nullquote:
g_lastSaveSlot = *insptr++;
if ((g_movesPerPacket == 4 && connecthead != myconnectindex) || g_lastSaveSlot > 9)
if (g_lastSaveSlot > 9)
continue;
if ((tw == CON_SAVE) || !(ud.savegame[g_lastSaveSlot][0]))
{
@ -4703,6 +4704,9 @@ void A_Execute(int32_t iActor,int32_t iPlayer,int32_t lDist)
// if (actorscrptr[sprite[iActor].picnum] == 0) return;
if (net_server || net_client)
randomseed = ticrandomseed;
vm.g_i = iActor; // Sprite ID
vm.g_p = iPlayer; // Player ID
vm.g_x = lDist; // ?
@ -4996,9 +5000,15 @@ void G_RestoreMapState(mapstate_t *save)
{
if (aGameVars[i].dwFlags & GAMEVAR_NORESET) continue;
if (aGameVars[i].dwFlags & GAMEVAR_PERPLAYER)
{
if (!save->vars[i]) continue;
Bmemcpy(&aGameVars[i].val.plValues[0],&save->vars[i][0],sizeof(intptr_t) * MAXPLAYERS);
}
else if (aGameVars[i].dwFlags & GAMEVAR_PERACTOR)
{
if (!save->vars[i]) continue;
Bmemcpy(&aGameVars[i].val.plValues[0],&save->vars[i][0],sizeof(intptr_t) * MAXSPRITES);
}
else aGameVars[i].val.lValue = (intptr_t)save->vars[i];
}
@ -5082,7 +5092,6 @@ void G_RestoreMapState(mapstate_t *save)
Net_ResetPrediction();
Net_WaitForEverybody();
mmulti_flushpackets();
clearfifo();
G_ResetTimers();
}

5
polymer/eduke32/source/global.c
View file

@ -49,7 +49,7 @@ int16_t cyclers[MAXCYCLERS][6],g_numCyclers;
char *ScriptQuotes[MAXQUOTES], *ScriptQuoteRedefinitions[MAXQUOTES];
char tempbuf[2048], packbuf[576], menutextbuf[128], buf[1024];
char tempbuf[2048], packbuf[4096], menutextbuf[128], buf[1024];
int16_t camsprite;
int16_t g_mirrorWall[64], g_mirrorSector[64], g_mirrorCount;
@ -163,7 +163,7 @@ int32_t myhorizbak[MOVEFIFOSIZ],g_playerFriction = 0xcc00, g_showShareware;
int16_t myangbak[MOVEFIFOSIZ];
char szPlayerName[32];
int32_t g_damageCameras,g_freezerSelfDamage=0,g_tripbombLaserMode=0;
int32_t g_networkBroadcastMode = 255, g_movesPerPacket = 1,g_gameQuit = 0,everyothertime;
int32_t g_gameQuit = 0,everyothertime;
int32_t g_numFreezeBounces=3,g_rpgBlastRadius,g_pipebombBlastRadius,g_tripbombBlastRadius,
g_shrinkerBlastRadius,g_morterBlastRadius,g_bouncemineBlastRadius,g_seenineBlastRadius;
DukeStatus_t sbar;
@ -185,7 +185,6 @@ projectile_t ProjectileData[MAXTILES], DefaultProjectileData[MAXTILES], SpritePr
char CheatKeys[2] = { sc_D, sc_N };
char setupfilename[BMAX_PATH]= SETUPFILENAME;
// char datetimestring[] = ""__DATE__" "__TIME__"";
int32_t g_doQuickSave = 0;
uint32_t g_moveThingsCount = 0;

10
polymer/eduke32/source/jaudiolib/src/driver_directsound.c
View file

@ -318,7 +318,10 @@ int32_t DirectSoundDrv_PCM_Init(int32_t *mixrate, int32_t *numchannels, int32_t
memset(&bufdesc, 0, sizeof(DSBUFFERDESC));
bufdesc.dwSize = sizeof(DSBUFFERDESC);
bufdesc.dwFlags = DSBCAPS_PRIMARYBUFFER;
bufdesc.dwFlags = DSBCAPS_LOCSOFTWARE |
DSBCAPS_PRIMARYBUFFER |
DSBCAPS_GETCURRENTPOSITION2 |
DSBCAPS_STICKYFOCUS ;
err = IDirectSound_CreateSoundBuffer(lpds, &bufdesc, &lpdsbprimary, 0);
if (FAILED( err )) {
@ -344,8 +347,9 @@ int32_t DirectSoundDrv_PCM_Init(int32_t *mixrate, int32_t *numchannels, int32_t
bufdesc.dwFlags = DSBCAPS_LOCSOFTWARE |
DSBCAPS_CTRLPOSITIONNOTIFY |
DSBCAPS_GETCURRENTPOSITION2;
bufdesc.dwBufferBytes = wfex.nBlockAlign * 2048 * 2;
DSBCAPS_GETCURRENTPOSITION2 |
DSBCAPS_STICKYFOCUS ;
bufdesc.dwBufferBytes = wfex.nBlockAlign * 2560 * 2;
bufdesc.lpwfxFormat = &wfex;
err = IDirectSound_CreateSoundBuffer(lpds, &bufdesc, &lpdsbsec, 0);

129
polymer/eduke32/source/jaudiolib/src/multivoc.c
View file

@ -159,22 +159,18 @@ uint32_t MV_MixPosition;
int32_t MV_ErrorCode = MV_Ok;
static int32_t lockdepth = 0;
static int32_t DisableInterrupts(void)
static void DisableInterrupts(void)
{
if (lockdepth++ > 0)
{
return 0;
}
return;
SoundDriver_Lock();
return 0;
return;
}
static void RestoreInterrupts(int32_t a)
static void RestoreInterrupts(void)
{
if (--lockdepth > 0)
{
return;
}
SoundDriver_Unlock();
}
@ -361,12 +357,11 @@ void MV_PlayVoice
)
{
int32_t flags;
flags = DisableInterrupts();
DisableInterrupts();
LL_SortedInsertion(&VoiceList, voice, prev, next, VoiceNode, priority);
RestoreInterrupts(flags);
RestoreInterrupts();
}
@ -382,15 +377,13 @@ void MV_StopVoice
)
{
int32_t flags;
flags = DisableInterrupts();
DisableInterrupts();
// move the voice from the play list to the free list
LL_Remove(voice, next, prev);
LL_Add((VoiceNode*) &VoicePool, voice, next, prev);
RestoreInterrupts(flags);
RestoreInterrupts();
if (voice->wavetype == Vorbis)
{
@ -501,49 +494,47 @@ void MV_ServiceVoc
}
// Play any waiting voices
//flags = DisableInterrupts();
//DisableInterrupts();
if (!VoiceList.next)
if (!VoiceList.next || (voice = VoiceList.next) == &VoiceList)
return;
for (voice = VoiceList.next; voice != &VoiceList; voice = next)
do
{
if ( voice->Paused )
{
next = voice->next;
next = voice->next;
if (voice->Paused)
continue;
}
MV_BufferEmpty[ MV_MixPage ] = FALSE;
// if (!voice->Paused)
MV_MixFunction(voice, MV_MixPage);
next = voice->next;
MV_MixFunction(voice, MV_MixPage);
// Is this voice done?
if (!voice->Playing/* && !voice->Paused*/)
if (!voice->Playing)
{
//JBF: prevent a deadlock caused by MV_StopVoice grabbing the mutex again
//MV_StopVoice( voice );
LL_Remove(voice, next, prev);
LL_Add((VoiceNode*) &VoicePool, voice, next, prev);
if (voice->wavetype == Vorbis)
MV_ReleaseVorbisVoice(voice);
if (MV_CallBackFunc)
{
MV_CallBackFunc(voice->callbackval);
}
}
}
while ((voice = next) != &VoiceList);
//RestoreInterrupts(flags);
//RestoreInterrupts();
}
/*---------------------------------------------------------------------
Function: MV_GetNextVOCBlock
Interperate the information of a VOC format sound file.
Interpret the information of a VOC format sound file.
---------------------------------------------------------------------*/
playbackstatus MV_GetNextVOCBlock
@ -585,7 +576,8 @@ playbackstatus MV_GetNextVOCBlock
packtype = 0;
done = FALSE;
while (!done)
do
{
// Stop playing if we get a NULL pointer
if (ptr == NULL)
@ -753,6 +745,7 @@ playbackstatus MV_GetNextVOCBlock
lastblocktype = blocktype;
}
while (!done);
if (voice->Playing)
{
@ -963,9 +956,8 @@ VoiceNode *MV_GetVoice
{
VoiceNode *voice;
int32_t flags;
flags = DisableInterrupts();
DisableInterrupts();
for (voice = VoiceList.next; voice != &VoiceList; voice = voice->next)
{
@ -975,7 +967,7 @@ VoiceNode *MV_GetVoice
}
}
RestoreInterrupts(flags);
RestoreInterrupts();
if (voice == &VoiceList)
{
@ -1031,8 +1023,7 @@ int32_t MV_KillAllVoices
)
{
VoiceNode * voice, * next;
int32_t flags;
VoiceNode * voice = VoiceList.prev;
if (!MV_Installed)
{
@ -1040,19 +1031,25 @@ int32_t MV_KillAllVoices
return(MV_Error);
}
flags = DisableInterrupts();
if (&VoiceList == VoiceList.next)
return(MV_Ok);
DisableInterrupts();
// Remove all the voices from the list
for (voice = VoiceList.next; voice != &VoiceList; voice = next)
while (voice != &VoiceList)
{
next = voice->next;
if (voice->priority < MV_MUSIC_PRIORITY)
if (voice->priority == MV_MUSIC_PRIORITY)
{
MV_Kill(voice->handle);
voice = voice->prev;
continue;
}
MV_Kill(voice->handle);
voice = VoiceList.prev;
}
RestoreInterrupts(flags);
RestoreInterrupts();
return(MV_Ok);
}
@ -1071,7 +1068,6 @@ int32_t MV_Kill
{
VoiceNode *voice;
int32_t flags;
uint32_t callbackval;
if (!MV_Installed)
@ -1080,12 +1076,12 @@ int32_t MV_Kill
return(MV_Error);
}
flags = DisableInterrupts();
DisableInterrupts();
voice = MV_GetVoice(handle);
if (voice == NULL)
{
RestoreInterrupts(flags);
RestoreInterrupts();
MV_SetErrorCode(MV_VoiceNotFound);
return(MV_Error);
}
@ -1094,7 +1090,7 @@ int32_t MV_Kill
MV_StopVoice(voice);
RestoreInterrupts(flags);
RestoreInterrupts();
if (MV_CallBackFunc)
{
@ -1119,7 +1115,6 @@ int32_t MV_VoicesPlaying
{
VoiceNode *voice;
int32_t NumVoices = 0;
int32_t flags;
if (!MV_Installed)
{
@ -1127,14 +1122,14 @@ int32_t MV_VoicesPlaying
return(0);
}
flags = DisableInterrupts();
DisableInterrupts();
for (voice = VoiceList.next; voice != &VoiceList; voice = voice->next)
{
NumVoices++;
}
RestoreInterrupts(flags);
RestoreInterrupts();
return(NumVoices);
}
@ -1154,15 +1149,13 @@ VoiceNode *MV_AllocVoice
{
VoiceNode *voice;
VoiceNode *node;
int32_t flags;
//return( NULL );
if (MV_Recording)
{
return(NULL);
}
flags = DisableInterrupts();
DisableInterrupts();
// Check if we have any free voices
if (LL_Empty(&VoicePool, next, prev))
@ -1187,13 +1180,13 @@ VoiceNode *MV_AllocVoice
if (LL_Empty(&VoicePool, next, prev))
{
// No free voices
RestoreInterrupts(flags);
RestoreInterrupts();
return(NULL);
}
voice = VoicePool.next;
LL_Remove(voice, next, prev);
RestoreInterrupts(flags);
RestoreInterrupts();
// Find a free voice handle
do
@ -1226,7 +1219,6 @@ int32_t MV_VoiceAvailable
{
VoiceNode *voice;
VoiceNode *node;
int32_t flags;
// Check if we have any free voices
if (!LL_Empty(&VoicePool, next, prev))
@ -1234,7 +1226,7 @@ int32_t MV_VoiceAvailable
return(TRUE);
}
flags = DisableInterrupts();
DisableInterrupts();
// check if we have a higher priority than a voice that is playing.
voice = VoiceList.next;
@ -1246,7 +1238,7 @@ int32_t MV_VoiceAvailable
}
}
RestoreInterrupts(flags);
RestoreInterrupts();
if ((voice != &VoiceList) && (priority >= voice->priority))
{
@ -1411,7 +1403,7 @@ void MV_SetVoiceMixMode
//int32_t flags;
int32_t test;
//flags = DisableInterrupts();
//DisableInterrupts();
test = T_DEFAULT;
if (MV_Bits == 8)
@ -1608,7 +1600,6 @@ int32_t MV_PauseVoice
{
VoiceNode *voice;
int32_t flags;
if (!MV_Installed)
{
@ -1616,19 +1607,19 @@ int32_t MV_PauseVoice
return(MV_Error);
}
flags = DisableInterrupts();
DisableInterrupts();
voice = MV_GetVoice(handle);
if (voice == NULL)
{
RestoreInterrupts(flags);
RestoreInterrupts();
MV_SetErrorCode(MV_VoiceNotFound);
return(MV_Warning);
}
voice->Paused = pause;
RestoreInterrupts(flags);
RestoreInterrupts();
return(MV_Ok);
}
@ -1648,7 +1639,6 @@ int32_t MV_EndLooping
{
VoiceNode *voice;
int32_t flags;
if (!MV_Installed)
{
@ -1656,12 +1646,12 @@ int32_t MV_EndLooping
return(MV_Error);
}
flags = DisableInterrupts();
DisableInterrupts();
voice = MV_GetVoice(handle);
if (voice == NULL)
{
RestoreInterrupts(flags);
RestoreInterrupts();
MV_SetErrorCode(MV_VoiceNotFound);
return(MV_Warning);
}
@ -1670,7 +1660,7 @@ int32_t MV_EndLooping
voice->LoopStart = NULL;
voice->LoopEnd = NULL;
RestoreInterrupts(flags);
RestoreInterrupts();
return(MV_Ok);
}
@ -1974,13 +1964,12 @@ void MV_StopPlayback
{
VoiceNode *voice;
VoiceNode *next;
int32_t flags;
// Stop sound playback
SoundDriver_StopPlayback();
// Make sure all callbacks are done.
flags = DisableInterrupts();
DisableInterrupts();
for (voice = VoiceList.next; voice != &VoiceList; voice = next)
{
@ -1994,7 +1983,7 @@ void MV_StopPlayback
}
}
RestoreInterrupts(flags);
RestoreInterrupts();
}

10
polymer/eduke32/source/jmact/_control.h
View file

@ -94,15 +94,7 @@ extern "C" {
// Number of JOY axes
#define MAXJOYAXES 6
// Number of GamePad axes
#define MAXGAMEPADAXES 2
// Number of axes
#define MAXAXES 6
#define MAXJOYAXES 8
// NORMAL axis scale

2
polymer/eduke32/source/jmact/control.c
View file

@ -50,7 +50,7 @@ static int32_t CONTROL_MouseButtonClicked[MAXMOUSEBUTTONS], CONTROL_JoyButt
static uint8_t CONTROL_MouseButtonClickedCount[MAXMOUSEBUTTONS], CONTROL_JoyButtonClickedCount[MAXJOYBUTTONS];
static int32_t CONTROL_UserInputCleared[3];
static int32_t(*GetTime)(void);
static int32_t CONTROL_Started = FALSE;
int32_t CONTROL_Started = FALSE;
static int32_t ticrate;
static int32_t CONTROL_DoubleClickSpeed;

1
polymer/eduke32/source/jmact/control.h
View file

@ -132,6 +132,7 @@ typedef enum
//
//***************************************************************************
extern int32_t CONTROL_Started;
extern int32_t CONTROL_MousePresent;
extern int32_t CONTROL_JoyPresent;
extern int32_t CONTROL_MouseEnabled;

2
polymer/eduke32/source/macros.h
View file

@ -4,7 +4,7 @@
#define TRAVERSE_SPRITE_SECT(l, o, n) for ((o) = (l); (n) = nextspritesect[o], (o) != -1; (o) = (n))
#define TRAVERSE_SPRITE_STAT(l, o, n) for ((o) = (l); (n) = nextspritestat[o], (o) != -1; (o) = (n))
#define TRAVERSE_CONNECT(i) for (i = connecthead; i != -1; i = connectpoint2[i])
#define TRAVERSE_CONNECT(i) for (i = 0; i != -1; i = connectpoint2[i])
#define TEST(flags,mask) ((flags) & (mask))
#define SET(flags,mask) ((flags) |= (mask))

121
polymer/eduke32/source/menus.c
View file

@ -1460,11 +1460,12 @@ void M_DisplayMenus(void)
tempbuf[0] = PACKET_LOAD_GAME;
tempbuf[1] = g_lastSaveSlot;
tempbuf[2] = myconnectindex;
TRAVERSE_CONNECT(x)
{
if (x != myconnectindex) mmulti_sendpacket(x,tempbuf,3);
if ((!g_networkBroadcastMode) && (myconnectindex != connecthead)) break; //slaves in M/S mode only send to master
}
if (net_client)
enet_peer_send(net_peer, 0, enet_packet_create(tempbuf, 3, ENET_PACKET_FLAG_RELIABLE));
else if (net_server)
enet_host_broadcast(net_server, 0, enet_packet_create(tempbuf, 3, ENET_PACKET_FLAG_RELIABLE));
Net_GetPackets();
G_LoadPlayer(g_lastSaveSlot);
@ -1789,26 +1790,25 @@ void M_DisplayMenus(void)
cheat_for_port_credits:
if (g_scriptVersion == 13) l = (-2);
mgametext(160,38-l,"GAME PROGRAMMING",0,2+8+16);
mgametext(160,38-l,"PROGRAMMING AND PROJECT MANAGEMENT",0,2+8+16);
p = "Richard \"TerminX\" Gobeille";
minitext(161-(Bstrlen(p)<<1), 39+10-l, p, 4, 10+16+128);
minitext(160-(Bstrlen(p)<<1), 38+10-l, p, 8, 10+16+128);
mgametext(160,57-l,"\"JFDUKE3D\" AND \"JFBUILD\" CODE",0,2+8+16);
p = "Jonathon \"JonoF\" Fowler";
mgametext(160,57-l,"POLYMER RENDERING SYSTEM",0,2+8+16);
p = "Pierre-Loup \"Plagman\" Griffais";
minitext(161-(Bstrlen(p)<<1), 58+10-l, p, 4, 10+16+128);
minitext(160-(Bstrlen(p)<<1), 57+10-l, p, 8, 10+16+128);
mgametext(160,76-l,"BUILD ENGINE, \"POLYMOST\" RENDERER",0,2+8+16);
mgametext(160,76+8-l,"NETWORKING, OTHER CODE",0,2+8+16);
p = "Ken \"Awesoken\" Silverman";
minitext(161-(Bstrlen(p)<<1), 77+8+10-l, p, 4, 10+16+128);
minitext(160-(Bstrlen(p)<<1), 76+8+10-l, p, 8, 10+16+128);
mgametext(160,76-l,"ENGINE AND GAME PORTING WORK",0,2+8+16);
p = "Jonathon \"JonoF\" Fowler";
minitext(161-(Bstrlen(p)<<1), 77+10-l, p, 4, 10+16+128);
minitext(160-(Bstrlen(p)<<1), 76+10-l, p, 8, 10+16+128);
mgametext(160,103-l,"ADDITIONAL RENDERING FEATURES",0,2+8+16);
p = "Pierre-Loup \"Plagman\" Griffais";
minitext(161-(Bstrlen(p)<<1), 104+10-l, p, 4, 10+16+128);
minitext(160-(Bstrlen(p)<<1), 103+10-l, p, 8, 10+16+128);
mgametext(160,95-l,"BUILD ENGINE AND POLYMOST RENDERER",0,2+8+16);
p = "Ken \"Awesoken\" Silverman";
minitext(161-(Bstrlen(p)<<1), 96+10-l, p, 4, 10+16+128);
minitext(160-(Bstrlen(p)<<1), 95+10-l, p, 8, 10+16+128);
mgametext(160,122-l,"LICENSE AND OTHER CONTRIBUTORS",0,2+8+16);
{
@ -1836,11 +1836,15 @@ cheat_for_port_credits:
"Ozkan Sezer", // SDL/GTK version checking improvements
"Peter Green", // dynamic remapping, custom gametypes
"Peter Veenstra", // port to 64-bit
"Randy Heit", // random snippets of ZDoom here and there
"Robin Green", // CON array support
"Philipp Kutin", // Mapster32 improvements
"Ryan Gordon", // icculus.org Duke3D port sound code
"Stephen Anthony", // early 64-bit porting work
" ",
"EDuke originally by Matt Saettler",
"EDuke originally by Matt Saettler.",
" ",
"BUILD engine technology available under BUILDLIC.",
" ",
"--x--",
" ",
@ -1862,9 +1866,6 @@ cheat_for_port_credits:
p = "Visit www.eduke32.com for news and updates";
minitext(161-(Bstrlen(p)<<1), 136+10+10+10+10+4-l, p, 4, 10+16+128);
minitext(160-(Bstrlen(p)<<1), 135+10+10+10+10+4-l, p, 8, 10+16+128);
p = "See wiki.eduke32.com/stuff for new releases";
minitext(161-(Bstrlen(p)<<1), 143+10+10+10+10+4-l, p, 4, 10+16+128);
minitext(160-(Bstrlen(p)<<1), 142+10+10+10+10+4-l, p, 8, 10+16+128);
}
break;
@ -1878,9 +1879,6 @@ cheat_for_port_credits:
{
if (ud.multimode > 1 && x == 0 && ud.recstat != 2)
{
if (g_movesPerPacket == 4 && myconnectindex != connecthead)
break;
last_zero = 0;
ChangeToMenu(600);
}
@ -1897,8 +1895,6 @@ cheat_for_port_credits:
ChangeToMenu(202);
break; // JBF 20031205: was 200
case 2:
if (g_movesPerPacket == 4 && connecthead != myconnectindex)
break;
ChangeToMenu(300);
break;
case 3:
@ -1927,23 +1923,13 @@ cheat_for_port_credits:
}
}
if (g_movesPerPacket == 4)
{
if (myconnectindex == connecthead)
menutext(c,67,MENUHIGHLIGHT(0),PHX(-2),"NEW GAME");
else
menutext(c,67,MENUHIGHLIGHT(0),1,"NEW GAME");
}
else
menutext(c,67,MENUHIGHLIGHT(0),PHX(-2),"NEW GAME");
menutext(c,67,MENUHIGHLIGHT(0),PHX(-2),"NEW GAME");
// menutext(c,67+16,0,1,"NETWORK GAME");
menutext(c,67+16/*+16*/,MENUHIGHLIGHT(1),PHX(-3),"OPTIONS");
if (g_movesPerPacket == 4 && connecthead != myconnectindex)
menutext(c,67+16+16/*+16*/,MENUHIGHLIGHT(2),1,"LOAD GAME");
else menutext(c,67+16+16/*+16*/,MENUHIGHLIGHT(2),PHX(-4),"LOAD GAME");
menutext(c,67+16+16/*+16*/,MENUHIGHLIGHT(2),PHX(-4),"LOAD GAME");
if (!VOLUMEALL)
{
@ -1971,8 +1957,6 @@ cheat_for_port_credits:
switch (x)
{
case 0:
if (g_movesPerPacket == 4 && myconnectindex != connecthead)
break;
if (ud.multimode < 2 || ud.recstat == 2)
ChangeToMenu(1500);
else
@ -1982,8 +1966,6 @@ cheat_for_port_credits:
}
break;
case 1:
if (g_movesPerPacket == 4 && connecthead != myconnectindex)
break;
if (ud.recstat != 2)
{
last_fifty = 1;
@ -1992,8 +1974,6 @@ cheat_for_port_credits:
}
break;
case 2:
if (g_movesPerPacket == 4 && connecthead != myconnectindex)
break;
last_fifty = 2;
ChangeToMenu(300);
break;
@ -2030,18 +2010,9 @@ cheat_for_port_credits:
if (KB_KeyPressed(sc_Q))
ChangeToMenu(500);
if (g_movesPerPacket == 4 && connecthead != myconnectindex)
{
menutext(c,67 ,MENUHIGHLIGHT(0),1,"NEW GAME");
menutext(c,67+16 ,MENUHIGHLIGHT(1),1,"SAVE GAME");
menutext(c,67+16+16 ,MENUHIGHLIGHT(2),1,"LOAD GAME");
}
else
{
menutext(c,67 ,MENUHIGHLIGHT(0),PHX(-2),"NEW GAME");
menutext(c,67+16 ,MENUHIGHLIGHT(1),PHX(-3),"SAVE GAME");
menutext(c,67+16+16 ,MENUHIGHLIGHT(2),PHX(-4),"LOAD GAME");
}
menutext(c,67 ,MENUHIGHLIGHT(0),PHX(-2),"NEW GAME");
menutext(c,67+16 ,MENUHIGHLIGHT(1),PHX(-3),"SAVE GAME");
menutext(c,67+16+16 ,MENUHIGHLIGHT(2),PHX(-4),"LOAD GAME");
menutext(c,67+16+16+16 ,MENUHIGHLIGHT(3),PHX(-5),"OPTIONS");
if (!VOLUMEALL)
@ -5102,11 +5073,11 @@ VOLUME_ALL_40x:
tempbuf[0] = PACKET_MAP_VOTE_CANCEL;
tempbuf[1] = myconnectindex;
TRAVERSE_CONNECT(c)
{
if (c != myconnectindex) mmulti_sendpacket(c,tempbuf,2);
if ((!g_networkBroadcastMode) && (myconnectindex != connecthead)) break; //slaves in M/S mode only send to master
}
if (net_client)
enet_peer_send(net_peer, 0, enet_packet_create(tempbuf, 2, ENET_PACKET_FLAG_RELIABLE));
else if (net_server)
enet_host_broadcast(net_server, 0, enet_packet_create(tempbuf, 2, ENET_PACKET_FLAG_RELIABLE));
voting = -1;
}
ChangeToMenu(0);
@ -5117,9 +5088,9 @@ VOLUME_ALL_40x:
plrvotes += g_player[i].vote;
j += g_player[i].gotvote;
}
if (j == numplayers || !g_player[myconnectindex].ps->i || (plrvotes > (numplayers>>1)) || (!g_networkBroadcastMode && myconnectindex == connecthead))
if (j == numplayers || !g_player[myconnectindex].ps->i || (plrvotes > (numplayers>>1)) || (net_server))
{
if (plrvotes > (numplayers>>1) || !g_player[myconnectindex].ps->i || (!g_networkBroadcastMode && myconnectindex == connecthead))
if (plrvotes > (numplayers>>1) || !g_player[myconnectindex].ps->i || (net_server))
{
if (ud.m_player_skill == 3) ud.m_respawn_monsters = 1;
else ud.m_respawn_monsters = 0;
@ -5138,7 +5109,7 @@ VOLUME_ALL_40x:
Net_NewGame(ud.m_volume_number,ud.m_level_number);
if (voting == myconnectindex && !(!g_networkBroadcastMode && myconnectindex == connecthead))
if (voting == myconnectindex && !(net_server))
G_AddUserQuote("VOTE SUCCEEDED");
G_NewGame(ud.m_volume_number,ud.m_level_number,ud.m_player_skill+1);
@ -5159,12 +5130,12 @@ VOLUME_ALL_40x:
tempbuf[0] = PACKET_MAP_VOTE_CANCEL;
tempbuf[1] = myconnectindex;
tempbuf[2] = 1;
tempbuf[3] = myconnectindex;
TRAVERSE_CONNECT(c)
{
if (c != myconnectindex) mmulti_sendpacket(c,tempbuf,3);
if ((!g_networkBroadcastMode) && (myconnectindex != connecthead)) break; //slaves in M/S mode only send to master
}
if (net_client)
enet_peer_send(net_peer, 0, enet_packet_create(tempbuf, 4, ENET_PACKET_FLAG_RELIABLE));
else if (net_server)
enet_host_broadcast(net_server, 0, enet_packet_create(tempbuf, 4, ENET_PACKET_FLAG_RELIABLE));
Bsprintf(ScriptQuotes[116],"VOTE FAILED");
P_DoQuote(116,g_player[myconnectindex].ps);
@ -5290,7 +5261,7 @@ VOLUME_ALL_40x:
break;
case 7:
// master does whatever it wants
if (!g_networkBroadcastMode && myconnectindex == connecthead)
if (net_server)
{
ChangeToMenu(603);
break;
@ -5311,12 +5282,12 @@ VOLUME_ALL_40x:
tempbuf[1] = myconnectindex;
tempbuf[2] = ud.m_volume_number;
tempbuf[3] = ud.m_level_number;
tempbuf[4] = myconnectindex;
TRAVERSE_CONNECT(c)
{
if (c != myconnectindex) mmulti_sendpacket(c,tempbuf,4);
if ((!g_networkBroadcastMode) && (myconnectindex != connecthead)) break; //slaves in M/S mode only send to master
}
if (net_client)
enet_peer_send(net_peer, 0, enet_packet_create(tempbuf, 5, ENET_PACKET_FLAG_RELIABLE));
else if (net_server)
enet_host_broadcast(net_server, 0, enet_packet_create(tempbuf, 5, ENET_PACKET_FLAG_RELIABLE));
}
if ((GametypeFlags[ud.m_coop] & GAMETYPE_PLAYERSFRIENDLY) && !(GametypeFlags[ud.m_coop] & GAMETYPE_TDM))
ud.m_noexits = 0;

19
polymer/eduke32/source/osdcmds.c
View file

@ -102,7 +102,7 @@ static int32_t osdcmd_changelevel(const osdfuncparm_t *parm)
if (numplayers > 1)
{
if (myconnectindex == connecthead && g_networkBroadcastMode == 0)
if (net_server)
Net_NewGame(volume,level);
else if (voting == -1)
{
@ -128,11 +128,7 @@ static int32_t osdcmd_changelevel(const osdfuncparm_t *parm)
tempbuf[2] = ud.m_volume_number;
tempbuf[3] = ud.m_level_number;
TRAVERSE_CONNECT(i)
{
if (i != myconnectindex) mmulti_sendpacket(i,tempbuf,4);
if ((!g_networkBroadcastMode) && (myconnectindex != connecthead)) break; //slaves in M/S mode only send to master
}
enet_peer_send(net_peer, 0, enet_packet_create(tempbuf, 4, ENET_PACKET_FLAG_RELIABLE));
}
if ((GametypeFlags[ud.m_coop] & GAMETYPE_PLAYERSFRIENDLY) && !(GametypeFlags[ud.m_coop] & GAMETYPE_TDM))
ud.m_noexits = 0;
@ -254,7 +250,7 @@ static int32_t osdcmd_map(const osdfuncparm_t *parm)
if (numplayers > 1)
{
if (myconnectindex == connecthead && g_networkBroadcastMode == 0)
if (net_server)
{
Net_SendUserMapName();
ud.m_volume_number = 0;
@ -286,11 +282,7 @@ static int32_t osdcmd_map(const osdfuncparm_t *parm)
tempbuf[2] = ud.m_volume_number;
tempbuf[3] = ud.m_level_number;
TRAVERSE_CONNECT(i)
{
if (i != myconnectindex) mmulti_sendpacket(i,tempbuf,4);
if ((!g_networkBroadcastMode) && (myconnectindex != connecthead)) break; //slaves in M/S mode only send to master
}
enet_peer_send(net_peer, 0, enet_packet_create(tempbuf, 4, ENET_PACKET_FLAG_RELIABLE));
}
if ((GametypeFlags[ud.m_coop] & GAMETYPE_PLAYERSFRIENDLY) && !(GametypeFlags[ud.m_coop] & GAMETYPE_TDM))
ud.m_noexits = 0;
@ -1115,9 +1107,6 @@ static int32_t osdcmd_screenshot(const osdfuncparm_t *parm)
return OSDCMD_OK;
}
extern void G_SaveMapState(mapstate_t *save);
extern void G_RestoreMapState(mapstate_t *save);
/*
static int32_t osdcmd_savestate(const osdfuncparm_t *parm)
{

16
polymer/eduke32/source/player.c
View file

@ -3317,9 +3317,11 @@ void getinput(int32_t snum)
return;
}
if (numplayers > 1)
daang = myang;
else daang = p->ang;
/*
if (numplayers > 1)
daang = myang;
else*/
daang = p->ang;
momx = mulscale9(vel,sintable[(daang+2560)&2047]);
momy = mulscale9(vel,sintable[(daang+2048)&2047]);
@ -4142,14 +4144,6 @@ void P_ProcessInput(int32_t snum)
G_AddUserQuote(tempbuf);
}
}
if (myconnectindex == connecthead)
{
Bsprintf(tempbuf,"frag %d killed %d\n",p->frag_ps+1,snum+1);
sendscore(tempbuf);
// printf(tempbuf);
}
p->frag_ps = snum;
pus = NUMPAGES;
}

169
polymer/eduke32/source/premap.c
View file

@ -621,7 +621,7 @@ void P_RandomSpawnPoint(int32_t snum)
p->cursectnum = g_playerSpawnPoints[i].os;
}
static void P_ResetStatus(int32_t snum)
void P_ResetStatus(int32_t snum)
{
DukePlayer_t *p = g_player[snum].ps;
@ -1304,20 +1304,6 @@ quick:
display_mirror = 0;
if (ud.multimode > 1)
{
if (numplayers < 2)
{
connecthead = 0;
for (i=0; i<MAXPLAYERS; i++) connectpoint2[i] = i+1;
connectpoint2[ud.multimode-1] = -1;
}
}
else
{
connecthead = 0;
connectpoint2[0] = -1;
}
X_OnEvent(EVENT_NEWGAME, g_player[screenpeek].ps->i, screenpeek, -1);
}
@ -1333,7 +1319,7 @@ static void resetpspritevars(char g)
APLAYER,0,0,0,g_player[0].ps->ang,0,0,0,10);
if (ud.recstat != 2)
for (i=0; i<ud.multimode; i++)
TRAVERSE_CONNECT(i)
{
aimmode[i] = g_player[i].ps->aim_mode;
autoaim[i] = g_player[i].ps->auto_aim;
@ -1362,11 +1348,11 @@ static void resetpspritevars(char g)
P_ResetStatus(0);
for (i=1; i<ud.multimode; i++)
TRAVERSE_CONNECT(i)
Bmemcpy(g_player[i].ps,g_player[0].ps,sizeof(DukePlayer_t));
if (ud.recstat != 2)
for (i=0; i<ud.multimode; i++)
TRAVERSE_CONNECT(i)
{
g_player[i].ps->aim_mode = aimmode[i];
g_player[i].ps->auto_aim = autoaim[i];
@ -1396,7 +1382,7 @@ static void resetpspritevars(char g)
circ = 2048/ud.multimode;
g_whichPalForPlayer = 9;
j = connecthead;
j = 0;
i = headspritestat[STAT_PLAYER];
while (i >= 0)
{
@ -1419,73 +1405,76 @@ static void resetpspritevars(char g)
g_playerSpawnPoints[(uint8_t)g_numPlayerSprites].os = s->sectnum;
g_numPlayerSprites++;
if (j >= 0)
if (j < MAXPLAYERS)
{
s->owner = i;
s->shade = 0;
s->xrepeat = 42;
s->yrepeat = 36;
s->cstat = 1+256;
s->cstat = j < numplayers ? 1+256 : 32768;
s->xoffset = 0;
s->clipdist = 64;
if ((g&MODE_EOL) != MODE_EOL || g_player[j].ps->last_extra == 0)
// if (j < playerswhenstarted)
{
g_player[j].ps->last_extra = g_player[j].ps->max_player_health;
s->extra = g_player[j].ps->max_player_health;
g_player[j].ps->runspeed = g_playerFriction;
}
else s->extra = g_player[j].ps->last_extra;
s->yvel = j;
if (!g_player[j].pcolor && ud.multimode > 1 && !(GametypeFlags[ud.coop] & GAMETYPE_TDM))
{
if (s->pal == 0)
if ((g&MODE_EOL) != MODE_EOL || g_player[j].ps->last_extra == 0)
{
int32_t k = 0;
g_player[j].ps->last_extra = g_player[j].ps->max_player_health;
s->extra = g_player[j].ps->max_player_health;
g_player[j].ps->runspeed = g_playerFriction;
}
else s->extra = g_player[j].ps->last_extra;
for (; k<ud.multimode; k++)
s->yvel = j;
if (!g_player[j].pcolor && ud.multimode > 1 && !(GametypeFlags[ud.coop] & GAMETYPE_TDM))
{
if (s->pal == 0)
{
if (g_whichPalForPlayer == g_player[k].ps->palookup)
int32_t k = 0;
for (; k<ud.multimode; k++)
{
g_whichPalForPlayer++;
if (g_whichPalForPlayer >= 17)
g_whichPalForPlayer = 9;
k=0;
if (g_whichPalForPlayer == g_player[k].ps->palookup)
{
g_whichPalForPlayer++;
if (g_whichPalForPlayer >= 17)
g_whichPalForPlayer = 9;
k=0;
}
}
g_player[j].pcolor = s->pal = g_player[j].ps->palookup = g_whichPalForPlayer++;
if (g_whichPalForPlayer >= 17)
g_whichPalForPlayer = 9;
}
g_player[j].pcolor = s->pal = g_player[j].ps->palookup = g_whichPalForPlayer++;
if (g_whichPalForPlayer >= 17)
g_whichPalForPlayer = 9;
else g_player[j].pcolor = g_player[j].ps->palookup = s->pal;
}
else g_player[j].pcolor = g_player[j].ps->palookup = s->pal;
}
else
{
int32_t k = g_player[j].pcolor;
if (GametypeFlags[ud.coop] & GAMETYPE_TDM)
else
{
k = G_GetTeamPalette(g_player[j].pteam);
g_player[j].ps->team = g_player[j].pteam;
int32_t k = g_player[j].pcolor;
if (GametypeFlags[ud.coop] & GAMETYPE_TDM)
{
k = G_GetTeamPalette(g_player[j].pteam);
g_player[j].ps->team = g_player[j].pteam;
}
s->pal = g_player[j].ps->palookup = k;
}
s->pal = g_player[j].ps->palookup = k;
g_player[j].ps->i = i;
g_player[j].ps->frag_ps = j;
ActorExtra[i].owner = i;
ActorExtra[i].bposx = g_player[j].ps->bobposx = g_player[j].ps->oposx = g_player[j].ps->posx = s->x;
ActorExtra[i].bposy = g_player[j].ps->bobposy = g_player[j].ps->oposy = g_player[j].ps->posy = s->y;
ActorExtra[i].bposz = g_player[j].ps->oposz = g_player[j].ps->posz = s->z;
g_player[j].ps->oang = g_player[j].ps->ang = s->ang;
updatesector(s->x,s->y,&g_player[j].ps->cursectnum);
}
g_player[j].ps->i = i;
g_player[j].ps->frag_ps = j;
ActorExtra[i].owner = i;
ActorExtra[i].bposx = g_player[j].ps->bobposx = g_player[j].ps->oposx = g_player[j].ps->posx = s->x;
ActorExtra[i].bposy = g_player[j].ps->bobposy = g_player[j].ps->oposy = g_player[j].ps->posy = s->y;
ActorExtra[i].bposz = g_player[j].ps->oposz = g_player[j].ps->posz = s->z;
g_player[j].ps->oang = g_player[j].ps->ang = s->ang;
updatesector(s->x,s->y,&g_player[j].ps->cursectnum);
j = connectpoint2[j];
j++;
}
else deletesprite(i);
i = nexti;
@ -1518,20 +1507,15 @@ void G_ResetTimers(void)
void Net_WaitForEverybody(void)
{
int32_t i;
int32_t server_ready = g_player[0].playerreadyflag;
if (numplayers < 2 || net_server) return;
if (numplayers < 2) return;
packbuf[0] = PACKET_PLAYER_READY;
packbuf[1] = myconnectindex;
g_player[myconnectindex].playerreadyflag++;
// if we're a peer or slave, not a master
if ((g_networkBroadcastMode == 1) || (!g_networkBroadcastMode && (myconnectindex != connecthead)))
TRAVERSE_CONNECT(i)
{
if (i != myconnectindex) mmulti_sendpacket(i,packbuf,1);
if ((!g_networkBroadcastMode) && (myconnectindex != connecthead)) break; //slaves in M/S mode only send to master
}
if (net_client)
enet_peer_send(net_peer, 0, enet_packet_create(packbuf, 2, ENET_PACKET_FLAG_RELIABLE));
if (ud.multimode > 1)
{
@ -1543,7 +1527,7 @@ void Net_WaitForEverybody(void)
if (PLUTOPAK) // JBF 20030804
rotatesprite(160<<16,(151)<<16,30<<11,0,PLUTOPAKSPRITE+1,0,0,2+8,0,0,xdim-1,ydim-1);
gametext(160,190,"WAITING FOR PLAYERS",14,2);
gametext(160,190,"WAITING FOR SERVER",14,2);
nextpage();
}
@ -1551,28 +1535,11 @@ void Net_WaitForEverybody(void)
{
if (quitevent || keystatus[1]) G_GameExit("");
handleevents();
Net_GetPackets();
TRAVERSE_CONNECT(i)
if (g_player[0].playerreadyflag > server_ready)
{
if (g_player[i].playerreadyflag < g_player[myconnectindex].playerreadyflag) break;
if ((!g_networkBroadcastMode) && (myconnectindex != connecthead))
{
// we're a slave
i = -1; break;
}
//slaves in M/S mode only wait for master
}
if (i < 0)
{
// master sends ready packet once it hears from all slaves
if (!g_networkBroadcastMode && myconnectindex == connecthead)
TRAVERSE_CONNECT(i)
{
packbuf[0] = PACKET_PLAYER_READY;
if (i != myconnectindex) mmulti_sendpacket(i,packbuf,1);
}
P_SetGamePalette(g_player[myconnectindex].ps, palette, 11);
return;
}
@ -1580,8 +1547,6 @@ void Net_WaitForEverybody(void)
}
extern int32_t jump_input;
extern char g_szfirstSyncMsg[MAXSYNCBYTES][60];
extern int32_t g_foundSyncError;
void clearfifo(void)
{
@ -1590,8 +1555,6 @@ void clearfifo(void)
syncvaltail = 0L;
syncvaltottail = 0L;
memset(&syncstat, 0, sizeof(syncstat));
memset(&g_szfirstSyncMsg, 0, sizeof(g_szfirstSyncMsg));
g_foundSyncError = 0;
bufferjitter = 1;
mymaxlag = otherminlag = 0;
jump_input = 0;
@ -1952,7 +1915,7 @@ int32_t G_EnterLevel(int32_t g)
if (!premap_quickenterlevel)
{
Net_WaitForEverybody();
mmulti_flushpackets();
// mmulti_flushpackets();
G_FadePalette(0,0,0,0);
G_UpdateScreenArea();
@ -1961,8 +1924,6 @@ int32_t G_EnterLevel(int32_t g)
G_DrawRooms(myconnectindex,65536);
}
for (i=0; i<ud.multimode; i++)
clearbufbyte(&g_player[i].playerquitflag,1,0x01010101);
g_player[myconnectindex].ps->over_shoulder_on = 0;
clearfrags();

6
polymer/eduke32/source/sector.c
View file

@ -190,8 +190,8 @@ int32_t isanearoperator(int32_t lotag)
inline int32_t G_CheckPlayerInSector(int32_t sect)
{
int32_t i = connecthead;
for (; i>=0; i=connectpoint2[i])
int32_t i;
TRAVERSE_CONNECT(i)
if (sprite[g_player[i].ps->i].sectnum == sect) return i;
return -1;
}
@ -310,7 +310,7 @@ void G_DoSectorAnimations(void)
{
my.z += v;
myvel.z = 0;
myzbak[((movefifoplc-1)&(MOVEFIFOSIZ-1))] = g_player[p].ps->posz;
myzbak[0] = g_player[p].ps->posz;
}
}

2
polymer/eduke32/source/sync.c
View file

@ -386,7 +386,7 @@ void Net_GetSyncData(char *packbuf, int32_t packbufleng, int32_t *j, int32_t oth
while (1)
{
for (i = connectpoint2[connecthead]; i >= 0; i = connectpoint2[i])
TRAVERSE_CONNECT(i)
{
for (sb = 0; sb < g_numSyncBytes; sb++)
{