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

Minor formatting changes, fix nedmalloc on BSD, fix win32 joystick detection issue, fix for ambient sounds, possible fix for stopsound malfunctioning after extended play time, add CON compilation error for duplicate "break" in switch statement

Browse source 
git-svn-id: https://svn.eduke32.com/eduke32@1599 1a8010ca-5511-0410-912e-c29ae57300e0
This commit is contained in:
terminx 2010-02-23 18:13:46 +00:00
parent 512535c53f
commit c369aec8cc
20 changed files with 167 additions and 756 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

11
polymer/eduke32/Makefile
View file

@ -198,8 +198,6 @@ else
GAMEOBJS+= $(OBJ)/game_icon.$o $(OBJ)/sdlmusic.$o GAMEOBJS+= $(OBJ)/game_icon.$o $(OBJ)/sdlmusic.$o
EDITOROBJS+= $(OBJ)/build_icon.$o EDITOROBJS+= $(OBJ)/build_icon.$o
else
GAMEOBJS+= $(OBJ)/audiolib_musicstub.$o
endif endif
endif endif
@ -248,15 +246,6 @@ ifeq (1,$(RELEASE))
endif endif
endif endif
duke3d_w32$(EXESUFFIX): $(OBJ)/wrapper.$o
$(LINK_STATUS)
if $(CC) $(CFLAGS) $(OURCFLAGS) -o $@ $^ -Wl; then $(LINK_OK); else $(LINK_FAILED); fi
ifeq (1,$(RELEASE))
ifeq (0,$(DEBUGANYWAY))
$(STRIP) duke3d_w32$(EXESUFFIX)
endif
endif
include Makefile.deps include Makefile.deps
.PHONY: enginelib editorlib .PHONY: enginelib editorlib

2
polymer/eduke32/Makefile.deps
View file

@ -46,8 +46,6 @@ $(OBJ)/mathutil.$o: $(SRC)/jmact/mathutil.c
$(OBJ)/scriplib.$o: $(SRC)/jmact/scriplib.c $(SRC)/jmact/scriplib.h $(SRC)/jmact/util_lib.h $(SRC)/jmact/_scrplib.h $(EINC)/compat.h $(OBJ)/scriplib.$o: $(SRC)/jmact/scriplib.c $(SRC)/jmact/scriplib.h $(SRC)/jmact/util_lib.h $(SRC)/jmact/_scrplib.h $(EINC)/compat.h
# jAudioLib objects # jAudioLib objects
$(OBJ)/audiolib_fxstub.$o: $(SRC)/jaudiolib/audiolib_fxstub.c $(SRC)/jaudiolib/fx_man.h
$(OBJ)/audiolib_musicstub.$o: $(SRC)/audiolib_musicstub.c $(JAUDIOLIBDIR)/include/music.h
$(OBJ)/mv_mix.$o: $(SRC)/jaudiolib/mv_mix.nasm $(OBJ)/mv_mix.$o: $(SRC)/jaudiolib/mv_mix.nasm
$(OBJ)/mv_mix16.$o: $(SRC)/jaudiolib/mv_mix16.nasm $(OBJ)/mv_mix16.$o: $(SRC)/jaudiolib/mv_mix16.nasm

4
polymer/eduke32/Makefile.msvc
View file

@ -142,10 +142,6 @@ mapster32$(EXESUFFIX): $(EDITOROBJS) $(EOBJ)\$(ENGINELIB) $(EOBJ)\$(EDITORLIB) $
$(LINK) /OUT:$@ /SUBSYSTEM:WINDOWS /LIBPATH:$(DXROOT)\lib\x86" /LIBPATH:$(PLATFORMSDK)\lib" /LIBPATH:$(MSSDKROOT)\lib" $(flags_link) /MAP $** $(LIBS) $(LINK) /OUT:$@ /SUBSYSTEM:WINDOWS /LIBPATH:$(DXROOT)\lib\x86" /LIBPATH:$(PLATFORMSDK)\lib" /LIBPATH:$(MSSDKROOT)\lib" $(flags_link) /MAP $** $(LIBS)
$(MT) -manifest $(RSRC)\manifest.build.xml -hashupdate -outputresource:$@ -out:$@.manifest $(MT) -manifest $(RSRC)\manifest.build.xml -hashupdate -outputresource:$@ -out:$@.manifest
duke3d_w32$(EXESUFFIX): $(OBJ)/wrapper.$o
$(LINK) /OUT:$@ /SUBSYSTEM:WINDOWS /LIBPATH:$(DXROOT)\lib\x86" /LIBPATH:$(PLATFORMSDK)\lib" /LIBPATH:$(MSSDKROOT)\lib" $(flags_link) /MAP $** $(LIBS)
$(MT) -manifest $@.manifest -outputresource:$@
!include Makefile.deps !include Makefile.deps
enginelib editorlib: AlwaysBuild enginelib editorlib: AlwaysBuild

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

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

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

@ -60,7 +60,7 @@ DEALINGS IN THE SOFTWARE.
#if defined(_WIN32) #if defined(_WIN32)
#include <malloc.h> #include <malloc.h>
#endif #endif
#ifdef __linux__ #if defined(__linux__) || defined(__FreeBSD__)
/* Sadly we can't include <malloc.h> as it causes a redefinition error */ /* Sadly we can't include <malloc.h> as it causes a redefinition error */
extern size_t malloc_usable_size(void *); extern size_t malloc_usable_size(void *);
#endif #endif
@ -215,10 +215,10 @@ size_t (*sysblksize)(void *)=
#ifdef WIN32 #ifdef WIN32
/* This is the MSVCRT equivalent */ /* This is the MSVCRT equivalent */
_msize; _msize;
#elif defined(__linux__) #elif defined(__linux__) || defined(__FreeBSD__)
/* This is the glibc/ptmalloc2/dlmalloc equivalent. */ /* This is the glibc/ptmalloc2/dlmalloc equivalent. */
malloc_usable_size; malloc_usable_size;
#elif defined(__FreeBSD__) || defined(__APPLE__) #elif defined(__APPLE__)
/* This is the BSD libc equivalent. */ /* This is the BSD libc equivalent. */
malloc_size; malloc_size;
#else #else

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

@ -1259,7 +1259,7 @@ static BOOL CALLBACK InitDirectInput_enum(LPCDIDEVICEINSTANCE lpddi, LPVOID pvRe
break; break;
default: default:
// d = "OTHER"; break; // d = "OTHER"; break;
return DIENUM_STOP; return DIENUM_CONTINUE;
} }
initprintf(" * %s: %s\n", d, lpddi->tszProductName); initprintf(" * %s: %s\n", d, lpddi->tszProductName);

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

@ -1238,7 +1238,7 @@ ACTOR_STATIC void G_MoveFX(void)
} }
if (x >= ht && T1 == 1) if (x >= ht && T1 == 1)
{ {
T1 = 0; // T1 = 0;
S_StopEnvSound(s->lotag,i); S_StopEnvSound(s->lotag,i);
} }
} }

510
polymer/eduke32/source/audiolib_musicstub.c
View file

@ -1,510 +0,0 @@
//-------------------------------------------------------------------------
/*
Duke Nukem Copyright (C) 1996, 2003 3D Realms Entertainment
This file is part of Duke Nukem 3D version 1.5 - Atomic Edition
Duke Nukem 3D is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
Dummy AudioLib stub implementation by Jonathon Fowler (jonof@edgenetwk.com)
*/
//-------------------------------------------------------------------------
#include "music.h"
#define TRUE ( 1 == 1 )
#define FALSE ( !TRUE )
int32_t MUSIC_ErrorCode = MUSIC_Ok;
/*---------------------------------------------------------------------
Function: MUSIC_ErrorString
Returns a pointer to the error message associated with an error
number. A -1 returns a pointer the current error.
---------------------------------------------------------------------*/
char *MUSIC_ErrorString
(
int32_t ErrorNumber
)
{
char *ErrorString;
switch (ErrorNumber)
{
case MUSIC_Warning :
case MUSIC_Error :
ErrorString = MUSIC_ErrorString(MUSIC_ErrorCode);
break;
case MUSIC_Ok :
ErrorString = "Music ok.";
break;
case MUSIC_ASSVersion :
ErrorString = "Apogee Sound System Version "
"Programmed by Jim Dose\n"
"(c) Copyright 1996 James R. Dose. All Rights Reserved.\n";
break;
case MUSIC_SoundCardError :
break;
case MUSIC_MPU401Error :
ErrorString = "Could not detect MPU-401.";
break;
case MUSIC_InvalidCard :
ErrorString = "Invalid Music device.";
break;
case MUSIC_MidiError :
ErrorString = "Error playing MIDI file.";
break;
case MUSIC_TaskManError :
ErrorString = "TaskMan error.";
break;
case MUSIC_DPMI_Error :
ErrorString = "DPMI Error in MUSIC.";
break;
default :
ErrorString = "Unknown Music error code.";
break;
}
return(ErrorString);
}
/*---------------------------------------------------------------------
Function: MUSIC_Init
Selects which sound device to use.
---------------------------------------------------------------------*/
int32_t MUSIC_Init
(
int32_t SoundCard,
int32_t Address
)
{
int32_t i;
int32_t status;
status = MUSIC_Ok;
return(status);
}
/*---------------------------------------------------------------------
Function: MUSIC_Shutdown
Terminates use of sound device.
---------------------------------------------------------------------*/
int32_t MUSIC_Shutdown
(
void
)
{
int32_t status;
status = MUSIC_Ok;
return(status);
}
/*---------------------------------------------------------------------
Function: MUSIC_SetMaxFMMidiChannel
Sets the maximum MIDI channel that FM cards respond to.
---------------------------------------------------------------------*/
void MUSIC_SetMaxFMMidiChannel
(
int32_t channel
)
{
}
/*---------------------------------------------------------------------
Function: MUSIC_SetVolume
Sets the volume of music playback.
---------------------------------------------------------------------*/
void MUSIC_SetVolume
(
int32_t volume
)
{
}
/*---------------------------------------------------------------------
Function: MUSIC_SetMidiChannelVolume
Sets the volume of music playback on the specified MIDI channel.
---------------------------------------------------------------------*/
void MUSIC_SetMidiChannelVolume
(
int32_t channel,
int32_t volume
)
{
}
/*---------------------------------------------------------------------
Function: MUSIC_ResetMidiChannelVolumes
Sets the volume of music playback on all MIDI channels to full volume.
---------------------------------------------------------------------*/
void MUSIC_ResetMidiChannelVolumes
(
void
)
{
}
/*---------------------------------------------------------------------
Function: MUSIC_GetVolume
Returns the volume of music playback.
---------------------------------------------------------------------*/
int32_t MUSIC_GetVolume
(
void
)
{
return(0);
}
/*---------------------------------------------------------------------
Function: MUSIC_SetLoopFlag
Set whether the music will loop or end when it reaches the end of
the song.
---------------------------------------------------------------------*/
void MUSIC_SetLoopFlag
(
int32_t loopflag
)
{
}
/*---------------------------------------------------------------------
Function: MUSIC_SongPlaying
Returns whether there is a song playing.
---------------------------------------------------------------------*/
int32_t MUSIC_SongPlaying
(
void
)
{
return(0);
}
/*---------------------------------------------------------------------
Function: MUSIC_Continue
Continues playback of a paused song.
---------------------------------------------------------------------*/
void MUSIC_Continue
(
void
)
{
}
/*---------------------------------------------------------------------
Function: MUSIC_Pause
Pauses playback of a song.
---------------------------------------------------------------------*/
void MUSIC_Pause
(
void
)
{
}
/*---------------------------------------------------------------------
Function: MUSIC_StopSong
Stops playback of current song.
---------------------------------------------------------------------*/
int32_t MUSIC_StopSong
(
void
)
{
return(MUSIC_Ok);
}
/*---------------------------------------------------------------------
Function: MUSIC_PlaySong
Begins playback of MIDI song.
---------------------------------------------------------------------*/
int32_t MUSIC_PlaySong
(
uint8_t *song,
int32_t loopflag
)
{
return(MUSIC_Ok);
}
/*---------------------------------------------------------------------
Function: MUSIC_SetContext
Sets the song context.
---------------------------------------------------------------------*/
void MUSIC_SetContext
(
int32_t context
)
{
}
/*---------------------------------------------------------------------
Function: MUSIC_GetContext
Returns the current song context.
---------------------------------------------------------------------*/
int32_t MUSIC_GetContext
(
void
)
{
}
/*---------------------------------------------------------------------
Function: MUSIC_SetSongTick
Sets the position of the song pointer.
---------------------------------------------------------------------*/
void MUSIC_SetSongTick
(
uint32_t PositionInTicks
)
{
}
/*---------------------------------------------------------------------
Function: MUSIC_SetSongTime
Sets the position of the song pointer.
---------------------------------------------------------------------*/
void MUSIC_SetSongTime
(
uint32_t milliseconds
)
{
}
/*---------------------------------------------------------------------
Function: MUSIC_SetSongPosition
Sets the position of the song pointer.
---------------------------------------------------------------------*/
void MUSIC_SetSongPosition
(
int32_t measure,
int32_t beat,
int32_t tick
)
{
}
/*---------------------------------------------------------------------
Function: MUSIC_GetSongPosition
Returns the position of the song pointer.
---------------------------------------------------------------------*/
void MUSIC_GetSongPosition
(
songposition *pos
)
{
}
/*---------------------------------------------------------------------
Function: MUSIC_GetSongLength
Returns the length of the song.
---------------------------------------------------------------------*/
void MUSIC_GetSongLength
(
songposition *pos
)
{
}
/*---------------------------------------------------------------------
Function: MUSIC_FadeVolume
Fades music volume from current level to another over a specified
period of time.
---------------------------------------------------------------------*/
int32_t MUSIC_FadeVolume
(
int32_t tovolume,
int32_t milliseconds
)
{
return(MUSIC_Ok);
}
/*---------------------------------------------------------------------
Function: MUSIC_FadeActive
Returns whether the fade routine is active.
---------------------------------------------------------------------*/
int32_t MUSIC_FadeActive
(
void
)
{
return(0);
}
/*---------------------------------------------------------------------
Function: MUSIC_StopFade
Stops fading the music.
---------------------------------------------------------------------*/
void MUSIC_StopFade
(
void
)
{
}
/*---------------------------------------------------------------------
Function: MUSIC_RerouteMidiChannel
Sets callback function to reroute MIDI commands from specified
function.
---------------------------------------------------------------------*/
void MUSIC_RerouteMidiChannel
(
int32_t channel,
int32_t (*function)(int32_t event, int32_t c1, int32_t c2)
)
{
}
/*---------------------------------------------------------------------
Function: MUSIC_RegisterTimbreBank
Halts playback of all sounds.
---------------------------------------------------------------------*/
void MUSIC_RegisterTimbreBank
(
uint8_t *timbres
)
{
}
void MUSIC_Update(void)
{
}

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

@ -42,7 +42,7 @@ extern int32_t A_PlaySound(uint32_t num,int32_t i);
extern void S_StopSound(int32_t num); extern void S_StopSound(int32_t num);
extern void S_StopEnvSound(int32_t num,int32_t i); extern void S_StopEnvSound(int32_t num,int32_t i);
extern void S_Pan3D(void); extern void S_Pan3D(void);
extern void S_TestSoundCallback(uint32_t num); extern void S_Callback(uint32_t num);
extern void S_ClearSoundLocks(void); extern void S_ClearSoundLocks(void);
extern int32_t A_CallSound(int32_t sn,int32_t whatsprite); extern int32_t A_CallSound(int32_t sn,int32_t whatsprite);
extern int32_t G_CheckActivatorMotion(int32_t lotag); extern int32_t G_CheckActivatorMotion(int32_t lotag);

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

@ -67,6 +67,12 @@ extern int32_t G_GetVersionFromWebsite(char *buffer);
static int32_t usecwd = 0; static int32_t usecwd = 0;
#endif /* _WIN32 */ #endif /* _WIN32 */
/*
this should be lower than the MTU size by at least the size of the UDP and ENet headers
or else fragmentation will occur
*/
#define SYNCPACKETSIZE 1408
ENetHost * g_netServer = NULL; ENetHost * g_netServer = NULL;
ENetHost * g_netClient = NULL; ENetHost * g_netClient = NULL;
ENetPeer * g_netClientPeer = NULL; ENetPeer * g_netClientPeer = NULL;
@ -318,6 +324,7 @@ void P_SetGamePalette(DukePlayer_t *player, uint8_t *pal, int32_t set)
player->palette = pal; player->palette = pal;
} }
// FIXME: this function sucks.
int32_t gametext_z(int32_t small, int32_t starttile, int32_t x,int32_t y,const char *t,int32_t s,int32_t p,int32_t orientation,int32_t x1, int32_t y1, int32_t x2, int32_t y2, int32_t z) int32_t gametext_z(int32_t small, int32_t starttile, int32_t x,int32_t y,const char *t,int32_t s,int32_t p,int32_t orientation,int32_t x1, int32_t y1, int32_t x2, int32_t y2, int32_t z)
{ {
int32_t ac,newx,oldx=x; int32_t ac,newx,oldx=x;
@ -609,7 +616,6 @@ void Net_Connect(const char * srvaddr)
enet_address_set_host(&address, addrstr); enet_address_set_host(&address, addrstr);
address.port = atoi((addrstr = strtok(NULL, ":")) == NULL ? "23513" : addrstr); address.port = atoi((addrstr = strtok(NULL, ":")) == NULL ? "23513" : addrstr);
// use 2 channels for easy packet sorting at a lower level than the game later
g_netClientPeer = enet_host_connect(g_netClient, &address, CHAN_MAX); g_netClientPeer = enet_host_connect(g_netClient, &address, CHAN_MAX);
if (g_netClientPeer == NULL) if (g_netClientPeer == NULL)
@ -786,6 +792,7 @@ void Net_SendUserMapName(void)
enet_host_broadcast(g_netServer, CHAN_GAMESTATE, enet_packet_create(packbuf, j, ENET_PACKET_FLAG_RELIABLE)); enet_host_broadcast(g_netServer, CHAN_GAMESTATE, enet_packet_create(packbuf, j, ENET_PACKET_FLAG_RELIABLE));
} }
// FIXME: change all of the game starting support code to be fully server controlled
void Net_NewGame(int32_t volume, int32_t level) void Net_NewGame(int32_t volume, int32_t level)
{ {
packbuf[0] = PACKET_NEW_GAME; packbuf[0] = PACKET_NEW_GAME;
@ -813,18 +820,16 @@ static int32_t spritecrc[MAXSPRITES], lastupdate[MAXSPRITES], sectcrc[MAXSECTORS
static int32_t wallcrc[MAXWALLS], lastwallupdate[MAXWALLS]; static int32_t wallcrc[MAXWALLS], lastwallupdate[MAXWALLS];
static int32_t peractorvals[MAXGAMEVARS][MAXSPRITES], perplayervals[MAXGAMEVARS][MAXPLAYERS]; static int32_t peractorvals[MAXGAMEVARS][MAXSPRITES], perplayervals[MAXGAMEVARS][MAXPLAYERS];
// sends a simple crc32 of the current password, verified by the server before the connection can continue
static void Net_SendChallenge(void) static void Net_SendChallenge(void)
{ {
int32_t l; int32_t l = 1;
uint32_t crc; uint32_t crc = crc32once((uint8_t *)g_netPassword, Bstrlen(g_netPassword));
if (!g_netClientPeer) return; if (!g_netClientPeer) return;
crc = crc32once((uint8_t *)g_netPassword, Bstrlen(g_netPassword));
buf[0] = PACKET_AUTH; buf[0] = PACKET_AUTH;
l = 1; *(uint32_t *)&buf[1] = crc;
*(uint32_t *)&buf[l] = crc;
l += sizeof(int32_t); l += sizeof(int32_t);
buf[l++] = myconnectindex; buf[l++] = myconnectindex;
@ -872,10 +877,12 @@ void P_Disconnected(int32_t i)
} }
Bstrcpy(ScriptQuotes[116],buf); Bstrcpy(ScriptQuotes[116],buf);
g_player[myconnectindex].ps->ftq = 116, g_player[myconnectindex].ps->fta = 180; g_player[myconnectindex].ps->ftq = 116;
g_player[myconnectindex].ps->fta = 180;
} }
} }
// sync a connecting player up with the current game state
void Net_SyncPlayer(ENetEvent * event) void Net_SyncPlayer(ENetEvent * event)
{ {
int32_t i, j; int32_t i, j;
@ -886,10 +893,8 @@ void Net_SyncPlayer(ENetEvent * event)
if (!g_player[i].playerquitflag) if (!g_player[i].playerquitflag)
break; break;
// no slots empty from players quitting, so open a new one // open a new slot if necessary
if (i == -1) event->peer->data = (void *)((intptr_t) (i = (i == -1 ? playerswhenstarted++ : i)));
i = playerswhenstarted++;
event->peer->data = (void *) ((intptr_t) i);
clearbufbyte(&g_player[i].playerquitflag,1,0x01010101); clearbufbyte(&g_player[i].playerquitflag,1,0x01010101);
g_player[i].movefifoend = 1; g_player[i].movefifoend = 1;
@ -946,12 +951,17 @@ void Net_SyncPlayer(ENetEvent * event)
G_SaveMapState(g_multiMapState); G_SaveMapState(g_multiMapState);
j = qlz_compress((char *)g_multiMapState, buf, sizeof(mapstate_t), state_compress); j = qlz_compress((char *)g_multiMapState, buf, sizeof(mapstate_t), state_compress);
while (j > 1024)
// all of these packets are SYNCPACKETSIZE
while (j >= SYNCPACKETSIZE)
{ {
enet_peer_send(event->peer, CHAN_SYNC, enet_packet_create((char *)(buf)+qlz_size_compressed(buf)-j, 1024, ENET_PACKET_FLAG_RELIABLE)); enet_peer_send(event->peer, CHAN_SYNC,
j -= 1024; enet_packet_create((char *)(buf)+qlz_size_compressed(buf)-j, SYNCPACKETSIZE, ENET_PACKET_FLAG_RELIABLE));
j -= SYNCPACKETSIZE;
} }
enet_peer_send(event->peer, CHAN_SYNC, enet_packet_create((char *)(buf)+qlz_size_compressed(buf)-j, j, ENET_PACKET_FLAG_RELIABLE)); // ...except for this one. A non-SYNCPACKETSIZE packet on CHAN_SYNC doubles as the signal that the transfer is done.
enet_peer_send(event->peer, CHAN_SYNC,
enet_packet_create((char *)(buf)+qlz_size_compressed(buf)-j, j, ENET_PACKET_FLAG_RELIABLE));
Bfree(buf); Bfree(buf);
Bfree(g_multiMapState); Bfree(g_multiMapState);
g_multiMapState = NULL; g_multiMapState = NULL;
@ -1231,22 +1241,17 @@ process:
} }
Bfree(packbuf); Bfree(packbuf);
// movefifosendplc++;
break; break;
g_player[other].playerreadyflag++;
return;
case PACKET_MESSAGE: case PACKET_MESSAGE:
//slaves in M/S mode only send to master Bstrncpy(recbuf, (char *)packbuf+2, packbufleng-2);
Bstrcpy(recbuf,(char *)packbuf+2);
recbuf[packbufleng-2] = 0; recbuf[packbufleng-2] = 0;
G_AddUserQuote(recbuf); G_AddUserQuote(recbuf);
S_PlaySound(EXITMENUSOUND); S_PlaySound(EXITMENUSOUND);
pus = NUMPAGES; pus = pub = NUMPAGES;
pub = NUMPAGES;
break; break;
@ -1564,8 +1569,7 @@ void Net_ParseClientPacket(ENetEvent * event)
return; return;
case PACKET_MESSAGE: case PACKET_MESSAGE:
//slaves in M/S mode only send to master Bstrncpy(recbuf, (char *)packbuf+2, packbufleng-2);
Bstrcpy(recbuf,(char *)packbuf+2);
recbuf[packbufleng-2] = 0; recbuf[packbufleng-2] = 0;
G_AddUserQuote(recbuf); G_AddUserQuote(recbuf);
@ -1630,8 +1634,7 @@ void Net_ParseClientPacket(ENetEvent * event)
g_player[other].ps->palookup = g_player[other].pcolor = packbuf[i++]; g_player[other].ps->palookup = g_player[other].pcolor = packbuf[i++];
g_player[other].pteam = packbuf[i++]; g_player[other].pteam = packbuf[i++];
j = i; for (j=i; i-j<10; i++) g_player[other].wchoice[i-j] = packbuf[i];
for (; i-j<10; i++) g_player[other].wchoice[i-j] = packbuf[i];
break; break;
@ -1855,7 +1858,7 @@ void Net_GetPackets(void)
event.peer -> data, event.peer -> data,
event.channelID); event.channelID);
// mapstate transfer from the server... all packets but the last are exactly 1 kB // mapstate transfer from the server... all packets but the last are SYNCPACKETSIZE
if (event.channelID == CHAN_SYNC) if (event.channelID == CHAN_SYNC)
{ {
static int32_t datasiz = 0; static int32_t datasiz = 0;
@ -1871,10 +1874,10 @@ void Net_GetPackets(void)
buf = Bcalloc(1, sizeof(mapstate_t)<<1); buf = Bcalloc(1, sizeof(mapstate_t)<<1);
} }
if (buf && event.packet->dataLength == 1024) if (buf && event.packet->dataLength == SYNCPACKETSIZE)
{ {
Bmemcpy((char *)(buf)+datasiz, event.packet->data, event.packet->dataLength); Bmemcpy((char *)(buf)+datasiz, event.packet->data, event.packet->dataLength);
datasiz += 1024; datasiz += SYNCPACKETSIZE;
} }
// last packet of mapstate sequence // last packet of mapstate sequence
else if (buf) else if (buf)
@ -2116,7 +2119,8 @@ void Net_UpdateClients(void)
{ {
l = crc32once((uint8_t *)&sprite[i], sizeof(spritetype)); l = crc32once((uint8_t *)&sprite[i], sizeof(spritetype));
if (!lastupdate[i] || spritecrc[i] != l) // only send STAT_MISC sprites at spawn time and let the client handle it from there
if (!lastupdate[i] || (spritecrc[i] != l && sprite[i].statnum != STAT_MISC))
{ {
int32_t jj = 0; int32_t jj = 0;

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

@ -39,7 +39,7 @@ char g_szScriptFileName[BMAX_PATH] = "(none)"; // file we're currently compilin
static char g_szCurrentBlockName[256] = "(none)", g_szLastBlockName[256] = "NULL"; static char g_szCurrentBlockName[256] = "(none)", g_szLastBlockName[256] = "NULL";
int32_t g_totalLines,g_lineNumber; int32_t g_totalLines,g_lineNumber;
static int32_t g_checkingIfElse,g_processingState; static int32_t g_checkingIfElse, g_processingState, g_lastKeyword = -1;
char g_szBuf[1024]; char g_szBuf[1024];
intptr_t *g_caseScriptPtr=NULL; // the pointer to the start of the case table in a switch statement intptr_t *g_caseScriptPtr=NULL; // the pointer to the start of the case table in a switch statement
@ -1993,7 +1993,7 @@ static int32_t C_CountCaseStatements()
static int32_t C_ParseCommand(void) static int32_t C_ParseCommand(void)
{ {
int32_t i, j=0, k=0, done, tw; int32_t i, j=0, k=0, done, tw, otw = g_lastKeyword;
char *temptextptr; char *temptextptr;
intptr_t *tempscrptr = NULL; intptr_t *tempscrptr = NULL;
@ -2015,7 +2015,7 @@ static int32_t C_ParseCommand(void)
//Bsprintf(g_szBuf,"PC(): '%.25s'",textptr); //Bsprintf(g_szBuf,"PC(): '%.25s'",textptr);
//AddLog(g_szBuf); //AddLog(g_szBuf);
} }
tw = C_GetNextKeyword(); g_lastKeyword = tw = C_GetNextKeyword();
// Bsprintf(tempbuf,"%s",keyw[tw]); // Bsprintf(tempbuf,"%s",keyw[tw]);
// AddLog(tempbuf); // AddLog(tempbuf);
@ -4677,8 +4677,7 @@ repeatcase:
//Bsprintf(g_szBuf,"case3: %.12s",textptr); //Bsprintf(g_szBuf,"case3: %.12s",textptr);
//AddLog(g_szBuf); //AddLog(g_szBuf);
j = C_GetKeyword(); if (C_GetKeyword() == CON_CASE)
if (j == CON_CASE)
{ {
//AddLog("Found Repeat Case"); //AddLog("Found Repeat Case");
C_GetNextKeyword(); // eat 'case' C_GetNextKeyword(); // eat 'case'
@ -4691,8 +4690,7 @@ repeatcase:
{ {
//Bsprintf(g_szBuf,"case5 '%.25s'",textptr); //Bsprintf(g_szBuf,"case5 '%.25s'",textptr);
//AddLog(g_szBuf); //AddLog(g_szBuf);
j = C_GetKeyword(); if (C_GetKeyword() == CON_CASE)
if (j == CON_CASE)
{ {
//AddLog("Found Repeat Case"); //AddLog("Found Repeat Case");
C_GetNextKeyword(); // eat 'case' C_GetNextKeyword(); // eat 'case'
@ -5651,6 +5649,13 @@ repeatcase:
case CON_BREAK: case CON_BREAK:
if (g_checkingSwitch) if (g_checkingSwitch)
{ {
if (otw == CON_BREAK)
{
C_ReportError(-1);
initprintf("%s:%d: error: duplicate `break'.\n",g_szScriptFileName, g_lineNumber);
g_numCompilerErrors++;
}
//Bsprintf(g_szBuf," * (L%d) case Break statement.\n",g_lineNumber); //Bsprintf(g_szBuf," * (L%d) case Break statement.\n",g_lineNumber);
//AddLog(g_szBuf); //AddLog(g_szBuf);
return 1; return 1;

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

@ -3829,7 +3829,8 @@ cheat_for_port_credits:
else if (function == 2) else if (function == 2)
{ {
static char *directions[] = static char *directions[] =
{ "UP", "RIGHT", "DOWN", "LEFT" {
"UP", "RIGHT", "DOWN", "LEFT"
}; };
if (whichkey < 2*joynumbuttons) if (whichkey < 2*joynumbuttons)
Bsprintf(tempbuf,"TO %s%s", (whichkey&1)?"DOUBLE-CLICKED ":"", getjoyname(1,whichkey>>1)); Bsprintf(tempbuf,"TO %s%s", (whichkey&1)?"DOUBLE-CLICKED ":"", getjoyname(1,whichkey>>1));
@ -4094,7 +4095,8 @@ cheat_for_port_credits:
else else
{ {
static char *directions[] = static char *directions[] =
{ "Up", "Right", "Down", "Left" {
"Up", "Right", "Down", "Left"
}; };
Bsprintf(tempbuf, "Hat %s", directions[(l+m)-2*joynumbuttons]); Bsprintf(tempbuf, "Hat %s", directions[(l+m)-2*joynumbuttons]);
x = ud.config.JoystickFunctions[joynumbuttons + ((l+m)-2*joynumbuttons)][0]; x = ud.config.JoystickFunctions[joynumbuttons + ((l+m)-2*joynumbuttons)][0];

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

@ -2123,8 +2123,7 @@ static int32_t doloadplayer2(int32_t spot, int32_t fil, uint8_t **memptr)
{ {
if (LOADRDU(&tbuf, 19, 1)) return -3; if (LOADRDU(&tbuf, 19, 1)) return -3;
} }
else else if (LOADRDU(&ud.savegame[spot][0], 19, 1)) return -3;
if (LOADRDU(&ud.savegame[spot][0], 19, 1)) return -3;
if (LOADRDU(tbuf, 1, 1)) return -3; if (LOADRDU(tbuf, 1, 1)) return -3;
if (tbuf[0]) if (tbuf[0])
@ -2282,7 +2281,8 @@ static void postloadplayer2()
G_ResetTimers(); G_ResetTimers();
#ifdef POLYMER #ifdef POLYMER
if (getrendermode() == 4) { if (getrendermode() == 4)
{
polymer_loadboard(); polymer_loadboard();
polymer_resetlights(); polymer_resetlights();
} }

42
polymer/eduke32/source/sounds.c
View file

@ -78,7 +78,7 @@ void S_SoundStartup(void)
FX_SetVolume(ud.config.FXVolume); FX_SetVolume(ud.config.FXVolume);
FX_SetReverseStereo(ud.config.ReverseStereo); FX_SetReverseStereo(ud.config.ReverseStereo);
status = FX_SetCallBack(S_TestSoundCallback); status = FX_SetCallBack(S_Callback);
} }
/* /*
@ -562,6 +562,8 @@ int32_t S_PlaySound3D(int32_t num, int32_t i, const vec3_t *pos)
while (l < MAXSOUNDINSTANCES && g_sounds[num].SoundOwner[l].voice > 0) while (l < MAXSOUNDINSTANCES && g_sounds[num].SoundOwner[l].voice > 0)
l++; l++;
if (l < MAXSOUNDINSTANCES)
{
if (g_sounds[num].m&1) if (g_sounds[num].m&1)
{ {
if (g_sounds[num].num > 0) return -1; if (g_sounds[num].num > 0) return -1;
@ -583,6 +585,12 @@ int32_t S_PlaySound3D(int32_t num, int32_t i, const vec3_t *pos)
} }
else g_soundlocks[num]--; else g_soundlocks[num]--;
} }
else
{
g_soundlocks[num]--;
return -1;
}
}
return (voice); return (voice);
} }
@ -655,9 +663,7 @@ int32_t A_PlaySound(uint32_t num, int32_t i)
void S_StopSound(int32_t num) void S_StopSound(int32_t num)
{ {
if (num >= 0 && num < MAXSOUNDS) if (num >= 0 && num < MAXSOUNDS && g_sounds[num].num > 0)
{
if (g_sounds[num].num > 0)
{ {
int32_t j=MAXSOUNDINSTANCES-1; int32_t j=MAXSOUNDINSTANCES-1;
@ -666,34 +672,28 @@ void S_StopSound(int32_t num)
if (g_sounds[num].SoundOwner[j].voice) if (g_sounds[num].SoundOwner[j].voice)
{ {
FX_StopSound(g_sounds[num].SoundOwner[j].voice); FX_StopSound(g_sounds[num].SoundOwner[j].voice);
g_sounds[num].SoundOwner[j].voice = 0; // g_sounds[num].SoundOwner[j].voice = 0;
}
// S_TestSoundCallback(num);
} }
// S_Callback(num);
} }
} }
} }
void S_StopEnvSound(int32_t num,int32_t i) void S_StopEnvSound(int32_t num,int32_t i)
{ {
if (num >= 0 && num < MAXSOUNDS) if (num >= 0 && num < MAXSOUNDS && g_sounds[num].num > 0)
{
if (g_sounds[num].num > 0)
{ {
int32_t j=MAXSOUNDINSTANCES-1; int32_t j=MAXSOUNDINSTANCES-1;
for (; j>=0; j--) for (; j>=0; j--)
{ {
if (g_sounds[num].SoundOwner[j].i == i) if (g_sounds[num].SoundOwner[j].i == i && g_sounds[num].SoundOwner[j].voice)
{
if (g_sounds[num].SoundOwner[j].voice)
{ {
// OSD_Printf("stopping sound %d index %d spr %d\n",num,j,i);
FX_StopSound(g_sounds[num].SoundOwner[j].voice); FX_StopSound(g_sounds[num].SoundOwner[j].voice);
g_sounds[num].SoundOwner[j].voice = 0; // g_sounds[num].SoundOwner[j].voice = 0;
}
// S_TestSoundCallback(num);
}
} }
// S_Callback(num);
} }
} }
} }
@ -730,7 +730,7 @@ void S_Pan3D(void)
if (i < 0 || i >= MAXSPRITES || g_sounds[j].SoundOwner[k].voice < 1) if (i < 0 || i >= MAXSPRITES || g_sounds[j].SoundOwner[k].voice < 1)
{ {
// OSD_Printf(OSD_ERROR "S_Pan3D(): INTERNAL ERROR: invalid id %d!\n",i); // OSD_Printf(OSD_ERROR "S_Pan3D(): INTERNAL ERROR: invalid id %d!\n",i);
k--; // k--;
continue; continue;
} }
@ -788,7 +788,7 @@ void S_Pan3D(void)
while (j--); while (j--);
} }
void S_TestSoundCallback(uint32_t num) void S_Callback(uint32_t num)
{ {
if ((int32_t)num == MUSIC_ID) if ((int32_t)num == MUSIC_ID)
return; return;
@ -809,9 +809,11 @@ void S_TestSoundCallback(uint32_t num)
{ {
int32_t i = g_sounds[num].SoundOwner[j].i; int32_t i = g_sounds[num].SoundOwner[j].i;
// OSD_Printf("removing sound %d index %d from spr %d\n",num,j,i);
if (sprite[i].picnum == MUSICANDSFX && sector[sprite[i].sectnum].lotag < 3 && sprite[i].lotag < 999) if (sprite[i].picnum == MUSICANDSFX && sector[sprite[i].sectnum].lotag < 3 && sprite[i].lotag < 999)
{
// OSD_Printf("removing sound %d index %d from spr %d\n",num,j,i);
ActorExtra[i].temp_data[0] = 0; ActorExtra[i].temp_data[0] = 0;
}
g_sounds[num].SoundOwner[j].i = -1; g_sounds[num].SoundOwner[j].i = -1;
g_sounds[num].SoundOwner[j].voice = 0; g_sounds[num].SoundOwner[j].voice = 0;

8
polymer/eduke32/source/sounds_mapster32.c
View file

@ -55,7 +55,7 @@ int32_t backflag,g_numEnvSoundsPlaying;
void MUSIC_Update(void) {} // needed when linking void MUSIC_Update(void) {} // needed when linking
void S_TestSoundCallback(uint32_t); void S_Callback(uint32_t);
extern void initprintf(const char *f, ...); extern void initprintf(const char *f, ...);
/* /*
@ -91,7 +91,7 @@ int32_t S_SoundStartup(void)
{ {
FX_SetVolume(FXVolume); FX_SetVolume(FXVolume);
FX_SetReverseStereo(ReverseStereo); FX_SetReverseStereo(ReverseStereo);
status = FX_SetCallBack(S_TestSoundCallback); status = FX_SetCallBack(S_Callback);
} }
if (status != FX_Ok) if (status != FX_Ok)
@ -360,7 +360,7 @@ void S_StopSound(int32_t num)
if (g_sounds[num].num > 0) if (g_sounds[num].num > 0)
{ {
FX_StopSound(g_sounds[num].SoundOwner[g_sounds[num].num-1].voice); FX_StopSound(g_sounds[num].SoundOwner[g_sounds[num].num-1].voice);
S_TestSoundCallback(num); S_Callback(num);
} }
} }
@ -444,7 +444,7 @@ void S_Pan3D(void)
} }
} }
void S_TestSoundCallback(uint32_t num) void S_Callback(uint32_t num)
{ {
int32_t i,j,k; int32_t i,j,k;

75
polymer/eduke32/source/wrapper.c
View file

@ -1,75 +0,0 @@
// this is a wrapper to launch EDuke32 properly from Dukester X 1.5
// gcc -o duke3d_w32.exe wrapper.c
#include <windows.h>
#include <string.h>
#include <stdio.h>
#define ISWS(x) ((x == ' ') || (x == '\t') || (x == '\r') || (x == '\n'))
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInst, LPSTR lpCmdLine, int nCmdShow)
{
int i=0,j=0;
char CmdLine[1024], sCmdLine[1024], szFileName[255];
LPTSTR szCmdLine;
FILE * fp=fopen("wrapper.log","w");
STARTUPINFO si;
PROCESS_INFORMATION pi;
UNREFERENCED_PARAMETER(hInstance);
UNREFERENCED_PARAMETER(hPrevInst);
UNREFERENCED_PARAMETER(nCmdShow);
strcpy(sCmdLine,lpCmdLine);
szFileName[0] = '\0';
while (sCmdLine[i] == ' ') i++;
while (i < (signed)strlen(sCmdLine))
{
if (sCmdLine[i] == '-' && sCmdLine[i+1] == 'n' && sCmdLine[i+2] == 'e' && sCmdLine[i+3] == 't')
{
CmdLine[i-1] = '\0';
i += 5;
while (sCmdLine[i] != ' ' && i < (signed)strlen(sCmdLine))
{
szFileName[j] = sCmdLine[i];
j++,i++;
}
szFileName[j] = '\0';
break;
}
else CmdLine[i] = sCmdLine[i];
i++;
CmdLine[i] = '\0';
}
if (szFileName[0] != '\0' && CmdLine[0] != '\0') Bsprintf(sCmdLine,"eduke32.exe %s -rmnet %s",CmdLine,szFileName);
else if (CmdLine[0] != '\0') Bsprintf(sCmdLine,"eduke32.exe %s",CmdLine);
else Bsprintf(sCmdLine,"eduke32.exe");
szCmdLine = sCmdLine;
fprintf(fp,"EDuke32 wrapper for Dukester X v0.02\n");
fprintf(fp,"Copyright (c) 2006 EDuke32 team\n\n");
fprintf(fp,"Args passed to wrapper: %s\n",lpCmdLine);
fprintf(fp,"Final command line: %s",szCmdLine);
fclose(fp);
ZeroMemory(&si,sizeof(si));
ZeroMemory(&pi,sizeof(pi));
si.cb = sizeof(si);
printf("Launching EDuke32...\n\nPlease leave this window open for the entire duration of your game.");
if (!CreateProcess(NULL,szCmdLine,NULL,NULL,0,0,NULL,NULL,&si,&pi))
{
MessageBox(0,"Failed to start eduke32.exe.", "Failure starting game", MB_OK|MB_ICONSTOP);
return 1;
}
else WaitForSingleObject(pi.hProcess,INFINITE);
return 0;
}