// ------------------------------------------------------------------------------------
void avUpdateTiles( void )
{
const int len = mapHeight * mapWidth;
const int playermask = 1 << selectedPlayer;
UDWORD i = 0;
float maxLevel, increment = graphicsTimeAdjustedIncrement(FADE_IN_TIME); // call once per frame
MAPTILE *psTile;
/* Go through the tiles */
for (psTile = psMapTiles; i < len; i++)
{
maxLevel = psTile->illumination;
if (psTile->level > 0 || psTile->tileExploredBits & playermask) // seen
{
// If we are not omniscient, and we are not seeing the tile, and none of our allies see the tile...
if (!godMode && !(alliancebits[selectedPlayer] & (satuplinkbits | psTile->sensorBits)))
{
maxLevel /= 2;
}
if (psTile->level > maxLevel)
{
psTile->level = MAX(psTile->level - increment, 0);
}
else if (psTile->level < maxLevel)
{
psTile->level = MIN(psTile->level + increment, maxLevel);
}
}
psTile++;
}
}
void calcDroidIllumination(DROID *psDroid)
{
UDWORD lightVal; // sum of light vals
UDWORD presVal;
UDWORD tileX,tileY;
UDWORD retVal;
float adjust;
/* See if the droid's at the edge of the map */
tileX = psDroid->pos.x/TILE_UNITS;
tileY = psDroid->pos.y/TILE_UNITS;
/* Are we at the edge */
if(tileX<=1 || tileX>=mapWidth-2 || tileY<=1 || tileY>=mapHeight-2)
{
lightVal = mapTile(tileX,tileY)->illumination;
lightVal += MIN_DROID_LIGHT_LEVEL;
}
else
{
lightVal = mapTile(tileX,tileY)->illumination + //
mapTile(tileX-1,tileY)->illumination + // *
mapTile(tileX,tileY-1)->illumination + // *** pattern
mapTile(tileX+1,tileY)->illumination + // *
mapTile(tileX+1,tileY+1)->illumination; //
lightVal/=5;
lightVal += MIN_DROID_LIGHT_LEVEL;
}
/* Saturation */
if(lightVal>255) lightVal = 255;
presVal = psDroid->illumination;
adjust = (float)lightVal - (float)presVal;
adjust *= graphicsTimeAdjustedIncrement(DROID_SEEK_LIGHT_SPEED);
retVal = presVal + adjust;
if(retVal > 255) retVal = 255;
psDroid->illumination = (UBYTE)retVal;
}
/**
* Draw the water.
*/
void drawWater(const glm::mat4 &viewMatrix)
{
int x, y;
const glm::vec4 paramsX(0, 0, -1.0f / world_coord(4), 0);
const glm::vec4 paramsY(1.0f / world_coord(4), 0, 0, 0);
const glm::vec4 paramsX2(0, 0, -1.0f / world_coord(5), 0);
const glm::vec4 paramsY2(1.0f / world_coord(5), 0, 0, 0);
const auto &renderState = getCurrentRenderState();
const auto &program = pie_ActivateShader(SHADER_WATER, viewMatrix, paramsX, paramsY, paramsX2, paramsY2, 0, 1,
glm::translate(glm::vec3(waterOffset, 0.f, 0.f)), glm::mat4(1.f), renderState.fogEnabled, renderState.fogBegin, renderState.fogEnd);
glDepthMask(GL_FALSE);
// first texture unit
pie_SetTexturePage(iV_GetTexture("page-80-water-1.png"));
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
// multiplicative blending
pie_SetRendMode(REND_MULTIPLICATIVE);
// second texture unit
glActiveTexture(GL_TEXTURE1);
pie_Texture(iV_GetTexture("page-81-water-2.png")).bind();
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
// bind the vertex buffer
waterIndexVBO->bind();
waterVBO->bind();
glVertexAttribPointer(program.locVertex, 3, GL_FLOAT, GL_FALSE, sizeof(RenderVertex), BUFFER_OFFSET(0));
glEnableVertexAttribArray(program.locVertex);
for (x = 0; x < xSectors; x++)
{
for (y = 0; y < ySectors; y++)
{
if (sectors[x * ySectors + y].draw)
{
addDrawRangeElements(GL_TRIANGLES,
sectors[x * ySectors + y].geometryOffset,
sectors[x * ySectors + y].geometryOffset + sectors[x * ySectors + y].geometrySize,
sectors[x * ySectors + y].waterIndexSize,
GL_UNSIGNED_INT,
sectors[x * ySectors + y].waterIndexOffset);
}
}
}
finishDrawRangeElements();
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glDisableVertexAttribArray(program.locVertex);
// move the water
if (!gamePaused())
{
waterOffset += graphicsTimeAdjustedIncrement(0.1f);
}
// disable second texture
glActiveTexture(GL_TEXTURE0);
// clean up
glDepthMask(GL_TRUE);
pie_DeactivateShader();
//glBindBuffer(GL_ARRAY_BUFFER, 0); // HACK Must unbind GL_ARRAY_BUFFER (don't know if it has to be unbound everywhere), otherwise text rendering may mysteriously crash.
}
// ////////////////////////////////////////////////////////////////////////////
// throw a party when you win!
bool multiplayerWinSequence(bool firstCall)
{
static Position pos;
Position pos2;
static UDWORD last=0;
float rotAmount;
STRUCTURE *psStruct;
if(firstCall)
{
pos = cameraToHome(selectedPlayer,true); // pan the camera to home if not already doing so
last =0;
// stop all research
CancelAllResearch(selectedPlayer);
// stop all manufacture.
for(psStruct=apsStructLists[selectedPlayer];psStruct;psStruct = psStruct->psNext)
{
if (StructIsFactory(psStruct))
{
if (((FACTORY *)psStruct->pFunctionality)->psSubject)//check if active
{
cancelProduction(psStruct, ModeQueue);
}
}
}
}
// rotate world
if (MissionResUp && !getWarCamStatus())
{
rotAmount = graphicsTimeAdjustedIncrement(MAP_SPIN_RATE / 12);
player.r.y += rotAmount;
}
if(last > gameTime)last= 0;
if((gameTime-last) < 500 ) // only if not done recently.
{
return true;
}
last = gameTime;
if(rand()%3 == 0)
{
pos2=pos;
pos2.x += (rand() % world_coord(8)) - world_coord(4);
pos2.z += (rand() % world_coord(8)) - world_coord(4);
if (pos2.x < 0)
pos2.x = 128;
if ((unsigned)pos2.x > world_coord(mapWidth))
pos2.x = world_coord(mapWidth);
if (pos2.z < 0)
pos2.z = 128;
if ((unsigned)pos2.z > world_coord(mapHeight))
pos2.z = world_coord(mapHeight);
addEffect(&pos2,EFFECT_FIREWORK,FIREWORK_TYPE_LAUNCHER,false,NULL,0); // throw up some fire works.
}
// show the score..
return true;
}
/* Moves one of the particles */
static void processParticle(ATPART *psPart)
{
SDWORD groundHeight;
Vector3i pos;
UDWORD x, y;
MAPTILE *psTile;
/* Only move if the game isn't paused */
if (!gamePaused())
{
/* Move the particle - frame rate controlled */
psPart->position.x += graphicsTimeAdjustedIncrement(psPart->velocity.x);
psPart->position.y += graphicsTimeAdjustedIncrement(psPart->velocity.y);
psPart->position.z += graphicsTimeAdjustedIncrement(psPart->velocity.z);
/* Wrap it around if it's gone off grid... */
testParticleWrap(psPart);
/* If it's gone off the WORLD... */
if (psPart->position.x < 0 || psPart->position.z < 0 ||
psPart->position.x > ((mapWidth - 1)*TILE_UNITS) ||
psPart->position.z > ((mapHeight - 1)*TILE_UNITS))
{
/* The kill it */
psPart->status = APS_INACTIVE;
return;
}
/* What height is the ground under it? Only do if low enough...*/
if (psPart->position.y < 255 * ELEVATION_SCALE)
{
/* Get ground height */
groundHeight = map_Height(psPart->position.x, psPart->position.z);
/* Are we below ground? */
if ((int)psPart->position.y < groundHeight
|| psPart->position.y < 0.f)
{
/* Kill it and return */
psPart->status = APS_INACTIVE;
if (psPart->type == AP_RAIN)
{
x = map_coord(psPart->position.x);
y = map_coord(psPart->position.z);
psTile = mapTile(x, y);
if (terrainType(psTile) == TER_WATER && TEST_TILE_VISIBLE(selectedPlayer, psTile))
{
pos.x = psPart->position.x;
pos.z = psPart->position.z;
pos.y = groundHeight;
effectSetSize(60);
addEffect(&pos, EFFECT_EXPLOSION, EXPLOSION_TYPE_SPECIFIED, true, getImdFromIndex(MI_SPLASH), 0);
}
}
return;
}
}
if (psPart->type == AP_SNOW)
{
if (rand() % 30 == 1)
{
psPart->velocity.z = (float)SNOW_SPEED_DRIFT;
}
if (rand() % 30 == 1)
{
psPart->velocity.x = (float)SNOW_SPEED_DRIFT;
}
}
}
}
