PFAMILYNODE FamilyTreeAddChild ( PFAMILYTREE *root, POINTER userdata, uintptr_t key )
{
if( root )
{
PFAMILYNODE node;
if( !(*root ) )
(*root) = CreateFamilyTree( NULL, NULL );
node = (PFAMILYNODE)GetFromSet( FAMILYNODE, &(*root)->nodes /*Allocate( sizeof( FAMILYNODE )*/ );
node->child = NULL;
node->younger = NULL;
node->flags.bUsed = 0;
node->userdata = userdata;
node->key = key;
node->parent = (*root)->prior;
if( !node->parent )
{
if( ( node->elder = (*root)->family ) )
(*root)->family->younger = node;
(*root)->family = node;
}
else
{
if( ( node->elder = (*root)->prior->child ) )
node->elder->younger = node;
(*root)->prior->child = node;
}
(*root)->prior = node;
(*root)->lastfound = node;
(*root)->current = node;
return node;
}
return NULL;
}
INDEX SrvrOpenWorld( uint32_t client_id, CTEXTSTR name )
{
PWORLD world;
INDEX iWorld;
uintptr_t psvResult;
psvResult = ForAllInSet( WORLD, g.worlds, CompareWorldName, (uintptr_t)name );
if( psvResult )
{
world = (PWORLD)psvResult;
iWorld = GetMemberIndex( WORLD, &g.worlds, world );
#if defined( WORLD_SCAPE_SERVER_EXPORTS ) || defined( WORLDSCAPE_SERVICE )
SrvrMarkWorldUpdated( client_id, iWorld );
#endif
}
else
{
world = GetFromSet( WORLD, &g.worlds );
iWorld = GetMemberIndex( WORLD, &g.worlds, world );
#if defined( WORLD_SCAPE_SERVER_EXPORTS ) || defined( WORLDSCAPE_SERVICE )
SrvrMarkWorldUpdated( client_id, iWorld );
#endif
world->name = SrvrMakeName( client_id, iWorld, name );
// get from set is zero initialized.
//world->lines = NULL;
//world->walls = NULL;
//world->sectors = NULL;
//world->textures = NULL;
//world->names = NULL; // derr just made a name for this world itself... then do what?!
//world->spacetree = NULL;
SrvrCreateSquareSector( client_id, iWorld, VectorConst_0, 50 );
}
return iWorld;
}
INDEX SrvrMakeTexture( uint32_t client_id, INDEX iWorld, INDEX iName )
{
PWORLD world = GetSetMember( WORLD, &g.worlds, iWorld );
PFLATLAND_TEXTURE texture;
INDEX iTexture = INVALID_INDEX;
FINDTHING ft;
ft.iWorld = iWorld;
ft.iName = iName;
if( iName != INVALID_INDEX )
{
iTexture = ForAllTextures( iWorld, FindTextureName, (uintptr_t)&ft );
if( iTexture != INVALID_INDEX )
texture = GetSetMember( FLATLAND_TEXTURE, &world->textures, iTexture );
else
{
texture = GetFromSet( FLATLAND_TEXTURE, &world->textures );
iTexture = GetMemberIndex( FLATLAND_TEXTURE, &world->textures, texture );
texture->iName = iName;
}
}
#if defined( WORLD_SCAPE_SERVER_EXPORTS ) || defined( WORLDSCAPE_SERVICE )
MarkTextureUpdated( client_id, iWorld, iTexture );
#endif
return iTexture;
}
void *LAYER_DATA::operator new( size_t sz, struct LAYER_DATAset_tag **frompool )
{
if( sz != sizeof( LAYER_DATA ) )
return NULL;
//if( !(*frompool ) )
// (*frompool) = new LAYER_DATASET;
PLAYER_DATA layer = GetFromSet( LAYER_DATA, (frompool) );
layer->pool = frompool;
return layer;
}
void classify( char *file, uint8_t* p, uintptr_t size )
{
int n;
for( n = 0; n < size; n += 12 )
{
PRELATION relation = GetFromSet( RELATION, &relations );
relation->card = p + n;
relation->file = file;
relation->number = ( n / 12 ) + 1;
PRELATION *rel = related[p[n+0]] + p[n+1];
LinkThing( rel[0], relation );
totalCount++;
//TickLog( "classify", n / 12 );
}
}
INDEX MakeName( INDEX iWorld, CTEXTSTR text )
{
PWORLD world = GetSetMember( WORLD, &g.worlds, iWorld );
// anmes should be cached... and referenced...
// ahh well we'll deal with this for now... there's not
// that many names....
// see procreg for someone who needs to worry.
PNAME name = GetFromSet( NAME, &world->names );
INDEX iName = GetMemberIndex( NAME, &world->names, name );
MemSet( name, 0, sizeof( NAME ) );
if( text )
SetName( iWorld, iName, text );
#ifdef WORLDSCAPE_SERVICE
MarkNameUpdated( iWorld, iName );
#endif
return iName;
}
void *LAYER::operator new( size_t sz, LAYERSET **frompool, LAYER_DATASET **fromdatapool )
{
if( sz != sizeof( LAYER ) )
return NULL;
if( !(*frompool ) )
{
//(*frompool) = NULL; //new LAYERSET;
PLAYER layer0 = GetSetMember( LAYER, (frompool), 0 );
// grab the 0'th layer from the pool.
// this layer is the root of all layers, and allows
// the tracking of the order of under/over
// by being a well known variable that this
// module has access to.
layer0->next = NULL;
layer0->prior = NULL;
layer0->flags.bRoot = 1;
}
PLAYER layer = GetFromSet( LAYER, (frompool) );
MemSet( layer, 0, sizeof( LAYER ) );
layer->pool = frompool;
layer->pLayerData = new( fromdatapool ) LAYER_DATA();
layer->link_top();
return layer;
}
void CPROC EditResizeCallback( uintptr_t dwUser )
{
PEDITOR pe = (PEDITOR)dwUser;
//PFACETSET *ppfs;
//PFACET pf;
//PLINESEGPSET *pplps;
//PMYLINESEGSET *ppls;
//PMYLINESEG pl;
//int l;
// ShowCurrent();
//ClearImage( surface );
{
//IMAGE_RECTANGLE r;
//GetDisplayPosition( pe->hVideo, pe->ptUpperLeft, pe->ptUpperLeft + 1, NULL, NULL );
/*
GetWindowRect( pe->hVideo->hWndOutput, &r );
pe->ptUpperLeft[0] = r.left //+ GetSystemMetrics( SM_CXBORDER )
+ GetSystemMetrics( SM_CXFRAME );
pe->ptUpperLeft[1] = r.top + GetSystemMetrics( SM_CYBORDER )
+ GetSystemMetrics( SM_CYFRAME )
+ GetSystemMetrics( SM_CYCAPTION );
*/
}
#if 0
SetClip( (RCOORD)GetDisplayImage( pe->hVideo )->width,
(RCOORD)GetDisplayImage( pe->hVideo )->height );
ppfs = pe->pCurrent->objinfo->ppFacetPool;
ppls = GetFromSet( LINEPSEG, pe->pCurrent->objinfo->ppLinePool );
//ForAllInSet( FACET, &pe->pCurrent->objinfo->ppFacetPool, DrawLineSegs );
//int f;
//for( f = 0; f < ; f++ )
{
int lines;
//pf = GetFromSet( FACET, pfs->pFacets + f;
pplps = &pf->pLineSet;
lines = CountUsedInSet( LINESEGP, pf->pLineSet );
for( l = 0; l < lines; l++ )
{
RAY ld; // local directional...
PLINESEGP plsp = GetSetMember( LINESEGP, pplps, l );
pl = GetSetMember( MYLINESEG, ppls, plsp->nLine );
if( pl == pe->pCurrentLine )
{
ApplyInverseR( pe->TView, &ld, &pl->r );
DrawLine(surface, ld.o, ld.n, pl->dFrom-5, pl->dFrom, Color( 192, 192, 0 ) );
DrawLine(surface, ld.o, ld.n, pl->dFrom, pl->dTo, Color( 0, 150, 0 ) );
DrawLine(surface, ld.o, ld.n, pl->dTo, pl->dTo+5, Color( 192, 192, 0 ) );
GetViewPoint(surface, &pe->ptO, ld.o );
add( ld.o, ld.o, ld.n ); // add one slope to origin to get slope point
GetViewPoint(surface, &pe->ptN, ld.o );
MarkOrigin( pe, surface );
MarkSlope( pe,surface );
}
else
if( pf = pe->pCurrentFacet )
{
ApplyInverseR( pe->TView, &ld, &pl->r );
DrawLine(surface, ld.o, ld.n, pl->dFrom, pl->dTo, Color( 0, 0, 150 ) );
}
else
{
ApplyInverseR( pe->TView, &ld, &pl->r );
DrawLine(surface, ld.o, ld.n, pl->dFrom, pl->dTo, Color( 92, 92, 92 ) );
}
}
}
UpdateDisplay( pe->hVideo );
#endif
}
int SrvrLoadWorldFromFile( uint32_t client_id, FILE *file, INDEX iWorld )
{
FILE *pFile;
PWORLD world = GetSetMember( WORLD, &g.worlds, iWorld );
int sz = 0, cnt, version, size;
char tag[4]; // read in make sure we're still aligned in the file...
int linesize;
int nlines;
PFLATLAND_MYLINESEG *linearray;
int wallsize;
int nwalls;
PWALL *wallarray;
int sectorsize;
int nsectors;
PSECTOR *sectorarray;
int namesize;
int nnames;
PNAME *namearray;
int texturesize;
int ntextures;
PFLATLAND_TEXTURE *texturearray;
INDEX texture;
if( !world )
return 0;
{
char buffer[256];
GetNameText( iWorld, world->name, buffer, sizeof( buffer ) );
Fopen( pFile, buffer, "rb" );
}
if( !pFile )
return 0;
ResetWorld( iWorld ); // make sure this thing is empty );
sz += fread( tag, 1, 4, pFile );
if( strncmp( tag, "FLAT", 4 ) )
{
Log( "Alignment error in file load... totally invalid file." );
return 0;
}
sz += fread( &size, 1, sizeof( size ), pFile );
if( size < 10 ) // can assume that it was a version ID
version = size;
else
sz = fread( &version, 1, sizeof( version ), pFile );
if( version < 8 )
{
texture = SrvrMakeTexture( client_id, iWorld, SrvrMakeName( client_id, iWorld, WIDE( "Default" ) ) );
SrvrSetSolidColor( client_id, iWorld, texture, AColor( 43, 76, 180, 0x80 ) );
}
Log1( "Loading version: %d", version );
sz += fread( tag, 1, 4, pFile );
if( strncmp( tag, "LINE", 4 ) )
{
// was not LINE or FLAT tag...
Log( "Alignment error in file line load." );
return 0;
}
if( version > 9 )
sz += fread( &linesize, 1, sizeof( linesize ), pFile );
sz += fread( &nlines, 1, sizeof(nlines), pFile );
linearray = (PFLATLAND_MYLINESEG*)Allocate( sizeof( PFLATLAND_MYLINESEG ) * nlines );
for( cnt = 0; cnt < nlines; cnt++ )
{
PFLATLAND_MYLINESEG pls;
LINESEGFILE lsf;
sz += fread( &lsf, 1, sizeof(LINESEGFILE), pFile );
pls = GetFromSet( FLATLAND_MYLINESEG, &world->lines );
#ifdef OUTPUT_TO_VIRTUALITY
pls->pfl = CreateFacetLine( world->object, lsf.r.o, lsf.r.n, lsf.start, lsf.end );
#endif
linearray[cnt] = pls;
/* some sort of update line... */
SetRay( &pls->r, &lsf.r );
if( version < 9 )
{
pls->r.o[1] = -pls->r.o[1];
pls->r.n[1] = -pls->r.n[1];
}
pls->dFrom = lsf.start;
pls->dTo = lsf.end;
}
sz += fread( tag, 1, 4, pFile );
if( strncmp( tag, "WALL", 4 ) )
{
Log( "Alignment error in file wall load." );
return 0;
}
if( version > 9 )
sz += fread( &wallsize, 1, sizeof( wallsize ), pFile );
sz += fread( &nwalls, 1, sizeof(nwalls), pFile );
wallarray = (PWALL*)Allocate( sizeof( PWALL ) * nwalls );
for( cnt = 0; cnt < nwalls; cnt++ )
{
wallarray[cnt] = GetFromSet( WALL, &world->walls );
}
for( cnt = 0; cnt < nwalls; cnt++ )
{
FILEWALLV1 ReadWall1;
FILEWALLV2 ReadWall2;
PWALL pwall;
pwall = wallarray[cnt];
if( version < 2 )
{
sz += fread( &ReadWall1, 1, sizeof( FILEWALLV1 ), pFile );
pwall->flags = ReadWall1.flags;
pwall->iSector = ReadWall1.nSector;
SetLineWorld( world, pwall->iLine, linearray[ReadWall1.nLine] );
if( ReadWall1.nWallInto == -1 )
pwall->iWallInto = INVALID_INDEX;
else
pwall->iWallInto = GetMemberIndex( WALL, &world->walls, wallarray[ReadWall1.nWallInto] );
pwall->iWallStart = GetMemberIndex( WALL, &world->walls, wallarray[ReadWall1.nWallStart] );
pwall->iWallEnd = GetMemberIndex( WALL, &world->walls, wallarray[ReadWall1.nWallEnd] );
}
else
{
sz += fread( &ReadWall2, 1, sizeof( FILEWALLV2 ), pFile );
pwall->flags = ReadWall2.flags;
pwall->iSector = ReadWall2.nSector;
if( ReadWall2.nLine != -1 )
{
pwall->iLine = GetMemberIndex( FLATLAND_MYLINESEG, &world->lines, linearray[ReadWall2.nLine] );
//SetLine( pwall->line, linearray[ReadWall2.nLine] );
}
else
{
Log( "Wall without line? cant be!" );
DebugBreak();
pwall->iLine = INVALID_INDEX;
}
if( ReadWall2.nWallInto == -1 )
pwall->iWallInto = INVALID_INDEX;
else
pwall->iWallInto = GetMemberIndex( WALL, &world->walls, wallarray[ReadWall2.nWallInto] );
pwall->iWallStart = GetMemberIndex( WALL, &world->walls, wallarray[ReadWall2.nWallStart] );
pwall->iWallEnd = GetMemberIndex( WALL, &world->walls, wallarray[ReadWall2.nWallEnd] );
}
}
sz += fread( tag, 1, 4, pFile );
if( strncmp( tag, "SECT", 4 ) )
{
Log2( "Alignment error in file sector load. %s(%d)", __FILE__, __LINE__ );
return 0;
}
if( version > 9 )
sz += fread( §orsize, 1, sizeof( sectorsize ), pFile );
sz += fread( &nsectors, 1, sizeof(nsectors), pFile );
sectorarray = (PSECTOR*)Allocate( sizeof( PSECTOR ) * nsectors );
for( cnt = 0; cnt < nsectors; cnt++ )
{
FILESECTORV3 ReadSector3;
FILESECTORV4 ReadSector4;
FILESECTORV5 ReadSector5;
FILESECTORV8 ReadSector8;
INDEX sector;
sectorarray[cnt] = GetFromSet( SECTOR, &world->sectors );
#ifdef OUTPUT_TO_VIRTUALITY
sectorarray[cnt]->facet = AddNormalPlane( world->object, VectorConst_0, VectorConst_Z, 0 );
#endif
sector = GetMemberIndex( SECTOR, &world->sectors, sectorarray[cnt] );
if( version < 8 )
{
// one texture is sufficient...
// in fact textures should be highly sharable.
sectorarray[cnt]->iTexture = texture;
}
if( version < 4 )
{
/*
{
char name[20];
sprintf( name, "%d", SectorIDs++ );
sectorarray[cnt]->name = GetName( &world->names, name );
}
*/
sectorarray[cnt]->iName = INVALID_INDEX;
sz += fread( &ReadSector3, 1, sizeof( FILESECTORV3 ), pFile );
sectorarray[cnt]->flags = ReadSector3.flags;
sectorarray[cnt]->iWorld = iWorld;
SetRay( §orarray[cnt]->r, &ReadSector3.r );
sectorarray[cnt]->iWall = GetMemberIndex( WALL, &world->walls, wallarray[ReadSector3.nwall] );
if( version < 3 )
{
ComputeSectorOrigin( iWorld, sector);
}
}
else if( version < 5 )
{
sz += fread( &ReadSector4, 1, sizeof( FILESECTORV4 ), pFile );
/*
{
char name[20];
sprintf( name, "%d", ReadSector4.nID );
sectorarray[cnt]->name = GetName( &world->names, name );
if( atoi( name ) > SectorIDs )
SectorIDs = atoi( name );
}
*/
sectorarray[cnt]->iName = INVALID_INDEX;
sectorarray[cnt]->flags = ReadSector4.flags;
sectorarray[cnt]->iWorld = iWorld;
SetRay( §orarray[cnt]->r, &ReadSector4.r );
sectorarray[cnt]->iWall = GetMemberIndex( WALL, &world->walls, wallarray[ReadSector4.nwall] );
}
else if( version < 8 )
{
sz += fread( &ReadSector5, 1, sizeof( FILESECTORV5 ), pFile );
sectorarray[cnt]->iName = ReadSector5.nName;
sectorarray[cnt]->flags = ReadSector5.flags;
sectorarray[cnt]->iWorld = iWorld;
SetRay( §orarray[cnt]->r, &ReadSector5.r );
sectorarray[cnt]->iWall = GetMemberIndex( WALL, &world->walls, wallarray[ReadSector5.nwall] );
}
else
{
sz += fread( &ReadSector8, 1, sizeof( FILESECTORV8 ), pFile );
sectorarray[cnt]->iName = ReadSector8.nName;
sectorarray[cnt]->flags = ReadSector8.flags;
sectorarray[cnt]->iWorld = iWorld;
SetRay( §orarray[cnt]->r, &ReadSector8.r );
sectorarray[cnt]->iWall = ReadSector8.nwall;
sectorarray[cnt]->iTexture = ReadSector8.nTexture;
}
// walls should all be valid at this point...
// have valid lines, and valid linkings...
ComputeSectorPointList( iWorld, sector, NULL );
ComputeSectorOrigin( iWorld, sector );
#ifdef OUTPUT_TO_VIRTUALITY
OrderObjectLines( world->object );
#endif
}
// fix sector references in walls.
//for( cnt = 0; cnt < nwalls; cnt++ )
//{
// wallarray[cnt]->iSector = wallarray[cnt]->iSector;
//}
for( cnt = 0; cnt < nwalls; cnt++ )
{
if( wallarray[cnt]->iLine == INVALID_INDEX )
{
SrvrDestroySector( client_id, iWorld, wallarray[cnt]->iSector );
Log( "attempting to fix broken walls" );
break;
}
}
if( version >= 5 )
{
sz += fread( tag, 1, 4, pFile );
if( strncmp( tag, "NAME", 4 ) )
{
Log2( "Alignment error in name section load. %s(%d)", __FILE__, __LINE__ );
return 0;
}
if( version > 9 )
sz += fread( &namesize, 1, sizeof( namesize ), pFile );
sz += fread( &nnames, 1, sizeof(nnames), pFile );
namearray = (PNAME*)Allocate( sizeof( PNAME ) * nnames );
for( cnt = 0; cnt < nnames; cnt++ )
{
namearray[cnt] = GetFromSet( NAME, &world->names );
if( version < 6 )
{
uint32_t length;
namearray[cnt]->name = (struct name_data*)Allocate( sizeof( *namearray[cnt]->name ) );
sz += fread( &length, 1, sizeof( length ), pFile );
namearray[cnt]->name[0].length = length;
namearray[cnt]->name[0].name = (TEXTSTR)Allocate( namearray[cnt]->name[0].length + 1 );
sz += fread( namearray[cnt]->name[0].name, 1, namearray[cnt]->name[0].length, pFile );
namearray[cnt]->name[0].name[namearray[cnt]->name[0].length] = 0;
namearray[cnt]->lines = 1;
}
else if( version < 7 )
{
int l;
sz += fread( &namearray[cnt]->lines, 1, sizeof( namearray[cnt]->lines ), pFile );
if( namearray[cnt]->lines )
{
namearray[cnt]->name = (struct name_data*)Allocate( sizeof( *namearray[cnt]->name ) * namearray[cnt]->lines );
for( l = 0; l < namearray[cnt]->lines; l++ )
{
sz += fread( &namearray[cnt]->name[l].length, 1, sizeof( namearray[cnt]->name[l].length ), pFile );
namearray[cnt]->name[l].name = (TEXTSTR)Allocate( namearray[cnt]->name[l].length + 1 );
sz += fread( namearray[cnt]->name[l].name, 1, namearray[cnt]->name[l].length, pFile );
namearray[cnt]->name[l].name[namearray[cnt]->name[l].length] = 0;
}
}
else
namearray[cnt]->name = NULL;
}
else
{
int l;
sz += fread( &namearray[cnt]->flags, 1, sizeof( namearray[cnt]->flags ), pFile );
sz += fread( &namearray[cnt]->lines, 1, sizeof( namearray[cnt]->lines ), pFile );
if( namearray[cnt]->lines )
{
namearray[cnt]->name = (struct name_data*)Allocate( sizeof( *namearray[cnt]->name ) * namearray[cnt]->lines );
for( l = 0; l < namearray[cnt]->lines; l++ )
{
sz += fread( &namearray[cnt]->name[l].length, 1, sizeof( namearray[cnt]->name[l].length ), pFile );
namearray[cnt]->name[l].name = (TEXTSTR)Allocate( namearray[cnt]->name[l].length + 1 );
sz += fread( namearray[cnt]->name[l].name, 1, namearray[cnt]->name[l].length, pFile );
namearray[cnt]->name[l].name[namearray[cnt]->name[l].length] = 0;
}
}
else
namearray[cnt]->name = NULL;
}
}
/*
for( cnt = 0; cnt < nsectors; cnt++ )
{
if( (int)sectorarray[cnt]->iName == -1 )
sectorarray[cnt]->iName = INVALID_INDEX;
else
{
int n;
PNAME pName = namearray[(int)sectorarray[cnt]->name];
if( pName->name && pName->name[0].name )
if( ( n = atoi( pName->name[0].name ) ) > SectorIDs )
SectorIDs = n;
sectorarray[cnt]->name = pName;
}
}
*/
if( version >= 8 )
{
sz += fread( tag, 1, 4, pFile );
if( strncmp( tag, "TEXT", 4 ) )
{
Log2( "Alignment error in texture section load. %s(%d)", __FILE__, __LINE__ );
return 0;
}
if( version > 9 )
sz += fread( &texturesize, 1, sizeof( texturesize ), pFile );
sz += fread( &ntextures, 1, sizeof(ntextures), pFile );
texturearray = (PFLATLAND_TEXTURE*)Allocate( sizeof( PFLATLAND_TEXTURE ) * ntextures );
for( cnt = 0; cnt < ntextures; cnt++ )
{
char flag;
int nName;
sz += fread( &nName, 1, sizeof( nName ), pFile );
texturearray[cnt] = GetFromSet( FLATLAND_TEXTURE, &world->textures );
texturearray[cnt]->iName = GetMemberIndex( NAME, &world->names, namearray[nName] );
sz += fread( &flag, 1, sizeof( flag ), pFile );
texturearray[cnt]->flags.bColor = flag;
if( flag )
{
sz += fread( &texturearray[cnt]->data.color, 1, sizeof(CDATA), pFile );
}
}
//for( cnt = 0; cnt < nsectors; cnt++ )
//{
// int ntexture = (int)sectorarray[cnt]->iTexture;
// sectorarray[cnt]->texture = NULL;
// SetTexture( sectorarray[cnt]->texture, texturearray[ntexture] );
//}
Release( texturearray );
}
Release( namearray );
}
if( version > 9 )
{
if( sz != size )
{
Log2( "Total load size %d is not %d", sz, size );
}
}
//for( cnt = 0; cnt < nsectors; cnt++ )
{
//PSECTOR pSector = sectorarray[cnt];
// again with the min/max fetch with
// spacetree add
//pSector->spacenode = AddSpaceNode( &world->spacetree, pSector, min, max );
}
Release( linearray );
Release( wallarray );
Release( sectorarray );
ValidateWorldLinks(iWorld);
return version;
}
INDEX SrvrCreateSquareSector( uint32_t client_id, INDEX iWorld, PC_POINT pOrigin, RCOORD size )
{
PWORLD world = GetSetMember( WORLD, &g.worlds, iWorld );
PSECTOR pSector;
INDEX iSector;
_POINT o, n;
pSector = GetFromSet( SECTOR, &world->sectors );
#ifdef OUTPUT_TO_VIRTUALITY
pSector->facet = AddNormalPlane( world->object, VectorConst_0, VectorConst_Z, 0 );
#endif
iSector = GetMemberIndex( SECTOR, &world->sectors, pSector );
/*
{
char name[20];
sprintf( name, "%d", SectorIDs++ );
pSector->name = GetName( &world->names, name );
}
*/
pSector->iName = INVALID_INDEX;
pSector->iWorld = iWorld;
/* east */
addscaled( o, pOrigin, VectorConst_X, size/2 );
scale( n, VectorConst_Y, 20 );
// creates an open line....
pSector->iWall = SrvrCreateWall( client_id, iWorld, iSector, INVALID_INDEX, FALSE, INVALID_INDEX, FALSE, o, n );
/* south */
addscaled( o, pOrigin, VectorConst_Y, size/2 );
scale( n, VectorConst_X, -20 );
// creates a wall whos start is at the start of the wall...
SrvrCreateWall( client_id, iWorld, iSector, pSector->iWall, TRUE, INVALID_INDEX, FALSE, o, n );
/* west */
addscaled( o, pOrigin, VectorConst_Y, -size/2 );
scale( n, VectorConst_X, -20 );
SrvrCreateWall( client_id, iWorld, iSector, pSector->iWall, FALSE, INVALID_INDEX, FALSE, o, n );
/* north */
addscaled( o, pOrigin, VectorConst_X, -size/2 );
scale( n, VectorConst_Y, 20 );
{
PWALL pWall = GetSetMember( WALL, &world->walls, pSector->iWall );
SrvrCreateWall( client_id, iWorld, iSector
, pWall->iWallStart, TRUE
, pWall->iWallEnd, TRUE, o, n );
}
//ComputeSectorPointList( iWorld, iSector, NULL );
//ComputeSectorOrigin( iWorld, iSector );
#ifdef OUTPUT_TO_VIRTUALITY
OrderObjectLines( world->object );
#endif
SetPoint( pSector->r.n, VectorConst_Y );
//DumpWall( pSector->wall );
//DumpWall( pSector->wall->wall_at_start );
//DumpWall( pSector->wall->wall_at_end );
//DumpWall( pSector->wall->wall_at_start->wall_at_end );
{
INDEX texture = SrvrMakeTexture( client_id, iWorld, SrvrMakeName( client_id, iWorld, WIDE( "Default" ) ) );
PFLATLAND_TEXTURE pTexture = GetSetMember( FLATLAND_TEXTURE, &world->textures, texture );
if( !pTexture->flags.bColor )
SrvrSetSolidColor( client_id, iWorld, texture, AColor( 170, 170, 170, 0x80 ) );
SrvrSetTexture( client_id, iWorld, iSector, texture );
}
#ifdef WORLDSCAPE_SERVER
/* this doesn't exist in direct library */
MarkSectorUpdated( client_id, iWorld, iSector );
#endif
return iSector;
}
LAYER::LAYER( PODBC odbc, PLIST peices, INDEX iLoadLayer )
{
if( !this )
return;
if( iLayer && iLayer != INVALID_INDEX )
{
lprintf( WIDE("Recovering prior layer") );
return;
}
{
CTEXTSTR *results;
if( SQLRecordQueryf( odbc, NULL, &results, NULL
, WIDE("select x,y,min_x,min_y,width,height,linked_from_id,linked_from_x,linked_from_y,linked_to_id,linked_to_x,linked_to_y,route,peice_info_id,peice_type from board_layer where board_layer_id=%lu")
, iLoadLayer
) && results )
{
PIPEICE peice_type = ::GetPeice( peices, results[14] );
pLayerData->psvInstance = peice_type->Load( odbc, atoi( results[13] ) );//, pLayerData->psvInstance );
pLayerData->SetPeice( peice_type );
pds_path = CreateDataStack( sizeof( LAYER_PATH_NODE ) );
x = atoi( results[0] );
y = atoi( results[1] );
min_x = atoi( results[2] );
min_y = atoi( results[3] );
w = IntCreateFromText( results[4] );
h = IntCreateFromText( results[5] );
flags.bRoute = atoi( results[12] );
iLayer = iLoadLayer;
INDEX iStart = IntCreateFromText( results[6] );
if( iStart != INVALID_INDEX )
{
int32_t x, y;
x = atoi( results[7] );
y = atoi( results[8] );
PLAYER loaded_route_start_layer;
loaded_route_start_layer = FindLayer( iStart );
if( !loaded_route_start_layer )
loaded_route_start_layer = GetFromSet( LAYER, pool ); //new(pool,pLayerData->pool) LAYER( odbc, peices, iStart );
loaded_route_start_layer->pLayerData->peice->methods->ConnectBegin( loaded_route_start_layer->pLayerData->psvInstance
, x, y // connect x, y
, pLayerData->peice, pLayerData->psvInstance );
loaded_route_start_layer->Link( this, LINK_VIA_START, x, y);
}
INDEX iEnd = IntCreateFromText( results[9] );
if( iEnd != INVALID_INDEX )
{
int32_t x, y;
x = atoi( results[10] );
y = atoi( results[11] );
PLAYER loaded_route_end_layer;
loaded_route_end_layer = FindLayer( iEnd );
if( !loaded_route_end_layer )
loaded_route_end_layer = GetFromSet( LAYER, pool ); //new(pool,pLayerData->pool) LAYER( odbc, peices, iEnd );
loaded_route_end_layer->pLayerData->peice->methods->ConnectEnd( loaded_route_end_layer->pLayerData->psvInstance
, x, y // connect x, y
, pLayerData->peice, pLayerData->psvInstance );
loaded_route_end_layer->Link( this, LINK_VIA_END, x, y );
}
//}
}
SQLEndQuery( odbc );
for( SQLRecordQueryf( odbc, NULL, &results, NULL, WIDE("select x,y,fore,back from board_layer_path where board_layer_id=%lu order by board_layer_path_id desc"), iLoadLayer );
results;
FetchSQLRecord( odbc, &results ) )
{
// add path node for a routed type peice
LAYER_PATH_NODE node;
node.x = atoi( results[0] );
node.y = atoi( results[1] );
node.flags.ForeDir = atoi( results[2] );
node.flags.BackDir = atoi( results[3] );
PushData( &pds_path, &node );
}
}
//return iLayer;
}
int main( void )
{
int n;
char tmp[256];
int card_count = 0;
int card;
char *cardset;
int cardset_start = 0;
int cardset_end = 32000;
snprintf( tmp, sizeof( tmp ), "cards.dat" );
printf( "Loading cardset....\n" );
LoadCardset( tmp, &card_count, &cardset );
{
int num;
//int s = ( n - 1 ) / 15;
printf( "Sorting cardset...\n" );
for( card = 0; card < card_count; card++ )
{
PCARD_TESTER tester = GetFromSet( CARD_TESTER, &test_set );
tester->card = cardset + (card * 25);
//lprintf( "card %d(%d) = %p", card, GetMemberIndex( CARD_TESTER, &test_set, tester ), tester );
for( num = 0; num < 25; num++ )
{
if( num == 12 )
continue;
{
PCARD_TESTER_LINK link = GetFromSet( CARD_TESTER_LINK, &test_set_links );
PCARD_TESTER_LINK *base_tester= &sorted_cards[cardset[card*25+num]];
link->tester = tester;
//lprintf( "Add card %d to %d", card, cardset[card*25+num] );
if( link->next = (*base_tester) )
(*base_tester)->me = &link->next;
(*base_tester) = link;
}
}
}
}
printf( "Drawing balls...\n" );
for( n = 0; n < 0x40000000; n++ )
{
int *source_balls = DrawRandomNumbers2();
int *balls;
int ball;
switch( n % 6 )
{
case 0:
max_counts[0] = 5;
max_counts[1] = 15;
max_counts[2] = 15;
max_counts[3] = 15;
max_counts[4] = 5;
break;
case 1:
max_counts[0] = 15;
max_counts[1] = 5;
max_counts[2] = 15;
max_counts[3] = 15;
max_counts[4] = 5;
break;
case 2:
max_counts[0] = 5;
max_counts[1] = 15;
max_counts[2] = 15;
max_counts[3] = 5;
max_counts[4] = 15;
break;
case 3:
max_counts[0] = 15;
max_counts[1] = 5;
max_counts[2] = 15;
max_counts[3] = 5;
max_counts[4] = 15;
break;
case 4:
max_counts[0] = 5;
max_counts[1] = 5;
max_counts[2] = 15;
max_counts[3] = 15;
max_counts[4] = 15;
break;
case 5:
max_counts[0] = 15;
max_counts[1] = 15;
max_counts[2] = 15;
max_counts[3] = 5;
max_counts[4] = 5;
break;
}
balls = PickBalls( source_balls );
for( card = 0; card < card_count; card++ )
{
PCARD_TESTER tester = GetSetMember( CARD_TESTER, &test_set, card );
tester->marks = 0;
}
for( ball = 0; ball <= 75; ball++ )
{
lprintf( "First card %p", sorted_cards[ball] );
}
for( ball = 0; ball < 45; ball++ )
{
int cards_marked = 0;
int real_ball = balls[ball];
PCARD_TESTER_LINK tester;
PCARD_TESTER_LINK prior = NULL;
PCARD_TESTER_LINK _prior = NULL;
lprintf( "First card %p", sorted_cards[real_ball] );
for( tester = sorted_cards[real_ball]; tester; tester = tester->next )
{
cards_marked++;
tester->tester->marks++;
_prior = prior;
prior = tester;
}
lprintf( "Marked %d cards with %d", cards_marked, real_ball );
}
printf( "balls: " );
for( ball = 0; ball < 75; ball++ )
{
printf( "%d,", balls[ball] );
}
printf( "\n" );
fflush( stdout );
{
for( ball = 0; ball < 25; ball++ )
{
marks[ball] = 0;
}
ForAllInSet( CARD_TESTER, test_set, TestOk, 0 );
printf( "cards with X marks: " );
for( ball = 0; ball < 25; ball++ )
{
printf( "%d,", marks[ball] );
}
}
printf( "\n" );
fflush( stdout );
{
for( ball = 0; ball < 25; ball++ )
{
marks[ball] = 0;
}
ForAllInSet( CARD_TESTER, test_set, TestOk2, 0 );
printf( "cards with X marks: " );
for( ball = 0; ball < 25; ball++ )
{
printf( "%d,", marks[ball] );
}
}
printf( "\n" );
fflush( stdout );
}
return 0;
}
