Initial Source Code commit

Initial commit of original Tiberian Dawn and Red Alert source code converted to build as DLLs, and compatible with the release version of Command & Conquer Remastered.

CnCRemastered.sln

+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 15
+VisualStudioVersion = 15.0.28307.1022
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "TiberianDawn", "TiberianDawn\TiberianDawn.vcxproj", "{1380ED08-82A3-49C2-A171-1915574B3382}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "RedAlert", "RedAlert\RedAlert.vcxproj", "{DA948ED9-EF67-4813-94B7-995BE956786E}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Release|x86 = Release|x86
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{1380ED08-82A3-49C2-A171-1915574B3382}.Release|x86.ActiveCfg = Release|Win32
+		{1380ED08-82A3-49C2-A171-1915574B3382}.Release|x86.Build.0 = Release|Win32
+		{DA948ED9-EF67-4813-94B7-995BE956786E}.Release|x86.ActiveCfg = Release|Win32
+		{DA948ED9-EF67-4813-94B7-995BE956786E}.Release|x86.Build.0 = Release|Win32
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {712D2733-25EE-407D-AEF8-B2342757E119}
+	EndGlobalSection
+EndGlobal

REDALERT/2SUPPORT.ASM

+;
+; Copyright 2020 Electronic Arts Inc.
+;
+; TiberianDawn.DLL and RedAlert.dll and corresponding source code is free 
+; software: you can redistribute it and/or modify it under the terms of 
+; the GNU General Public License as published by the Free Software Foundation, 
+; either version 3 of the License, or (at your option) any later version.
+
+; TiberianDawn.DLL and RedAlert.dll and corresponding source code is distributed 
+; in the hope that it will be useful, but with permitted additional restrictions 
+; under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT 
+; distributed with this program. You should have received a copy of the 
+; GNU General Public License along with permitted additional restrictions 
+; with this program. If not, see [https://github.com/electronicarts/CnC_Remastered_Collection]>.
+
+; $Header:   F:\projects\c&c0\vcs\code\2support.asv   5.0   11 Nov 1996 09:40:36   JOE_BOSTIC  $
+;***************************************************************************
+;**   C O N F I D E N T I A L --- W E S T W O O D    S T U D I O S        **
+;***************************************************************************
+;*                                                                         *
+;*                 Project Name : Command & Conquer                        *
+;*                                                                         *
+;*                    File Name : SUPPORT.ASM                              *
+;*                                                                         *
+;*                   Programmer : Joe L. Bostic                            *
+;*                                                                         *
+;*                   Start Date : September 23, 1993                       *
+;*                                                                         *
+;*                  Last Update : May 10, 1994   [JLB]                     *
+;*                                                                         *
+;*-------------------------------------------------------------------------*
+;* Functions:                                                              *
+;*   strtrim -- Remove the trailing white space from a string.             *
+;*   Fat_Put_Pixel -- Draws a fat pixel.                                   *
+;*   Conquer_Build_Fading_Table -- Builds custom shadow/light fading table.*
+;*   Remove_From_List -- Removes a pointer from a list of pointers.        *
+;* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *
+
+IDEAL
+P386
+MODEL USE32 FLAT
+
+INCLUDE "gbuffer.inc"
+	DISPLAY	"Command & Conquer assembly support routines."
+
+	CODESEG
+
+
+;***************************************************************************
+;* Fat_Put_Pixel -- Draws a fat pixel.                                     *
+;*                                                                         *
+;*    Use this routine to draw a "pixel" that is bigger than 1 pixel       *
+;*    across.  This routine is faster than drawing a similar small shape   *
+;*    and faster than calling Fill_Rect.                                   *
+;*                                                                         *
+;* INPUT:   x,y       -- Screen coordinates to draw the pixel's upper      *
+;*                       left corner.                                      *
+;*                                                                         *
+;*          color     -- The color to render the pixel in.                 *
+;*                                                                         *
+;*          size      -- The number of pixels width of the big "pixel".    *
+;*                                                                         *
+;*          page      -- The pointer to a GraphicBuffer class or something *
+;*                                                                         *
+;* OUTPUT:  none                                                           *
+;*                                                                         *
+;* WARNINGS:   none                                                        *
+;*                                                                         *
+;* HISTORY:                                                                *
+;*   03/17/1994 JLB : Created.                                             *
+;*=========================================================================*
+; VOID cdecl Fat_Put_Pixel(long x, long y, long color, long size, void *page)
+	GLOBAL	C Fat_Put_Pixel:NEAR
+	PROC	Fat_Put_Pixel C near
+	USES	eax, ebx, ecx, edx, edi, esi
+
+	ARG	x:DWORD		; X coordinate of upper left pixel corner.
+	ARG	y:DWORD		; Y coordinate of upper left pixel corner.
+	ARG	color:DWORD	; Color to use for the "pixel".
+	ARG	siz:DWORD	; Size of "pixel" to plot (square).
+	ARG	gpage:DWORD	; graphic page address to plot onto
+
+	cmp	[siz],0
+	je	short ??exit
+
+	; Set EDI to point to start of logical page memory.
+	;*===================================================================
+	; Get the viewport information and put bytes per row in ecx
+	;*===================================================================
+	mov	ebx,[gpage]				; get a pointer to viewport
+	mov	edi,[(GraphicViewPort ebx).GVPOffset]	; get the correct offset
+
+	; Verify the the Y pixel offset is legal.
+	mov	eax,[y]
+	cmp	eax,[(GraphicViewPort ebx).GVPHeight]	;YPIXEL_MAX
+	jae	short ??exit
+	mov	ecx,[(GraphicViewPort ebx).GVPWidth]
+	add	ecx,[(GraphicViewPort ebx).GVPXAdd]
+	add	ecx,[(GraphicViewPort ebx).GVPPitch]
+	mul	ecx
+	add	edi,eax
+
+	; Verify the the X pixel offset is legal.
+
+	mov	edx,[(GraphicViewPort ebx).GVPWidth]
+	cmp	edx,[x]
+	mov	edx,ecx
+	jbe	short ??exit
+	add	edi,[x]
+
+	; Write the pixel to the screen.
+	mov	ebx,[siz]		; Copy of pixel size.
+	sub	edx,ebx			; Modulo to reach start of next row.
+	mov	eax,[color]
+??again:
+	mov	ecx,ebx
+	rep stosb
+	add	edi,edx			; EDI points to start of next row.
+	dec	[siz]
+	jnz	short ??again
+
+??exit:
+	ret
+
+	ENDP	Fat_Put_Pixel
+
+
+if 0
+
+;***************************************************************************
+;* strtrim -- Remove the trailing white space from a string.               *
+;*                                                                         *
+;*    Use this routine to remove white space characters from the beginning *
+;*    and end of the string.        The string is modified in place by     *
+;*    this routine.                                                        *
+;*                                                                         *
+;* INPUT:   buffer   -- Pointer to the string to modify.                   *
+;*                                                                         *
+;* OUTPUT:     none                                                        *
+;*                                                                         *
+;* WARNINGS:   none                                                        *
+;*                                                                         *
+;* HISTORY:                                                                *
+;*   10/07/1992 JLB : Created.                                             *
+;*=========================================================================*
+; VOID cdecl strtrim(BYTE *buffer);
+	GLOBAL	C strtrim :NEAR
+	PROC	strtrim C near
+	USES	ax, edi, esi
+
+	ARG	buffer:DWORD		; Pointer to string to modify.
+
+	cmp	[buffer],0
+	je	short ??fini
+
+	; Prepare for string scanning by loading pointers.
+	cld
+	mov	esi,[buffer]
+	mov	edi,esi
+
+	; Strip white space from the start of the string.
+??looper:
+	lodsb
+	cmp	al,20h			; Space
+	je	short ??looper
+	cmp	al,9			; TAB
+	je	short ??looper
+	stosb
+
+	; Copy the rest of the string.
+??gruntloop:
+	lodsb
+	stosb
+	or	al,al
+	jnz	short ??gruntloop
+	dec	edi
+	; Strip the white space from the end of the string.
+??looper2:
+	mov	[edi],al
+	dec	edi
+	mov	ah,[edi]
+	cmp	ah,20h
+	je	short ??looper2
+	cmp	ah,9
+	je	short ??looper2
+
+??fini:
+	ret
+
+	ENDP	strtrim
+
+
+;***************************************************************************
+;* Conquer_Build_Fading_Table -- Builds custom shadow/light fading table.  *
+;*                                                                         *
+;*    This routine is used to build a special fading table for C&C.  There *
+;*    are certain colors that get faded to and cannot be faded again.      *
+;*    With this rule, it is possible to draw a shadow multiple times and   *
+;*    not have it get any lighter or darker.                               *
+;*                                                                         *
+;* INPUT:   palette  -- Pointer to the 768 byte IBM palette to build from. *
+;*                                                                         *
+;*          dest     -- Pointer to the 256 byte remap table.               *
+;*                                                                         *
+;*          color    -- Color index of the color to "fade to".             *
+;*                                                                         *
+;*          frac     -- The fraction to fade to the specified color        *
+;*                                                                         *
+;* OUTPUT:  Returns with pointer to the remap table.                       *
+;*                                                                         *
+;* WARNINGS:   none                                                        *
+;*                                                                         *
+;* HISTORY:                                                                *
+;*   10/07/1992 JLB : Created.                                             *
+;*=========================================================================*/
+;VOID * cdecl Conquer_Build_Fading_Table(VOID *palette, VOID *dest, long color, long frac);
+	GLOBAL	C Conquer_Build_Fading_Table : NEAR
+	PROC	Conquer_Build_Fading_Table C near
+	USES	ebx, ecx, edi, esi
+
+	ARG	palette:DWORD
+	ARG	dest:DWORD
+	ARG	color:DWORD
+	ARG	frac:DWORD
+
+	LOCAL	matchvalue:DWORD	; Last recorded match value.
+	LOCAL	targetred:BYTE		; Target gun red.
+	LOCAL	targetgreen:BYTE	; Target gun green.
+	LOCAL	targetblue:BYTE		; Target gun blue.
+	LOCAL	idealred:BYTE
+	LOCAL	idealgreen:BYTE
+	LOCAL	idealblue:BYTE
+	LOCAL	matchcolor:BYTE		; Tentative match color.
+
+ALLOWED_COUNT	EQU	16
+ALLOWED_START	EQU	256-ALLOWED_COUNT
+
+	cld
+
+	; If the source palette is NULL, then just return with current fading table pointer.
+	cmp	[palette],0
+	je	??fini1
+	cmp	[dest],0
+	je	??fini1
+
+	; Fractions above 255 become 255.
+	mov	eax,[frac]
+	cmp	eax,0100h
+	jb	short ??ok
+	mov	[frac],0FFh
+??ok:
+
+	; Record the target gun values.
+	mov	esi,[palette]
+	mov	ebx,[color]
+	add	esi,ebx
+	add	esi,ebx
+	add	esi,ebx
+	lodsb
+	mov	[targetred],al
+	lodsb
+	mov	[targetgreen],al
+	lodsb
+	mov	[targetblue],al
+
+	; Main loop.
+	xor	ebx,ebx			; Remap table index.
+
+	; Transparent black never gets remapped.
+	mov	edi,[dest]
+	mov	[edi],bl
+	inc	edi
+
+	; EBX = source palette logical number (1..255).
+	; EDI = running pointer into dest remap table.
+??mainloop:
+	inc	ebx
+	mov	esi,[palette]
+	add	esi,ebx
+	add	esi,ebx
+	add	esi,ebx
+
+	mov	edx,[frac]
+	shr	edx,1
+	; new = orig - ((orig-target) * fraction);
+
+	lodsb				; orig
+	mov	dh,al			; preserve it for later.
+	sub	al,[targetred]		; al = (orig-target)
+	imul	dl			; ax = (orig-target)*fraction
+	shl	eax,1
+	sub	dh,ah			; dh = orig - ((orig-target) * fraction)
+	mov	[idealred],dh		; preserve ideal color gun value.
+
+	lodsb				; orig
+	mov	dh,al			; preserve it for later.
+	sub	al,[targetgreen]	; al = (orig-target)
+	imul	dl			; ax = (orig-target)*fraction
+	shl	eax,1
+	sub	dh,ah			; dh = orig - ((orig-target) * fraction)
+	mov	[idealgreen],dh		; preserve ideal color gun value.
+
+	lodsb				; orig
+	mov	dh,al			; preserve it for later.
+	sub	al,[targetblue]		; al = (orig-target)
+	imul	dl			; ax = (orig-target)*fraction
+	shl	eax,1
+	sub	dh,ah			; dh = orig - ((orig-target) * fraction)
+	mov	[idealblue],dh		; preserve ideal color gun value.
+
+	; Sweep through a limited set of existing colors to find the closest
+	; matching color.
+
+	mov	eax,[color]
+	mov	[matchcolor],al		; Default color (self).
+	mov	[matchvalue],-1		; Ridiculous match value init.
+	mov	ecx,ALLOWED_COUNT
+
+	mov	esi,[palette]		; Pointer to original palette.
+	add	esi,(ALLOWED_START)*3
+
+	; BH = color index.
+	mov	bh,ALLOWED_START
+??innerloop:
+
+	xor	edx,edx			; Comparison value starts null.
+
+	; Build the comparison value based on the sum of the differences of the color
+	; guns squared.
+	lodsb
+	sub	al,[idealred]
+	mov	ah,al
+	imul	ah
+	add	edx,eax
+
+	lodsb
+	sub	al,[idealgreen]
+	mov	ah,al
+	imul	ah
+	add	edx,eax
+
+	lodsb
+	sub	al,[idealblue]
+	mov	ah,al
+	imul	ah
+	add	edx,eax
+	jz	short ??perfect		; If perfect match found then quit early.
+
+	cmp	edx,[matchvalue]
+	jae	short ??notclose
+	mov	[matchvalue],edx	; Record new possible color.
+	mov	[matchcolor],bh
+??notclose:
+	inc	bh			; Checking color index.
+	loop	??innerloop
+	mov	bh,[matchcolor]
+??perfect:
+	mov	[matchcolor],bh
+	xor	bh,bh			; Make BX valid main index again.
+
+	; When the loop exits, we have found the closest match.
+	mov	al,[matchcolor]
+	stosb
+	cmp	ebx,ALLOWED_START-1
+	jne	??mainloop
+
+	; Fill the remainder of the remap table with values
+	; that will remap the color to itself.
+	mov	ecx,ALLOWED_COUNT
+??fillerloop:
+	inc	bl
+	mov	al,bl
+	stosb
+	loop	??fillerloop
+
+??fini1:
+	mov	esi,[dest]
+	mov	eax,esi
+	ret
+
+	ENDP	Conquer_Build_Fading_Table
+
+
+;***************************************************************************
+;* Remove_From_List -- Removes a pointer from a list of pointers.          *
+;*                                                                         *
+;*    This low level routine is used to remove a pointer from a list of    *
+;*    pointers.  The trailing pointers are moved downward to fill the      *
+;*    hole.                                                                *
+;*                                                                         *
+;* INPUT:   list     -- Pointer to list of pointer.                        *
+;*                                                                         *
+;*          index    -- Pointer to length of pointer list.                 *
+;*                                                                         *
+;*          ptr      -- The pointer value to search for and remove.        *
+;*                                                                         *
+;* OUTPUT:  none                                                           *
+;*                                                                         *
+;* WARNINGS:   none                                                        *
+;*                                                                         *
+;* HISTORY:                                                                *
+;*   04/11/1994 JLB : Created.                                             *
+;*   04/22/1994 JLB : Convert to assembly language.                        *
+;*   05/10/1994 JLB : Short pointers now.                                  *
+;*=========================================================================*/
+;VOID cdecl Remove_From_List(VOID **list, long *index, long ptr);
+	GLOBAL	C Remove_From_List:NEAR
+	PROC	Remove_From_List C near
+	USES	edi, esi, ecx, eax
+	ARG	list:DWORD		; Pointer to list.
+	ARG	index:DWORD		; Pointer to count.
+	ARG	element:DWORD		; Element to remove.
+
+	; Fetch the number of elements in the list.  If there are no
+	; elements, then just exit quickly.
+	mov	edi,[index]
+	mov	ecx,[edi]
+	jcxz	short ??fini2
+
+	; Fetch pointer to list.
+	cmp	[list],0
+	je	short ??fini2
+	mov	edi,[list]
+
+	; Loop through all elements searching for a match.
+	mov	eax,[element]
+	repne scasd
+	jne	short ??fini2		; No match found.
+
+	; Copy all remaining elements down.  If this is the
+	; last element in the list then nothing needs to be
+	; copied -- just decrement the list size.
+	jcxz	short ??nocopy		; No copy necessary.
+	mov	esi,edi
+	sub	edi,4
+	rep movsd
+
+	; Reduce the list count by one.
+??nocopy:
+	mov	edi,[index]
+	dec	[DWORD PTR edi]
+
+??fini2:
+	ret
+
+	ENDP	Remove_From_List
+
+
+; long cdecl Get_EAX();
+	GLOBAL	C Get_EAX :NEAR
+	PROC	Get_EAX C near
+	ret
+
+	ENDP	Get_EAX
+endif
+
+
+	DATASEG
+
+TabA	DD 6949350
+	DD 4913933
+	DD 3474675
+	DD 2456966
+	DD 1737338
+	DD 1228483
+	DD 868669
+	DD 614242
+	DD 434334
+	DD 307121
+	DD 217167
+	DD 153560
+	DD 108584
+	DD 76780
+	DD 54292
+	DD 38390
+	DD 27146
+	DD 19195
+	DD 13573
+	DD 9598
+	DD 6786
+	DD 4799
+	DD 3393
+	DD 2399
+	DD 1697
+	DD 1200
+	DD 848
+	DD 600
+	DD 424
+	DD 300
+	DD 212
+	DD 150
+	DD 106
+
+TabB	DD 154
+	DD 218
+	DD 309
+	DD 437
+	DD 618
+	DD 874
+	DD 1236
+	DD 1748
+	DD 2472
+	DD 3496
+	DD 4944
+	DD 6992
+	DD 9888
+	DD 13983
+	DD 19775
+	DD 27967
+	DD 39551
+	DD 55933
+	DD 79101
+	DD 111866
+	DD 158203
+	DD 223732
+	DD 316405
+	DD 447465
+	DD 632811
+	DD 894929
+	DD 1265621
+	DD 1789859
+	DD 2531243
+	DD 3579718
+	DD 5062486
+	DD 7159436
+	DD 10124971
+
+	CODESEG
+
+;***********************************************************************************************
+;* Square_Root -- Finds the square root of the fixed pointer parameter.                        *
+;*                                                                                             *
+;* INPUT:   val   -- The fixed point (16:16) value to find the square root of.                 *
+;*                                                                                             *
+;* OUTPUT:  Returns with the square root of the fixed pointer parameter.                       *
+;*                                                                                             *
+;* WARNINGS:   none                                                                            *
+;*                                                                                             *
+;* HISTORY:                                                                                    *
+;*   10/04/1995 JLB : Adapted.                                                                 *
+;*=============================================================================================*/
+;unsigned Square_Root(unsigned val);
+	GLOBAL	C Square_Root :NEAR
+	PROC	Square_Root C near
+	USES	ebx,edx
+
+	bsr ebx,eax
+	jz ??zero
+
+	mul [DWORD 4*ebx + OFFSET TabA]
+	shrd eax,edx,10h
+	add eax, [4*ebx + OFFSET TabB]
+??zero:
+	ret
+
+	ENDP	Square_Root
+
+;----------------------------------------------------------------------------
+
+	END
+

REDALERT/ABSTRACT.CPP

+//
+// Copyright 2020 Electronic Arts Inc.
+//
+// TiberianDawn.DLL and RedAlert.dll and corresponding source code is free 
+// software: you can redistribute it and/or modify it under the terms of 
+// the GNU General Public License as published by the Free Software Foundation, 
+// either version 3 of the License, or (at your option) any later version.
+
+// TiberianDawn.DLL and RedAlert.dll and corresponding source code is distributed 
+// in the hope that it will be useful, but with permitted additional restrictions 
+// under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT 
+// distributed with this program. You should have received a copy of the 
+// GNU General Public License along with permitted additional restrictions 
+// with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection
+
+/* $Header: /CounterStrike/ABSTRACT.CPP 1     3/03/97 10:24a Joe_bostic $ */
+/***********************************************************************************************
+ ***              C O N F I D E N T I A L  ---  W E S T W O O D  S T U D I O S               ***
+ ***********************************************************************************************
+ *                                                                                             *
+ *                 Project Name : Command & Conquer                                            *
+ *                                                                                             *
+ *                    File Name : ABSTRACT.CPP                                                 *
+ *                                                                                             *
+ *                   Programmer : Joe L. Bostic                                                *
+ *                                                                                             *
+ *                   Start Date : 01/26/95                                                     *
+ *                                                                                             *
+ *                  Last Update : July 10, 1996 [JLB]                                          *
+ *                                                                                             *
+ *---------------------------------------------------------------------------------------------*
+ * Functions:                                                                                  *
+ *   AbstractClass::Debug_Dump -- Display debug information to mono screen.                    *
+ *   AbstractClass::Distance -- Determines distance to target.                                 *
+ *   AbstractTypeClass::AbstractTypeClass -- Constructor for abstract type objects.            *
+ *   AbstractTypeClass::Coord_Fixup -- Performs custom adjustments to location coordinate.     *
+ *   AbstractTypeClass::Full_Name -- Returns the full name (number) of this object type.       *
+ *   AbstractTypeClass::Get_Ownable -- Fetch the ownable bits for this object.                 *
+ * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+
+#include	"function.h"
+
+
+/***********************************************************************************************
+ * AbstractClass::Debug_Dump -- Display debug information to mono screen.                      *
+ *                                                                                             *
+ *    This debug only routine will display various information about this abstract class       *
+ *    object to the monochrome screen specified.                                               *
+ *                                                                                             *
+ * INPUT:   mono  -- Pointer to the monochrome screen to display the debug information to.     *
+ *                                                                                             *
+ * OUTPUT:  none                                                                               *
+ *                                                                                             *
+ * WARNINGS:   none                                                                            *
+ *                                                                                             *
+ * HISTORY:                                                                                    *
+ *   07/10/1996 JLB : Created.                                                                 *
+ *=============================================================================================*/
+#ifdef CHEAT_KEYS
+void AbstractClass::Debug_Dump(MonoClass * mono) const
+{
+	assert(IsActive);
+
+	mono->Set_Cursor(11, 5);mono->Printf("%08X", As_Target());
+	mono->Set_Cursor(20, 1);mono->Printf("%08X", Coord);
+	mono->Set_Cursor(29, 1);mono->Printf("%3d", Height);
+	if (Owner() != HOUSE_NONE) {
+		mono->Set_Cursor(1, 3);
+		mono->Printf("%-18s", Text_String(HouseTypeClass::As_Reference(Owner()).FullName));
+	}
+}
+#endif
+
+
+/***********************************************************************************************
+ * AbstractClass::Distance -- Determines distance to target.                                   *
+ *                                                                                             *
+ *    This will determine the distance (direct line) to the target. The distance is in         *
+ *    'leptons'. This routine is typically used for weapon range checks.                       *
+ *                                                                                             *
+ * INPUT:   target   -- The target to determine range to.                                      *
+ *                                                                                             *
+ * OUTPUT:  Returns with the range to the specified target (in leptons).                       *
+ *                                                                                             *
+ * WARNINGS:   none                                                                            *
+ *                                                                                             *
+ * HISTORY:                                                                                    *
+ *   08/17/1994 JLB : Created.                                                                 *
+ *=============================================================================================*/
+int AbstractClass::Distance(TARGET target) const
+{
+	/*
+	**	Should subtract a fudge-factor distance for building targets.
+	*/
+	BuildingClass * obj = As_Building(target);
+	int dist = Distance(As_Coord(target));
+
+	/*
+	** If the object is a building the adjust it by the average radius
+	** of the object.
+	*/
+	if (obj && obj->IsActive) {
+		dist -= ((obj->Class->Width() + obj->Class->Height()) * (0x100 / 4));
+		if (dist < 0) dist = 0;
+	}
+
+	/*
+	** Return the distance to the target
+	*/
+	return(dist);
+}
+
+
+/***********************************************************************************************
+ * AbstractTypeClass::AbstractTypeClass -- Constructor for abstract type objects.              *
+ *                                                                                             *
+ *    This is the constructor for AbstractTypeClass objects. It initializes the INI name and   *
+ *    the text name for this object type.                                                      *
+ *                                                                                             *
+ * INPUT:   name  -- Text number for the full name of the object.                              *
+ *                                                                                             *
+ *          ini   -- The ini name for this object type.                                        *
+ *                                                                                             *
+ * OUTPUT:  none                                                                               *
+ *                                                                                             *
+ * WARNINGS:   none                                                                            *
+ *                                                                                             *
+ * HISTORY:                                                                                    *
+ *   05/22/1995 JLB : Created.                                                                 *
+ *=============================================================================================*/
+AbstractTypeClass::AbstractTypeClass(RTTIType rtti, int id, int name, char const * ini) :
+	RTTI(rtti),
+	ID(id),
+	FullName(name)
+{
+	strncpy((char *)IniName, ini, sizeof(IniName));
+	((char &)IniName[sizeof(IniName)-1]) = '\0';
+}
+
+
+/***********************************************************************************************
+ * AbstractTypeClass::Coord_Fixup -- Performs custom adjustments to location coordinate.       *
+ *                                                                                             *
+ *    This routine is called when the placement coordinate should be fixed up according        *
+ *    to any special rules specific to this object type. At this level, no transformation      *
+ *    occurs. Derived classes will transform the coordinate as necessary.                      *
+ *                                                                                             *
+ * INPUT:   coord -- The proposed coordinate that this object type will be placed down at.     *
+ *                                                                                             *
+ * OUTPUT:  Returns with the adjusted coordinate that the object should be placed down at.     *
+ *                                                                                             *
+ * WARNINGS:   none                                                                            *
+ *                                                                                             *
+ * HISTORY:                                                                                    *
+ *   09/21/1995 JLB : Created.                                                                 *
+ *=============================================================================================*/
+COORDINATE AbstractTypeClass::Coord_Fixup(COORDINATE coord) const
+{
+	return(coord);
+}
+
+
+/***********************************************************************************************
+ * AbstractTypeClass::Full_Name -- Returns the full name (number) of this object type.         *
+ *                                                                                             *
+ *    This routine is used to fetch the full name of this object type. The name value          *
+ *    returned is actually the index number into the text array.                               *
+ *                                                                                             *
+ * INPUT:   none                                                                               *
+ *                                                                                             *
+ * OUTPUT:  Returns with the full name index number for this object type.                      *
+ *                                                                                             *
+ * WARNINGS:   none                                                                            *
+ *                                                                                             *
+ * HISTORY:                                                                                    *
+ *   09/21/1995 JLB : Created.                                                                 *
+ *=============================================================================================*/
+int AbstractTypeClass::Full_Name(void) const
+{
+#ifdef FIXIT_NAME_OVERRIDE
+	for (int index = 0; index < ARRAY_SIZE(NameOverride); index++) {
+		if (NameIDOverride[index] == ((RTTI+1) * 100) + ID)  {
+			return(-(index+1));
+		}
+	}
+#endif
+	return(FullName);
+}
+
+
+/***********************************************************************************************
+ * AbstractTypeClass::Get_Ownable -- Fetch the ownable bits for this object.                   *
+ *                                                                                             *
+ *    This returns a bit flag that indicates which houses are allowed to own this object       *
+ *    type. At this level, all houses have ownership rights. This routine will be overridden   *
+ *    by object types that restrict ownership.                                                 *
+ *                                                                                             *
+ * INPUT:   none                                                                               *
+ *                                                                                             *
+ * OUTPUT:  Returns with a bit flag indicating which houses have ownership rights.             *
+ *                                                                                             *
+ * WARNINGS:   none                                                                            *
+ *                                                                                             *
+ * HISTORY:                                                                                    *
+ *   09/21/1995 JLB : Created.                                                                 *
+ *=============================================================================================*/
+int AbstractTypeClass::Get_Ownable(void) const
+{
+	return(HOUSEF_ALLIES | HOUSEF_SOVIET | HOUSEF_OTHERS);
+}
+
+
+

REDALERT/ABSTRACT.H

+//
+// Copyright 2020 Electronic Arts Inc.
+//
+// TiberianDawn.DLL and RedAlert.dll and corresponding source code is free 
+// software: you can redistribute it and/or modify it under the terms of 
+// the GNU General Public License as published by the Free Software Foundation, 
+// either version 3 of the License, or (at your option) any later version.
+
+// TiberianDawn.DLL and RedAlert.dll and corresponding source code is distributed 
+// in the hope that it will be useful, but with permitted additional restrictions 
+// under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT 
+// distributed with this program. You should have received a copy of the 
+// GNU General Public License along with permitted additional restrictions 
+// with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection
+
+/* $Header: /CounterStrike/ABSTRACT.H 1     3/03/97 10:24a Joe_bostic $ */
+/***********************************************************************************************
+ ***              C O N F I D E N T I A L  ---  W E S T W O O D  S T U D I O S               ***
+ ***********************************************************************************************
+ *                                                                                             *
+ *                 Project Name : Command & Conquer                                            *
+ *                                                                                             *
+ *                    File Name : ABSTRACT.H                                                   *
+ *                                                                                             *
+ *                   Programmer : Joe L. Bostic                                                *
+ *                                                                                             *
+ *                   Start Date : 01/26/95                                                     *
+ *                                                                                             *
+ *                  Last Update : January 26, 1995 [JLB]                                       *
+ *                                                                                             *
+ *---------------------------------------------------------------------------------------------*
+ * Functions:                                                                                  *
+ * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+
+#ifndef ABSTRACT_H
+#define ABSTRACT_H
+
+DirType Direction(CELL cell1, CELL cell2);
+DirType Direction(COORDINATE coord1, COORDINATE coord2);
+int Distance(COORDINATE coord1, COORDINATE coord2);
+COORDINATE As_Coord(TARGET target);
+
+class AbstractTypeClass;
+
+/*
+**	This class is the base class for all game objects that have an existence on the
+**	battlefield.
+*/
+class AbstractClass
+{
+	public:
+
+		/*
+		**	This specifies the type of object and the unique ID number
+		**	associated with it. The ID number happens to match the index into
+		**	the object heap appropriate for this object type.
+		*/
+		RTTIType RTTI;
+		int ID;
+
+		/*
+		**	The coordinate location of the unit. For vehicles, this is the center
+		**	point. For buildings, it is the upper left corner.
+		*/
+		COORDINATE Coord;
+
+		/*
+		**	This is the height of the object above ground (expressed in leptons).
+		*/
+		int Height;
+
+		/*
+		**	The actual object ram-space is located in arrays in the data segment. This flag
+		**	is used to indicate which objects are free to be reused and which are currently
+		**	in use by the game.
+		*/
+		unsigned IsActive:1;
+
+		/*
+		** A flag to indicate that this object was recently created. Since an object's allocation is just a matter of whether
+		** the IsActive flag is set, during a logic frame an object with a given ID could be 'deleted' then reallocated 
+		** as a different type of object in a different location. This flag lets us know that this happened. ST - 8/19/2019 5:33PM
+		*/
+		unsigned IsRecentlyCreated:1;
+
+		/*-----------------------------------------------------------------------------------
+		**	Constructor & destructors.
+		*/
+		AbstractClass(RTTIType rtti, int id) : RTTI(rtti), ID(id), Coord(0xFFFFFFFFL), Height(0) {};
+		AbstractClass(NoInitClass const & x) {x();};
+		virtual ~AbstractClass(void) {};
+
+		/*
+		**	Query functions.
+		*/
+		virtual char const * Name(void) const {return("");}
+		virtual HousesType Owner(void) const {return HOUSE_NONE;};
+		TARGET As_Target(void) const {return(Build_Target(RTTI, ID));};
+		RTTIType What_Am_I(void) const {return(RTTI);};
+
+		/*
+		**	Scenario and debug support.
+		*/
+		#ifdef CHEAT_KEYS
+		virtual void Debug_Dump(MonoClass * mono) const;
+		#endif
+
+		/*
+		**	Coordinate query support functions.
+		*/
+		virtual COORDINATE Center_Coord(void) const {return Coord;};
+		virtual COORDINATE Target_Coord(void) const {return Coord;};
+
+		/*
+		**	Coordinate inquiry functions. These are used for both display and
+		**	combat purposes.
+		*/
+		DirType Direction(AbstractClass const * object) const {return ::Direction(Center_Coord(), object->Target_Coord());};
+		DirType Direction(COORDINATE coord) const {return ::Direction(Center_Coord(), coord);};
+		DirType Direction(TARGET target) const {return ::Direction(Center_Coord(), As_Coord(target));};
+		DirType Direction(CELL cell) const {return ::Direction(Coord_Cell(Center_Coord()), cell);};
+		int Distance(TARGET target) const;
+		int Distance(COORDINATE coord) const {return ::Distance(Center_Coord(), coord);};
+		int Distance(AbstractClass const * object) const {return ::Distance(Center_Coord(), object->Target_Coord());};
+
+		/*
+		**	Object entry and exit from the game system.
+		*/
+		virtual MoveType Can_Enter_Cell(CELL , FacingType = FACING_NONE) const {return MOVE_OK;};
+
+		/*
+		**	AI.
+		*/
+		virtual void AI(void) {};
+
+		/*
+		** Set the new recently created flag every time the active flag is set. ST - 8/19/2019 5:41PM
+		*/
+		void Set_Active(void) {IsActive = true; IsRecentlyCreated = true;}
+
+};
+
+
+#endif
\ No newline at end of file

REDALERT/ADPCM.CPP

+//
+// Copyright 2020 Electronic Arts Inc.
+//
+// TiberianDawn.DLL and RedAlert.dll and corresponding source code is free 
+// software: you can redistribute it and/or modify it under the terms of 
+// the GNU General Public License as published by the Free Software Foundation, 
+// either version 3 of the License, or (at your option) any later version.
+
+// TiberianDawn.DLL and RedAlert.dll and corresponding source code is distributed 
+// in the hope that it will be useful, but with permitted additional restrictions 
+// under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT 
+// distributed with this program. You should have received a copy of the 
+// GNU General Public License along with permitted additional restrictions 
+// with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection
+
+#include "function.h"
+
+extern "C" {
+#include "soscomp.h"
+#include "itable.cpp"
+#include "dtable.cpp"
+
+
+void sosCODECInitStream(_SOS_COMPRESS_INFO* info)
+{
+	info->dwSampleIndex = 0;
+	info->dwPredicted = 0;
+}
+
+
+unsigned long sosCODECDecompressData(_SOS_COMPRESS_INFO* info, unsigned long numbytes)
+{
+	unsigned long token;
+	long sample;
+	unsigned int fastindex;
+	unsigned char *inbuff;
+	unsigned short *outbuff;
+
+	inbuff = (unsigned char *)info->lpSource;
+	outbuff = (unsigned short *)info->lpDest;
+
+	// Preload variables before the big loop
+	fastindex = (unsigned int)info->dwSampleIndex;
+	sample = info->dwPredicted;
+
+	if (!numbytes)
+		goto SkipLoop;
+
+	do {
+		// First nibble
+		token = *inbuff++;
+		fastindex += token & 0x0f;
+		sample += DiffTable[fastindex];
+		fastindex = IndexTable[fastindex];
+		if (sample > 32767L)
+			sample = 32767L;
+		if (sample < -32768L)
+			sample = -32768L;
+		*outbuff++ = (unsigned short)sample;
+
+		// Second nibble
+		fastindex += token >> 4;
+		sample += DiffTable[fastindex];
+		fastindex = IndexTable[fastindex];
+		if (sample > 32767L)
+			sample = 32767L;
+		if (sample < -32768L)
+			sample = -32768L;
+		*outbuff++ = (unsigned short)sample;
+	} while(--numbytes);
+
+SkipLoop:
+
+	// Put local vars back
+	info->dwSampleIndex = (unsigned long)fastindex;
+	info->dwPredicted = sample;
+	return(numbytes << 2);
+}
+
+}

REDALERT/AIRCRAFT.H

+//
+// Copyright 2020 Electronic Arts Inc.
+//
+// TiberianDawn.DLL and RedAlert.dll and corresponding source code is free 
+// software: you can redistribute it and/or modify it under the terms of 
+// the GNU General Public License as published by the Free Software Foundation, 
+// either version 3 of the License, or (at your option) any later version.
+
+// TiberianDawn.DLL and RedAlert.dll and corresponding source code is distributed 
+// in the hope that it will be useful, but with permitted additional restrictions 
+// under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT 
+// distributed with this program. You should have received a copy of the 
+// GNU General Public License along with permitted additional restrictions 
+// with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection
+
+/* $Header: /CounterStrike/AIRCRAFT.H 1     3/03/97 10:24a Joe_bostic $ */
+/***********************************************************************************************
+ ***              C O N F I D E N T I A L  ---  W E S T W O O D  S T U D I O S               ***
+ ***********************************************************************************************
+ *                                                                                             *
+ *                 Project Name : Command & Conquer                                            *
+ *                                                                                             *
+ *                    File Name : AIRCRAFT.H                                                   *
+ *                                                                                             *
+ *                   Programmer : Joe L. Bostic                                                *
+ *                                                                                             *
+ *                   Start Date : July 22, 1994                                                *
+ *                                                                                             *
+ *                  Last Update : November 28, 1994 [JLB]                                      *
+ *                                                                                             *
+ *---------------------------------------------------------------------------------------------*
+ * Functions:                                                                                  *
+ * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+
+#ifndef AIRCRAFT_H
+#define AIRCRAFT_H
+
+#include	"radio.h"
+#include	"fly.h"
+#include	"target.h"
+
+
+/*
+**	This aircraft class is used for all flying sentient objects. This includes fixed wing
+**	aircraft as well as helicopters. It excludes bullets even though some bullets might
+**	be considered to be "flying" in a loose interpretatin of the word.
+*/
+class AircraftClass : public FootClass, public FlyClass
+{
+	public:
+		/*
+		**	This is a pointer to the class control structure for the aircraft.
+		*/
+		CCPtr<AircraftTypeClass> Class;
+
+		//-----------------------------------------------------------------------------
+		static void * operator new(size_t);
+		static void * operator new(size_t, void * ptr) {return(ptr);};
+		static void operator delete(void *);
+		operator AircraftType(void) const {return Class->Type;};
+		AircraftClass(AircraftType classid, HousesType house);
+		AircraftClass(NoInitClass const & x) : FootClass(x), FlyClass(x), Class(x), SecondaryFacing(x), SightTimer(x) {};
+		virtual ~AircraftClass(void);
+
+		static void Init(void);
+
+		virtual int Mission_Attack(void);
+		virtual int Mission_Unload(void);
+		virtual int Mission_Hunt(void);
+		virtual int Mission_Retreat(void);
+		virtual int Mission_Move(void);
+		virtual int Mission_Enter(void);
+		virtual int Mission_Guard(void);
+		virtual int Mission_Guard_Area(void);
+
+		virtual void Assign_Destination(TARGET target);
+		/*
+		**	State machine support routines.
+		*/
+		bool Process_Take_Off(void);
+		bool Process_Landing(void);
+		int Process_Fly_To(bool slowdown, TARGET dest);
+
+		/*
+		**	Query functions.
+		*/
+		virtual LayerType In_Which_Layer(void) const;
+		virtual DirType Turret_Facing(void) const {return(SecondaryFacing.Current());}
+		int Shape_Number(void) const;
+		virtual MoveType Can_Enter_Cell(CELL cell, FacingType facing=FACING_NONE) const;
+		virtual ObjectTypeClass const & Class_Of(void) const {return *Class;};
+		virtual ActionType What_Action(ObjectClass const * target) const;
+		virtual ActionType What_Action(CELL cell) const;
+		virtual DirType Desired_Load_Dir(ObjectClass * passenger, CELL & moveto) const;
+		virtual int Pip_Count(void) const;
+		TARGET Good_Fire_Location(TARGET target) const;
+		bool Cell_Seems_Ok(CELL cell, bool landing=false) const;
+		DirType Pose_Dir(void) const;
+		TARGET Good_LZ(void) const;
+		virtual DirType Fire_Direction(void) const;
+		virtual FireErrorType Can_Fire(TARGET target, int which) const;
+
+		/*
+		**	Landing zone support functionality.
+		*/
+		virtual void Per_Cell_Process(PCPType why);
+		bool Is_LZ_Clear(TARGET target) const;
+		TARGET New_LZ(TARGET oldlz) const;
+
+		/*
+		**	Coordinate inquiry functions. These are used for both display and
+		**	combat purposes.
+		*/
+		virtual COORDINATE Sort_Y(void) const;
+
+		/*
+		**	Object entry and exit from the game system.
+		*/
+		virtual bool Unlimbo(COORDINATE , DirType facing = DIR_N);
+
+		/*
+		**	Display and rendering support functionality. Supports imagery and how
+		**	object interacts with the map and thus indirectly controls rendering.
+		*/
+		virtual void Look(bool incremental=false);
+		void Draw_Rotors(int x, int y, WindowNumberType window) const;
+		virtual int Exit_Object(TechnoClass *);
+		virtual short const * Overlap_List(bool redraw=false) const;
+		virtual void Draw_It(int x, int y, WindowNumberType window) const;
+		virtual void Set_Speed(int speed);
+
+		/*
+		**	User I/O.
+		*/
+		virtual void Active_Click_With(ActionType action, ObjectClass * object);
+		virtual void Active_Click_With(ActionType action, CELL cell);
+		virtual void Player_Assign_Mission(MissionType mission, TARGET target=TARGET_NONE, TARGET destination=TARGET_NONE);
+		virtual void Response_Select(void);
+		virtual void Response_Move(void);
+		virtual void Response_Attack(void);
+
+		/*
+		**	Combat related.
+		*/
+		virtual ResultType Take_Damage(int & damage, int distance, WarheadType warhead, TechnoClass * source, bool forced=false);
+		virtual BulletClass * Fire_At(TARGET target, int which);
+
+		/*
+		**	AI.
+		*/
+		bool Landing_Takeoff_AI(void);
+		bool Edge_Of_World_AI(void);
+		void Movement_AI(void);
+		void Rotation_AI(void);
+		int Paradrop_Cargo(void);
+		virtual void AI(void);
+		virtual void Enter_Idle_Mode(bool initial = false);
+		virtual RadioMessageType Receive_Message(RadioClass * from, RadioMessageType message, long & param);
+		virtual void Scatter(COORDINATE threat, bool forced=false, bool nokidding=false);
+
+		/*
+		**	Scenario and debug support.
+		*/
+		#ifdef CHEAT_KEYS
+		virtual void Debug_Dump(MonoClass *mono) const;
+		#endif
+
+		/*
+		**	File I/O.
+		*/
+		static void Read_INI(CCINIClass & ini);
+		static char * INI_Name(void) {return "AIRCRAFT";};
+		bool Load(Straw & file);
+		bool Save(Pipe & file) const;
+
+		virtual unsigned Spied_By() const;
+
+	public:
+
+		/*
+		**	This is the facing used for the body of the aircraft. Typically, this is the same
+		**	as the PrimaryFacing, but in the case of helicopters, it can be different.
+		*/
+		FacingClass SecondaryFacing;
+
+		/*
+		**	If this is a passenger carrying aircraft then this flag will be set. This is
+		**	necessary because once the passengers are unloaded, the fact that it was a
+		**	passenger carrier must still be known.
+		*/
+		bool Passenger;
+
+	private:
+
+		/*
+		**	Aircraft can be in either state of landing, taking off, or in steady altitude.
+		**	These flags are used to control transition between flying and landing. It is
+		**	necessary to handle the transition in this manner so that it occurs smoothly
+		**	during the graphic processing section.
+		*/
+		unsigned IsLanding:1;
+		unsigned IsTakingOff:1;
+
+		/*
+		**	It is very common for aircraft to be homing in on a target. When this flag is
+		**	true, the aircraft will constantly adjust its facing toward the TarCom. When the
+		**	target is very close (one cell away or less), then this flag is automatically cleared.
+		**	This is because the homing algorithm is designed to get the aircraft to the destination
+		**	but no more. Checking when this flag is cleared is a way of flagging transition into
+		**	a new mode. Example: Transport helicopters go into a hovering into correct position
+		**	mode when the target is reached.
+		*/
+		unsigned IsHoming:1;
+
+		/*
+		**	Helicopters that are about to land must hover into a position exactly above the landing
+		**	zone. When this flag is true, the aircraft will be adjusted so that it is exactly over
+		**	the TarCom. The facing of the aircraft is not altered by this movement. The affect
+		**	like the helicopter is hovering and shifting sideways to position over the landing
+		**	zone. When the position is over the landing zone, then this flag is set to false.
+		*/
+		unsigned IsHovering:1;
+
+		/*
+		**	This is the jitter tracker to be used when the aircraft is a helicopter and
+		**	is flying. It is most noticeable when the helicopter is hovering.
+		*/
+		unsigned char Jitter;
+
+	private:
+
+		/*
+		**	This timer controls when the aircraft will reveal the terrain around itself.
+		**	When this timer expires and this aircraft has a sight range, then the
+		**	look around process will occur.
+		*/
+		CDTimerClass<FrameTimerClass> SightTimer;
+
+		/*
+		**	Most attack aircraft can make several attack runs. This value contains the
+		**	number of attack runs the aircraft has left. When this value reaches
+		**	zero then the aircraft is technically out of ammo.
+		*/
+		char AttacksRemaining;
+
+		/*
+		** Some additional padding in case we need to add data to the class and maintain backwards compatibility for save/load
+		*/
+		unsigned char SaveLoadPadding[32];
+};
+
+#endif
\ No newline at end of file

REDALERT/ANIM.H

+//
+// Copyright 2020 Electronic Arts Inc.
+//
+// TiberianDawn.DLL and RedAlert.dll and corresponding source code is free 
+// software: you can redistribute it and/or modify it under the terms of 
+// the GNU General Public License as published by the Free Software Foundation, 
+// either version 3 of the License, or (at your option) any later version.
+
+// TiberianDawn.DLL and RedAlert.dll and corresponding source code is distributed 
+// in the hope that it will be useful, but with permitted additional restrictions 
+// under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT 
+// distributed with this program. You should have received a copy of the 
+// GNU General Public License along with permitted additional restrictions 
+// with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection
+
+/* $Header: /CounterStrike/ANIM.H 1     3/03/97 10:24a Joe_bostic $ */
+/***********************************************************************************************
+ ***              C O N F I D E N T I A L  ---  W E S T W O O D  S T U D I O S               ***
+ ***********************************************************************************************
+ *                                                                                             *
+ *                 Project Name : Command & Conquer                                            *
+ *                                                                                             *
+ *                    File Name : ANIM.H                                                       *
+ *                                                                                             *
+ *                   Programmer : Joe L. Bostic                                                *
+ *                                                                                             *
+ *                   Start Date : May 30, 1994                                                 *
+ *                                                                                             *
+ *                  Last Update : May 30, 1994   [JLB]                                         *
+ *                                                                                             *
+ *---------------------------------------------------------------------------------------------*
+ * Functions:                                                                                  *
+ * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+
+#ifndef ANIM_H
+#define ANIM_H
+
+#include	"type.h"
+
+
+/**********************************************************************************************
+**	This is the class that controls the shape animation objects. Shape animation objects are
+**	displayed over the top of the game map. Typically, they are used for explosion and fire
+**	effects.
+*/
+class AnimClass : public ObjectClass, public StageClass {
+		/*
+		**	This points to the type of animation object this is.
+		*/
+		CCPtr<AnimTypeClass> Class;
+
+	public:
+
+		AnimClass(AnimType animnum, COORDINATE coord, unsigned char timedelay=0, unsigned char loop=1);
+		AnimClass(NoInitClass const & x) : ObjectClass(x), Class(x), StageClass(x) {};
+		virtual ~AnimClass(void);
+
+		operator AnimType(void) const {return Class->Type;};
+
+		static void * operator new(size_t size);
+		static void * operator new(size_t , void * ptr) {return(ptr);};
+		static void operator delete(void *ptr);
+
+		/*---------------------------------------------------------------------
+		**	Member function prototypes.
+		*/
+		static void Init(void);
+
+		void Attach_To(ObjectClass *obj);
+		void Sort_Above(TARGET target);
+		void Make_Invisible(void) {IsInvisible = true;};
+		void Make_Visible(void) {IsInvisible = false;};
+		static void Do_Atom_Damage(HousesType ownerhouse, CELL cell);
+
+		/*
+		** 2019/09/19 JAS
+		** Added functions for accessing which players can see this anim
+		*/
+		void Set_Visible_Flags(unsigned flags) { VisibleFlags = flags; }
+		unsigned Get_Visible_Flags() const { return (Delay == 0) ? VisibleFlags : 0; }
+
+		virtual bool Can_Place_Here(COORDINATE ) const {return true;}
+		virtual bool Mark(MarkType mark=MARK_CHANGE);
+		virtual bool Render(bool forced) const;
+		virtual COORDINATE Center_Coord(void) const;
+		virtual COORDINATE Sort_Y(void) const;
+		virtual LayerType In_Which_Layer(void) const;
+		virtual ObjectTypeClass const & Class_Of(void) const {return *Class;};
+		virtual short const * Occupy_List(bool = false) const;
+		virtual short const * Overlap_List(void) const;
+		virtual void Draw_It(int x, int y, WindowNumberType window) const;
+		virtual void AI(void);
+		virtual void Detach(TARGET target, bool all);
+
+		/*
+		**	File I/O.
+		*/
+		bool Load(Straw & file);
+		bool Save(FileClass & file);
+
+		/*
+		**	If this animation is attached to an object, then this points to that object. An
+		**	animation that is attached will follow that object as it moves. This is important
+		**	for animations such as flames and smoke.
+		*/
+		TARGET xObject;
+
+		/*
+		**	If specified, this animation uses the sort target for Y sorting
+		*/
+		TARGET SortTarget;
+
+		/*
+		**	If this animation has an owner, then it will be recorded here. An owner
+		**	is used when damage is caused by this animation during the middle of its
+		**	animation.
+		*/
+		HousesType OwnerHouse;
+
+		/*
+		**	This counter tells how many more times the animation should loop before it
+		**	terminates.
+		*/
+		unsigned char Loops;
+
+	protected:
+		void Middle(void);
+		void Start(void);
+		void Chain(void);
+
+	private:
+		/*
+		**	Delete this animation at the next opportunity. This is flagged when the
+		**	animation is to be prematurely ended as a result of some outside event.
+		*/
+		unsigned IsToDelete:1;
+
+		/*
+		**	If the animation has just been created, then don't do any animation
+		**	processing until it has been through the render loop at least once.
+		*/
+		unsigned IsBrandNew:1;
+
+		/*
+		**	If this animation is invisible, then this flag will be true. An invisible
+		**	animation is one that is created for the sole purpose of keeping all
+		**	machines synchronized. It will not be displayed.
+		*/
+		unsigned IsInvisible:1;
+
+		/*
+		** 2019/09/19 JAS
+		** Flags storing which players can see this anim.
+		*/
+		unsigned VisibleFlags;
+
+		/*
+		**	Is this animation in a temporary suspended state?  If so, then it won't
+		**	be rendered until this value is zero. The flag will be set to false
+		**	after the first countdown timer reaches 0.
+		*/
+		int Delay;
+
+		/*
+		**	If this is an animation that damages whatever it is attached to, then this
+		**	value holds the accumulation of fractional damage points. When the accumulated
+		**	fractions reach 256, then one damage point is applied to the attached object.
+		*/
+		fixed Accum;
+
+		/*
+		**	The map layer this animation is in when attached to an object.
+		*/
+		LayerType AttachLayer;
+
+		/*
+		**	This references the virtual animation.
+		*/
+		TARGET VirtualAnimTarget;
+
+		/*
+		** Some additional padding in case we need to add data to the class and maintain backwards compatibility for save/load
+		*/
+		unsigned char SaveLoadPadding[32];
+};
+
+
+
+#endif
\ No newline at end of file

REDALERT/AUDIO.H

+//
+// Copyright 2020 Electronic Arts Inc.
+//
+// TiberianDawn.DLL and RedAlert.dll and corresponding source code is free 
+// software: you can redistribute it and/or modify it under the terms of 
+// the GNU General Public License as published by the Free Software Foundation, 
+// either version 3 of the License, or (at your option) any later version.
+
+// TiberianDawn.DLL and RedAlert.dll and corresponding source code is distributed 
+// in the hope that it will be useful, but with permitted additional restrictions 
+// under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT 
+// distributed with this program. You should have received a copy of the 
+// GNU General Public License along with permitted additional restrictions 
+// with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection
+
+/* $Header:   F:\projects\c&c0\vcs\code\audio.h_v   4.43   05 Jul 1996 17:58:10   JOE_BOSTIC  $ */
+/***********************************************************************************************
+ ***              C O N F I D E N T I A L  ---  W E S T W O O D  S T U D I O S               *** 
+ ***********************************************************************************************
+ *                                                                                             *
+ *                 Project Name : Command & Conquer                                            *
+ *                                                                                             *
+ *                    File Name : AUDIO.H                                                      *
+ *                                                                                             *
+ *                   Programmer : Joe L. Bostic                                                *
+ *                                                                                             *
+ *                   Start Date : June 21, 1994                                                *
+ *                                                                                             *
+ *                  Last Update : June 21, 1994   [JLB]                                        *
+ *                                                                                             *
+ *---------------------------------------------------------------------------------------------*
+ * Functions:                                                                                  *
+ * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+
+#ifndef AUDIO_H
+#define AUDIO_H
+
+#include	"memory.h"
+
+class AudioClass {
+		char const * Name;	// Name of audio asset.
+		void const * Data;	// Loaded audio data.
+		int Handle;				// Handle of asset (as it is playing).
+		MemoryClass *Mem;		// Pointer to memory handler class.
+		unsigned IsMIDI:1;	// Is this a midi file?
+
+	public:
+		AudioClass(void);
+		AudioClass(char const *name, MemoryClass &mem);
+		virtual ~AudioClass(void);
+
+		bool Load(char const *name = 0);
+		bool Free(void);
+		bool Play(int volume = 0xFF);
+		bool Stop(void);
+		bool Pause(void);
+		bool Resume(void);
+		bool Set_Name(char const *name);
+		bool Is_Playing(void) const;
+		bool Is_Loaded(void) const;
+		bool Is_MIDI(void) const;
+};
+
+inline AudioClass::AudioClass(void)
+{
+	Name = 0; 
+	Data = 0; 
+	Mem = 0;
+	Handle = -1;
+};
+
+inline AudioClass::AudioClass(char const *name, MemoryClass &mem) 
+{
+	if (mem) {
+		Mem = &mem;
+	} else {
+		Mem = &::Mem;		// Uses global default memory handler.
+	}
+	Name = strdup(name);
+	Data = 0;
+	Handle = -1;
+};
+
+inline AudioClass::~AudioClass(void)
+{
+	if (GameActive) {
+		if (Name) free(Name);
+		if (Data) Mem->Free(Data);
+		Name = 0;
+		Data = 0;
+		Handle = -1;
+	}
+};
+
+
+#endif

REDALERT/B64PIPE.CPP

+//
+// Copyright 2020 Electronic Arts Inc.
+//
+// TiberianDawn.DLL and RedAlert.dll and corresponding source code is free 
+// software: you can redistribute it and/or modify it under the terms of 
+// the GNU General Public License as published by the Free Software Foundation, 
+// either version 3 of the License, or (at your option) any later version.
+
+// TiberianDawn.DLL and RedAlert.dll and corresponding source code is distributed 
+// in the hope that it will be useful, but with permitted additional restrictions 
+// under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT 
+// distributed with this program. You should have received a copy of the 
+// GNU General Public License along with permitted additional restrictions 
+// with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection
+
+/* $Header: /CounterStrike/B64PIPE.CPP 1     3/03/97 10:24a Joe_bostic $ */
+/***********************************************************************************************
+ ***              C O N F I D E N T I A L  ---  W E S T W O O D  S T U D I O S               ***
+ ***********************************************************************************************
+ *                                                                                             *
+ *                 Project Name : Command & Conquer                                            *
+ *                                                                                             *
+ *                    File Name : B64PIPE.CPP                                                  *
+ *                                                                                             *
+ *                   Programmer : Joe L. Bostic                                                *
+ *                                                                                             *
+ *                   Start Date : 06/30/96                                                     *
+ *                                                                                             *
+ *                  Last Update : July 3, 1996 [JLB]                                           *
+ *                                                                                             *
+ *---------------------------------------------------------------------------------------------*
+ * Functions:                                                                                  *
+ *   Base64Pipe::Put -- Processes a block of data through the pipe.                            *
+ *   Base64Pipe::Flush -- Flushes the final pending data through the pipe.                     *
+ * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+
+
+#include "b64pipe.h"
+#include	"base64.h"
+#include	<string.h>
+
+
+/***********************************************************************************************
+ * Base64Pipe::Put -- Processes a block of data through the pipe.                              *
+ *                                                                                             *
+ *    This will take the data submitted and either Base64 encode or decode it (as specified    *
+ *    in the pipe's constructor). The nature of Base64 encoding means that the data will       *
+ *    grow 30% in size when encoding and decrease by a like amount when decoding.              *
+ *                                                                                             *
+ * INPUT:   source   -- Pointer to the data to be translated.                                  *
+ *                                                                                             *
+ *          length   -- The number of bytes to translate.                                      *
+ *                                                                                             *
+ * OUTPUT:  Returns with the actual number of bytes output at the far distant final end of     *
+ *          the pipe chain.                                                                    *
+ *                                                                                             *
+ * WARNINGS:   none                                                                            *
+ *                                                                                             *
+ * HISTORY:                                                                                    *
+ *   07/03/1996 JLB : Created.                                                                 *
+ *=============================================================================================*/
+int Base64Pipe::Put(void const * source, int slen)
+{
+	if (source == NULL || slen < 1) {
+		return(Pipe::Put(source, slen));
+	}
+
+	int total = 0;
+
+	char * from;
+	int fromsize;
+	char * to;
+	int tosize;
+
+	if (Control == ENCODE) {
+		from = PBuffer;
+		fromsize = sizeof(PBuffer);
+		to = CBuffer;
+		tosize = sizeof(CBuffer);
+	} else {
+		from = CBuffer;
+		fromsize = sizeof(CBuffer);
+		to = PBuffer;
+		tosize = sizeof(PBuffer);
+	}
+
+	if (Counter > 0) {
+		int len = (slen < (fromsize-Counter)) ? slen : (fromsize-Counter);
+		memmove(&from[Counter], source, len);
+		Counter += len;
+		slen -= len;
+		source = ((char *)source) + len;
+
+		if (Counter == fromsize) {
+			int outcount;
+			if (Control == ENCODE) {
+				outcount = Base64_Encode(from, fromsize, to, tosize);
+			} else {
+				outcount = Base64_Decode(from, fromsize, to, tosize);
+			}
+			total += Pipe::Put(to, outcount);
+			Counter = 0;
+		}
+	}
+
+	while (slen >= fromsize) {
+		int outcount;
+		if (Control == ENCODE) {
+			outcount = Base64_Encode(source, fromsize, to, tosize);
+		} else {
+			outcount = Base64_Decode(source, fromsize, to, tosize);
+		}
+		source = ((char *)source) + fromsize;
+		total += Pipe::Put(to, outcount);
+		slen -= fromsize;
+	}
+
+	if (slen > 0) {
+		memmove(from, source, slen);
+		Counter = slen;
+	}
+
+	return(total);
+}
+
+
+/***********************************************************************************************
+ * Base64Pipe::Flush -- Flushes the final pending data through the pipe.                       *
+ *                                                                                             *
+ *    If there is any non-processed data accumulated in the holding buffer (quite likely when  *
+ *    encoding), then it will be processed and flushed out the end of the pipe.                *
+ *                                                                                             *
+ * INPUT:   none                                                                               *
+ *                                                                                             *
+ * OUTPUT:  Returns with the number of bytes output at the far distant final end of the pipe   *
+ *          chain.                                                                             *
+ *                                                                                             *
+ * WARNINGS:   none                                                                            *
+ *                                                                                             *
+ * HISTORY:                                                                                    *
+ *   07/03/1996 JLB : Created.                                                                 *
+ *=============================================================================================*/
+int Base64Pipe::Flush(void)
+{
+	int len = 0;
+
+	if (Counter) {
+		if (Control == ENCODE) {
+			int chars = Base64_Encode(PBuffer, Counter, CBuffer, sizeof(CBuffer));
+			len += Pipe::Put(CBuffer, chars);
+		} else {
+			int chars = Base64_Decode(CBuffer, Counter, PBuffer, sizeof(PBuffer));
+			len += Pipe::Put(PBuffer, chars);
+		}
+		Counter = 0;
+	}
+	len += Pipe::Flush();
+	return(len);
+}
+
+
+

REDALERT/B64PIPE.H

+//
+// Copyright 2020 Electronic Arts Inc.
+//
+// TiberianDawn.DLL and RedAlert.dll and corresponding source code is free 
+// software: you can redistribute it and/or modify it under the terms of 
+// the GNU General Public License as published by the Free Software Foundation, 
+// either version 3 of the License, or (at your option) any later version.
+
+// TiberianDawn.DLL and RedAlert.dll and corresponding source code is distributed 
+// in the hope that it will be useful, but with permitted additional restrictions 
+// under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT 
+// distributed with this program. You should have received a copy of the 
+// GNU General Public License along with permitted additional restrictions 
+// with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection
+
+/* $Header: /CounterStrike/B64PIPE.H 1     3/03/97 10:24a Joe_bostic $ */
+/***********************************************************************************************
+ ***              C O N F I D E N T I A L  ---  W E S T W O O D  S T U D I O S               ***
+ ***********************************************************************************************
+ *                                                                                             *
+ *                 Project Name : Command & Conquer                                            *
+ *                                                                                             *
+ *                    File Name : B64PIPE.H                                                    *
+ *                                                                                             *
+ *                   Programmer : Joe L. Bostic                                                *
+ *                                                                                             *
+ *                   Start Date : 06/30/96                                                     *
+ *                                                                                             *
+ *                  Last Update : June 30, 1996 [JLB]                                          *
+ *                                                                                             *
+ *---------------------------------------------------------------------------------------------*
+ * Functions:                                                                                  *
+ * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+
+
+#ifndef B64PIPE_H
+#define B64PIPE_H
+
+#include	"pipe.h"
+
+/*
+**	This class performs Base64 encoding/decoding to the data that is piped through. Note that
+**	encoded data will grow in size by about 30%. The reverse occurs when decoding.
+*/
+class Base64Pipe : public Pipe
+{
+	public:
+		typedef enum CodeControl {
+			ENCODE,
+			DECODE
+		} CodeControl;
+
+		Base64Pipe(CodeControl control) : Control(control), Counter(0) {}
+
+		virtual int Flush(void);
+		virtual int Put(void const * source, int slen);
+
+	private:
+
+		/*
+		**	Indicates if this is for encoding or decoding of Base64 data.
+		*/
+		CodeControl Control;
+
+		/*
+		**	The counter of the number of accumulated bytes pending for processing.
+		*/
+		int Counter;
+
+		/*
+		**	Buffer that holds the Base64 coded bytes. This will be the staging buffer if
+		**	this is for a decoding process. Otherwise, it will be used as a scratch buffer.
+		*/
+		char CBuffer[4];
+
+		/*
+		**	Buffer that holds the plain bytes. This will be the staging buffer if this
+		**	is for an encoding process. Otherwise, it will be used as a scratch buffer.
+		*/
+		char PBuffer[3];
+
+		/*
+		**	Explicitly disable the copy constructor and the assignment operator.
+		*/
+		Base64Pipe(Base64Pipe & rvalue);
+		Base64Pipe & operator = (Base64Pipe const & pipe);
+};
+
+#endif

REDALERT/B64STRAW.CPP

+//
+// Copyright 2020 Electronic Arts Inc.
+//
+// TiberianDawn.DLL and RedAlert.dll and corresponding source code is free 
+// software: you can redistribute it and/or modify it under the terms of 
+// the GNU General Public License as published by the Free Software Foundation, 
+// either version 3 of the License, or (at your option) any later version.
+
+// TiberianDawn.DLL and RedAlert.dll and corresponding source code is distributed 
+// in the hope that it will be useful, but with permitted additional restrictions 
+// under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT 
+// distributed with this program. You should have received a copy of the 
+// GNU General Public License along with permitted additional restrictions 
+// with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection
+
+/* $Header: /CounterStrike/B64STRAW.CPP 1     3/03/97 10:24a Joe_bostic $ */
+/***********************************************************************************************
+ ***              C O N F I D E N T I A L  ---  W E S T W O O D  S T U D I O S               ***
+ ***********************************************************************************************
+ *                                                                                             *
+ *                 Project Name : Command & Conquer                                            *
+ *                                                                                             *
+ *                    File Name : B64STRAW.CPP                                                 *
+ *                                                                                             *
+ *                   Programmer : Joe L. Bostic                                                *
+ *                                                                                             *
+ *                   Start Date : 07/02/96                                                     *
+ *                                                                                             *
+ *                  Last Update : July 3, 1996 [JLB]                                           *
+ *                                                                                             *
+ *---------------------------------------------------------------------------------------------*
+ * Functions:                                                                                  *
+ *   Base64Straw::Get -- Fetch data and convert it to/from base 64 encoding.                   *
+ * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+
+
+#include	"b64straw.h"
+#include	"base64.h"
+#include	<string.h>
+
+
+/***********************************************************************************************
+ * Base64Straw::Get -- Fetch data and convert it to/from base 64 encoding.                     *
+ *                                                                                             *
+ *    This routine will fetch the number of bytes requested and perform any conversion as      *
+ *    necessary upon the data. The nature of Base 64 encoding means that the data will         *
+ *    increase in size by 30% when encoding and decrease in like manner when decoding.         *
+ *                                                                                             *
+ * INPUT:   source   -- The buffer to hold the processed data.                                 *
+ *                                                                                             *
+ *          length   -- The number of bytes requested.                                         *
+ *                                                                                             *
+ * OUTPUT:  Returns with the number of bytes stored into the buffer. If the number is less     *
+ *          than requested, then this indicates that the data stream has been exhausted.       *
+ *                                                                                             *
+ * WARNINGS:   none                                                                            *
+ *                                                                                             *
+ * HISTORY:                                                                                    *
+ *   07/03/1996 JLB : Created.                                                                 *
+ *=============================================================================================*/
+int Base64Straw::Get(void * source, int slen)
+{
+	int total = 0;
+
+	char * from;
+	int fromsize;
+	char * to;
+	int tosize;
+
+	if (Control == ENCODE) {
+		from = PBuffer;
+		fromsize = sizeof(PBuffer);
+		to = CBuffer;
+		tosize = sizeof(CBuffer);
+	} else {
+		from = CBuffer;
+		fromsize = sizeof(CBuffer);
+		to = PBuffer;
+		tosize = sizeof(PBuffer);
+	}
+
+	/*
+	**	Process the byte request in code blocks until there are either
+	**	no more source bytes available or the request has been fulfilled.
+	*/
+	while (slen > 0) {
+
+		/*
+		**	Transfer any processed bytes available to the request buffer.
+		*/
+		if (Counter > 0) {
+			int len = (slen < Counter) ? slen : Counter;
+			memmove(source, &to[tosize-Counter], len);
+			Counter -= len;
+			slen -= len;
+			source = ((char *)source) + len;
+			total += len;
+		}
+		if (slen == 0) break;
+
+		/*
+		**	More bytes are needed, so fetch and process another base 64 block.
+		*/
+		int incount = Straw::Get(from, fromsize);
+		if (Control == ENCODE) {
+			Counter = Base64_Encode(from, incount, to, tosize);
+		} else {
+			Counter = Base64_Decode(from, incount, to, tosize);
+		}
+		if (Counter == 0) break;
+	}
+
+	return(total);
+}

REDALERT/B64STRAW.H

+//
+// Copyright 2020 Electronic Arts Inc.
+//
+// TiberianDawn.DLL and RedAlert.dll and corresponding source code is free 
+// software: you can redistribute it and/or modify it under the terms of 
+// the GNU General Public License as published by the Free Software Foundation, 
+// either version 3 of the License, or (at your option) any later version.
+
+// TiberianDawn.DLL and RedAlert.dll and corresponding source code is distributed 
+// in the hope that it will be useful, but with permitted additional restrictions 
+// under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT 
+// distributed with this program. You should have received a copy of the 
+// GNU General Public License along with permitted additional restrictions 
+// with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection
+
+/* $Header: /CounterStrike/B64STRAW.H 1     3/03/97 10:24a Joe_bostic $ */
+/***********************************************************************************************
+ ***              C O N F I D E N T I A L  ---  W E S T W O O D  S T U D I O S               ***
+ ***********************************************************************************************
+ *                                                                                             *
+ *                 Project Name : Command & Conquer                                            *
+ *                                                                                             *
+ *                    File Name : B64STRAW.H                                                   *
+ *                                                                                             *
+ *                   Programmer : Joe L. Bostic                                                *
+ *                                                                                             *
+ *                   Start Date : 07/02/96                                                     *
+ *                                                                                             *
+ *                  Last Update : July 2, 1996 [JLB]                                           *
+ *                                                                                             *
+ *---------------------------------------------------------------------------------------------*
+ * Functions:                                                                                  *
+ * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+
+
+#ifndef B64STRAW_H
+#define B64STRAW_H
+
+#include	"straw.h"
+
+/*
+**	Performs Base 64 encoding/decoding on the data that is drawn through the straw. Note that
+**	encoding increases the data size by about 30%. The reverse occurs when decoding.
+*/
+class Base64Straw : public Straw
+{
+	public:
+		typedef enum CodeControl {
+			ENCODE,
+			DECODE
+		} CodeControl;
+
+		Base64Straw(CodeControl control) : Control(control), Counter(0) {}
+		virtual int Get(void * source, int slen);
+
+	private:
+
+		/*
+		**	Indicates if this is for encoding or decoding of Base64 data.
+		*/
+		CodeControl Control;
+
+		/*
+		**	The counter of the number of accumulated bytes pending for processing.
+		*/
+		int Counter;
+
+		/*
+		**	Buffer that holds the Base64 coded bytes. This will be the staging buffer if
+		**	this is for a decoding process. Otherwise, it will be used as a scratch buffer.
+		*/
+		char CBuffer[4];
+
+		/*
+		**	Buffer that holds the plain bytes. This will be the staging buffer if this
+		**	is for an encoding process. Otherwise, it will be used as a scratch buffer.
+		*/
+		char PBuffer[3];
+
+		/*
+		**	Explicitly disable the copy constructor and the assignment operator.
+		*/
+		Base64Straw(Base64Straw & rvalue);
+		Base64Straw & operator = (Base64Straw const & pipe);
+};
+
+
+#endif