void liBlendScreen(color *buffer, color *layer, real32 opacity, sdword nPixels)
{
real32 redSource, greenSource, blueSource, alpha;
real32 redDest, greenDest, blueDest;//, alphaDest;
real32 oneMinusAlpha;
while (nPixels > 0)
{
alpha = colUbyteToReal(colAlpha(*layer)) * opacity;
oneMinusAlpha = 1.0f - alpha;
redSource = colUbyteToReal(colRed(*layer)); //read pixel to floating point
greenSource = colUbyteToReal(colGreen(*layer));
blueSource = colUbyteToReal(colBlue(*layer));
redDest = colUbyteToReal(colRed(*buffer));
greenDest = colUbyteToReal(colGreen(*buffer));
blueDest = colUbyteToReal(colBlue(*buffer));
redDest = (1.0f - (1.0f - redDest) * (1.0f - redSource)) * alpha + redDest * oneMinusAlpha;
greenDest = (1.0f - (1.0f - greenDest) * (1.0f - greenSource)) * alpha + greenDest * oneMinusAlpha;
blueDest = (1.0f - (1.0f - blueDest) * (1.0f - blueSource)) * alpha + blueDest * oneMinusAlpha;
redDest = min(redDest, 1.0f);
greenDest = min(greenDest, 1.0f);
blueDest = min(blueDest, 1.0f);
*buffer = colRGB(colRealToUbyte(redDest), colRealToUbyte(greenDest),
colRealToUbyte(blueDest));
buffer++;
layer++;
nPixels--;
}
}
/*-----------------------------------------------------------------------------
Name : teColorAdjust
Description : Adjust a color according to a HLS colorizing table.
Inputs : baseColor - origional color
colorize - HLS parameters to adjust by.
Outputs :
Return : newly adjusted color
----------------------------------------------------------------------------*/
color teColorAdjust(color baseColor, trhlscolorize *colorize)
{
real32 red, green, blue, hue, lum, sat;
colRGBToHLS(&hue, &lum, &sat, colUbyteToReal(colRed(baseColor)),
colUbyteToReal(colGreen(baseColor)),
colUbyteToReal(colBlue(baseColor)));
hue += colorize->hue;
if (hue < 0)
{
hue += 1.0f;
}
if (hue > 1.0f)
{
hue -= 1.0f;
}
lum *= colorize->lum;
sat *= colorize->sat;
if (lum > 1.0f)
{
lum = 1.0f;
}
if (sat > 1.0f)
{
sat = 1.0f;
}
colHLSToRGB(&red, &green, &blue, hue, lum, sat);
return(colRGB(colRealToUbyte(red), colRealToUbyte(green), colRealToUbyte(blue)));
}
/*-----------------------------------------------------------------------------
Name : tmNumberRUsDraw
Description : Callback to draw number of RU's available
Inputs :
Outputs :
Return :
----------------------------------------------------------------------------*/
void tmNumberRUsDraw(featom *atom, regionhandle region)
{
sdword width;
fonthandle oldfont;
rectangle rect = region->rect;
tmNumberRUsRegion = region;
oldfont = fontMakeCurrent(tmTechListFont);
width = fontWidthf("%d", universe.curPlayerPtr->resourceUnits);//width of number
primModeSet2();
primRectSolid2(&rect, colRGB(0, 0, 0));
glEnable(GL_SCISSOR_TEST);
glScissor(rect.x0, MAIN_WindowHeight - rect.y1, rect.x1 - rect.x0, rect.y1 - rect.y0);
glClear(GL_DEPTH_BUFFER_BIT);
glDisable(GL_SCISSOR_TEST);
feStaticRectangleDraw(region); //draw regular rectangle as backdrop
fontPrintf(region->rect.x1 - width - TM_RUMarginRight,
(region->rect.y1 - region->rect.y0 - fontHeight(NULL)) / 2 + region->rect.y0,
atom->borderColor, "%d", universe.curPlayerPtr->resourceUnits);
fontMakeCurrent(oldfont);
}
void hrDrawChatBox(featom *atom, regionhandle region)
{
fonthandle currentfont;
sdword x,y,i;
char name[128];
hrChatBoxRegion = region;
currentfont = fontMakeCurrent(playernamefont);
primRectSolid2(®ion->rect,colRGB(0,0,0));
feStaticRectangleDraw(region);
x = region->rect.x0+10;
y = region->rect.y0;
for (i=0;i<NUM_CHAT_LINES;i++)
{
if (chathistory[i].message[0]!=0)
{
x = region->rect.x0;
sprintf(name,"%s >",tpGameCreated.playerInfo[chathistory[i].packetheader.frame].PersonalName);
fontPrintf(x,y,tpGameCreated.playerInfo[chathistory[i].packetheader.frame].baseColor,"%s",name);
x+=fontWidth(name)+10;
//fontShadowSet(FS_E | FS_SE | FS_S);
fontPrintf(x,y,hrChatTextColor,"%s",chathistory[i].message);
//fontShadowSet(FS_NONE);
y+= fontHeight(" ");
}
}
fontMakeCurrent(currentfont);
}
void liBlendOverlay(color *buffer, color *layer, real32 opacity, sdword nPixels)
{
real32 redSource, greenSource, blueSource, alpha;
real32 redDest, greenDest, blueDest;//, alphaDest;
real32 oneMinusAlpha;
real32 redTemp, greenTemp, blueTemp;
while (nPixels > 0)
{
alpha = colUbyteToReal(colAlpha(*layer)) * opacity;
oneMinusAlpha = 1.0f - alpha;
redSource = colUbyteToReal(colRed(*layer)); //read pixel to floating point
greenSource = colUbyteToReal(colGreen(*layer));
blueSource = colUbyteToReal(colBlue(*layer));
redDest = colUbyteToReal(colRed(*buffer));
greenDest = colUbyteToReal(colGreen(*buffer));
blueDest = colUbyteToReal(colBlue(*buffer));
if (redDest < 0.5f)
{
redTemp = (2.0f * redSource * 2.0f * redDest) / 2.0f;
}
else
{
redTemp = 1.0f - ((2.0f * (1.0f - redSource)) * (2.0f * (1.0f - redDest)) / 2.0f);
}
if (greenDest < 0.5f)
{
greenTemp = (2.0f * greenSource * 2.0f * greenDest) / 2.0f;
}
else
{
greenTemp = 1.0f - ((2.0f * (1.0f - greenSource)) * (2.0f * (1.0f - greenDest)) / 2.0f);
}
if (blueDest < 0.5f)
{
blueTemp = (2.0f * blueSource * 2.0f * blueDest) / 2.0f;
}
else
{
blueTemp = 1.0f - ((2.0f * (1.0f - blueSource)) * (2.0f * (1.0f - blueDest)) / 2.0f);
}
redDest = redTemp * alpha + redDest * oneMinusAlpha;
greenDest = greenTemp * alpha + greenDest * oneMinusAlpha;
blueDest = blueTemp * alpha + blueDest * oneMinusAlpha;
redDest = min(redDest, 1.0f);
greenDest = min(greenDest, 1.0f);
blueDest = min(blueDest, 1.0f);
*buffer = colRGB(colRealToUbyte(redDest), colRealToUbyte(greenDest),
colRealToUbyte(blueDest));
buffer++;
layer++;
nPixels--;
}
}
/*=============================================================================
Script-parsing functions:
=============================================================================*/
void teTrailColorSet(char *directory,char *field,void *dataToFillIn)
{
sdword iPlayer, iPoint, red, green, blue, nScanned;
nScanned = sscanf(field, "%d,%d,%d,%d,%d", &iPlayer, &iPoint, &red, &green, &blue);
dbgAssert(nScanned == 5);
dbgAssert(iPlayer >= 0 && iPlayer < TE_NumberPlayers);
dbgAssert(iPoint >= 0 && iPoint < TE_NumberTrailColors);
dbgAssert(red >= 0 && red < 256);
dbgAssert(green >= 0 && green < 256);
dbgAssert(blue >= 0 && blue < 256);
teColorSchemes[iPlayer].trailColors[iPoint] = colRGB(red, green, blue);
}
/*-----------------------------------------------------------------------------
Name : teColorSet
Description : Set a color for a particular color scheme structure.
Inputs : script callback
Outputs :
Return :
----------------------------------------------------------------------------*/
void teColorSet(char *directory,char *field,void *dataToFillIn)
{
sdword iPlayer, red, green, blue, nScanned;
color *dest;
nScanned = sscanf(field, "%d,%d,%d,%d", &iPlayer, &red, &green, &blue);
dbgAssert(nScanned == 4);
dbgAssert(iPlayer >= 0 && iPlayer < TE_NumberPlayers);
dbgAssert(red >= 0 && red < 256);
dbgAssert(green >= 0 && green < 256);
dbgAssert(blue >= 0 && blue < 256);
dest = (color *)(((ubyte*)(&teColorSchemes[iPlayer])) +
(udword)dataToFillIn - (udword)(&teColorSchemes));
// teColorSchemes[iPlayer].tacticalColor = colRGB(red, green, blue);
*dest = colRGB(red, green, blue);
}
void teTeamColorsSet(sdword iTeam, color baseColor, color stripeColor)
{
sdword index;
real32 red, green, blue, hue, sat, val;
dbgAssert(iTeam >= 0 && iTeam < TE_NumberPlayers);
if (multiPlayerGame)
{ //if somebody in a multiplayer game
red = colUbyteToReal(colRed(baseColor));
green = colUbyteToReal(colGreen(baseColor));
blue = colUbyteToReal(colBlue(baseColor));
colRGBToHSV(&hue, &sat, &val, red, green, blue);
if (colRealToUbyte(val) < cpDarkestColor0 * TE_DarkColorGraceFactor)
{ //is trying to set his ships to black
baseColor = TE_DorkyCheaterBaseColor;
stripeColor = TE_DorkyCheaterStripeColor;
}
}
teColorSchemes[iTeam].textureColor.base = baseColor;
teColorSchemes[iTeam].textureColor.detail = stripeColor;
#if !TO_STANDARD_COLORS
teColorSchemes[iTeam].tacticalColor =
teColorAdjust(baseColor, &teTacticalColorize);
#endif
for (index = 0; index < TE_NumberTrailColors; index++)
{
teColorSchemes[iTeam].trailColors[index] =
teColorAdjust(baseColor, &teTrailColorize[index]);
}
for (iTeam = 0; iTeam < TE_NumberPlayers; iTeam++)
{
teColorSchemes[iTeam].ambient = colRGB(colClamp256(colRed(teColorSchemes[iTeam].textureColor.base) * teAmbientAdjust / 65536),
colClamp256(colGreen(teColorSchemes[iTeam].textureColor.base) * teAmbientAdjust / 65536),
colClamp256(colBlue(teColorSchemes[iTeam].textureColor.base) * teAmbientAdjust / 65536));
teColorSchemes[iTeam].diffuse = colRGB(colClamp256(colRed(teColorSchemes[iTeam].textureColor.base) * teDiffuseAdjust / 65536),
colClamp256(colGreen(teColorSchemes[iTeam].textureColor.base) * teDiffuseAdjust / 65536),
colClamp256(colBlue(teColorSchemes[iTeam].textureColor.base) * teDiffuseAdjust / 65536));
teColorSchemes[iTeam].specular = colRGB(colClamp256(colRed(teColorSchemes[iTeam].textureColor.base) * teSpecularAdjust / 65536),
colClamp256(colGreen(teColorSchemes[iTeam].textureColor.base) * teSpecularAdjust / 65536),
colClamp256(colBlue(teColorSchemes[iTeam].textureColor.base) * teSpecularAdjust / 65536));
teColorSchemes[iTeam].stripeAmbient = colRGB(colClamp256(colRed(teColorSchemes[iTeam].textureColor.base) * teAmbientAdjust / 65536),
colClamp256(colGreen(teColorSchemes[iTeam].textureColor.base) * teAmbientAdjust / 65536),
colClamp256(colBlue(teColorSchemes[iTeam].textureColor.base) * teAmbientAdjust / 65536));
teColorSchemes[iTeam].stripeDiffuse = colRGB(colClamp256(colRed(teColorSchemes[iTeam].textureColor.base) * teDiffuseAdjust / 65536),
colClamp256(colGreen(teColorSchemes[iTeam].textureColor.base) * teDiffuseAdjust / 65536),
colClamp256(colBlue(teColorSchemes[iTeam].textureColor.base) * teDiffuseAdjust / 65536));
teColorSchemes[iTeam].stripeSpecular = colRGB(colClamp256(colRed(teColorSchemes[iTeam].textureColor.base) * teSpecularAdjust / 65536),
colClamp256(colGreen(teColorSchemes[iTeam].textureColor.base) * teSpecularAdjust / 65536),
colClamp256(colBlue(teColorSchemes[iTeam].textureColor.base) * teSpecularAdjust / 65536));
}
}
void GUILevelPathing::Render(float elapsedTime, const RenderInfo& info)
{
//Overlay a color onto each room based on its proximity to each team.
for (unsigned int i = 0; i < editor.LevelData.Rooms.size(); ++i)
{
const LevelInfo::RoomData& room = editor.LevelData.Rooms[i];
Vector2f worldCenter = ToV2f(room.MinCornerPos) + (ToV2f(room.Walls.GetDimensions()) * 0.5f);
SetBounds(Box2D(editor.WorldPosToScreen(worldCenter),
editor.WorldSizeToScreen(ToV2f(room.Walls.GetDimensions()))));
Vector3f colRGB((COLOR_Team1 * (1.0f - powf(roomNormalizedDistsToTeamBases[i][0], COLOR_Exponent))) +
(COLOR_Team2 * (1.0f - powf(roomNormalizedDistsToTeamBases[i][1], COLOR_Exponent))));
SetColor(Vector4f(colRGB, ALPHA_Team));
GUITexture::Render(elapsedTime, info);
}
}
//This one not a perfect copy, but pretty close
void liBlendColor(color *buffer, color *layer, real32 opacity, sdword nPixels)
{
real32 redSource, greenSource, blueSource, alpha;
real32 redDest, greenDest, blueDest;//, alphaDest;
real32 oneMinusAlpha;
real32 hueS, satS, hueD, satD, lumS, lumD;
real32 clumD, clumS;
real32 redTemp, greenTemp, blueTemp;
#if LI_VERBOSE_LEVEL >= 2
dbgMessagef("\nColor: Blending mode not implemented perfectly.");
#endif
while (nPixels > 0)
{
alpha = colUbyteToReal(colAlpha(*layer)) * opacity;
oneMinusAlpha = 1.0f - alpha;
redSource = colUbyteToReal(colRed(*layer)); //read pixel to floating point
greenSource = colUbyteToReal(colGreen(*layer));
blueSource = colUbyteToReal(colBlue(*layer));
redDest = colUbyteToReal(colRed(*buffer));
greenDest = colUbyteToReal(colGreen(*buffer));
blueDest = colUbyteToReal(colBlue(*buffer));
clumS = (redSource * LI_RedGamma + greenSource * LI_GreenGamma + blueSource * LI_BlueGamma) / LI_TotalGamma;
clumD = (redDest * LI_RedGamma + greenDest * LI_GreenGamma + blueDest * LI_BlueGamma) / LI_TotalGamma;
colRGBToHLS(&hueS, &lumS, &satS, redSource, greenSource, blueSource);
colRGBToHLS(&hueD, &lumD, &satD, redDest, greenDest, blueDest);
colHLSToRGB(&redTemp, &greenTemp, &blueTemp, hueS, clumD, satS);
redDest = redTemp * alpha + redDest * oneMinusAlpha;
greenDest = greenTemp * alpha + greenDest * oneMinusAlpha;
blueDest = blueTemp * alpha + blueDest * oneMinusAlpha;
redDest = min(redDest, 1.0f);
greenDest = min(greenDest, 1.0f);
blueDest = min(blueDest, 1.0f);
*buffer = colRGB(colRealToUbyte(redDest), colRealToUbyte(greenDest),
colRealToUbyte(blueDest));
buffer++;
layer++;
nPixels--;
}
}
/*-----------------------------------------------------------------------------
Name : colMultiplyClamped
Description : multiply a color by a floating-point factor clamping to prevent overflow
Inputs :
Outputs :
Return : multiplied color
----------------------------------------------------------------------------*/
color colMultiplyClamped(color c, real32 factor)
{
udword red, green, blue;
udword intFactor;
if (factor < 0.0f)
{
intFactor = 0;
}
else if (factor > 1.0f)
{
intFactor = 255;
}
else
{
intFactor = (udword)(factor * 255.0f);
}
red = (colRed(c) * intFactor) >> 8;
green = (colGreen(c) * intFactor) >> 8;
blue = (colBlue(c) * intFactor) >> 8;
return(colRGB(red, green, blue));
}
/*-----------------------------------------------------------------------------
Name : Make3dStar
Description : Makes a 3d-star with random position, color, and brightness
Inputs : innerlimit, outerlimit (distances from origin)
Outputs :
Return :
----------------------------------------------------------------------------*/
void Make3dStar(Star3d *star,real32 innerlimit,real32 outerlimit)
{
real32 distance = frandyrandombetween(0,innerlimit,outerlimit);
real32 rotaboutx = frandyrandom(0,2*PI);
real32 rotabouty = frandyrandom(0,2*PI);
real32 rotaboutz = frandyrandom(0,2*PI);
matrix rotxmat;
matrix rotymat;
matrix rotzmat;
vector position1 = { 0.0f,0.0f,0.0f };
vector position2;
udword colorComponent, red, green, blue;
position1.z = distance;
matMakeRotAboutX(&rotxmat,(real32)cos(rotaboutx),(real32)sin(rotaboutx));
matMakeRotAboutY(&rotymat,(real32)cos(rotabouty),(real32)sin(rotabouty));
matMakeRotAboutZ(&rotzmat,(real32)cos(rotaboutz),(real32)sin(rotaboutz));
matMultiplyMatByVec(&position2,&rotxmat,&position1);
matMultiplyMatByVec(&position1,&rotymat,&position2);
matMultiplyMatByVec(&star->position,&rotzmat,&position1);
star->brightness = frandyrandom(0,1.0f);
//compute star color with an random intensity and random variance
colorComponent = randyrandom(0,starMaxColor - starMinColor) + starMinColor;
red = colorComponent + randyrandom(0,starRedVariance * 2) - starRedVariance;
red = min(255, max(0, red));
green = colorComponent + randyrandom(0,starGreenVariance * 2) - starGreenVariance;
green = min(255, max(0, green));
blue = colorComponent + randyrandom(0,starBlueVariance * 2) - starBlueVariance;
blue = min(255, max(0, blue));
star->c = colRGB(red, green, blue);
star->r = (ubyte)red;
star->g = (ubyte)green;
star->b = (ubyte)blue;
}
/*-----------------------------------------------------------------------------
Name : RenderNAVLights
Description : TODO: render sorted by projected depth value so alpha sorts correctly
Inputs : ship - the ship whose navlights we are to render
Outputs :
Return :
----------------------------------------------------------------------------*/
void RenderNAVLights(Ship *ship)
{
sdword i;
NAVLight *navLight;
NAVLightInfo *navLightInfo;
ShipStaticInfo *shipStaticInfo;
NAVLightStatic *navLightStatic;
vector origin = {0.0f, 0.0f, 0.0f};
NAVLightStaticInfo *navLightStaticInfo;
real32 fade;
bool lightOn;
extern bool bFade;
extern real32 meshFadeAlpha;
fade = bFade ? meshFadeAlpha : 1.0f;
shipStaticInfo = (ShipStaticInfo *)ship->staticinfo;
navLightInfo = ship->navLightInfo;
if(shipStaticInfo->navlightStaticInfo && navLightInfo != NULL)
{
glDepthMask(GL_FALSE);
rndAdditiveBlends(TRUE);
lightOn = rndLightingEnable(FALSE);
navLightStaticInfo = shipStaticInfo->navlightStaticInfo;
navLightStatic = navLightStaticInfo->navlightstatics;
navLight = navLightInfo->navLights;
for( i=0 ; i<navLightStaticInfo->numNAVLights ; i++, navLight ++, navLightStatic ++)
{
// Account for the startdelay.
if(navLight->lastTimeFlashed == navLightStatic->startdelay)
{
navLight->lastTimeFlashed = universe.totaltimeelapsed + navLightStatic->startdelay;
}
if(universe.totaltimeelapsed > navLight->lastTimeFlashed)
{
if(navLight->lightstate == 1)
{
navLight->lastTimeFlashed = universe.totaltimeelapsed + navLightStatic->flashrateoff;
}
else
{
navLight->lastTimeFlashed = universe.totaltimeelapsed + navLightStatic->flashrateon;
}
navLight->lightstate = 1 - navLight->lightstate;
}
if(navLight->lightstate)
{
if (ship->currentLOD <= (sdword)navLightStatic->minLOD)
{
navLightBillboardEnable(ship, navLightStatic);
if(navLightStatic->texturehandle == TR_InvalidHandle)
{
primCircleSolid3Fade(&origin, navLightStatic->size, 10, navLightStatic->color, fade);
}
else
{
primSolidTexture3Fade(&origin, navLightStatic->size, navLightStatic->color, navLightStatic->texturehandle, fade);
}
navLightBillboardDisable();
}
else
{
color tempColor;
tempColor = colRGB(colRed(navLightStatic->color) * 2 / 3,
colGreen(navLightStatic->color) * 2 / 3,
colBlue(navLightStatic->color) * 2 / 3);
rndTextureEnable(FALSE);
if (RGL)
{
if (glCapFastFeature(GL_BLEND))
{
rndAdditiveBlends(TRUE);
primPointSize3(&navLightStatic->position, 2.0f, tempColor);
}
else
{
primPointSize3(&navLightStatic->position, 1.0f, tempColor);
}
}
else
{
rndAdditiveBlends(TRUE);
glEnable(GL_POINT_SMOOTH);
primPointSize3Fade(&navLightStatic->position, 2.0f, tempColor, fade);
glDisable(GL_POINT_SMOOTH);
}
}
}
}
rndLightingEnable(lightOn);
rndAdditiveBlends(FALSE);
glDepthMask(GL_TRUE);
}
}
/*=============================================================================
defines:
=============================================================================*/
#ifdef _MACOSX
#define HR_SCALE_MISSION_LOADING_SCREENS TRUE
#else
#define HR_SCALE_MISSION_LOADING_SCREENS FALSE
#endif
#define HR_PlayerNameFont "Arial_12.hff"
#define MAX_CHAT_TEXT 64
#define NUM_CHAT_LINES 10
real32 HorseRacePlayerDropoutTime = 10.0f; // tweakable
color HorseRaceDropoutColor = colRGB(75,75,75);
/*=============================================================================
data:
=============================================================================*/
/*extern HDC hGLDeviceContext;*/
static rectangle hrSinglePlayerPos;
static color hrSinglePlayerLoadingBarColor = colRGB(255,63,63); // pastel red
static sdword JustInit;
static sdword localbar;
// Pixels and info about the background image chosen
static bool hrBackgroundInitFrame = 0;
/*-----------------------------------------------------------------------------
Name : btgLoad
Description : load a btg scene into our structures
Inputs : filename - the name of the btg file to load
Outputs :
Return :
----------------------------------------------------------------------------*/
void btgLoad(char* filename)
{
ubyte* btgData = NULL;
ubyte* btgDataOffset = NULL;
ubyte* instarp = NULL;
udword headSize;
udword vertSize;
udword vertSizeFile;
udword starSize, fileStarSize;
udword polySize;
real32 thetaSave, phiSave;
udword i;
#if FIX_ENDIAN
Uint64 *swap;
#endif
#if BTG_VERBOSE_LEVEL >= 2
dbgMessagef("filename= %s", filename);
#endif
fileLoadAlloc(filename, (void**)&btgData, 0);
btgDataOffset=btgData;
memStrncpy(btgLastBackground, filename, 127);
//reset / free any previous structures
thetaSave = btgThetaOffset;
phiSave = btgPhiOffset;
btgReset();
btgThetaOffset = thetaSave;
btgPhiOffset = phiSave;
//header. trivial copy
headSize = sizeof(btgHeader);
btgHead = (btgHeader*)memAlloc(headSize, "btg header", 0);
#if BTG_VERBOSE_LEVEL >=3
dbgMessagef("btgData= %x", btgData);
dbgMessagef("btgHead= %x", btgHead);
#endif
// Hard coding sizeof values.
// This is because they may change later on in the world but static in the file.
// This allows us to align variables. It replaces
// memcpy(btgHead, btgData, headSize);
memset(btgHead,0,sizeof(btgHead));
memcpy( (ubyte*)btgHead+offsetof(btgHeader,btgFileVersion), btgDataOffset, 4 );
btgDataOffset += 4;
memcpy( (ubyte*)btgHead+offsetof(btgHeader,numVerts ), btgDataOffset, 4 );
btgDataOffset += 4;
memcpy( (ubyte*)btgHead+offsetof(btgHeader,numStars ), btgDataOffset, 4 );
btgDataOffset += 4;
memcpy( (ubyte*)btgHead+offsetof(btgHeader,numPolys ), btgDataOffset, 4 );
btgDataOffset += 4;
memcpy( (ubyte*)btgHead+offsetof(btgHeader,xScroll ), btgDataOffset, 4 );
btgDataOffset += 4;
memcpy( (ubyte*)btgHead+offsetof(btgHeader,yScroll ), btgDataOffset, 4 );
btgDataOffset += 4;
memcpy( (ubyte*)btgHead+offsetof(btgHeader,zoomVal ), btgDataOffset, 4 );
btgDataOffset += 4;
memcpy( (ubyte*)btgHead+offsetof(btgHeader,pageWidth ), btgDataOffset, 4 );
btgDataOffset += 4;
memcpy( (ubyte*)btgHead+offsetof(btgHeader,pageHeight ), btgDataOffset, 4 );
btgDataOffset += 4;
memcpy( (ubyte*)btgHead+offsetof(btgHeader,mRed ), btgDataOffset, 4 );
btgDataOffset += 4;
memcpy( (ubyte*)btgHead+offsetof(btgHeader,mGreen ), btgDataOffset, 4 );
btgDataOffset += 4;
memcpy( (ubyte*)btgHead+offsetof(btgHeader,mBlue ), btgDataOffset, 4 );
btgDataOffset += 4;
memcpy( (ubyte*)btgHead+offsetof(btgHeader,mBGRed ), btgDataOffset, 4 );
btgDataOffset += 4;
memcpy( (ubyte*)btgHead+offsetof(btgHeader,mBGGreen ), btgDataOffset, 4 );
btgDataOffset += 4;
memcpy( (ubyte*)btgHead+offsetof(btgHeader,mBGBlue ), btgDataOffset, 4 );
btgDataOffset += 4;
memcpy( (ubyte*)btgHead+offsetof(btgHeader,bVerts ), btgDataOffset, 4 );
btgDataOffset += 4;
memcpy( (ubyte*)btgHead+offsetof(btgHeader,bPolys ), btgDataOffset, 4 );
btgDataOffset += 4;
memcpy( (ubyte*)btgHead+offsetof(btgHeader,bStars ), btgDataOffset, 4 );
btgDataOffset += 4;
memcpy( (ubyte*)btgHead+offsetof(btgHeader,bOutlines ), btgDataOffset, 4 );
btgDataOffset += 4;
memcpy( (ubyte*)btgHead+offsetof(btgHeader,bBlends ), btgDataOffset, 4 );
btgDataOffset += 4;
memcpy( (ubyte*)btgHead+offsetof(btgHeader,renderMode ), btgDataOffset, 4 );
btgDataOffset += 4;
// memcpy(btgHead, btgData, headSize); //See above.
#if FIX_ENDIAN
btgHead->btgFileVersion = FIX_ENDIAN_INT_32( btgHead->btgFileVersion );
btgHead->numVerts = FIX_ENDIAN_INT_32( btgHead->numVerts );
btgHead->numStars = FIX_ENDIAN_INT_32( btgHead->numStars );
btgHead->numPolys = FIX_ENDIAN_INT_32( btgHead->numPolys );
btgHead->xScroll = FIX_ENDIAN_INT_32( btgHead->xScroll );
btgHead->yScroll = FIX_ENDIAN_INT_32( btgHead->yScroll );
btgHead->zoomVal = FIX_ENDIAN_INT_32( btgHead->zoomVal );
btgHead->pageWidth = FIX_ENDIAN_INT_32( btgHead->pageWidth );
btgHead->pageHeight = FIX_ENDIAN_INT_32( btgHead->pageHeight );
btgHead->mRed = FIX_ENDIAN_INT_32( btgHead->mRed );
btgHead->mGreen = FIX_ENDIAN_INT_32( btgHead->mGreen );
btgHead->mBlue = FIX_ENDIAN_INT_32( btgHead->mBlue );
btgHead->mBGRed = FIX_ENDIAN_INT_32( btgHead->mBGRed );
btgHead->mBGGreen = FIX_ENDIAN_INT_32( btgHead->mBGGreen );
btgHead->mBGBlue = FIX_ENDIAN_INT_32( btgHead->mBGBlue );
btgHead->bVerts = FIX_ENDIAN_INT_32( btgHead->bVerts );
btgHead->bPolys = FIX_ENDIAN_INT_32( btgHead->bPolys );
btgHead->bStars = FIX_ENDIAN_INT_32( btgHead->bStars );
btgHead->bOutlines = FIX_ENDIAN_INT_32( btgHead->bOutlines );
btgHead->bBlends = FIX_ENDIAN_INT_32( btgHead->bBlends );
btgHead->renderMode = FIX_ENDIAN_INT_32( btgHead->renderMode );
#endif
//set background colour
universe.backgroundColor = colRGB(btgHead->mBGRed, btgHead->mBGGreen, btgHead->mBGBlue);
//version check
dbgAssertOrIgnore(btgHead->btgFileVersion == BTG_FILE_VERSION);
vertSize = btgHead->numVerts * sizeof(btgVertex); //Machine Specific size
vertSizeFile = btgHead->numVerts * (4 + (2* 8) + (5*4)); //Actual size from file. (No Alignment)
if (vertSize)
{
btgVerts = (btgVertex*)memAlloc(vertSize, "btg verts", 0);
for( i=0; i<btgHead->numVerts; i++ )
{
memcpy( (ubyte*)btgVerts+ ( i * sizeof(btgVertex)) +offsetof(btgVertex,flags ), btgDataOffset, 4 );
btgDataOffset += 4;
memcpy( (ubyte*)btgVerts+( i * sizeof(btgVertex)) +offsetof(btgVertex,x ), btgDataOffset, 8 );
btgDataOffset += 8;
memcpy( (ubyte*)btgVerts+( i * sizeof(btgVertex)) +offsetof(btgVertex,y ), btgDataOffset, 8 );
btgDataOffset += 8;
memcpy( (ubyte*)btgVerts+( i * sizeof(btgVertex)) +offsetof(btgVertex,red ), btgDataOffset, 4 );
btgDataOffset += 4;
memcpy( (ubyte*)btgVerts+( i * sizeof(btgVertex)) +offsetof(btgVertex,green ), btgDataOffset, 4 );
btgDataOffset += 4;
memcpy( (ubyte*)btgVerts+( i * sizeof(btgVertex)) +offsetof(btgVertex,blue ), btgDataOffset, 4 );
btgDataOffset += 4;
memcpy( (ubyte*)btgVerts+( i * sizeof(btgVertex)) +offsetof(btgVertex,alpha ), btgDataOffset, 4 );
btgDataOffset += 4;
memcpy( (ubyte*)btgVerts+( i * sizeof(btgVertex)) +offsetof(btgVertex,brightness ), btgDataOffset, 4 );
btgDataOffset += 4;
}
// memcpy(btgVerts, btgData + headSize, vertSize); //Replaced by above.
#if FIX_ENDIAN
for( i=0; i<btgHead->numVerts; i++ )
{
btgVerts[i].flags = FIX_ENDIAN_INT_32( btgVerts[i].flags );
swap = ( Uint64 *)&btgVerts[i].x;
*swap = SDL_SwapLE64( *swap );
swap = ( Uint64 *)&btgVerts[i].y;
*swap = SDL_SwapLE64( *swap );
btgVerts[i].red = FIX_ENDIAN_INT_32( btgVerts[i].red );
btgVerts[i].green = FIX_ENDIAN_INT_32( btgVerts[i].green );
btgVerts[i].blue = FIX_ENDIAN_INT_32( btgVerts[i].blue );
btgVerts[i].alpha = FIX_ENDIAN_INT_32( btgVerts[i].alpha );
btgVerts[i].brightness = FIX_ENDIAN_INT_32( btgVerts[i].brightness );
}
#endif
}
#if BTG_VERBOSE_LEVEL >= 2
dbgMessagef("numStars= %d", btgHead->numStars);
#endif
//stars. non-trivial munging around
starSize = btgHead->numStars * sizeof(btgStar);
fileStarSize = 0;
if (starSize != 0)
{
btgStar* outstarp;
btgStar* inp;
udword* udp;
sdword j, tempSize, count, length;
char filename[48];
btgStars = (btgStar*)memAlloc(starSize, "btg stars", 0);
instarp = btgDataOffset;
#if BTG_VERBOSE_LEVEL >= 3
dbgMessagef("instarp= %x",instarp);
dbgMessagef("Offset= %x",instarp - btgData);
#endif
outstarp = btgStars;
inp = ( btgStar *)instarp;
for (i = 0; i < btgHead->numStars; i++, outstarp++)
{
//extract constant-sized header
// tempSize = sizeof(udword) + 2*sizeof(real64) + 4*sizeof(sdword);
tempSize = 4 + 2*8 + 4*4;
memcpy( (ubyte*)outstarp+offsetof(btgStar,flags), instarp, 4);
instarp += 4;
memcpy( (ubyte*)outstarp+offsetof(btgStar,x), instarp, 8);
instarp += 8;
memcpy( (ubyte*)outstarp+offsetof(btgStar,y), instarp, 8);
instarp += 8;
memcpy( (ubyte*)outstarp+offsetof(btgStar,red), instarp, 4);
instarp += 4;
memcpy( (ubyte*)outstarp+offsetof(btgStar,green), instarp, 4);
instarp += 4;
memcpy( (ubyte*)outstarp+offsetof(btgStar,blue), instarp, 4);
instarp += 4;
memcpy( (ubyte*)outstarp+offsetof(btgStar,alpha), instarp, 4);
instarp += 4;
// memcpy(outstarp, instarp, tempSize); //Replaced by Above.
#if BTG_VERBOSE_LEVEL >= 3
dbgMessagef("tempSize= %x", tempSize);
dbgMessagef("instarp= %x", instarp);
#endif
fileStarSize += tempSize;
#if FIX_ENDIAN
swap = ( Uint64 *)&outstarp->x;
*swap = SDL_SwapLE64( *swap );
swap = ( Uint64 *)&outstarp->y;
*swap = SDL_SwapLE64( *swap );
outstarp->flags = FIX_ENDIAN_INT_32( outstarp->flags );
outstarp->red = FIX_ENDIAN_INT_32( outstarp->red );
outstarp->green = FIX_ENDIAN_INT_32( outstarp->green );
outstarp->blue = FIX_ENDIAN_INT_32( outstarp->blue );
outstarp->alpha = FIX_ENDIAN_INT_32( outstarp->alpha );
#endif
//extract variable-sized filename
count = 0;
memset(filename, 0, 48);
udp = (udword*)instarp;
#if FIX_ENDIAN
length = FIX_ENDIAN_INT_32( (sdword)*udp );
#else
length = (sdword)*udp;
#endif
#if BTG_VERBOSE_LEVEL >=4
dbgMessagef("instarp= %x", instarp);
dbgMessagef("udp= %x", udp);
dbgMessagef("length= %d", length);
dbgMessagef("filename= %s", filename);
#endif
instarp += 4;
fileStarSize += 4;
for (j = 0; j < length; j++)
{
filename[count++] = *instarp++;
fileStarSize++;
}
memcpy(outstarp->filename, filename, 48);
//create a GL texture object
if (!btgTexInList(filename))
{
btgGetTexture(filename, &outstarp->glhandle, &outstarp->width, &outstarp->height);
btgAddTexToList(filename, outstarp->glhandle, outstarp->width, outstarp->height);
}
else
{
btgFindTexture(filename, outstarp);
}
}
}
//reset the game's current texture, which now differs from the GL's
trClearCurrent();
btgPolygon* polyOut;
//polys. trivial copy
polySize = btgHead->numPolys * sizeof(btgPolygon);
if (polySize != 0)
{
btgPolys = (btgPolygon*)memAlloc(polySize, "btg polys", 0);
polyOut= btgPolys;
// HERE FIX IT HERE
// memcpy(btgPolys, btgData + headSize + vertSize + fileStarSize, polySize);
for( i=0; i<btgHead->numPolys; i++, polyOut++ )
{
memcpy((ubyte*)polyOut+offsetof(btgPolygon,flags), instarp, 4);
instarp += 4;
memcpy((ubyte*)polyOut+offsetof(btgPolygon,v0), instarp, 4);
instarp += 4;
memcpy((ubyte*)polyOut+offsetof(btgPolygon,v1), instarp, 4);
instarp += 4;
memcpy((ubyte*)polyOut+offsetof(btgPolygon,v2), instarp, 4);
instarp += 4;
}
#if FIX_ENDIAN
for( i=0; i<btgHead->numPolys; i++ )
{
btgPolys[i].flags = FIX_ENDIAN_INT_32( btgPolys[i].flags );
btgPolys[i].v0 = FIX_ENDIAN_INT_32( btgPolys[i].v0 );
btgPolys[i].v1 = FIX_ENDIAN_INT_32( btgPolys[i].v1 );
btgPolys[i].v2 = FIX_ENDIAN_INT_32( btgPolys[i].v2 );
}
#endif
}
memFree(btgData);
btgIndices = (uword*)memAlloc(3 * btgHead->numPolys * sizeof(uword), "btg indices", NonVolatile);
if (useVBO) glGenBuffers(1, &vboIndices);
#ifndef _WIN32_FIXME
//spherically project things, blend colours, &c
btgConvertVerts();
#endif
}
unsigned long AD_PORT = 2501; char PATCHNAME[50] = "HomeworldPatch.exe"; char ROUTING_SERVER_NAME[30] = "routingserv"; real32 LAN_ADVERTISE_USER_TIME = 1.0f; real32 LAN_ADVERTISE_USER_TIMEOUT = 5.0f; real32 LAN_ADVERTISE_GAME_TIME = 1.0f; real32 LAN_ADVERTISE_GAME_TIMEOUT = 5.0f; real32 KEEPALIVE_SEND_IAMALIVE_TIME = 10.0f; real32 KEEPALIVE_IAMALIVE_TIMEOUT = 25.0f; real32 KEEPALIVE_SEND_ALIVESTATUS_TIME = 30.0f; color PATCHBARCOLOR = colRGB(255, 0, 0); color PATCHBAROUTLINECOLOR = colWhite; udword PRINTLAG_IFGREATERTHAN = 10; udword PRINTLAG_MINFRAMES = 20; udword ROOM_MIN_THRESHOLD = 1; udword ROOM_MAX_THRESHOLD = 50; unsigned long WAIT_SHUTDOWN_MS = 1000; void scriptSetIPStrings(char *directory,char *field,void *dataToFillIn); void scriptSetPortNumbers(char *directory,char *field,void *dataToFillIn); extern sdword TimedOutWaitingForPauseAcksGiveUpAfterNumTimes;
/*-----------------------------------------------------------------------------
Name : pingListDraw
Description : Draw all pings from farthest to nearest.
Inputs : camera - the camera we're rendering from
modelView, projection - current matrices
viewPort - rectangle we're rending in, for the TO legend
Outputs :
Return :
Note : The renderer should be in 2D mode at this point.
----------------------------------------------------------------------------*/
void pingListDraw(Camera *camera, hmatrix *modelView, hmatrix *projection, rectangle *viewPort)
{
real32 pingAge, pingCycle, pingMod, pingSize;
real32 x, y, radius;
Node *thisNode, *nextNode;
ping *thisPing;
vector distSquared;
sdword nSegments, index, rowHeight, xScreen, yScreen;
oval o;
udword TOFlags = 0;
fonthandle fhSave;
toicon *icon;
color col;
real32 realMargin;
ShipClass shipClass;
static real32 lastProximityPing = REALlyBig;
static real32 lastAnomolyPing = REALlyBig;
static real32 lastBattlePing = REALlyBig;
static real32 lastHyperspacePing = REALlyBig;
static real32 lastNewshipPing = REALlyBig;
bool pingset;
//start by sorting the ping list from farthest to nearest
thisNode = pingList.head;
while (thisNode != NULL)
{ //scan all pings
nextNode = thisNode->next;
thisPing = listGetStructOfNode(thisNode);
if (thisPing->owner != NULL)
{
thisPing->centre = thisPing->owner->posinfo.position;
}
vecSub(distSquared, camera->eyeposition, thisPing->centre);
thisPing->cameraDistanceSquared = vecMagnitudeSquared(distSquared);
TOFlags |= thisPing->TOMask;
thisNode = nextNode;
}
listMergeSortGeneral(&pingList, pingListSortCallback);
//now the list is sorted; proceed to draw all the pings
thisNode = pingList.head;
pingset = FALSE;
while (thisNode != NULL)
{ //scan all pings
nextNode = thisNode->next;
thisPing = listGetStructOfNode(thisNode);
pingCycle = thisPing->pingDuration + thisPing->interPingPause;
pingAge = universe.totaltimeelapsed - thisPing->creationTime;
pingMod = (real32)fmod((double)pingAge, (double)pingCycle);
if (pingMod <= thisPing->pingDuration)
{
pingSize = (thisPing->size - thisPing->minSize) * pingMod / thisPing->pingDuration + thisPing->minSize;
selCircleComputeGeneral(modelView, projection, &thisPing->centre, max(thisPing->size,thisPing->minSize), &x, &y, &radius);
if (radius > 0.0f)
{
radius = max(radius, thisPing->minScreenSize);
radius *= pingSize / max(thisPing->size,thisPing->minSize);
o.centreX = primGLToScreenX(x);
o.centreY = primGLToScreenY(y);
o.radiusX = o.radiusY = primGLToScreenScaleX(radius);
nSegments = pieCircleSegmentsCompute(radius);
primOvalArcOutline2(&o, 0.0f, 2*PI, 1, nSegments, thisPing->c);
/* starting to draw a new ping so play the sound */
if (!smZoomingIn && !smZoomingOut && !pingset)
{
switch (thisPing->TOMask)
{
case PTOM_Anomaly:
if (pingSize <=lastAnomolyPing)
{
soundEvent(NULL, UI_SensorsPing);
pingset = TRUE;
lastAnomolyPing = pingSize;
}
break;
case PTOM_Battle:
if (pingSize <= lastBattlePing)
{
soundEvent(NULL, UI_PingBattle);
pingset = TRUE;
lastBattlePing = pingSize;
}
break;
case PTOM_Hyperspace:
if (pingSize <= lastHyperspacePing)
{
soundEvent(NULL, UI_PingHyperspace);
pingset = TRUE;
lastHyperspacePing = pingSize;
}
break;
case PTOM_Proximity:
if (pingSize <= lastProximityPing)
{
soundEvent(NULL, UI_PingProximity);
pingset = TRUE;
lastProximityPing = pingSize;
}
break;
case PTOM_NewShips:
if (pingSize <= lastNewshipPing)
{
soundEvent(NULL, UI_PingNewShips);
pingset = TRUE;
lastNewshipPing = pingSize;
}
break;
default:
break;
}
}
}
}
thisNode = nextNode;
}
//draw the blip TO
if (smTacticalOverlay)
{
realMargin = primScreenToGLScaleX(viewPort->x0);
fhSave = fontCurrentGet(); //save the current font
fontMakeCurrent(selGroupFont2); // use a common, fairly small font
rowHeight = fontHeight("M"); // used to space the legend
yScreen = viewPort->y0 + rowHeight; //leave some space at the top to start
radius = primScreenToGLScaleX(rowHeight)/2;
xScreen = viewPort->x0 + (sdword)(rowHeight * 2.5);
for (index = 0; index < PTO_NumberTOs; index++)
{
if ((TOFlags & pingTOList[index].bitMask))
{
// fontPrint(xScreen, yScreen, *pingTOList[index].c, "O");
pingTOList[index].lastTimeDrawn = universe.totaltimeelapsed;
}
if (universe.totaltimeelapsed - pingTOList[index].lastTimeDrawn <= pingTOLingerTime)
{
o.centreX = viewPort->x0 + rowHeight * 3 / 2;
o.centreY = yScreen + rowHeight / 2;
o.radiusX = o.radiusY = rowHeight / 2;
primOvalArcOutline2(&o, 0.0f, TWOPI, 1, pingTONSegments, *pingTOList[index].c);
fontPrint(xScreen, yScreen, TO_TextColor, strGetString(pingTOList[index].stringEnum));
yScreen += rowHeight + 1;
}
}
for (shipClass = 0; shipClass < NUM_CLASSES; shipClass++)
{
if (!toClassUsed[shipClass][0])
{
continue;
}
icon = toClassIcon[shipClass];
fontPrint(xScreen, yScreen + (rowHeight>>2), TO_TextColor, ShipClassToNiceStr(shipClass));
#if TO_STANDARD_COLORS
col = teFriendlyColor;
#else
col = teColorSchemes[universe.curPlayerIndex].tacticalColor;
#endif
col = colRGB(colRed(col)/TO_IconColorFade, colGreen(col)/TO_IconColorFade, colBlue(col)/TO_IconColorFade);
primLineLoopStart2(1, col);
for (index = icon->nPoints - 1; index >= 0; index--)
{
primLineLoopPoint3F(realMargin + primScreenToGLX(rowHeight*1.5) + icon->loc[index].x * radius,
primScreenToGLY(yScreen + rowHeight/2) + icon->loc[index].y * radius);
}
primLineLoopEnd2();
yScreen += rowHeight + 1;
}
fontMakeCurrent(fhSave);
}
}
sdword MessageToAllies;
bool ViewingBuffer=FALSE;
//bool reset=FALSE;
fonthandle chathistoryfont=0;
char chathistoryfontname[64]="default.hff";
LinkedList chathistorylist;
Node *curPosition=NULL;
chathistory threadtransfer[40];
sdword numnewchat=0;
// tweakable variables for color
color gcGamePrivateChatColor=colRGB(255,0,0);
color gcGameWhisperedColor=colRGB(0,255,0);
color gcGameNormalChatColor=colRGB(200,200,200);
void *chatmutex=NULL;
BabyCallBack *ScrollDownAutoBaby=NULL;
real32 GC_SCROLL_TIME=2.5f;
sdword maxlines=3;
uword RUTransferToPlayer;
sdword chatwidth;
/*=============================================================================
function prototypes:
=============================================================================*/
void liBlendColorDodge(color *buffer, color *layer, real32 opacity, sdword nPixels)
{
real32 redSource, greenSource, blueSource, alpha;
real32 redDest, greenDest, blueDest;//, alphaDest;
real32 oneMinusAlpha;
while (nPixels > 0)
{
alpha = colUbyteToReal(colAlpha(*layer)) * opacity;
oneMinusAlpha = 1.0f - alpha;
redSource = colUbyteToReal(colRed(*layer)); //read pixel to floating point
greenSource = colUbyteToReal(colGreen(*layer));
blueSource = colUbyteToReal(colBlue(*layer));
redDest = colUbyteToReal(colRed(*buffer));
greenDest = colUbyteToReal(colGreen(*buffer));
blueDest = colUbyteToReal(colBlue(*buffer));
redDest = (redDest + redSource * redSource * redDest) * alpha + redDest * oneMinusAlpha;
greenDest = (greenDest + greenSource * greenSource * greenDest) * alpha + greenDest * oneMinusAlpha;
blueDest = (blueDest + blueSource * blueSource * blueDest) * alpha + blueDest * oneMinusAlpha;
redDest = min(redDest, 1.0f);
greenDest = min(greenDest, 1.0f);
blueDest = min(blueDest, 1.0f);
*buffer = colRGB(colRealToUbyte(redDest), colRealToUbyte(greenDest),
colRealToUbyte(blueDest));
buffer++;
layer++;
nPixels--;
}
/*
real32 redSource, greenSource, blueSource, alpha;
real32 redDest, greenDest, blueDest;//, alphaDest;
real32 oneMinusAlpha;
real32 hueS, satS, valS, hueD, satD, valD;
// real32 cvalD, cvalS;
while (nPixels > 0)
{
alpha = colUbyteToReal(colAlpha(*layer)) * opacity;
oneMinusAlpha = 1.0f - alpha;
redSource = colUbyteToReal(colRed(*layer)); //read pixel to floating point
greenSource = colUbyteToReal(colGreen(*layer));
blueSource = colUbyteToReal(colBlue(*layer));
redDest = colUbyteToReal(colRed(*buffer));
greenDest = colUbyteToReal(colGreen(*buffer));
blueDest = colUbyteToReal(colBlue(*buffer));
// redDest = (redDest + redSource * redSource * redDest) * alpha + redDest * oneMinusAlpha;
// greenDest = (greenDest + greenSource * greenSource * greenDest) * alpha + greenDest * oneMinusAlpha;
// blueDest = (blueDest + blueSource * blueSource * blueDest) * alpha + blueDest * oneMinusAlpha;
colRGBToHSV(&hueS, &satS, &valS, redSource * alpha, greenSource * alpha, blueSource * alpha);
colRGBToHSV(&hueD, &satD, &valD, redDest, greenDest, blueDest);
valD += valS;
valD = min(valD, 1.0f);
colHSVToRGB(&redDest, &greenDest, &blueDest, hueD, satD, valD);
*buffer = colRGB(colRealToUbyte(redDest), colRealToUbyte(greenDest),
colRealToUbyte(blueDest));
buffer++;
layer++;
nPixels--;
}
*/
}
void tutExecute(regionhandle reg)
{
fonthandle currentfont;
sdword texty, bitmap;
rectangle rect; // used for translucent boxes behind text
rectangle *buttonrect = ®->rect; // used for "next" button
bool modeset = FALSE;
sdword bitmap_x, bitmap_vel;
if(tutorial == 3)
return;
if(tutRegion->previous)
regSiblingMoveToFront(tutRegion);
if(tutTransition == 0 && tutLesson != TUT_LESSON_ENTER_BUILD_MANAGER && tutLesson != TUT_LESSON_BUILD_SHIP) // don't draw button on build manager lessons
{
if(mouseInRect(buttonrect))
{
if(mouseLeftButton())
{
tutSkip = TRUE;
trRGBTextureMakeCurrent(tutButtonTexture[NEXT_ON]);
}
else
trRGBTextureMakeCurrent(tutButtonTexture[NEXT_MOUSE]);
}
else
trRGBTextureMakeCurrent(tutButtonTexture[NEXT_OFF]);
rndPerspectiveCorrection(FALSE);
// glEnable(GL_BLEND); // needs to be enabled once Keith fixes alpha blending intel compiler optimization bug
primRectSolidTextured2(buttonrect);
// glDisable(GL_BLEND); // needs to be enabled once Keith fixes alpha blending intel compiler optimization bug
}
if(tutTransition == 0)
{
switch(PassedTutorial(tutLesson))
{
case 0: // Didn't pass
break;
case 1: // Perform transition
tutTransition = 1;
break;
case -1: // No Transition
tutLesson++;
InitTutorial(tutLesson);
break;
}
}
else if(tutTransition == 1)
{
tutTransitionCount++;
if(tutTransitionCount == TUT_TransitionFramesOut)
{
tutTransition = 2;
tutTransitionCount = TUT_TransitionFramesIn;
tutLesson++;
InitTutorial(tutLesson);
if((tutLesson >= TUT_ADVANCED_INTRO && tutorial == 1) || (tutLesson >= TUT_TOTAL_LESSONS && tutorial == 2))
{
tutorialdone = TRUE;
return;
}
}
}
else if(tutTransition == 2)
{
tutTransitionCount--;
if(tutTransitionCount == 0)
tutTransition = 0;
}
if(tutBitmapList[tutLesson][2] != -1)
{
bitmap_x = TUT_BITMAP_X;
bitmap_vel = 210;
}
else if(tutBitmapList[tutLesson][1] != -1)
{
bitmap_x = TUT_BITMAP_X + (TUT_BITMAP_WIDTH + 8);
bitmap_vel = 150;
}
else
{
bitmap_x = TUT_BITMAP_X + ((2 * TUT_BITMAP_WIDTH) + 8);
bitmap_vel = 90;
}
if(tutTransition == 0)
bitmap_vel = 0;
else if(tutTransition == 1)
bitmap_vel = (long) (((float)bitmap_vel/(float)TUT_TransitionFramesOut) * (float)tutTransitionCount);
else if(tutTransition == 2)
bitmap_vel = (long) (((float)bitmap_vel/(float)TUT_TransitionFramesIn) * (float)tutTransitionCount);
// glEnable(GL_BLEND);
for(bitmap = 0; bitmap < 3; bitmap++)
{
if(tutBitmapList[tutLesson][bitmap] != -1)
{
trRGBTextureMakeCurrent(tutButtonTexture[tutBitmapList[tutLesson][bitmap]]);
rndPerspectiveCorrection(FALSE);
rect.x0 = bitmap_x + ((TUT_BITMAP_WIDTH + 8) * bitmap) + bitmap_vel;
rect.y0 = TUT_BITMAP_Y;
rect.x1 = bitmap_x + ((TUT_BITMAP_WIDTH + 8) * bitmap) + TUT_BITMAP_WIDTH + bitmap_vel;
rect.y1 = TUT_BITMAP_Y + TUT_BITMAP_HEIGHT;
primRectSolidTextured2(&rect);
}
}
// glDisable(GL_BLEND);
if (!primModeEnabled) // draw translucent polys before text
{
primModeSet2();
modeset = TRUE;
}
if(tutLesson != TUT_LESSON_BUILD_SHIP) // default behaviour for lessons
{
long TitlePos = (long)(TUT_TitleTransMult[tutTransition] * (float)tutTransitionCount);
long TextPos = (long)(TUT_TextTransMult[tutTransition] * (float)tutTransitionCount);
rect.x0 = 0;
rect.y0 = TUT_Title_Y - TitlePos - 7;
rect.x1 = 640;
rect.y1 = TUT_Title_Y - TitlePos + 22;
primRectTranslucent2(&rect, colRGBA(0, 0, 0, 128));
rect.x0 = TUT_Main_X - TextPos - 12;
rect.y0 = TUT_Main_Y - 6;
rect.x1 = TUT_Main_X - TextPos + TUT_MainTextWidth + 4;
rect.y1 = tutLastMainY;
primRectTranslucent2(&rect, colRGBA(0, 0, 0, 128));
currentfont = fontMakeCurrent(tutTitleFont); // draw text
fontPrintf(TUT_Title_X, TUT_Title_Y - TitlePos, TUT_TitleColor, "%s", strGetString(strTutorial00Title + (tutLesson * 7)));
currentfont = fontMakeCurrent(tutMainFont);
texty = DrawTextBlock(strGetString(strTutorial00Line01 + (tutLesson * 7)), TUT_Main_X - TextPos, TUT_Main_Y, TUT_MainTextWidth, TUT_MainTextHeight, TUT_MainColor);
texty = DrawTextBlock(strGetString(strTutorial00Line02 + (tutLesson * 7)), TUT_Main_X - TextPos, texty, TUT_MainTextWidth, TUT_MainTextHeight, TUT_MainColor);
texty = DrawTextBlock(strGetString(strTutorial00Line03 + (tutLesson * 7)), TUT_Main_X - TextPos, texty, TUT_MainTextWidth, TUT_MainTextHeight, TUT_MainColor);
texty = DrawTextBlock(strGetString(strTutorial00Line04 + (tutLesson * 7)), TUT_Main_X - TextPos, texty, TUT_MainTextWidth, TUT_MainTextHeight, TUT_MainColor);
tutLastMainY = DrawTextBlock(strGetString(strTutorial00Line05 + (tutLesson * 7)), TUT_Main_X - TextPos, texty, TUT_MainTextWidth, TUT_MainTextHeight, TUT_MainColor);
fontMakeCurrent(currentfont);
}
else // special case for build ship lesson
{
currentfont = fontMakeCurrent(tutMainFont);
texty = DrawTextBlock(strGetString(strTutorial17Line01 + tutVar.count), TUT_Build_X, TUT_Build_Y, TUT_BuildTextWidth, TUT_BuildTextHeight, TUT_BuildColor);
fontMakeCurrent(currentfont);
rect.x0 = TUT_Build_X - 8; // draw outline box around text
rect.y0 = TUT_Build_Y - 6;
rect.x1 = TUT_Build_X + TUT_BuildTextWidth + 8;
rect.y1 = texty;
primRectOutline2(&rect, 2, colRGB(tutPulseValue, tutPulseValue, tutPulseValue));
if(tutVar.count == 0) // point to appropriate place on screen
tutDrawLinePulse(TUT_Build_X - 8, texty, 160, 100, tutPulseValue, 8);
else if(tutVar.count == 1)
tutDrawLinePulse(TUT_Build_X - 8, texty, 180, 410, tutPulseValue, 8);
else if(tutVar.count == 2)
tutDrawLinePulse(TUT_Build_X - 8, texty, 550, 410, tutPulseValue, 8);
tutPulseValue -= 8;
}
if(!FirstWordNULL(strGetString(strTutorial00Tip + (tutLesson * 7))))
{
long TipPos = (long)(TUT_TipTransMult[tutTransition] * (float)tutTransitionCount);
long TextPos = (long)(TUT_TextTransMult[tutTransition] * (float)tutTransitionCount);
if (!primModeEnabled) // draw translucent polys before tip text
{
primModeSet2();
modeset = TRUE;
}
rect.x0 = TUT_TipTitle_X - 8;
rect.y0 = TUT_TipTitle_Y - TipPos - 6;
rect.x1 = TUT_Tip_X - 8;
rect.y1 = TUT_TipTitle_Y - TipPos + 18;
primRectTranslucent2(&rect, colRGBA(0, 0, 0, 128));
rect.x0 = TUT_Tip_X + TextPos - 8;
rect.y0 = TUT_Tip_Y - 6;
rect.x1 = TUT_Tip_X + TextPos + TUT_TipTextWidth + 8;
rect.y1 = tutLastTipY;
primRectTranslucent2(&rect, colRGBA(0, 0, 0, 128));
if(modeset)
primModeClear2();
currentfont = fontMakeCurrent(tutTipTitleFont);
fontPrintf(TUT_TipTitle_X, TUT_TipTitle_Y - TipPos, TUT_TipTitleColor, "%s", strGetString(strTutorialTip));
currentfont = fontMakeCurrent(tutTipFont);
tutLastTipY = DrawTextBlock(strGetString(strTutorial00Tip + (tutLesson * 7)), TUT_Tip_X + TextPos, TUT_Tip_Y, TUT_TipTextWidth, TUT_TipTextHeight, TUT_TipColor);
}
fontMakeCurrent(currentfont);
}
#include "Alliance.h"
#include "gamechat.h"
#include "chatting.h"
#include "utility.h"
#include "universe.h"
#include "commandnetwork.h"
#include "commandlayer.h"
#include "commandwrap.h"
#include "strings.h"
#include "soundevent.h"
/*=============================================================================
Data:
=============================================================================*/
color allianceMessageColor = colRGB(255,255,255);
/*=============================================================================
Function prototypes for some private functions:
=============================================================================*/
//void alliancePrintNamesNice(char *dest, uword alliance);
void allianceRemovePlayerShipsFromAttackList(SelectAnyCommand *list,uword playerindex,CommandToDo *todo);
void allianceCancelAttackOrders(uword playerone, uword playertwo);
/*=============================================================================
Function logic for Alliances:
=============================================================================*/
/*-----------------------------------------------------------------------------
