[Beta 2 Artpack 1.0 released] SplitWolf

SplitScreen for up to 4 players in cooperative mode on a single PC!!! (SDL)
Support for both vertical and horizontal splitscreen!
Minimap/radar support.

Coding: LinuxWolf
Additional art: DoomJedi
New Boss art by Untrustable
Beta testing by HexaDoken

Spoiler:

doomjedi wrote:The videos play old beta 1 BTW, as you can notice (not only by "pre beta 2" dates of those videos).
Noone here at the community offered to make a pack of coop levels.
I myself don't see any reasons for such zero offerings beside the "how difficult it is to find two wolf players on at same time to conviniently play such a thing." you've mentioned.

Wolfers should try to meet each other in the real world...we have here even wolfers from the same countries....

Dark_wizzie wrote:)I'm not sure how I would go about making a level designed for two players, actually. What do you think?

Dark_wizzie wrote:Let's play that, but I'll block Stathmk through a door so he can't get through and I'll hog all the ammo. XD
Just a funny thought. And what happens if I shoot the other player?

KasuPL wrote:Do SplitWolf (multiplayer) will be compatible with mods for Wolfenstein SDL port?

12.06.2014

This is an art patch 1.0 for "SplitWolf" (beta 2)
http://www.moddb.com/mods/splitwolf

Just replace the original lwmp folder with this one (deleting or overwriting the original folder)

What's new?
=============
Better player and SS sprites (by DoomJedi)
Fett and Otto 8-directional Boss frames (by UnTrustable)

Special thanks for Untrustable for the Boss frames.
http://forum.zdoom.org/viewtopic.php?f=19&t=33447

I know, quality stinks, and my commentating wasn't very good. I was kind of in a bad mood, but I thought I should still upload it and support you guys

D3m3 wrote:Found a nasty bug after folding and then unfolding port

I would also like to know the list of supported mods

doomjedi wrote:

D3m3 wrote:Found a nasty bug after folding and then unfolding port

Can you give us more details about what action/event created the bug?

SVN log:

Code:

Index: wl_draw.cpp

===================================================================
--- wl_draw.cpp (revision 258)
+++ wl_draw.cpp (revision 259)
@@ -1552,7 +1552,9 @@
     spotvis[player->tilex][player->tiley] = 1;       // Detect all sprites over player fix
 
     vbuf = VL_LockSurface(screenBuffer);
-    vbuf+=screenofs;
+    if(vbuf == NULL) return;
+
+    vbuf += screenofs;
     vbufPitch = bufferPitch;
 
     CalcViewVariables();
Index: id_in.cpp
===================================================================
--- id_in.cpp (revision 258)
+++ id_in.cpp (revision 259)
@@ -61,6 +61,7 @@
 static int JoyNumHats;
 
 static bool GrabInput = false;
+static bool NeedRestore = false;
 
 /*
 =============================================================================
@@ -327,6 +328,24 @@
             break;
         }
 
+        case SDL_ACTIVEEVENT:
+        {
+            if(fullscreen && (event->active.state & SDL_APPACTIVE) != 0)
+            {
+                if(event->active.gain)
+                {
+                    if(NeedRestore)
+                    {
+                        FreeLatchMem();
+                        LoadLatchMem();
+                    }
+
+                    NeedRestore = false;
+                }
+                else NeedRestore = true;
+            }
+        }
+
 #if defined(GP2X)
         case SDL_JOYBUTTONDOWN:
             GP2X_ButtonDown(event->jbutton.button);
Index: id_vh.h
===================================================================
--- id_vh.h (revision 258)
+++ id_vh.h (revision 259)
@@ -90,6 +90,7 @@
 void    LatchDrawPic (unsigned x, unsigned y, unsigned picnum);
 void    LatchDrawPicScaledCoord (unsigned scx, unsigned scy, unsigned picnum);
 void    LoadLatchMem (void);
+void    FreeLatchMem();
 
 void    VH_Startup();
 boolean FizzleFade (SDL_Surface *source, int x1, int y1,
Index: id_vl.h
===================================================================
--- id_vl.h (revision 258)
+++ id_vl.h (revision 259)
@@ -46,9 +46,6 @@
 byte *VL_LockSurface(SDL_Surface *surface);
 void VL_UnlockSurface(SDL_Surface *surface);
 
-#define LOCK() VL_LockSurface(curSurface)
-#define UNLOCK() VL_UnlockSurface(curSurface)
-
 byte VL_GetPixel        (int x, int y);
 void VL_Plot            (int x, int y, int color);
 void VL_Hlin            (unsigned x, unsigned y, unsigned width, int color);
Index: id_vh.cpp
===================================================================
--- id_vh.cpp (revision 258)
+++ id_vh.cpp (revision 259)
@@ -16,8 +16,11 @@
 int    width, step, height;
 byte    *source, *dest;
 byte    ch;
+ int i;
+ unsigned sx, sy;
 
-    byte *vbuf = LOCK();
+ byte *vbuf = VL_LockSurface(curSurface);
+ if(vbuf == NULL) return;
 
 font = (fontstruct *) grsegs[STARTFONT+fontnumber];
 height = font->height;
@@ -32,11 +35,11 @@
 for(int i=0;i<height;i++)
 {
 if(source[i*step])
-                {
-                    for(unsigned sy=0; sy<scaleFactor; sy++)
-                        for(unsigned sx=0; sx<scaleFactor; sx++)
-         dest[(scaleFactor*i+sy)*curPitch+sx]=fontcolor;
-                }
+ {
+ for(sy=0; sy<scaleFactor; sy++)
+ for(sx=0; sx<scaleFactor; sx++)
+ dest[(scaleFactor*i+sy)*curPitch+sx]=fontcolor;
+ }
 }
 
 source++;
@@ -45,7 +48,7 @@
 }
 }
 
- UNLOCK();
+ VL_UnlockSurface(curSurface);
 }
 
 /*
@@ -214,6 +217,16 @@
 
 //==========================================================================
 
+void FreeLatchMem()
+{
+    int i;
+    for(i = 0; i < 2 + LATCHPICS_LUMP_END - LATCHPICS_LUMP_START; i++)
+    {
+        SDL_FreeSurface(latchpics[i]);
+        latchpics[i] = NULL;
+    }
+}
+
 /*
 ===================
 =
@@ -250,6 +263,8 @@
 }
 UNCACHEGRCHUNK (STARTTILE8);
 
+ latchpics[1] = NULL;  // not used
+
 //
 // pics
 //
@@ -351,8 +366,12 @@
 
     frame = GetTimeCount();
     byte *srcptr = VL_LockSurface(source);
+    if(srcptr == NULL) return false;
+
     do
     {
+        IN_ProcessEvents();
+
         if(abortable && IN_CheckAck ())
         {
             VL_UnlockSurface(source);
@@ -363,65 +382,81 @@
 
         byte *destptr = VL_LockSurface(screen);
 
-        rndval = lastrndval;
+        if(destptr != NULL)
+        {
+            rndval = lastrndval;
 
-        // When using double buffering, we have to copy the pixels of the last AND the current frame.
-        // Only for the first frame, there is no "last frame"
-        for(int i = first; i < 2; i++)
-        {
-            for(unsigned p = 0; p < pixperframe; p++)
+            // When using double buffering, we have to copy the pixels of the last AND the current frame.
+            // Only for the first frame, there is no "last frame"
+            for(int i = first; i < 2; i++)
             {
-                //
-                // seperate random value into x/y pair
-                //
+                for(unsigned p = 0; p < pixperframe; p++)
+                {
+                    //
+                    // seperate random value into x/y pair
+                    //
 
-                x = rndval >> rndbits_y;
-                y = rndval & ((1 << rndbits_y) - 1);
+                    x = rndval >> rndbits_y;
+                    y = rndval & ((1 << rndbits_y) - 1);
 
-                //
-                // advance to next random element
-                //
+                    //
+                    // advance to next random element
+                    //
 
-                rndval = (rndval >> 1) ^ (rndval & 1 ? 0 : rndmask);
+                    rndval = (rndval >> 1) ^ (rndval & 1 ? 0 : rndmask);
 
-                if(x >= width || y >= height)
-                {
-                    if(rndval == 0)     // entire sequence has been completed
+                    if(x >= width || y >= height)
+                    {
+                        if(rndval == 0)     // entire sequence has been completed
+                            goto finished;
+                        p--;
+                        continue;
+                    }
+
+                    //
+                    // copy one pixel
+                    //
+
+                    if(screenBits ==
+                    {
+                        *(destptr + (y1 + y) * screen->pitch + x1 + x)
+                            = *(srcptr + (y1 + y) * source->pitch + x1 + x);
+                    }
+                    else
+                    {
+                        byte col = *(srcptr + (y1 + y) * source->pitch + x1 + x);
+                        uint32_t fullcol = SDL_MapRGB(screen->format, curpal[col].r, curpal[col].g, curpal[col].b);
+                        memcpy(destptr + (y1 + y) * screen->pitch + (x1 + x) * screen->format->BytesPerPixel,
+                            &fullcol, screen->format->BytesPerPixel);
+                    }
+
+                    if(rndval == 0) // entire sequence has been completed
                         goto finished;
-                    p--;
-                    continue;
                 }
 
-                //
-                // copy one pixel
-                //
+                if(!i || first) lastrndval = rndval;
+            }
 
-                if(screenBits ==
+            // If there is no double buffering, we always use the "first frame" case
+            if(usedoublebuffering) first = 0;
+
+            VL_UnlockSurface(screen);
+            SDL_Flip(screen);
+        }
+        else
+        {
+            // No surface, so only enhance rndval
+            for(int i = first; i < 2; i++)
+            {
+                for(unsigned p = 0; p < pixperframe; p++)
                 {
-                    *(destptr + (y1 + y) * screen->pitch + x1 + x)
-                        = *(srcptr + (y1 + y) * source->pitch + x1 + x);
+                    rndval = (rndval >> 1) ^ (rndval & 1 ? 0 : rndmask);
+                    if(rndval == 0)
+                        goto finished;
                 }
-                else
-                {
-                    byte col = *(srcptr + (y1 + y) * source->pitch + x1 + x);
-                    uint32_t fullcol = SDL_MapRGB(screen->format, curpal[col].r, curpal[col].g, curpal[col].b);
-                    memcpy(destptr + (y1 + y) * screen->pitch + (x1 + x) * screen->format->BytesPerPixel,
-                        &fullcol, screen->format->BytesPerPixel);
-                }
-
-                if(rndval == 0) // entire sequence has been completed
-                    goto finished;
             }
-
-            if(!i || first) lastrndval = rndval;
         }
 
-        // If there is no double buffering, we always use the "first frame" case
-        if(usedoublebuffering) first = 0;
-
-        VL_UnlockSurface(screen);
-        SDL_Flip(screen);
-
         frame++;
         Delay(frame - GetTimeCount());        // don't go too fast
     } while (1);
Index: README.txt
===================================================================
--- README.txt (revision 258)
+++ README.txt (revision 259)
@@ -79,7 +79,7 @@
 version.h as described in that file):
 
  - Wolfenstein 3D v1.1 full Apogee
- - Wolfenstein 3D v1.4 full Apogee (not tested)
+ - Wolfenstein 3D v1.4 full Apogee
  - Wolfenstein 3D v1.4 full GT/ID/Activision
  - Wolfenstein 3D v1.0 shareware Apogee
  - Wolfenstein 3D v1.1 shareware Apogee
Index: id_vl.cpp
===================================================================
--- id_vl.cpp (revision 258)
+++ id_vl.cpp (revision 259)
@@ -425,12 +425,17 @@
 
 void VL_Plot (int x, int y, int color)
 {
+    byte *ptr;
+
     assert(x >= 0 && (unsigned) x < screenWidth
             && y >= 0 && (unsigned) y < screenHeight
             && "VL_Plot: Pixel out of bounds!");
 
-    VL_LockSurface(curSurface);
- ((byte *) curSurface->pixels)[y * curPitch + x] = color;
+    ptr = VL_LockSurface(curSurface);
+    if(ptr == NULL) return;
+
+    ptr[y * curPitch + x] = color;
+
     VL_UnlockSurface(curSurface);
 }
 
@@ -444,14 +449,21 @@
 
 byte VL_GetPixel (int x, int y)
 {
+    byte *ptr;
+    byte col;
+
     assert_ret(x >= 0 && (unsigned) x < screenWidth
             && y >= 0 && (unsigned) y < screenHeight
             && "VL_GetPixel: Pixel out of bounds!");
 
-    VL_LockSurface(curSurface);
- byte col = ((byte *) curSurface->pixels)[y * curPitch + x];
+    ptr = VL_LockSurface(curSurface);
+    if(ptr == NULL) return 0;
+
+    col = ((byte *) curSurface->pixels)[y * curPitch + x];
+
     VL_UnlockSurface(curSurface);
- return col;
+
+    return col;
 }
 
 
@@ -465,13 +477,17 @@
 
 void VL_Hlin (unsigned x, unsigned y, unsigned width, int color)
 {
+    byte *ptr;
+
     assert(x >= 0 && x + width <= screenWidth
             && y >= 0 && y < screenHeight
             && "VL_Hlin: Destination rectangle out of bounds!");
 
-    VL_LockSurface(curSurface);
-    Uint8 *dest = ((byte *) curSurface->pixels) + y * curPitch + x;
-    memset(dest, color, width);
+    ptr = VL_LockSurface(curSurface);
+    if(ptr == NULL) return;
+
+    memset(ptr + y * curPitch + x, color, width);
+
     VL_UnlockSurface(curSurface);
 }
 
@@ -486,18 +502,23 @@
 
 void VL_Vlin (int x, int y, int height, int color)
 {
+ byte *ptr;
+
 assert(x >= 0 && (unsigned) x < screenWidth
 && y >= 0 && (unsigned) y + height <= screenHeight
 && "VL_Vlin: Destination rectangle out of bounds!");
 
- VL_LockSurface(curSurface);
- Uint8 *dest = ((byte *) curSurface->pixels) + y * curPitch + x;
+ ptr = VL_LockSurface(curSurface);
+ if(ptr == NULL) return;
 
+ ptr += y * curPitch + x;
+
 while (height--)
 {
- *dest = color;
- dest += curPitch;
+ *ptr = color;
+ ptr += curPitch;
 }
+
 VL_UnlockSurface(curSurface);
 }
 
@@ -512,17 +533,21 @@
 
 void VL_BarScaledCoord (int scx, int scy, int scwidth, int scheight, int color)
 {
+ byte *ptr;
+
 assert(scx >= 0 && (unsigned) scx + scwidth <= screenWidth
 && scy >= 0 && (unsigned) scy + scheight <= screenHeight
 && "VL_BarScaledCoord: Destination rectangle out of bounds!");
 
- VL_LockSurface(curSurface);
- Uint8 *dest = ((byte *) curSurface->pixels) + scy * curPitch + scx;
+ ptr = VL_LockSurface(curSurface);
+ if(ptr == NULL) return;
 
+ ptr += scy * curPitch + scx;
+
 while (scheight--)
 {
- memset(dest, color, scwidth);
- dest += curPitch;
+ memset(ptr, color, scwidth);
+ ptr += curPitch;
 }
 VL_UnlockSurface(curSurface);
 }
@@ -546,18 +571,23 @@
 void VL_MemToLatch(byte *source, int width, int height,
     SDL_Surface *destSurface, int x, int y)
 {
+    byte *ptr;
+    int xsrc, ysrc, pitch;
+
     assert(x >= 0 && (unsigned) x + width <= screenWidth
             && y >= 0 && (unsigned) y + height <= screenHeight
             && "VL_MemToLatch: Destination rectangle out of bounds!");
 
-    VL_LockSurface(destSurface);
-    int pitch = destSurface->pitch;
-    byte *dest = (byte *) destSurface->pixels + y * pitch + x;
-    for(int ysrc = 0; ysrc < height; ysrc++)
+    ptr = VL_LockSurface(destSurface);
+    if(ptr == NULL) return;
+
+    pitch = destSurface->pitch;
+    ptr += y * pitch + x;
+    for(ysrc = 0; ysrc < height; ysrc++)
     {
-        for(int xsrc = 0; xsrc < width; xsrc++)
+        for(xsrc = 0; xsrc < width; xsrc++)
         {
-            dest[ysrc * pitch + xsrc] = source[(ysrc * (width >> 2) + (xsrc >> 2))
+            ptr[ysrc * pitch + xsrc] = source[(ysrc * (width >> 2) + (xsrc >> 2))
                 + (xsrc & 3) * (width >> 2) * height];
         }
     }
@@ -579,22 +609,27 @@
 
 void VL_MemToScreenScaledCoord (byte *source, int width, int height, int destx, int desty)
 {
+    byte *ptr;
+    int i, j, sci, scj;
+    unsigned m, n;
+
     assert(destx >= 0 && destx + width * scaleFactor <= screenWidth
             && desty >= 0 && desty + height * scaleFactor <= screenHeight
             && "VL_MemToScreenScaledCoord: Destination rectangle out of bounds!");
 
-    VL_LockSurface(curSurface);
-    byte *vbuf = (byte *) curSurface->pixels;
-    for(int j=0,scj=0; j<height; j++, scj+=scaleFactor)
+    ptr = VL_LockSurface(curSurface);
+    if(ptr == NULL) return;
+
+    for(j = 0, scj = 0; j < height; j++, scj += scaleFactor)
     {
-        for(int i=0,sci=0; i<width; i++, sci+=scaleFactor)
+        for(i = 0, sci = 0; i < width; i++, sci += scaleFactor)
         {
-            byte col = source[(j*(width>>2)+(i>>2))+(i&3)*(width>>2)*height];
-            for(unsigned m=0; m<scaleFactor; m++)
+            byte col = source[(j * (width >> 2) + (i >> 2)) + (i & 3) * (width >> 2) * height];
+            for(m = 0; m < scaleFactor; m++)
             {
-                for(unsigned n=0; n<scaleFactor; n++)
+                for(n = 0; n < scaleFactor; n++)
                 {
-                    vbuf[(scj+m+desty)*curPitch+sci+n+destx] = col;
+                    ptr[(scj + m + desty) * curPitch + sci + n + destx] = col;
                 }
             }
         }
@@ -618,22 +653,29 @@
 void VL_MemToScreenScaledCoord (byte *source, int origwidth, int origheight, int srcx, int srcy,
                                 int destx, int desty, int width, int height)
 {
+    byte *ptr;
+    int i, j, sci, scj;
+    unsigned m, n;
+
     assert(destx >= 0 && destx + width * scaleFactor <= screenWidth
             && desty >= 0 && desty + height * scaleFactor <= screenHeight
             && "VL_MemToScreenScaledCoord: Destination rectangle out of bounds!");
 
-    VL_LockSurface(curSurface);
-    byte *vbuf = (byte *) curSurface->pixels;
-    for(int j=0,scj=0; j<height; j++, scj+=scaleFactor)
+    ptr = VL_LockSurface(curSurface);
+    if(ptr == NULL) return;
+
+    for(j = 0, scj = 0; j < height; j++, scj += scaleFactor)
     {
-        for(int i=0,sci=0; i<width; i++, sci+=scaleFactor)
+        for(i = 0, sci = 0; i < width; i++, sci += scaleFactor)
         {
-            byte col = source[((j+srcy)*(origwidth>>2)+((i+srcx)>>2))+((i+srcx)&3)*(origwidth>>2)*origheight];
-            for(unsigned m=0; m<scaleFactor; m++)
+            byte col = source[((j + srcy) * (origwidth >> 2) + ((i + srcx) >>2 ))
+                + ((i + srcx) & 3) * (origwidth >> 2) * origheight];
+
+            for(m = 0; m < scaleFactor; m++)
             {
-                for(unsigned n=0; n<scaleFactor; n++)
+                for(n = 0; n < scaleFactor; n++)
                 {
-                    vbuf[(scj+m+desty)*curPitch+sci+n+destx] = col;
+                    ptr[(scj + m + desty) * curPitch + sci + n + destx] = col;
                 }
             }
         }
@@ -670,18 +712,24 @@
         //       So, we do the blit on our own...
         if(screenBits !=
         {
-            VL_LockSurface(source);
-            byte *src = (byte *) source->pixels;
-            unsigned srcPitch = source->pitch;
+            byte *src, *dest;
+            unsigned srcPitch;
+            int i, j;
 
-            VL_LockSurface(curSurface);
-            byte *vbuf = (byte *) curSurface->pixels;
-            for(int j=0,scj=0; j<height; j++, scj++)
+            src = VL_LockSurface(source);
+            if(src == NULL) return;
+
+            srcPitch = source->pitch;
+
+            dest = VL_LockSurface(curSurface);
+            if(dest == NULL) return;
+
+            for(j = 0; j < height; j++)
             {
-                for(int i=0,sci=0; i<width; i++, sci++)
+                for(i = 0; i < width; i++)
                 {
                     byte col = src[(ysrc + j)*srcPitch + xsrc + i];
-                    vbuf[(scydest+scj)*curPitch+scxdest+sci] = col;
+                    dest[(scydest + j) * curPitch + scxdest + i] = col;
                 }
             }
             VL_UnlockSurface(curSurface);
@@ -696,22 +744,29 @@
     }
     else
     {
-        VL_LockSurface(source);
-        byte *src = (byte *) source->pixels;
-        unsigned srcPitch = source->pitch;
+        byte *src, *dest;
+        unsigned srcPitch;
+        int i, j, sci, scj;
+        unsigned m, n;
 
-        VL_LockSurface(curSurface);
-        byte *vbuf = (byte *) curSurface->pixels;
-        for(int j=0,scj=0; j<height; j++, scj+=scaleFactor)
+        src = VL_LockSurface(source);
+        if(src == NULL) return;
+
+        srcPitch = source->pitch;
+
+        dest = VL_LockSurface(curSurface);
+        if(dest == NULL) return;
+
+        for(j = 0, scj = 0; j < height; j++, scj += scaleFactor)
         {
-            for(int i=0,sci=0; i<width; i++, sci+=scaleFactor)
+            for(i = 0, sci = 0; i < width; i++, sci += scaleFactor)
             {
                 byte col = src[(ysrc + j)*srcPitch + xsrc + i];
-                for(unsigned m=0; m<scaleFactor; m++)
+                for(m = 0; m < scaleFactor; m++)
                 {
-                    for(unsigned n=0; n<scaleFactor; n++)
+                    for(n = 0; n < scaleFactor; n++)
                     {
-                        vbuf[(scydest+scj+m)*curPitch+scxdest+sci+n] = col;
+                        dest[(scydest + scj + m) * curPitch + scxdest + sci + n] = col;
                     }
                 }
             }
Index: id_ca.cpp
===================================================================
--- id_ca.cpp (revision 258)
+++ id_ca.cpp (revision 259)
@@ -979,6 +979,9 @@
     memptr  bigbufferseg;
     int32_t    *source;
     int             next;
+    byte *pic, *vbuf;
+    int x, y, scx, scy;
+    unsigned i, j;
 
 //
 // load the chunk into a buffer
@@ -1002,22 +1005,25 @@
 // allocate final space, decompress it, and free bigbuffer
 // Sprites need to have shifts made and various other junk
 //
-    byte *pic = (byte *) malloc(64000);
+    pic = (byte *) malloc(64000);
     CHECKMALLOCRESULT(pic);
     CAL_HuffExpand((byte *) source, pic, expanded, grhuffman);
 
-    byte *vbuf = LOCK();
-    for(int y = 0, scy = 0; y < 200; y++, scy += scaleFactor)
+    vbuf = VL_LockSurface(curSurface);
+    if(vbuf != NULL)
     {
-        for(int x = 0, scx = 0; x < 320; x++, scx += scaleFactor)
+        for(y = 0, scy = 0; y < 200; y++, scy += scaleFactor)
         {
-            byte col = pic[(y * 80 + (x >> 2)) + (x & 3) * 80 * 200];
-            for(unsigned i = 0; i < scaleFactor; i++)
-                for(unsigned j = 0; j < scaleFactor; j++)
-                    vbuf[(scy + i) * curPitch + scx + j] = col;
+            for(x = 0, scx = 0; x < 320; x++, scx += scaleFactor)
+            {
+                byte col = pic[(y * 80 + (x >> 2)) + (x & 3) * 80 * 200];
+                for(i = 0; i < scaleFactor; i++)
+                    for(j = 0; j < scaleFactor; j++)
+                        vbuf[(scy + i) * curPitch + scx + j] = col;
+            }
         }
+        VL_UnlockSurface(curSurface);
     }
-    UNLOCK();
     free(pic);
     free(bigbufferseg);
 }