mirror of
https://github.com/1dot13/source.git
synced 2026-07-22 13:40:22 +02:00
Overhaul
7a27e7105d
Added missing #includes Added LUA scripting and console Changed the way tracers are visualized, so they work more like real tracers instead of a light fountain Fixed signedness of many grid variables used in GetMouseMapPos calls Fixed enemy weapon choosing: Sometimes a mortar is chosen but later rejected, but the grenade class was not reset. Caused assertion failure Added checks so enemies don't try to chuck RPG grenades with their hands Now possible to shoot a someone in the head if he's in water Fixed InitSightArrays to also clear soldier interrupt duel points. This was causing an assertion failure elsewhere in the code because the interrupt list still had soldiers on it sometimes when this function was called. Soldiers are much less willing to forfeit their turn over an attempt to use more APs than they have Removed early setting of muzzle flash. This would allow enemies to get an interrupt before you even fired. Fixed item dropping by AI. If AI tried to drop something while standing it would cause deadlock Change to greatly speed up closing the sector inventory window in an unloaded sector Added conditional compile flag to always give robot weapon ready advantage, even for 360 degree sighting Check builddefines.h for the conditional flags. Of greatest interest might be LUA_CONSOLE. This will cause the game to bring up a command console when run. However this console is severely lacking in many areas. If anybody knows of an open-source terminal/console that could be used instead, it would be appreciated. The existing console does bad things when you try to close it, and since it counts as a separate app, it pauses the game while it has focus. LUA scripting is very limited, basically just proof of concept. There is one global variable, the Soldiers array. An array index gives you the soldier in that slot in the currently loaded sector. The soldier has a few things that can be accessed: name (short name); fullname (long name); grid (current grid #, can be changed); walkto(grid) (function to walk to another grid); runto(grid) (function to run to another grid) git-svn-id: https://ja2svn.mooo.com/source/ja2/trunk/GameSource/ja2_v1.13/Build@924 3b4a5df2-a311-0410-b5c6-a8a6f20db521
453 lines
8.2 KiB
C++
453 lines
8.2 KiB
C++
// WANNE: EDITOR: no changes
|
|
#ifdef PRECOMPILEDHEADERS
|
|
#include "Editor All.h"
|
|
#else
|
|
#include "builddefines.h"
|
|
#endif
|
|
|
|
#ifdef JA2EDITOR
|
|
|
|
#ifndef PRECOMPILEDHEADERS
|
|
#include "types.h"
|
|
#include "Road Smoothing.h"
|
|
#include "tiledat.h"
|
|
#include "worlddef.h"
|
|
#include "worldman.h"
|
|
#include "Editor Undo.h"
|
|
#endif
|
|
|
|
|
|
typedef struct MACROSTRUCT
|
|
{
|
|
INT16 sMacroID;
|
|
INT16 sOffset;
|
|
}MACROSTRUCT;
|
|
//road macros
|
|
|
|
//These define the macros for the 32 road pieces. The column contains the macro ID and
|
|
//the second contains the gridno offset from the anchor position (where the user clicks in the world to
|
|
//place the road). The actual index of the array refers to the offset from ROADPIECE001.
|
|
MACROSTRUCT gRoadMacros[] =
|
|
{
|
|
//left 1
|
|
{L1, -2 },
|
|
{L1, -162 },
|
|
{L1, -322 },
|
|
{L1, -1 },
|
|
{L1, -161 },
|
|
{L1, -321 },
|
|
{L1, 0 },
|
|
{L1, -160 },
|
|
{L1, -320 },
|
|
//right 1
|
|
{R1, -2 },
|
|
{R1, -162 },
|
|
{R1, -322 },
|
|
{R1, -1 },
|
|
{R1, -161 },
|
|
{R1, -321 },
|
|
{R1, 0 },
|
|
{R1, -160 },
|
|
{R1, -320 },
|
|
//bottom 1
|
|
{B1, -2 },
|
|
{B1, -162 },
|
|
{B1, -322 },
|
|
{B1, -1 },
|
|
{B1, -161 },
|
|
{B1, -321 },
|
|
{B1, 0 },
|
|
{B1, -160 },
|
|
{B1, -320 },
|
|
//top 1
|
|
{T1, -2 },
|
|
{T1, -162 },
|
|
{T1, -322 },
|
|
{T1, -1 },
|
|
{T1, -161 },
|
|
{T1, -321 },
|
|
{T1, 0 },
|
|
{T1, -160 },
|
|
{T1, -320 },
|
|
//top half of top-right corner
|
|
{TTR, -4 },
|
|
{TTR, -164 },
|
|
{TTR, -324 },
|
|
{TTR, -3 },
|
|
{TTR, -163 },
|
|
{TTR, -323 },
|
|
{TTR, -2 },
|
|
{TTR, -162 },
|
|
{TTR, -1 },
|
|
{TTR, -161 },
|
|
{TTR, 0 },
|
|
//bottom half of top-right corner
|
|
{BTR, -5 },
|
|
{BTR, -165 },
|
|
{BTR, -325 },
|
|
{BTR, -4 }, //50
|
|
{BTR, -164 },
|
|
{BTR, -324 },
|
|
{BTR, -3 },
|
|
{BTR, -163 },
|
|
{BTR, -323 },
|
|
{BTR, -2 },
|
|
{BTR, -162 },
|
|
{BTR, -322 },
|
|
{BTR, -1 },
|
|
{BTR, -161 },
|
|
{BTR, -321 },
|
|
{BTR, 0 },
|
|
{BTR, -160 },
|
|
//left half of bottom-left corner
|
|
{LBL, -322 },
|
|
{LBL, -482 },
|
|
{LBL, -642 },
|
|
{LBL, -161 },
|
|
{LBL, -321 },
|
|
{LBL, -481 },
|
|
{LBL, -641 },
|
|
{LBL, 0 },
|
|
{LBL, -160 },
|
|
{LBL, -320 },
|
|
{LBL, -480 },
|
|
{LBL, -640 },
|
|
//right half of bottom-left corner
|
|
{RBL, -162 },
|
|
{RBL, -322 },
|
|
{RBL, -482 },
|
|
{RBL, -642 },
|
|
{RBL, -802 },
|
|
{RBL, -1 },
|
|
{RBL, -161 },
|
|
{RBL, -321 },
|
|
{RBL, -481 },
|
|
{RBL, -641 },
|
|
{RBL, -801 },
|
|
{RBL, 0 },
|
|
{RBL, -160 },
|
|
{RBL, -320 },
|
|
{RBL, -480 },
|
|
{RBL, -640 },
|
|
{RBL, -800 },
|
|
//left half of the top-left corner
|
|
{LTL, -2 },
|
|
{LTL, -162 },
|
|
{LTL, -322 },
|
|
{LTL, -1 },
|
|
{LTL, -161 },
|
|
{LTL, -321 },
|
|
{LTL, -481 },
|
|
{LTL, 0 }, //100
|
|
{LTL, -160 },
|
|
{LTL, -320 },
|
|
{LTL, -480 },
|
|
{LTL, -640 },
|
|
//right half of top-left corner
|
|
{RTL, -2 },
|
|
{RTL, -162 },
|
|
{RTL, -322 },
|
|
{RTL, -482 },
|
|
{RTL, -642 },
|
|
{RTL, -802 },
|
|
{RTL, -1 },
|
|
{RTL, -161 },
|
|
{RTL, -321 },
|
|
{RTL, -481 },
|
|
{RTL, -641 },
|
|
{RTL, -801 },
|
|
{RTL, 0 },
|
|
{RTL, -160 },
|
|
{RTL, -320 },
|
|
{RTL, -480 },
|
|
{RTL, -640 },
|
|
{RTL, -800 },
|
|
//right half of top-left corner
|
|
{RBR, 159 },
|
|
{RBR, -1 },
|
|
{RBR, -161 },
|
|
{RBR, -321 },
|
|
{RBR, -481 },
|
|
{RBR, -641 },
|
|
{RBR, 0 },
|
|
{RBR, -160 },
|
|
{RBR, -320 },
|
|
{RBR, -480 },
|
|
{RBR, -640 },
|
|
{RBR, -159 },
|
|
{RBR, -319 },
|
|
{RBR, -479 },
|
|
{RBR, -639 },
|
|
//right half of top-left corner
|
|
{LBR, 158 },
|
|
{LBR, -2 },
|
|
{LBR, -162 },
|
|
{LBR, -322 },
|
|
{LBR, -482 },
|
|
{LBR, -642 },
|
|
{LBR, 159 },
|
|
{LBR, -1 },
|
|
{LBR, -161 },
|
|
{LBR, -321 },
|
|
{LBR, -481 },
|
|
{LBR, -641 },
|
|
{LBR, 160 }, //150
|
|
{LBR, 0 },
|
|
{LBR, -160 },
|
|
{LBR, -320 },
|
|
{LBR, -480 },
|
|
{LBR, -640 },
|
|
//left 2
|
|
{L2, -2 },
|
|
{L2, -162 },
|
|
{L2, -322 },
|
|
{L2, -1 },
|
|
{L2, -161 },
|
|
{L2, -321 },
|
|
{L2, 0 },
|
|
{L2, -160 },
|
|
{L2, -320 },
|
|
//right 2
|
|
{R2, -2 },
|
|
{R2, -162 },
|
|
{R2, -322 },
|
|
{R2, -1 },
|
|
{R2, -161 },
|
|
{R2, -321 },
|
|
{R2, 0 },
|
|
{R2, -160 },
|
|
{R2, -320 },
|
|
//left 3
|
|
{L3, -2 },
|
|
{L3, -162 },
|
|
{L3, -322 },
|
|
{L3, -1 },
|
|
{L3, -161 },
|
|
{L3, -321 },
|
|
{L3, 0 },
|
|
{L3, -160 },
|
|
{L3, -320 },
|
|
//right 3
|
|
{R3, -2 },
|
|
{R3, -162 },
|
|
{R3, -322 },
|
|
{R3, -1 },
|
|
{R3, -161 },
|
|
{R3, -321 },
|
|
{R3, 0 },
|
|
{R3, -160 },
|
|
{R3, -320 },
|
|
//bottom 2
|
|
{B2, -2 },
|
|
{B2, -162 },
|
|
{B2, -322 },
|
|
{B2, -1 },
|
|
{B2, -161 },
|
|
{B2, -321 },
|
|
{B2, 0 },
|
|
{B2, -160 },
|
|
{B2, -320 }, //200
|
|
//top 2
|
|
{T2, -2 },
|
|
{T2, -162 },
|
|
{T2, -322 },
|
|
{T2, -1 },
|
|
{T2, -161 },
|
|
{T2, -321 },
|
|
{T2, 0 },
|
|
{T2, -160 },
|
|
{T2, -320 },
|
|
//bottom 3
|
|
{B3, -2 },
|
|
{B3, -162 },
|
|
{B3, -322 },
|
|
{B3, -1 },
|
|
{B3, -161 },
|
|
{B3, -321 },
|
|
{B3, 0 },
|
|
{B3, -160 },
|
|
{B3, -320 },
|
|
//top 3
|
|
{T3, -2 },
|
|
{T3, -162 },
|
|
{T3, -322 },
|
|
{T3, -1 },
|
|
{T3, -161 },
|
|
{T3, -321 },
|
|
{T3, 0 },
|
|
{T3, -160 },
|
|
{T3, -320 },
|
|
//bottom interior
|
|
{BI, -2 },
|
|
{BI, -162 },
|
|
{BI, -322 },
|
|
{BI, -1 },
|
|
{BI, -161 },
|
|
{BI, -321 },
|
|
{BI, 0 },
|
|
{BI, -160 },
|
|
{BI, -320 },
|
|
//left interior
|
|
{LI, -2 },
|
|
{LI, -162 },
|
|
{LI, -322 },
|
|
{LI, -1 },
|
|
{LI, -161 },
|
|
{LI, -321 },
|
|
{LI, 0 },
|
|
{LI, -160 },
|
|
{LI, -320 },
|
|
//top interior
|
|
{TI, -2 },
|
|
{TI, -162 },
|
|
{TI, -322 },
|
|
{TI, -1 },
|
|
{TI, -161 }, //250
|
|
{TI, -321 },
|
|
{TI, 0 },
|
|
{TI, -160 },
|
|
{TI, -320 },
|
|
//right interior
|
|
{RI, -2 }, //0
|
|
{RI, -162 },
|
|
{RI, -322 },
|
|
{RI, -1 },
|
|
{RI, -161 },
|
|
{RI, -321 },
|
|
{RI, 0 },
|
|
{RI, -160 },
|
|
{RI, -320 },
|
|
//left 4
|
|
{L4, -2 },
|
|
{L4, -162 },
|
|
{L4, -322 },
|
|
{L4, -1 },
|
|
{L4, -161 },
|
|
{L4, -321 },
|
|
{L4, 0 },
|
|
{L4, -160 },
|
|
{L4, -320 },
|
|
//right 4
|
|
{R4, -2 },
|
|
{R4, -162 },
|
|
{R4, -322 },
|
|
{R4, -1 },
|
|
{R4, -161 },
|
|
{R4, -321 },
|
|
{R4, 0 },
|
|
{R4, -160 },
|
|
{R4, -320 },
|
|
//bottom 4
|
|
{B4, -2 },
|
|
{B4, -162 },
|
|
{B4, -322 },
|
|
{B4, -1 },
|
|
{B4, -161 },
|
|
{B4, -321 },
|
|
{B4, 0 },
|
|
{B4, -160 },
|
|
{B4, -320 },
|
|
//top 4
|
|
{T4, -2 },
|
|
{T4, -162 },
|
|
{T4, -322 },
|
|
{T4, -1 },
|
|
{T4, -161 },
|
|
{T4, -321 },
|
|
{T4, 0 },
|
|
{T4, -160 },
|
|
{T4, -320 },
|
|
//right edge (end of road)
|
|
{RE, 0 },
|
|
{RE, -160 },
|
|
{RE, -320 },
|
|
//left edge
|
|
{LE, 0 },
|
|
{LE, -160 },
|
|
{LE, -320 },
|
|
//bottom edge
|
|
{BE, -2 },
|
|
{BE, -1 },
|
|
{BE, 0 },
|
|
//top edge
|
|
{TE, -2 },
|
|
{TE, -1 },
|
|
{TE, 0 }
|
|
};
|
|
|
|
INT16 gsRoadMacroStartIndex[ NUM_ROAD_MACROS ];
|
|
|
|
//A simple optimization function that calculates the first index in the large database for
|
|
//the particular macro ID.
|
|
void InitializeRoadMacros()
|
|
{
|
|
INT16 i, end;
|
|
INT16 sMacro = 0;
|
|
end = sizeof( gRoadMacros ) / 4;
|
|
for( i = 0; i < end; i++ )
|
|
{
|
|
if( i >= sizeof( gRoadMacros ) / sizeof( MACROSTRUCT ) )
|
|
{
|
|
i = i;
|
|
}
|
|
if( gRoadMacros[ i ].sMacroID == sMacro )
|
|
{
|
|
gsRoadMacroStartIndex[ sMacro ] = i;
|
|
sMacro++;
|
|
}
|
|
}
|
|
// i = ROADPIECES001;
|
|
}
|
|
|
|
//Road macros vary in size from 3 gridnos to 18 gridnos. Using the anchor gridno based off of the original
|
|
//road system, this function will place the new macro (consisting of multiple road pieces in multiple
|
|
//gridnos).
|
|
void PlaceRoadMacroAtGridNo( INT32 iMapIndex, INT32 iMacroID )
|
|
{
|
|
INT32 i;
|
|
UINT16 usTileIndex;
|
|
i = gsRoadMacroStartIndex[ iMacroID ];
|
|
while( gRoadMacros[ i ].sMacroID == iMacroID )
|
|
{
|
|
AddToUndoList( iMapIndex + gRoadMacros[ i ].sOffset );
|
|
RemoveAllObjectsOfTypeRange( i, ROADPIECES, ROADPIECES );
|
|
GetTileIndexFromTypeSubIndex( ROADPIECES, (UINT16)(i+1) , &usTileIndex );
|
|
AddObjectToHead( iMapIndex + gRoadMacros[ i ].sOffset, usTileIndex );
|
|
i++;
|
|
}
|
|
}
|
|
|
|
//The old road system used multi-tiled roads as a single image. The new road system has taken these large
|
|
//pieces and chopped them up into single tiled images (to mitigate lighting problems). Some of the larger
|
|
//road pieces turned into 18 smaller pieces. So this function will go analyse the world, and replaces any
|
|
//locations containing the original road tile information, delete it, and replace it by inserting it's
|
|
//equivalent macro.
|
|
void ReplaceObsoleteRoads()
|
|
{
|
|
INT32 i;
|
|
INT32 iMacro;
|
|
LEVELNODE *pObject;
|
|
BOOLEAN fRoadExistsAtGridNo;
|
|
for( i = 0; i < WORLD_MAX; i++ )
|
|
{
|
|
pObject = gpWorldLevelData[ i ].pObjectHead;
|
|
fRoadExistsAtGridNo = FALSE;
|
|
while( pObject )
|
|
{
|
|
if( pObject->usIndex >= FIRSTROAD1 && pObject->usIndex <= FIRSTROAD32 )
|
|
{
|
|
fRoadExistsAtGridNo = TRUE;
|
|
iMacro = pObject->usIndex - FIRSTROAD1;
|
|
PlaceRoadMacroAtGridNo( i, iMacro );
|
|
}
|
|
pObject = pObject->pNext;
|
|
}
|
|
if( fRoadExistsAtGridNo )
|
|
{
|
|
RemoveAllObjectsOfTypeRange( i, FIRSTROAD, FIRSTROAD );
|
|
}
|
|
}
|
|
}
|
|
|
|
#endif
|