const char* getPlayerColourName(int player)
{
static const char* playerColors[] =
{
N_("Green"),
N_("Orange"),
N_("Grey"),
N_("Black"),
N_("Red"),
N_("Blue"),
N_("Pink"),
N_("Cyan"),
N_("Yellow"),
N_("Purple"),
N_("White"),
N_("Bright blue"),
N_("Neon green"),
N_("Infrared"),
N_("Ultraviolet"),
N_("Brown"),
};
STATIC_ASSERT(MAX_PLAYERS <= ARRAY_SIZE(playerColors));
ASSERT(player < ARRAY_SIZE(playerColors), "player number (%d) exceeds maximum (%lu)", player, (unsigned long) ARRAY_SIZE(playerColors));
if (player >= ARRAY_SIZE(playerColors))
{
return "";
}
return gettext(playerColors[getPlayerColour(player)]);
}
// Render a research item given a BASE_STATS structure.
//
void displayResearchButton(BASE_STATS *Stat, const Vector3i *Rotation, const Vector3i *Position, int scale)
{
iIMDShape *ResearchIMD = ((RESEARCH *)Stat)->pIMD;
iIMDShape *MountIMD = ((RESEARCH *)Stat)->pIMD2;
ASSERT(ResearchIMD, "ResearchIMD is NULL");
if (ResearchIMD)
{
const glm::mat4 &matrix = setMatrix(Position, Rotation, scale);
if (MountIMD)
{
pie_Draw3DShape(MountIMD, 0, getPlayerColour(selectedPlayer), WZCOL_WHITE, pie_BUTTON, 0, matrix);
}
pie_Draw3DShape(ResearchIMD, 0, getPlayerColour(selectedPlayer), WZCOL_WHITE, pie_BUTTON, 0, matrix);
}
}
// Render a component given a BASE_STATS structure.
//
void displayComponentButton(BASE_STATS *Stat, Vector3i *Rotation, Vector3i *Position,
bool RotXYZ, SDWORD scale)
{
iIMDShape *ComponentIMD = NULL;
iIMDShape *MountIMD = NULL;
SDWORD compID;
setMatrix(Position, Rotation, RotXYZ);
pie_MatScale(scale / 100.f);
compID = StatIsComponent(Stat);
if (compID > 0) {
StatGetComponentIMD(Stat, compID,&ComponentIMD, &MountIMD);
}
else
{
unsetMatrix();
return;
}
/* VTOL bombs are only stats allowed to have NULL ComponentIMD */
if (StatIsComponent(Stat) != COMP_WEAPON
|| (((WEAPON_STATS *)Stat)->weaponSubClass != WSC_BOMB
&& ((WEAPON_STATS *)Stat)->weaponSubClass != WSC_EMP))
{
ASSERT(ComponentIMD, "No ComponentIMD");
}
if (MountIMD)
{
pie_Draw3DShape(MountIMD, 0, getPlayerColour(selectedPlayer), WZCOL_WHITE, pie_BUTTON, 0);
/* translate for weapon mount point */
if (MountIMD->nconnectors)
{
pie_TRANSLATE(MountIMD->connectors->x, MountIMD->connectors->z, MountIMD->connectors->y);
}
}
if (ComponentIMD)
{
pie_Draw3DShape(ComponentIMD, 0, getPlayerColour(selectedPlayer), WZCOL_WHITE, pie_BUTTON, 0);
}
unsetMatrix();
}
void displayIMDButton(iIMDShape *IMDShape, Vector3i *Rotation, Vector3i *Position, bool RotXYZ, SDWORD scale)
{
setMatrix(Position, Rotation, RotXYZ);
pie_MatScale(scale / 100.f);
pie_SetFogStatus(false);
pie_Draw3DShape(IMDShape, 0, getPlayerColour(selectedPlayer), WZCOL_WHITE, pie_BUTTON, 0);
unsetMatrix();
}
// Render a research item given a BASE_STATS structure.
//
void displayResearchButton(BASE_STATS *Stat, Vector3i *Rotation, Vector3i *Position, bool RotXYZ, SDWORD scale)
{
iIMDShape *ResearchIMD = ((RESEARCH *)Stat)->pIMD;
iIMDShape *MountIMD = ((RESEARCH *)Stat)->pIMD2;
ASSERT(ResearchIMD, "ResearchIMD is NULL");
if (ResearchIMD)
{
setMatrix(Position, Rotation, RotXYZ, scale);
if(MountIMD) {
pie_Draw3DShape(MountIMD, 0, getPlayerColour(selectedPlayer), WZCOL_WHITE, pie_BUTTON, 0);
}
pie_Draw3DShape(ResearchIMD, 0, getPlayerColour(selectedPlayer), WZCOL_WHITE, pie_BUTTON, 0);
unsetMatrix();
}
}
// Render a research item given a BASE_STATS structure.
//
void displayResearchButton(BASE_STATS *Stat, Vector3i *Rotation, Vector3i *Position, bool RotXYZ, SDWORD scale)
{
iIMDShape *ResearchIMD = ((RESEARCH *)Stat)->pIMD;
iIMDShape *MountIMD = ((RESEARCH *)Stat)->pIMD2;
if(ResearchIMD)
{
setMatrix(Position, Rotation, RotXYZ);
pie_MatScale(scale / 100.f);
if(MountIMD) {
pie_Draw3DShape(MountIMD, 0, getPlayerColour(selectedPlayer), WZCOL_WHITE, pie_BUTTON, 0);
}
pie_Draw3DShape(ResearchIMD, 0, getPlayerColour(selectedPlayer), WZCOL_WHITE, pie_BUTTON, 0);
unsetMatrix();
}
else
{
debug(LOG_ERROR, "ResearchIMD == NULL");
}
}
// Render a component given a BASE_STATS structure.
//
void displayComponentButton(BASE_STATS *Stat, const Vector3i *Rotation, const Vector3i *Position, int scale)
{
iIMDShape *ComponentIMD = nullptr;
iIMDShape *MountIMD = nullptr;
int compID = StatIsComponent(Stat);
if (compID >= 0)
{
StatGetComponentIMD(Stat, compID, &ComponentIMD, &MountIMD);
}
else
{
return;
}
glm::mat4 matrix = setMatrix(Position, Rotation, scale);
/* VTOL bombs are only stats allowed to have NULL ComponentIMD */
if (StatIsComponent(Stat) != COMP_WEAPON
|| (((WEAPON_STATS *)Stat)->weaponSubClass != WSC_BOMB
&& ((WEAPON_STATS *)Stat)->weaponSubClass != WSC_EMP))
{
ASSERT(ComponentIMD, "No ComponentIMD");
}
if (MountIMD)
{
pie_Draw3DShape(MountIMD, 0, getPlayerColour(selectedPlayer), WZCOL_WHITE, pie_BUTTON, 0, matrix);
/* translate for weapon mount point */
if (MountIMD->nconnectors)
{
matrix *= glm::translate(glm::vec3(MountIMD->connectors->xzy()));
}
}
if (ComponentIMD)
{
pie_Draw3DShape(ComponentIMD, 0, getPlayerColour(selectedPlayer), WZCOL_WHITE, pie_BUTTON, 0, matrix);
}
}
void compPersonToBits(DROID *psDroid)
{
Vector3i position; //,rotation,velocity;
iIMDShape *headImd, *legsImd, *armImd, *bodyImd;
UDWORD groundHeight;
UDWORD col;
if(!psDroid->visible[selectedPlayer])
{
/* We can't see the person or cyborg - so get out */
return;
}
/* get bits pointers according to whether baba or cyborg*/
if (cyborgDroid(psDroid))
{
headImd = getImdFromIndex(MI_CYBORG_HEAD);
legsImd = getImdFromIndex(MI_CYBORG_LEGS);
armImd = getImdFromIndex(MI_CYBORG_ARM);
bodyImd = getImdFromIndex(MI_CYBORG_BODY);
}
else
{
headImd = getImdFromIndex(MI_BABA_HEAD);
legsImd = getImdFromIndex(MI_BABA_LEGS);
armImd = getImdFromIndex(MI_BABA_ARM);
bodyImd = getImdFromIndex(MI_BABA_BODY);
}
/* Get where he's at */
position.x = psDroid->pos.x;
position.y = psDroid->pos.z+1;
groundHeight = psDroid->pos.z;
position.z = psDroid->pos.y;
/* Tell about player colour */
col = getPlayerColour(psDroid->player);
addEffect(&position,EFFECT_GRAVITON,GRAVITON_TYPE_GIBLET,true,headImd,col);
addEffect(&position,EFFECT_GRAVITON,GRAVITON_TYPE_GIBLET,true,legsImd,col);
addEffect(&position,EFFECT_GRAVITON,GRAVITON_TYPE_GIBLET,true,armImd,col);
addEffect(&position,EFFECT_GRAVITON,GRAVITON_TYPE_GIBLET,true,bodyImd,col);
}
static void sharedStructureButton(STRUCTURE_STATS *Stats, iIMDShape *strImd, const Vector3i *Rotation, const Vector3i *Position, int scale)
{
iIMDShape *baseImd, *mountImd[MAX_WEAPONS], *weaponImd[MAX_WEAPONS];
Vector3i pos = *Position;
/* HACK HACK HACK!
if its a 'tall thin (ie tower)' structure stat with something on the top - offset the position to show the object on top */
if (strImd->nconnectors && scale == SMALL_STRUCT_SCALE && getStructureStatHeight(Stats) > TOWER_HEIGHT)
{
pos.y -= 20;
}
const glm::mat4 matrix = setMatrix(&pos, Rotation, scale);
/* Draw the building's base first */
baseImd = Stats->pBaseIMD;
if (baseImd != nullptr)
{
pie_Draw3DShape(baseImd, 0, getPlayerColour(selectedPlayer), WZCOL_WHITE, pie_BUTTON, 0, matrix);
}
pie_Draw3DShape(strImd, 0, getPlayerColour(selectedPlayer), WZCOL_WHITE, pie_BUTTON, 0, matrix);
//and draw the turret
if (strImd->nconnectors)
{
weaponImd[0] = nullptr;
mountImd[0] = nullptr;
for (int i = 0; i < Stats->numWeaps; i++)
{
weaponImd[i] = nullptr;//weapon is gun ecm or sensor
mountImd[i] = nullptr;
}
//get an imd to draw on the connector priority is weapon, ECM, sensor
//check for weapon
//can only have the MAX_WEAPONS
for (int i = 0; i < MAX(1, Stats->numWeaps); i++)
{
//can only have the one
if (Stats->psWeapStat[i] != nullptr)
{
weaponImd[i] = Stats->psWeapStat[i]->pIMD;
mountImd[i] = Stats->psWeapStat[i]->pMountGraphic;
}
if (weaponImd[i] == nullptr)
{
//check for ECM
if (Stats->pECM != nullptr)
{
weaponImd[i] = Stats->pECM->pIMD;
mountImd[i] = Stats->pECM->pMountGraphic;
}
}
if (weaponImd[i] == nullptr)
{
//check for sensor
if (Stats->pSensor != nullptr)
{
weaponImd[i] = Stats->pSensor->pIMD;
mountImd[i] = Stats->pSensor->pMountGraphic;
}
}
}
//draw Weapon/ECM/Sensor for structure
if (weaponImd[0] != nullptr)
{
for (int i = 0; i < MAX(1, Stats->numWeaps); i++)
{
glm::mat4 localMatrix = glm::translate(glm::vec3(strImd->connectors[i].xzy()));
if (mountImd[i] != nullptr)
{
pie_Draw3DShape(mountImd[i], 0, getPlayerColour(selectedPlayer), WZCOL_WHITE, pie_BUTTON, 0, matrix * localMatrix);
if (mountImd[i]->nconnectors)
{
localMatrix *= glm::translate(glm::vec3(mountImd[i]->connectors->xzy()));
}
}
pie_Draw3DShape(weaponImd[i], 0, getPlayerColour(selectedPlayer), WZCOL_WHITE, pie_BUTTON, 0, matrix * localMatrix);
//we have a droid weapon so do we draw a muzzle flash
}
}
}
}
void displayIMDButton(iIMDShape *IMDShape, const Vector3i *Rotation, const Vector3i *Position, int scale)
{
pie_Draw3DShape(IMDShape, 0, getPlayerColour(selectedPlayer), WZCOL_WHITE, pie_BUTTON, 0, setMatrix(Position, Rotation, scale));
}
static void displayMultiPlayer(WIDGET *psWidget, UDWORD xOffset, UDWORD yOffset, PIELIGHT *pColours)
{
char str[128];
UDWORD x = xOffset+psWidget->x;
UDWORD y = yOffset+psWidget->y;
UDWORD player = psWidget->UserData; //get the in game player number.
Position position;
Vector3i rotation;
if( responsibleFor(player,0) )
{
displayExtraGubbins(widgGetFromID(psWScreen,MULTIMENU_FORM)->height);
}
iV_SetFont(font_regular); // font
iV_SetTextColour(WZCOL_TEXT_BRIGHT);
if(isHumanPlayer(player) || (game.type == SKIRMISH && player<game.maxPlayers) )
{
ssprintf(str, "%d: %s", NetPlay.players[player].position, getPlayerName(player));
if (isHumanPlayer(player))
{
SetPlayerTextColor(alliances[selectedPlayer][player], player);
}
else
{
SetPlayerTextColor(alliances[selectedPlayer][player], player);
}
while(iV_GetTextWidth(str) >= (MULTIMENU_C0-MULTIMENU_C2-10) )
{
str[strlen(str)-1]='\0';
}
iV_DrawText(str, x+MULTIMENU_C2, y+MULTIMENU_FONT_OSET);
//c3-7 alliance
//manage buttons by showing or hiding them. gifts only in campaign,
{
if(game.alliance != NO_ALLIANCES)
{
if(alliances[selectedPlayer][player] == ALLIANCE_FORMED)
{
if(player != selectedPlayer && !giftsUp[player] )
{
if (game.alliance != ALLIANCES_TEAMS)
{
widgReveal(psWScreen,MULTIMENU_GIFT_RAD+ player);
widgReveal(psWScreen,MULTIMENU_GIFT_RES+ player);
}
widgReveal(psWScreen,MULTIMENU_GIFT_DRO+ player);
widgReveal(psWScreen,MULTIMENU_GIFT_POW+ player);
giftsUp[player] = true;
}
}
else
{
if(player != selectedPlayer && giftsUp[player])
{
if (game.alliance != ALLIANCES_TEAMS)
{
widgHide(psWScreen,MULTIMENU_GIFT_RAD+ player);
widgHide(psWScreen,MULTIMENU_GIFT_RES+ player);
}
widgHide(psWScreen,MULTIMENU_GIFT_DRO+ player);
widgHide(psWScreen,MULTIMENU_GIFT_POW+ player);
giftsUp[player] = false;
}
}
}
}
}
if(isHumanPlayer(player))
{
SetPlayerTextColor(alliances[selectedPlayer][player], player);
// Let's use the real score for MP games
if (NetPlay.bComms)
{
//c8:score,
if (Cheated)
{
sprintf(str,"(cheated)");
}
else
{
sprintf(str,"%d",getMultiStats(player).recentScore);
}
iV_DrawText(str, x+MULTIMENU_C8, y+MULTIMENU_FONT_OSET);
//c9:kills,
sprintf(str,"%d",getMultiStats(player).recentKills);
iV_DrawText(str, x+MULTIMENU_C9, y+MULTIMENU_FONT_OSET);
}
else
{
// estimate of score for skirmish games
sprintf(str,"%d",ingame.skScores[player][0]);
iV_DrawText(str, x+MULTIMENU_C8, y+MULTIMENU_FONT_OSET);
// estimated kills
sprintf(str,"%d",ingame.skScores[player][1]);
iV_DrawText(str, x+MULTIMENU_C9, y+MULTIMENU_FONT_OSET);
}
if(!getDebugMappingStatus())
{
//only show player's units, and nobody elses.
//c10:units
if (myResponsibility(player))
{
SetPlayerTextColor(alliances[selectedPlayer][player], player);
sprintf(str, "%d", getNumDroids(player) + getNumTransporterDroids(player));
iV_DrawText(str, x+MULTIMENU_C10, y+MULTIMENU_FONT_OSET);
}
if (runningMultiplayer())
{
//c11:ping
if (player != selectedPlayer)
{
if (ingame.PingTimes[player] >= 2000)
{
sprintf(str,"???");
}
else
{
sprintf(str, "%d", ingame.PingTimes[player]);
}
iV_DrawText(str, x+MULTIMENU_C11, y+MULTIMENU_FONT_OSET);
}
}
else
{
int num;
STRUCTURE *temp;
// NOTE, This tallys up *all* the structures you have. Test out via 'start with no base'.
for (num = 0, temp = apsStructLists[player]; temp != NULL;num++,temp = temp->psNext) {}
//c11: Structures
sprintf(str, "%d", num);
iV_DrawText(str, x+MULTIMENU_C11, y+MULTIMENU_FONT_OSET);
}
}
}
else
{
SetPlayerTextColor(alliances[selectedPlayer][player], player);
// Let's use the real score for MP games
if (NetPlay.bComms)
{
//c8:score,
if (Cheated)
{
sprintf(str,"(cheated)");
}
else
{
sprintf(str,"%d",getMultiStats(player).recentScore);
}
iV_DrawText(str, x+MULTIMENU_C8, y+MULTIMENU_FONT_OSET);
//c9:kills,
sprintf(str,"%d",getMultiStats(player).recentKills);
iV_DrawText(str, x+MULTIMENU_C9, y+MULTIMENU_FONT_OSET);
}
else
{
// estimate of score for skirmish games
sprintf(str,"%d",ingame.skScores[player][0]);
iV_DrawText(str, x+MULTIMENU_C8, y+MULTIMENU_FONT_OSET);
// estimated kills
sprintf(str,"%d",ingame.skScores[player][1]);
iV_DrawText(str, x+MULTIMENU_C9, y+MULTIMENU_FONT_OSET);
}
}
/* Display player power instead of number of played games
* and number of units instead of ping when in debug mode
*/
if(getDebugMappingStatus()) //Won't pass this when in both release and multiplayer modes
{
//c10: Total number of player units in possession
sprintf(str,"%d",getNumDroids(player) + getNumTransporterDroids(player));
iV_DrawText(str, x+MULTIMENU_C10, y+MULTIMENU_FONT_OSET);
//c11: Player power
sprintf(str, "%u", (int)getPower(player));
iV_DrawText(str, MULTIMENU_FORM_X+MULTIMENU_C11, y+MULTIMENU_FONT_OSET);
}
// a droid of theirs.
DROID *displayDroid = apsDroidLists[player];
while (displayDroid != NULL && !displayDroid->visible[selectedPlayer])
{
displayDroid = displayDroid->psNext;
}
if (displayDroid)
{
pie_SetGeometricOffset( MULTIMENU_FORM_X+MULTIMENU_C1 ,y+MULTIMENU_PLAYER_H);
rotation.x = -15;
rotation.y = 45;
rotation.z = 0;
position.x = 0;
position.y = 0;
position.z = 2000; //scale them!
displayComponentButtonObject(displayDroid, &rotation, &position, false, 100);
}
else if(apsDroidLists[player])
{
// Show that they have droids, but not which droids, since we can't see them.
iV_DrawImageTc(IntImages, IMAGE_GENERIC_TANK, IMAGE_GENERIC_TANK_TC, MULTIMENU_FORM_X + MULTIMENU_C1 - iV_GetImageWidth(IntImages, IMAGE_GENERIC_TANK)/2, y + MULTIMENU_PLAYER_H - iV_GetImageHeight(IntImages, IMAGE_GENERIC_TANK), pal_GetTeamColour(getPlayerColour(player)));
}
// clean up widgets if player leaves while menu is up.
if(!isHumanPlayer(player) && !(game.type == SKIRMISH && player<game.maxPlayers))
{
if(widgGetFromID(psWScreen,MULTIMENU_CHANNEL+player))
{
widgDelete(psWScreen,MULTIMENU_CHANNEL+ player);
}
if(widgGetFromID(psWScreen,MULTIMENU_ALLIANCE_BASE+player) )
{
widgDelete(psWScreen,MULTIMENU_ALLIANCE_BASE+ player);
widgDelete(psWScreen,MULTIMENU_GIFT_RAD+ player);
widgDelete(psWScreen,MULTIMENU_GIFT_RES+ player);
widgDelete(psWScreen,MULTIMENU_GIFT_DRO+ player);
widgDelete(psWScreen,MULTIMENU_GIFT_POW+ player);
giftsUp[player] = false;
}
}
}
// this is able to handle multiple weapon graphics now
// removed mountRotation,they get such stuff from psObj directly now
static void displayCompObj(DROID *psDroid, bool bButton)
{
iIMDShape *psShape, *psMoveAnim, *psStillAnim, *psShapeTemp = NULL, *psMountShape;
SDWORD iConnector;
PROPULSION_STATS *psPropStats;
SDWORD pieFlag, iPieData;
PIELIGHT brightness;
UDWORD colour;
UBYTE i;
if (graphicsTime - psDroid->timeLastHit < GAME_TICKS_PER_SEC / 4 && psDroid->lastHitWeapon == WSC_ELECTRONIC && !gamePaused())
{
colour = getPlayerColour(rand() % MAX_PLAYERS);
}
else
{
colour = getPlayerColour(psDroid->player);
}
/* get propulsion stats */
psPropStats = asPropulsionStats + psDroid->asBits[COMP_PROPULSION];
ASSERT_OR_RETURN(, psPropStats != NULL, "invalid propulsion stats pointer");
//set pieflag for button object or ingame object
if (bButton)
{
pieFlag = pie_BUTTON;
brightness = WZCOL_WHITE;
}
else
{
pieFlag = pie_SHADOW;
brightness = pal_SetBrightness(psDroid->illumination);
// NOTE: Beware of transporters that are offscreen, on a mission! We should *not* be checking tiles at this point in time!
if (!isTransporter(psDroid) && !missionIsOffworld())
{
MAPTILE *psTile = worldTile(psDroid->pos.x, psDroid->pos.y);
if (psTile->jammerBits & alliancebits[psDroid->player])
{
pieFlag |= pie_ECM;
}
}
}
/* set default components transparent */
if (psDroid->asBits[COMP_PROPULSION] == 0)
{
pieFlag |= pie_TRANSLUCENT;
iPieData = DEFAULT_COMPONENT_TRANSLUCENCY;
}
else
{
iPieData = 0;
}
if (!bButton && psPropStats->propulsionType == PROPULSION_TYPE_PROPELLOR)
{
// FIXME: change when adding submarines to the game
pie_TRANSLATE(0, -world_coord(1) / 2.3f, 0);
}
//uses psShapeTemp too separate it from turret's psShape
psShapeTemp = (leftFirst ? getLeftPropulsionIMD(psDroid) : getRightPropulsionIMD(psDroid));
if (psShapeTemp != NULL)
{
pie_Draw3DShape(psShapeTemp, 0, colour, brightness, pieFlag, iPieData);
}
/* set default components transparent */
if (psDroid->asBits[COMP_BODY] == 0)
{
pieFlag |= pie_TRANSLUCENT;
iPieData = DEFAULT_COMPONENT_TRANSLUCENCY;
}
else
{
pieFlag &= ~pie_TRANSLUCENT;
iPieData = 0;
}
/* Get the body graphic now*/
//uses psShapeTemp too separate it from turret's psShape
psShapeTemp = BODY_IMD(psDroid, psDroid->player);
if (psShapeTemp != NULL)
{
// FIXME
if (psDroid->droidType == DROID_PERSON)
{
/* draw body if not animating */
if (psDroid->psCurAnim == NULL || psDroid->psCurAnim->bVisible == false)
{
// FIXME - hideous....!!!!
pie_MatScale(.75f);
pie_Draw3DShape(psShapeTemp, 0, psDroid->player - 6, brightness, pieFlag, iPieData);
}
}
else if (cyborgDroid(psDroid))
{
/* draw body if cyborg not animating */
if (psDroid->psCurAnim == NULL || psDroid->psCurAnim->bVisible == false)
{
pie_Draw3DShape(psShapeTemp, 0, colour, brightness, pieFlag, iPieData);
}
}
else
{
pie_Draw3DShape(psShapeTemp, 0, colour, brightness, pieFlag, iPieData);
}
}
/* Render animation effects based on movement or lack thereof, if any */
psMoveAnim = asBodyStats[psDroid->asBits[COMP_BODY]].ppMoveIMDList[psDroid->asBits[COMP_PROPULSION]];
psStillAnim = asBodyStats[psDroid->asBits[COMP_BODY]].ppStillIMDList[psDroid->asBits[COMP_PROPULSION]];
if (!bButton && psMoveAnim && psDroid->sMove.Status != MOVEINACTIVE)
{
pie_Draw3DShape(psMoveAnim, getModularScaledGraphicsTime(psMoveAnim->animInterval, psMoveAnim->numFrames), colour, brightness, pie_ADDITIVE, 200);
}
else if (!bButton && psStillAnim) // standing still
{
pie_Draw3DShape(psStillAnim, getModularScaledGraphicsTime(psStillAnim->animInterval, psStillAnim->numFrames), colour, brightness, 0, 0);
}
//don't change the screen coords of an object if drawing it in a button
if (!bButton)
{
/* set up all the screen coords stuff - need to REMOVE FROM THIS LOOP */
calcScreenCoords(psDroid);
}
/* set default components transparent */
if (psDroid->asWeaps[0].nStat == 0 &&
psDroid->asBits[COMP_SENSOR] == 0 &&
psDroid->asBits[COMP_ECM] == 0 &&
psDroid->asBits[COMP_BRAIN] == 0 &&
psDroid->asBits[COMP_REPAIRUNIT] == 0 &&
psDroid->asBits[COMP_CONSTRUCT] == 0)
{
pieFlag |= pie_TRANSLUCENT;
iPieData = DEFAULT_COMPONENT_TRANSLUCENCY;
}
else
{
pieFlag &= ~pie_TRANSLUCENT;
iPieData = 0;
}
psShapeTemp = BODY_IMD(psDroid, psDroid->player);
if (psShapeTemp->nconnectors)
{
/* vtol weapons attach to connector 2 (underneath);
* all others to connector 1 */
/* VTOL's now skip the first 5 connectors(0 to 4),
VTOL's use 5,6,7,8 etc now */
if (psPropStats->propulsionType == PROPULSION_TYPE_LIFT && psDroid->droidType == DROID_WEAPON)
{
iConnector = VTOL_CONNECTOR_START;
}
else
{
iConnector = 0;
}
switch (psDroid->droidType)
{
case DROID_DEFAULT:
case DROID_TRANSPORTER:
case DROID_SUPERTRANSPORTER:
case DROID_CYBORG:
case DROID_CYBORG_SUPER:
case DROID_WEAPON:
case DROID_COMMAND: // command droids have a weapon to store all the graphics
/* Get the mounting graphic - we've already moved to the right position
Allegedly - all droids will have a mount graphic so this shouldn't
fall on it's arse......*/
/* Double check that the weapon droid actually has any */
for (i = 0; i < psDroid->numWeaps; i++)
{
if ((psDroid->asWeaps[i].nStat > 0 || psDroid->droidType == DROID_DEFAULT)
&& psShapeTemp->connectors)
{
Rotation rot = getInterpolatedWeaponRotation(psDroid, i, graphicsTime);
pie_MatBegin(!bButton);
//to skip number of VTOL_CONNECTOR_START ground unit connectors
if (iConnector < VTOL_CONNECTOR_START)
{
pie_TRANSLATE(psShapeTemp->connectors[i].x,
psShapeTemp->connectors[i].z,
psShapeTemp->connectors[i].y);
}
else
{
pie_TRANSLATE(psShapeTemp->connectors[iConnector + i].x,
psShapeTemp->connectors[iConnector + i].z,
psShapeTemp->connectors[iConnector + i].y);
}
pie_MatRotY(-rot.direction);
/* vtol weapons inverted */
if (iConnector >= VTOL_CONNECTOR_START)
{
pie_MatRotZ(65536 / 2); //this might affect gun rotation
}
/* Get the mount graphic */
psShape = WEAPON_MOUNT_IMD(psDroid, i);
int recoilValue = getRecoil(psDroid->asWeaps[i]);
pie_TRANSLATE(0, 0, recoilValue / 3);
/* Draw it */
if (psShape)
{
pie_Draw3DShape(psShape, 0, colour, brightness, pieFlag, iPieData);
}
pie_TRANSLATE(0, 0, recoilValue);
/* translate for weapon mount point */
if (psShape && psShape->nconnectors)
{
pie_TRANSLATE(psShape->connectors->x, psShape->connectors->z, psShape->connectors->y);
}
/* vtol weapons inverted */
if (iConnector >= VTOL_CONNECTOR_START)
{
//pitch the barrel down
pie_MatRotX(-rot.pitch);
}
else
{
//pitch the barrel up
pie_MatRotX(rot.pitch);
}
/* Get the weapon (gun?) graphic */
psShape = WEAPON_IMD(psDroid, i);
// We have a weapon so we draw it and a muzzle flash from weapon connector
if (psShape)
{
pie_Draw3DShape(psShape, 0, colour, brightness, pieFlag, iPieData);
drawMuzzleFlash(psDroid->asWeaps[i], psShape, MUZZLE_FLASH_PIE(psDroid, i), brightness, pieFlag, iPieData);
}
/* Pop Matrix */
pie_MatEnd();
}
}
break;
case DROID_SENSOR:
case DROID_CONSTRUCT:
case DROID_CYBORG_CONSTRUCT:
case DROID_ECM:
case DROID_REPAIR:
case DROID_CYBORG_REPAIR:
{
Rotation rot = getInterpolatedWeaponRotation(psDroid, 0, graphicsTime);
switch (psDroid->droidType)
{
default: ASSERT(false, "...");
case DROID_SENSOR:
psMountShape = SENSOR_MOUNT_IMD(psDroid, psDroid->player);
/* Get the sensor graphic, assuming it's there */
psShape = SENSOR_IMD(psDroid, psDroid->player);
break;
case DROID_CONSTRUCT:
case DROID_CYBORG_CONSTRUCT:
psMountShape = CONSTRUCT_MOUNT_IMD(psDroid, psDroid->player);
/* Get the construct graphic assuming it's there */
psShape = CONSTRUCT_IMD(psDroid, psDroid->player);
break;
case DROID_ECM:
psMountShape = ECM_MOUNT_IMD(psDroid, psDroid->player);
/* Get the ECM graphic assuming it's there.... */
psShape = ECM_IMD(psDroid, psDroid->player);
break;
case DROID_REPAIR:
case DROID_CYBORG_REPAIR:
psMountShape = REPAIR_MOUNT_IMD(psDroid, psDroid->player);
/* Get the Repair graphic assuming it's there.... */
psShape = REPAIR_IMD(psDroid, psDroid->player);
break;
}
/* Get the mounting graphic - we've already moved to the right position
Allegedly - all droids will have a mount graphic so this shouldn't
fall on it's arse......*/
//sensor and cyborg and ecm uses connectors[0]
pie_MatBegin(!bButton);
/* vtol weapons inverted */
if (iConnector >= VTOL_CONNECTOR_START)
{
pie_MatRotZ(65536 / 2); //this might affect gun rotation
}
pie_TRANSLATE(psShapeTemp->connectors[0].x,
psShapeTemp->connectors[0].z,
psShapeTemp->connectors[0].y);
pie_MatRotY(-rot.direction);
/* Draw it */
if (psMountShape)
{
pie_Draw3DShape(psMountShape, 0, colour, brightness, pieFlag, iPieData);
}
/* translate for construct mount point if cyborg */
if (cyborgDroid(psDroid) && psMountShape && psMountShape->nconnectors)
{
pie_TRANSLATE(psMountShape->connectors[0].x,
psMountShape->connectors[0].z,
psMountShape->connectors[0].y);
}
/* Draw it */
if (psShape)
{
pie_Draw3DShape(psShape, 0, colour, brightness, pieFlag, iPieData);
// In repair droid case only:
if ((psDroid->droidType == DROID_REPAIR || psDroid->droidType == DROID_CYBORG_REPAIR) &&
psShape->nconnectors && psDroid->action == DACTION_DROIDREPAIR)
{
Spacetime st = interpolateObjectSpacetime(psDroid, graphicsTime);
pie_TRANSLATE(psShape->connectors[0].x,
psShape->connectors[0].z,
psShape->connectors[0].y);
pie_TRANSLATE(0, -20, 0);
psShape = getImdFromIndex(MI_FLAME);
/* Rotate for droid */
pie_MatRotY(st.rot.direction);
pie_MatRotX(-st.rot.pitch);
pie_MatRotZ(-st.rot.roll);
//rotate Y
pie_MatRotY(rot.direction);
pie_MatRotY(-player.r.y);
pie_MatRotX(-player.r.x);
pie_Draw3DShape(psShape, getModularScaledGraphicsTime(psShape->animInterval, psShape->numFrames), 0, brightness, pie_ADDITIVE, 140);
pie_MatRotX(player.r.x);
pie_MatRotY(player.r.y);
}
}
/* Pop Matrix */
pie_MatEnd();
break;
}
case DROID_PERSON:
// no extra mounts for people
break;
default:
ASSERT(!"invalid droid type", "Whoa! Weirdy type of droid found in drawComponentObject!!!");
break;
}
}
/* We've also got a handle on the psShape here for the weapon which has a connector to point to
muzzle flash attachment points - just grab it from psShape->connectors->[x|y|z] */
/* set default components transparent */
if (psDroid->asBits[COMP_PROPULSION] == 0)
{
pieFlag |= pie_TRANSLUCENT;
iPieData = DEFAULT_COMPONENT_TRANSLUCENCY;
}
else
{
pieFlag &= ~pie_TRANSLUCENT;
iPieData = 0;
}
psShape = (leftFirst ? getRightPropulsionIMD(psDroid) : getLeftPropulsionIMD(psDroid));
if (psShape != NULL)
{
pie_Draw3DShape(psShape, 0, colour, brightness, pieFlag, iPieData);
}
}
void destroyFXDroid(DROID *psDroid)
{
UDWORD i;
iIMDShape *psImd = NULL;
SDWORD widthScatter, breadthScatter, heightScatter;
Vector3i pos;
widthScatter = TILE_UNITS/4;
breadthScatter = TILE_UNITS/4;
heightScatter = TILE_UNITS/5;
for(i=0; i<5; i++)
{
pos.x = psDroid->pos.x + widthScatter - rand()%(2*widthScatter);
pos.z = psDroid->pos.y + breadthScatter - rand()%(2*breadthScatter);
pos.y = psDroid->pos.z + 16 +heightScatter;
switch(i)
{
case 0:
switch(psDroid->droidType)
{
case DROID_DEFAULT:
case DROID_CYBORG:
case DROID_CYBORG_SUPER:
case DROID_CYBORG_CONSTRUCT:
case DROID_CYBORG_REPAIR:
case DROID_WEAPON:
case DROID_COMMAND:
if (psDroid->numWeaps > 0)
{
if(psDroid->asWeaps[0].nStat > 0)
{
// Tell the effect system that it needs to use this player's color for the next effect
SetEffectForPlayer(psDroid->player);
psImd = WEAPON_MOUNT_IMD(psDroid, 0);
}
}
else
{
psImd = getRandomDebrisImd();
}
break;
default:
psImd = getRandomDebrisImd();
break;
}
break;
case 1:
switch(psDroid->droidType)
{
case DROID_DEFAULT:
case DROID_CYBORG:
case DROID_CYBORG_SUPER:
case DROID_CYBORG_CONSTRUCT:
case DROID_CYBORG_REPAIR:
case DROID_WEAPON:
case DROID_COMMAND:
if(psDroid->numWeaps)
{
// get main weapon
psImd = WEAPON_IMD(psDroid, 0);
}
else
{
psImd = getRandomDebrisImd();
}
break;
default:
psImd = getRandomDebrisImd();
break;
}
break;
case 2:
case 3:
case 4:
psImd = getRandomDebrisImd();
break;
}
if(psImd)
{
addEffect(&pos,EFFECT_GRAVITON,GRAVITON_TYPE_EMITTING_DR,true,psImd,getPlayerColour(psDroid->player));
}
else
{
addEffect(&pos,EFFECT_GRAVITON,GRAVITON_TYPE_EMITTING_DR,true,getRandomDebrisImd(),0);
}
}
}
/** Draw the droids and structure positions on the radar. */
static void DrawRadarObjects()
{
UBYTE clan;
PIELIGHT playerCol;
PIELIGHT flashCol;
int x, y;
/* Show droids on map - go through all players */
for (clan = 0; clan < MAX_PLAYERS; clan++)
{
DROID *psDroid;
//see if have to draw enemy/ally color
if (bEnemyAllyRadarColor)
{
if (clan == selectedPlayer)
{
playerCol = colRadarMe;
}
else
{
playerCol = (aiCheckAlliances(selectedPlayer, clan) ? colRadarAlly : colRadarEnemy);
}
}
else
{
//original 8-color mode
STATIC_ASSERT(MAX_PLAYERS <= ARRAY_SIZE(clanColours));
playerCol = clanColours[getPlayerColour(clan)];
}
STATIC_ASSERT(MAX_PLAYERS <= ARRAY_SIZE(flashColours));
flashCol = flashColours[getPlayerColour(clan)];
/* Go through all droids */
for (psDroid = apsDroidLists[clan]; psDroid != NULL; psDroid = psDroid->psNext)
{
if (psDroid->pos.x < world_coord(scrollMinX) || psDroid->pos.y < world_coord(scrollMinY)
|| psDroid->pos.x >= world_coord(scrollMaxX) || psDroid->pos.y >= world_coord(scrollMaxY))
{
continue;
}
if (psDroid->visible[selectedPlayer]
|| (bMultiPlayer && alliancesSharedVision(game.alliance)
&& aiCheckAlliances(selectedPlayer, psDroid->player)))
{
int x = psDroid->pos.x / TILE_UNITS;
int y = psDroid->pos.y / TILE_UNITS;
size_t pos = (x - scrollMinX) + (y - scrollMinY) * radarTexWidth;
ASSERT(pos * sizeof(*radarBuffer) < radarBufferSize, "Buffer overrun");
if (clan == selectedPlayer && gameTime - psDroid->timeLastHit < HIT_NOTIFICATION)
{
radarBuffer[pos] = flashCol.rgba;
}
else
{
radarBuffer[pos] = playerCol.rgba;
}
}
}
}
/* Do the same for structures */
for (x = scrollMinX; x < scrollMaxX; x++)
{
for (y = scrollMinY; y < scrollMaxY; y++)
{
MAPTILE *psTile = mapTile(x, y);
STRUCTURE *psStruct;
size_t pos = (x - scrollMinX) + (y - scrollMinY) * radarTexWidth;
ASSERT(pos * sizeof(*radarBuffer) < radarBufferSize, "Buffer overrun");
if (!TileHasStructure(psTile))
{
continue;
}
psStruct = (STRUCTURE *)psTile->psObject;
clan = psStruct->player;
//see if have to draw enemy/ally color
if (bEnemyAllyRadarColor)
{
if (clan == selectedPlayer)
{
playerCol = colRadarMe;
}
else
{
playerCol = (aiCheckAlliances(selectedPlayer, clan) ? colRadarAlly : colRadarEnemy);
}
}
else
{
//original 8-color mode
playerCol = clanColours[getPlayerColour(clan)];
}
flashCol = flashColours[getPlayerColour(clan)];
if (psStruct->visible[selectedPlayer]
|| (bMultiPlayer && alliancesSharedVision(game.alliance)
&& aiCheckAlliances(selectedPlayer, psStruct->player)))
{
if (clan == selectedPlayer && gameTime - psStruct->timeLastHit < HIT_NOTIFICATION)
{
radarBuffer[pos] = flashCol.rgba;
}
else
{
radarBuffer[pos] = playerCol.rgba;
}
}
}
}
}
// this is able to handle multiple weapon graphics now
// removed mountRotation,they get such stuff from psObj directly now
static bool displayCompObj(DROID *psDroid, bool bButton, const glm::mat4 &viewMatrix)
{
iIMDShape *psMoveAnim, *psStillAnim;
SDWORD iConnector;
PROPULSION_STATS *psPropStats;
SDWORD pieFlag, iPieData;
PIELIGHT brightness;
UDWORD colour;
UBYTE i;
bool didDrawSomething = false;
glm::mat4 modelMatrix(1.f);
if (graphicsTime - psDroid->timeLastHit < GAME_TICKS_PER_SEC / 4 && psDroid->lastHitWeapon == WSC_ELECTRONIC && !gamePaused())
{
colour = getPlayerColour(rand() % MAX_PLAYERS);
}
else
{
colour = getPlayerColour(psDroid->player);
}
/* get propulsion stats */
psPropStats = asPropulsionStats + psDroid->asBits[COMP_PROPULSION];
ASSERT_OR_RETURN(didDrawSomething, psPropStats != nullptr, "invalid propulsion stats pointer");
//set pieflag for button object or ingame object
if (bButton)
{
pieFlag = pie_BUTTON;
brightness = WZCOL_WHITE;
}
else
{
pieFlag = pie_SHADOW;
brightness = pal_SetBrightness(psDroid->illumination);
// NOTE: Beware of transporters that are offscreen, on a mission! We should *not* be checking tiles at this point in time!
if (!isTransporter(psDroid) && !missionIsOffworld())
{
MAPTILE *psTile = worldTile(psDroid->pos.x, psDroid->pos.y);
if (psTile->jammerBits & alliancebits[psDroid->player])
{
pieFlag |= pie_ECM;
}
}
}
/* set default components transparent */
if (psDroid->asBits[COMP_PROPULSION] == 0)
{
pieFlag |= pie_TRANSLUCENT;
iPieData = DEFAULT_COMPONENT_TRANSLUCENCY;
}
else
{
iPieData = 0;
}
if (!bButton && psPropStats->propulsionType == PROPULSION_TYPE_PROPELLOR)
{
// FIXME: change when adding submarines to the game
modelMatrix *= glm::translate(glm::vec3(0.f, -world_coord(1) / 2.3f, 0.f));
}
iIMDShape *psShapeProp = (leftFirst ? getLeftPropulsionIMD(psDroid) : getRightPropulsionIMD(psDroid));
if (psShapeProp)
{
if (pie_Draw3DShape(psShapeProp, 0, colour, brightness, pieFlag, iPieData, viewMatrix * modelMatrix))
{
didDrawSomething = true;
}
}
/* set default components transparent */
if (psDroid->asBits[COMP_BODY] == 0)
{
pieFlag |= pie_TRANSLUCENT;
iPieData = DEFAULT_COMPONENT_TRANSLUCENCY;
}
else
{
pieFlag &= ~pie_TRANSLUCENT;
iPieData = 0;
}
/* Get the body graphic now*/
iIMDShape *psShapeBody = BODY_IMD(psDroid, psDroid->player);
if (psShapeBody)
{
iIMDShape *strImd = psShapeBody;
if (psDroid->droidType == DROID_PERSON)
{
modelMatrix *= glm::scale(glm::vec3(.75f)); // FIXME - hideous....!!!!
}
if (strImd->objanimpie[psDroid->animationEvent])
{
strImd = psShapeBody->objanimpie[psDroid->animationEvent];
}
glm::mat4 viewModelMatrix = viewMatrix * modelMatrix;
while (strImd)
{
if (drawShape(psDroid, strImd, colour, brightness, pieFlag, iPieData, viewModelMatrix))
{
didDrawSomething = true;
}
strImd = strImd->next;
}
}
/* Render animation effects based on movement or lack thereof, if any */
psMoveAnim = asBodyStats[psDroid->asBits[COMP_BODY]].ppMoveIMDList[psDroid->asBits[COMP_PROPULSION]];
psStillAnim = asBodyStats[psDroid->asBits[COMP_BODY]].ppStillIMDList[psDroid->asBits[COMP_PROPULSION]];
glm::mat4 viewModelMatrix = viewMatrix * modelMatrix;
if (!bButton && psMoveAnim && psDroid->sMove.Status != MOVEINACTIVE)
{
if (pie_Draw3DShape(psMoveAnim, getModularScaledGraphicsTime(psMoveAnim->animInterval, psMoveAnim->numFrames), colour, brightness, pie_ADDITIVE, 200, viewModelMatrix))
{
didDrawSomething = true;
}
}
else if (!bButton && psStillAnim) // standing still
{
if (pie_Draw3DShape(psStillAnim, getModularScaledGraphicsTime(psStillAnim->animInterval, psStillAnim->numFrames), colour, brightness, 0, 0, viewModelMatrix))
{
didDrawSomething = true;
}
}
//don't change the screen coords of an object if drawing it in a button
if (!bButton)
{
/* set up all the screen coords stuff - need to REMOVE FROM THIS LOOP */
calcScreenCoords(psDroid, viewModelMatrix);
}
/* set default components transparent */
if (psDroid->asWeaps[0].nStat == 0 &&
psDroid->asBits[COMP_SENSOR] == 0 &&
psDroid->asBits[COMP_ECM] == 0 &&
psDroid->asBits[COMP_BRAIN] == 0 &&
psDroid->asBits[COMP_REPAIRUNIT] == 0 &&
psDroid->asBits[COMP_CONSTRUCT] == 0)
{
pieFlag |= pie_TRANSLUCENT;
iPieData = DEFAULT_COMPONENT_TRANSLUCENCY;
}
else
{
pieFlag &= ~pie_TRANSLUCENT;
iPieData = 0;
}
if (psShapeBody && psShapeBody->nconnectors)
{
/* vtol weapons attach to connector 2 (underneath);
* all others to connector 1 */
/* VTOL's now skip the first 5 connectors(0 to 4),
VTOL's use 5,6,7,8 etc now */
if (psPropStats->propulsionType == PROPULSION_TYPE_LIFT && psDroid->droidType == DROID_WEAPON)
{
iConnector = VTOL_CONNECTOR_START;
}
else
{
iConnector = 0;
}
switch (psDroid->droidType)
{
case DROID_DEFAULT:
case DROID_TRANSPORTER:
case DROID_SUPERTRANSPORTER:
case DROID_CYBORG:
case DROID_CYBORG_SUPER:
case DROID_WEAPON:
case DROID_COMMAND: // command droids have a weapon to store all the graphics
/* Get the mounting graphic - we've already moved to the right position
Allegedly - all droids will have a mount graphic so this shouldn't
fall on it's arse......*/
/* Double check that the weapon droid actually has any */
for (i = 0; i < psDroid->numWeaps; i++)
{
if ((psDroid->asWeaps[i].nStat > 0 || psDroid->droidType == DROID_DEFAULT)
&& psShapeBody->connectors)
{
Rotation rot = getInterpolatedWeaponRotation(psDroid, i, graphicsTime);
glm::mat4 localModelMatrix = modelMatrix;
//to skip number of VTOL_CONNECTOR_START ground unit connectors
if (iConnector < VTOL_CONNECTOR_START)
{
localModelMatrix *= glm::translate(glm::vec3(psShapeBody->connectors[i].xzy()));
}
else
{
localModelMatrix *= glm::translate(glm::vec3(psShapeBody->connectors[iConnector + i].xzy()));
}
localModelMatrix *= glm::rotate(UNDEG(-rot.direction), glm::vec3(0.f, 1.f, 0.f));
/* vtol weapons inverted */
if (iConnector >= VTOL_CONNECTOR_START)
{
//this might affect gun rotation
localModelMatrix *= glm::rotate(UNDEG(65536 / 2), glm::vec3(0.f, 0.f, 1.f));
}
/* Get the mount graphic */
iIMDShape *psShape = WEAPON_MOUNT_IMD(psDroid, i);
int recoilValue = getRecoil(psDroid->asWeaps[i]);
localModelMatrix *= glm::translate(glm::vec3(0.f, 0.f, recoilValue / 3.f));
/* Draw it */
if (psShape)
{
if (pie_Draw3DShape(psShape, 0, colour, brightness, pieFlag, iPieData, viewMatrix * localModelMatrix))
{
didDrawSomething = true;
}
}
localModelMatrix *= glm::translate(glm::vec3(0, 0, recoilValue));
/* translate for weapon mount point */
if (psShape && psShape->nconnectors)
{
localModelMatrix *= glm::translate(glm::vec3(psShape->connectors->xzy()));
}
/* vtol weapons inverted */
if (iConnector >= VTOL_CONNECTOR_START)
{
//pitch the barrel down
localModelMatrix *= glm::rotate(UNDEG(-rot.pitch), glm::vec3(1.f, 0.f, 0.f));
}
else
{
//pitch the barrel up
localModelMatrix *= glm::rotate(UNDEG(rot.pitch), glm::vec3(1.f, 0.f, 0.f));
}
/* Get the weapon (gun?) graphic */
psShape = WEAPON_IMD(psDroid, i);
// We have a weapon so we draw it and a muzzle flash from weapon connector
if (psShape)
{
glm::mat4 localViewModelMatrix = viewMatrix * localModelMatrix;
if (pie_Draw3DShape(psShape, 0, colour, brightness, pieFlag, iPieData, localViewModelMatrix))
{
didDrawSomething = true;
}
drawMuzzleFlash(psDroid->asWeaps[i], psShape, MUZZLE_FLASH_PIE(psDroid, i), brightness, pieFlag, iPieData, localViewModelMatrix);
}
}
}
break;
case DROID_SENSOR:
case DROID_CONSTRUCT:
case DROID_CYBORG_CONSTRUCT:
case DROID_ECM:
case DROID_REPAIR:
case DROID_CYBORG_REPAIR:
{
Rotation rot = getInterpolatedWeaponRotation(psDroid, 0, graphicsTime);
iIMDShape *psShape = nullptr;
iIMDShape *psMountShape = nullptr;
switch (psDroid->droidType)
{
default:
ASSERT(false, "Bad component type");
break;
case DROID_SENSOR:
psMountShape = SENSOR_MOUNT_IMD(psDroid, psDroid->player);
/* Get the sensor graphic, assuming it's there */
psShape = SENSOR_IMD(psDroid, psDroid->player);
break;
case DROID_CONSTRUCT:
case DROID_CYBORG_CONSTRUCT:
psMountShape = CONSTRUCT_MOUNT_IMD(psDroid, psDroid->player);
/* Get the construct graphic assuming it's there */
psShape = CONSTRUCT_IMD(psDroid, psDroid->player);
break;
case DROID_ECM:
psMountShape = ECM_MOUNT_IMD(psDroid, psDroid->player);
/* Get the ECM graphic assuming it's there.... */
psShape = ECM_IMD(psDroid, psDroid->player);
break;
case DROID_REPAIR:
case DROID_CYBORG_REPAIR:
psMountShape = REPAIR_MOUNT_IMD(psDroid, psDroid->player);
/* Get the Repair graphic assuming it's there.... */
psShape = REPAIR_IMD(psDroid, psDroid->player);
break;
}
/* Get the mounting graphic - we've already moved to the right position
Allegedly - all droids will have a mount graphic so this shouldn't
fall on it's arse......*/
//sensor and cyborg and ecm uses connectors[0]
glm::mat4 localModelMatrix = modelMatrix;
/* vtol weapons inverted */
if (iConnector >= VTOL_CONNECTOR_START)
{
//this might affect gun rotation
localModelMatrix *= glm::rotate(UNDEG(65536 / 2), glm::vec3(0.f, 0.f, 1.f));
}
localModelMatrix *= glm::translate(glm::vec3(psShapeBody->connectors[0].xzy()));
localModelMatrix *= glm::rotate(UNDEG(-rot.direction), glm::vec3(0.f, 1.f, 0.f));
/* Draw it */
if (psMountShape)
{
if (pie_Draw3DShape(psMountShape, 0, colour, brightness, pieFlag, iPieData, viewMatrix * localModelMatrix))
{
didDrawSomething = true;
}
}
/* translate for construct mount point if cyborg */
if (cyborgDroid(psDroid) && psMountShape && psMountShape->nconnectors)
{
localModelMatrix *= glm::translate(glm::vec3(psMountShape->connectors[0].xzy()));
}
/* Draw it */
if (psShape)
{
if (pie_Draw3DShape(psShape, 0, colour, brightness, pieFlag, iPieData, viewMatrix * localModelMatrix))
{
didDrawSomething = true;
}
// In repair droid case only:
if ((psDroid->droidType == DROID_REPAIR || psDroid->droidType == DROID_CYBORG_REPAIR) &&
psShape->nconnectors && psDroid->action == DACTION_DROIDREPAIR)
{
Spacetime st = interpolateObjectSpacetime(psDroid, graphicsTime);
localModelMatrix *= glm::translate(glm::vec3(psShape->connectors[0].xzy()));
localModelMatrix *= glm::translate(glm::vec3(0.f, -20.f, 0.f));
psShape = getImdFromIndex(MI_FLAME);
/* Rotate for droid */
localModelMatrix *= glm::rotate(UNDEG(st.rot.direction), glm::vec3(0.f, 1.f, 0.f));
localModelMatrix *= glm::rotate(UNDEG(-st.rot.pitch), glm::vec3(1.f, 0.f, 0.f));
localModelMatrix *= glm::rotate(UNDEG(-st.rot.roll), glm::vec3(0.f, 0.f, 1.f));
//rotate Y
localModelMatrix *= glm::rotate(UNDEG(rot.direction), glm::vec3(0.f, 1.f, 0.f));
localModelMatrix *= glm::rotate(UNDEG(-player.r.y), glm::vec3(0.f, 1.f, 0.f));
localModelMatrix *= glm::rotate(UNDEG(-player.r.x), glm::vec3(1.f, 0.f, 0.f));
if (pie_Draw3DShape(psShape, getModularScaledGraphicsTime(psShape->animInterval, psShape->numFrames), 0, brightness, pie_ADDITIVE, 140, viewMatrix * localModelMatrix))
{
didDrawSomething = true;
}
// localModelMatrix *= glm::rotate(UNDEG(player.r.x), glm::vec3(1.f, 0.f, 0.f)); // Not used?
// localModelMatrix *= glm::rotate(UNDEG(player.r.y), glm::vec3(0.f, 1.f, 0.f)); // Not used?
}
}
break;
}
case DROID_PERSON:
// no extra mounts for people
break;
default:
ASSERT(!"invalid droid type", "Whoa! Weirdy type of droid found in drawComponentObject!!!");
break;
}
}
/* set default components transparent */
if (psDroid->asBits[COMP_PROPULSION] == 0)
{
pieFlag |= pie_TRANSLUCENT;
iPieData = DEFAULT_COMPONENT_TRANSLUCENCY;
}
else
{
pieFlag &= ~pie_TRANSLUCENT;
iPieData = 0;
}
// now render the other propulsion side
psShapeProp = (leftFirst ? getRightPropulsionIMD(psDroid) : getLeftPropulsionIMD(psDroid));
if (psShapeProp)
{
if (pie_Draw3DShape(psShapeProp, 0, colour, brightness, pieFlag, iPieData, viewModelMatrix)) // Safe to use viewModelMatrix because modelView has not been changed since it was calculated
{
didDrawSomething = true;
}
}
return didDrawSomething;
}
//changed it to loop thru and draw all weapons
void displayStructureButton(STRUCTURE *psStructure, Vector3i *rotation, Vector3i *Position, bool RotXYZ, SDWORD scale)
{
iIMDShape *baseImd,*strImd;//*mountImd,*weaponImd;
iIMDShape *mountImd[STRUCT_MAXWEAPS];
iIMDShape *weaponImd[STRUCT_MAXWEAPS];
UDWORD nWeaponStat;
int i;
/*HACK HACK HACK!
if its a 'tall thin (ie tower)' structure with something on the top - offset the
position to show the object on top*/
if (psStructure->pStructureType->pIMD[0]->nconnectors && scale == SMALL_STRUCT_SCALE &&
getStructureHeight(psStructure) > TOWER_HEIGHT)
{
Position->y -= 20;
}
setMatrix(Position, rotation, RotXYZ);
pie_MatScale(scale / 100.f);
/* Draw the building's base first */
baseImd = psStructure->pStructureType->pBaseIMD;
if(baseImd!=NULL) {
pie_Draw3DShape(baseImd, 0, getPlayerColour(selectedPlayer), WZCOL_WHITE, pie_BUTTON, 0);
}
pie_Draw3DShape(psStructure->sDisplay.imd, 0, getPlayerColour(selectedPlayer), WZCOL_WHITE, pie_BUTTON, 0);
//and draw the turret
if(psStructure->sDisplay.imd->nconnectors)
{
for (i = 0;i < STRUCT_MAXWEAPS;i++)
{
weaponImd[i] = NULL;//weapon is gun ecm or sensor
mountImd[i] = NULL;
}
strImd = psStructure->sDisplay.imd;
//get an imd to draw on the connector priority is weapon, ECM, sensor
//check for weapon
for (i = 0; i < MAX(1, psStructure->numWeaps); i++)
{
if (psStructure->asWeaps[i].nStat > 0)
{
nWeaponStat = psStructure->asWeaps[i].nStat;
weaponImd[i] = asWeaponStats[nWeaponStat].pIMD;
mountImd[i] = asWeaponStats[nWeaponStat].pMountGraphic;
}
if (weaponImd[i] == NULL)
{
//check for ECM
if (psStructure->pStructureType->pECM != NULL)
{
weaponImd[i] = psStructure->pStructureType->pECM->pIMD;
mountImd[i] = psStructure->pStructureType->pECM->pMountGraphic;
}
}
if (weaponImd[i] == NULL)
{
//check for sensor
if (psStructure->pStructureType->pSensor != NULL)
{
weaponImd[i] = psStructure->pStructureType->pSensor->pIMD;
mountImd[i] = psStructure->pStructureType->pSensor->pMountGraphic;
}
}
}
//draw Weapon/ECM/Sensor for structure
//uses 0
if (weaponImd[0] != NULL)
{
for (i = 0; i < MAX(1, psStructure->numWeaps); i++)
{
Rotation rot = structureGetInterpolatedWeaponRotation(psStructure, i, graphicsTime);
pie_MatBegin();
pie_TRANSLATE(strImd->connectors[i].x,strImd->connectors[i].z,strImd->connectors[i].y);
pie_MatRotY(-rot.direction);
if (mountImd[i] != NULL)
{
pie_Draw3DShape(mountImd[i], 0, getPlayerColour(selectedPlayer), WZCOL_WHITE, pie_BUTTON, 0);
if(mountImd[i]->nconnectors)
{
pie_TRANSLATE(mountImd[i]->connectors->x,mountImd[i]->connectors->z,mountImd[i]->connectors->y);
}
}
pie_MatRotX(rot.pitch);
pie_Draw3DShape(weaponImd[i], 0, getPlayerColour(selectedPlayer), WZCOL_WHITE, pie_BUTTON, 0);
//we have a droid weapon so do we draw a muzzle flash
pie_MatEnd();
}
}
}
unsetMatrix();
}
static void displayMultiPlayer(WIDGET *psWidget, UDWORD xOffset, UDWORD yOffset)
{
char str[128];
int x = xOffset + psWidget->x();
int y = yOffset + psWidget->y();
unsigned player = psWidget->UserData; // Get the in game player number.
if (responsibleFor(player, 0))
{
displayExtraGubbins(widgGetFromID(psWScreen,MULTIMENU_FORM)->height());
}
iV_SetFont(font_regular); // font
iV_SetTextColour(WZCOL_TEXT_BRIGHT);
const bool isHuman = isHumanPlayer(player);
const bool isAlly = aiCheckAlliances(selectedPlayer, player);
const bool isSelectedPlayer = player == selectedPlayer;
SetPlayerTextColor(alliances[selectedPlayer][player], player);
if (isHuman || (game.type == SKIRMISH && player<game.maxPlayers) )
{
ssprintf(str, "%d: %s", NetPlay.players[player].position, getPlayerName(player));
while (iV_GetTextWidth(str) >= MULTIMENU_C0 - MULTIMENU_C2 - 10)
{
str[strlen(str) - 1] = '\0';
}
iV_DrawText(str, x + MULTIMENU_C2, y + MULTIMENU_FONT_OSET);
//c3-7 alliance
//manage buttons by showing or hiding them. gifts only in campaign,
if (alliancesCanGiveAnything(game.alliance))
{
if (isAlly && !isSelectedPlayer && !giftsUp[player] )
{
if (alliancesCanGiveResearchAndRadar(game.alliance))
{
widgReveal(psWScreen, MULTIMENU_GIFT_RAD + player);
widgReveal(psWScreen, MULTIMENU_GIFT_RES + player);
}
widgReveal(psWScreen, MULTIMENU_GIFT_DRO + player);
widgReveal(psWScreen, MULTIMENU_GIFT_POW + player);
giftsUp[player] = true;
}
else if (!isAlly && !isSelectedPlayer && giftsUp[player])
{
if (alliancesCanGiveResearchAndRadar(game.alliance))
{
widgHide(psWScreen, MULTIMENU_GIFT_RAD + player);
widgHide(psWScreen, MULTIMENU_GIFT_RES + player);
}
widgHide(psWScreen, MULTIMENU_GIFT_DRO + player);
widgHide(psWScreen, MULTIMENU_GIFT_POW + player);
giftsUp[player] = false;
}
}
}
// Let's use the real score for MP games
if (NetPlay.bComms)
{
//c8:score,
if (Cheated)
{
sprintf(str, "(cheated)");
}
else
{
sprintf(str, "%d", getMultiStats(player).recentScore);
}
iV_DrawText(str, x + MULTIMENU_C8, y + MULTIMENU_FONT_OSET);
//c9:kills,
sprintf(str, "%d", getMultiStats(player).recentKills);
iV_DrawText(str, x + MULTIMENU_C9, y + MULTIMENU_FONT_OSET);
}
else
{
// estimate of score for skirmish games
sprintf(str, "%d", ingame.skScores[player][0]);
iV_DrawText(str, x + MULTIMENU_C8, y + MULTIMENU_FONT_OSET);
// estimated kills
sprintf(str, "%d", ingame.skScores[player][1]);
iV_DrawText(str, x + MULTIMENU_C9, y + MULTIMENU_FONT_OSET);
}
//only show player's and allies' unit counts, and nobody elses.
//c10:units
if (isAlly || getDebugMappingStatus())
{
sprintf(str, "%d", getNumDroids(player) + getNumTransporterDroids(player));
iV_DrawText(str, x + MULTIMENU_C10, y + MULTIMENU_FONT_OSET);
}
/* Display player power instead of number of played games
* and number of units instead of ping when in debug mode
*/
if (getDebugMappingStatus()) //Won't pass this when in both release and multiplayer modes
{
//c11: Player power
sprintf(str, "%u", (int)getPower(player));
iV_DrawText(str, MULTIMENU_FORM_X + MULTIMENU_C11, y + MULTIMENU_FONT_OSET);
}
else if (runningMultiplayer())
{
//c11:ping
if (!isSelectedPlayer && isHuman)
{
if (ingame.PingTimes[player] < PING_LIMIT)
{
sprintf(str, "%03d", ingame.PingTimes[player]);
}
else
{
sprintf(str, "∞");
}
iV_DrawText(str, x + MULTIMENU_C11, y + MULTIMENU_FONT_OSET);
}
}
else
{
//c11: Structures
if (isAlly || getDebugMappingStatus())
{
// NOTE, This tallys up *all* the structures you have. Test out via 'start with no base'.
int num = 0;
for (STRUCTURE *temp = apsStructLists[player]; temp != NULL; temp = temp->psNext)
{
++num;
}
sprintf(str, "%d", num);
iV_DrawText(str, x + MULTIMENU_C11, y + MULTIMENU_FONT_OSET);
}
}
// a droid of theirs.
DROID *displayDroid = apsDroidLists[player];
while (displayDroid != NULL && !displayDroid->visible[selectedPlayer])
{
displayDroid = displayDroid->psNext;
}
if (displayDroid)
{
pie_SetGeometricOffset( MULTIMENU_FORM_X+MULTIMENU_C1 ,y+MULTIMENU_PLAYER_H);
Vector3i rotation(-15, 45, 0);
Position position(0, 0, BUTTON_DEPTH); // Scale them.
if (displayDroid->droidType == DROID_SUPERTRANSPORTER)
{
position.z = 7850;
}
else if (displayDroid->droidType == DROID_TRANSPORTER)
{
position.z = 4100;
}
displayComponentButtonObject(displayDroid, &rotation, &position, false, 100);
}
else if (apsDroidLists[player])
{
// Show that they have droids, but not which droids, since we can't see them.
iV_DrawImageTc(IntImages, IMAGE_GENERIC_TANK, IMAGE_GENERIC_TANK_TC, MULTIMENU_FORM_X + MULTIMENU_C1 - iV_GetImageWidth(IntImages, IMAGE_GENERIC_TANK)/2, y + MULTIMENU_PLAYER_H - iV_GetImageHeight(IntImages, IMAGE_GENERIC_TANK), pal_GetTeamColour(getPlayerColour(player)));
}
// clean up widgets if player leaves while menu is up.
if (!isHuman && !(game.type == SKIRMISH && player < game.maxPlayers))
{
if (widgGetFromID(psWScreen, MULTIMENU_CHANNEL + player) != NULL)
{
widgDelete(psWScreen, MULTIMENU_CHANNEL + player);
}
if (widgGetFromID(psWScreen, MULTIMENU_ALLIANCE_BASE + player) != NULL)
{
widgDelete(psWScreen, MULTIMENU_ALLIANCE_BASE + player);
widgDelete(psWScreen, MULTIMENU_GIFT_RAD + player);
widgDelete(psWScreen, MULTIMENU_GIFT_RES + player);
widgDelete(psWScreen, MULTIMENU_GIFT_DRO + player);
widgDelete(psWScreen, MULTIMENU_GIFT_POW + player);
giftsUp[player] = false;
}
}
}
// this is able to handle multiple weapon graphics now
// removed mountRotation,they get such stuff from psObj directly now
static void displayCompObj(DROID *psDroid, BOOL bButton)
{
iIMDShape *psShape, *psJet, *psShapeTemp = NULL, *psMountShape;
Vector3i zero = {0, 0, 0};
Vector2i screenCoords;
SDWORD dummyZ, iConnector;
PROPULSION_STATS *psPropStats;
SDWORD frame;
SDWORD pieFlag, iPieData;
PIELIGHT brightness;
const PIELIGHT specular = WZCOL_BLACK;
UDWORD colour;
UBYTE i;
if( (gameTime-psDroid->timeLastHit < GAME_TICKS_PER_SEC/4 ) && psDroid->lastHitWeapon == WSC_ELECTRONIC && !gamePaused())
{
colour = getPlayerColour(rand()%MAX_PLAYERS);
}
else
{
colour = getPlayerColour(psDroid->player);
}
/* get propulsion stats */
psPropStats = asPropulsionStats + psDroid->asBits[COMP_PROPULSION].nStat;
ASSERT_OR_RETURN( , psPropStats != NULL, "invalid propulsion stats pointer");
//set pieflag for button object or ingame object
if ( bButton )
{
pieFlag = pie_BUTTON;
}
else
{
pieFlag = 0;
}
if(!bButton)
{
brightness = pal_SetBrightness(psDroid->illumination);
pieFlag = pie_SHADOW;
}
else
{
brightness = WZCOL_WHITE;
}
/* We've got a z value here _and_ screen coords of origin */
dummyZ = pie_RotateProject(&zero, &screenCoords);
/* set default components transparent */
if ( psDroid->asBits[COMP_PROPULSION].nStat == 0 )
{
pieFlag |= pie_TRANSLUCENT;
iPieData = DEFAULT_COMPONENT_TRANSLUCENCY;
}
else
{
iPieData = 0;
}
if (!bButton && psPropStats->propulsionType == PROPULSION_TYPE_PROPELLOR)
{
// FIXME: change when adding submarines to the game
pie_TRANSLATE(0, -world_coord(1)/2.3f, 0);
}
//uses psShapeTemp too separate it from turret's psShape
psShapeTemp = (leftFirst ? getLeftPropulsionIMD(psDroid) : getRightPropulsionIMD(psDroid));
if(psShapeTemp!=NULL)
{
pie_Draw3DShape(psShapeTemp, 0, colour, brightness, specular, pieFlag, iPieData);
}
/* set default components transparent */
if ( psDroid->asBits[COMP_BODY].nStat == 0 )
{
pieFlag |= pie_TRANSLUCENT;
iPieData = DEFAULT_COMPONENT_TRANSLUCENCY;
}
else
{
pieFlag &= ~pie_TRANSLUCENT;
iPieData = 0;
}
/* Get the body graphic now*/
//uses psShapeTemp too separate it from turret's psShape
psShapeTemp = BODY_IMD(psDroid,psDroid->player);
if(psShapeTemp!=NULL)
{
// FIXME
if ( psDroid->droidType == DROID_PERSON)
{
/* draw body if not animating */
if ( psDroid->psCurAnim == NULL || psDroid->psCurAnim->bVisible == false )
{
// FIXME - hideous....!!!!
pie_MatScale(.75f);
pie_Draw3DShape(psShapeTemp, 0, psDroid->player-6, brightness, specular, pieFlag, iPieData);
}
}
else if (cyborgDroid(psDroid))
{
/* draw body if cyborg not animating */
if ( psDroid->psCurAnim == NULL || psDroid->psCurAnim->bVisible == false )
{
pie_Draw3DShape(psShapeTemp, 0, colour, brightness, specular, pieFlag, iPieData);
}
}
else
{
pie_Draw3DShape(psShapeTemp, 0, colour, brightness, specular, pieFlag, iPieData);
}
}
/* render vtol jet if flying - horrible hack - GJ */
if (((psPropStats->propulsionType == PROPULSION_TYPE_LIFT) &&
//(psDroid->droidType != DROID_CYBORG)) && (!bButton))
(!cyborgDroid(psDroid))) && (!bButton))
{
/* show flame if above ground */
if ( psDroid->sMove.Status != MOVEINACTIVE )
{
/* draw flame if found */
/* GJ TODO: add flame-finding code here */
psJet = asBodyStats[psDroid->asBits[COMP_BODY].nStat].pFlameIMD;
if ( psJet != NULL )
{
pie_Draw3DShape(psJet, getModularScaledGraphicsTime(100, psJet->numFrames), colour, brightness, specular, pie_ADDITIVE, 200);
}
}
}
//don't change the screen coords of an object if drawing it in a button
if (!bButton)
{
/* set up all the screen coords stuff - need to REMOVE FROM THIS LOOP */
calcScreenCoords(psDroid);
}
/* set default components transparent */
if (psDroid->asWeaps[0].nStat == 0 &&
psDroid->asBits[COMP_SENSOR].nStat == 0 &&
psDroid->asBits[COMP_ECM].nStat == 0 &&
psDroid->asBits[COMP_BRAIN].nStat == 0 &&
psDroid->asBits[COMP_REPAIRUNIT].nStat == 0 &&
psDroid->asBits[COMP_CONSTRUCT].nStat == 0)
{
pieFlag |= pie_TRANSLUCENT;
iPieData = DEFAULT_COMPONENT_TRANSLUCENCY;
}
else
{
pieFlag &= ~pie_TRANSLUCENT;
iPieData = 0;
}
/* Indenting here is only to show new matrix context */
{
psShapeTemp = BODY_IMD(psDroid,psDroid->player);
if( psShapeTemp->nconnectors )
{
/* vtol weapons attach to connector 2 (underneath);
* all others to connector 1 */
/* VTOL's now skip the first 5 connectors(0 to 4),
VTOL's use 5,6,7,8 etc now */
if ( (psPropStats->propulsionType == PROPULSION_TYPE_LIFT) &&
psDroid->droidType == DROID_WEAPON )
{
iConnector = VTOL_CONNECTOR_START;
}
else
{
iConnector = 0;
}
switch(psDroid->droidType)
{
case DROID_DEFAULT:
case DROID_TRANSPORTER:
case DROID_CYBORG:
case DROID_CYBORG_SUPER:
case DROID_WEAPON:
case DROID_COMMAND: // command droids have a weapon to store all the graphics
/* Get the mounting graphic - we've already moved to the right position
Allegedly - all droids will have a mount graphic so this shouldn't
fall on it's arse......*/
/* Double check that the weapon droid actually has any */
for (i = 0;i < psDroid->numWeaps;i++)
{
if (psDroid->asWeaps[i].nStat > 0 || psDroid->droidType == DROID_DEFAULT)
{
if ( psShapeTemp->connectors )
{
Rotation rot = getInterpolatedWeaponRotation(psDroid, i, graphicsTime);
pie_MatBegin();
//reset Z?
dummyZ = pie_RotateProject(&zero, &screenCoords);
//to skip number of VTOL_CONNECTOR_START ground unit connectors
if ( iConnector < VTOL_CONNECTOR_START )
{
pie_TRANSLATE(psShapeTemp->connectors[i].x,
psShapeTemp->connectors[i].z,
psShapeTemp->connectors[i].y);
}
else
{
pie_TRANSLATE( psShapeTemp->connectors[iConnector + i].x,
psShapeTemp->connectors[iConnector + i].z,
psShapeTemp->connectors[iConnector + i].y );
}
pie_MatRotY(-rot.direction);
/* vtol weapons inverted */
if ( iConnector >= VTOL_CONNECTOR_START )
{
pie_MatRotZ(65536/2); //this might affect gun rotation
}
/* Get the mount graphic */
psShape = WEAPON_MOUNT_IMD(psDroid, i);
pie_TRANSLATE(0,0,psDroid->asWeaps[i].recoilValue/3);
/* Draw it */
if(psShape)
{
pie_Draw3DShape(psShape, 0, colour, brightness, specular, pieFlag, iPieData);
}
pie_TRANSLATE(0,0,psDroid->asWeaps[i].recoilValue);
/* translate for weapon mount point */
if (psShape && psShape->nconnectors)
{
pie_TRANSLATE(psShape->connectors->x, psShape->connectors->z, psShape->connectors->y);
}
/* vtol weapons inverted */
if ( iConnector >= VTOL_CONNECTOR_START )
{
//pitch the barrel down
pie_MatRotX(-rot.pitch);
}
else
{
//pitch the barrel up
pie_MatRotX(rot.pitch);
}
/* Get the weapon (gun?) graphic */
psShape = WEAPON_IMD(psDroid, i);
// We have a weapon so we draw it and a muzzle flash from weapon connector
if (psShape)
{
pie_Draw3DShape(psShape, 0, colour, brightness, specular, pieFlag, iPieData);
if (psShape->nconnectors)
{
unsigned int connector_num = 0;
// which barrel is firing if model have multiple muzzle connectors?
if (psDroid->asWeaps[i].shotsFired && (psShape->nconnectors > 1))
{
// shoot first, draw later - substract one shot to get correct results
connector_num = (psDroid->asWeaps[i].shotsFired - 1) % (psShape->nconnectors);
}
/* Now we need to move to the end of the firing barrel (there maybe multiple barrels) */
pie_TRANSLATE( psShape->connectors[connector_num].x,
psShape->connectors[connector_num].z,
psShape->connectors[connector_num].y);
//and draw the muzzle flash
psShape = MUZZLE_FLASH_PIE(psDroid, i);
if (psShape)
{
//assume no clan colours for muzzle effects
if ((psShape->numFrames == 0) || (psShape->animInterval <= 0))
{
//no anim so display one frame for a fixed time
if (gameTime < (psDroid->asWeaps[i].lastFired + BASE_MUZZLE_FLASH_DURATION))
{
pie_Draw3DShape(psShape, 0, 0, brightness, WZCOL_BLACK, pieFlag | pie_ADDITIVE, EFFECT_MUZZLE_ADDITIVE);
}
}
else
{
// animated muzzle
frame = (gameTime - psDroid->asWeaps[i].lastFired) / psShape->animInterval;
if (frame < psShape->numFrames)
{
pie_Draw3DShape(psShape, frame, 0, brightness, WZCOL_BLACK, pieFlag | pie_ADDITIVE, EFFECT_MUZZLE_ADDITIVE);
}
}
}
}
}
}
/* Pop Matrix */
pie_MatEnd();
}
}
break;
case DROID_SENSOR:
case DROID_CONSTRUCT:
case DROID_CYBORG_CONSTRUCT:
case DROID_ECM:
case DROID_REPAIR:
case DROID_CYBORG_REPAIR:
{
Rotation rot = getInterpolatedWeaponRotation(psDroid, 0, graphicsTime);
switch (psDroid->droidType)
{
default: ASSERT(false, "...");
case DROID_SENSOR:
psMountShape = SENSOR_MOUNT_IMD(psDroid, psDroid->player);
/* Get the sensor graphic, assuming it's there */
psShape = SENSOR_IMD(psDroid, psDroid->player);
break;
case DROID_CONSTRUCT:
case DROID_CYBORG_CONSTRUCT:
psMountShape = CONSTRUCT_MOUNT_IMD(psDroid, psDroid->player);
/* Get the construct graphic assuming it's there */
psShape = CONSTRUCT_IMD(psDroid, psDroid->player);
break;
case DROID_ECM:
psMountShape = ECM_MOUNT_IMD(psDroid, psDroid->player);
/* Get the ECM graphic assuming it's there.... */
psShape = ECM_IMD(psDroid, psDroid->player);
break;
case DROID_REPAIR:
case DROID_CYBORG_REPAIR:
psMountShape = REPAIR_MOUNT_IMD(psDroid, psDroid->player);
/* Get the Repair graphic assuming it's there.... */
psShape = REPAIR_IMD(psDroid, psDroid->player);
break;
}
/* Get the mounting graphic - we've already moved to the right position
Allegedly - all droids will have a mount graphic so this shouldn't
fall on it's arse......*/
//sensor and cyborg and ecm uses connectors[0]
pie_MatBegin();
//reset Z?
dummyZ = pie_RotateProject(&zero, &screenCoords);
/* vtol weapons inverted */
if ( iConnector >= VTOL_CONNECTOR_START )
{
pie_MatRotZ(65536/2); //this might affect gun rotation
}
pie_TRANSLATE( psShapeTemp->connectors[0].x,
psShapeTemp->connectors[0].z,
psShapeTemp->connectors[0].y );
pie_MatRotY(-rot.direction);
/* Draw it */
if (psMountShape)
{
pie_Draw3DShape(psMountShape, 0, colour, brightness, specular, pieFlag, iPieData);
}
/* translate for construct mount point if cyborg */
if (cyborgDroid(psDroid) && psMountShape && psMountShape->nconnectors)
{
pie_TRANSLATE(psMountShape->connectors[0].x,
psMountShape->connectors[0].z,
psMountShape->connectors[0].y);
}
/* Draw it */
if(psShape)
{
pie_Draw3DShape(psShape, 0, colour, brightness, specular, pieFlag, iPieData);
// In repair droid case only:
if ((psDroid->droidType == DROID_REPAIR || psDroid->droidType == DROID_CYBORG_REPAIR) &&
psShape->nconnectors && psDroid->action == DACTION_DROIDREPAIR)
{
SPACETIME st = interpolateObjectSpacetime((SIMPLE_OBJECT *)psDroid, graphicsTime);
Rotation rot = getInterpolatedWeaponRotation(psDroid, 0, graphicsTime);
pie_TRANSLATE( psShape->connectors[0].x,
psShape->connectors[0].z,
psShape->connectors[0].y );
pie_TRANSLATE(0,-20,0);
psShape = getImdFromIndex(MI_FLAME);
/* Rotate for droid */
pie_MatRotY(st.rot.direction);
pie_MatRotX(-st.rot.pitch);
pie_MatRotZ(-st.rot.roll);
//rotate Y
pie_MatRotY(rot.direction);
pie_MatRotY(-player.r.y);
pie_MatRotX(-player.r.x);
/* Dither on software */
pie_Draw3DShape(psShape, getModularScaledGraphicsTime(100, psShape->numFrames), 0, brightness, WZCOL_BLACK, pie_ADDITIVE, 140);
/* Dither off software */
pie_MatRotX(player.r.x);
pie_MatRotY(player.r.y);
}
}
/* Pop Matrix */
pie_MatEnd();
break;
}
case DROID_PERSON:
// no extra mounts for people
break;
default:
ASSERT(!"invalid droid type", "Whoa! Weirdy type of droid found in drawComponentObject!!!");
break;
}
}
/* We've also got a handle on the psShape here for the weapon which has a connector to point to
muzzle flash attachment points - just grab it from psShape->connectors->[x|y|z] */
} // end of illustrative indentation - see above
/* set default components transparent */
if ( psDroid->asBits[COMP_PROPULSION].nStat == 0 )
{
pieFlag |= pie_TRANSLUCENT;
iPieData = DEFAULT_COMPONENT_TRANSLUCENCY;
}
else
{
pieFlag &= ~pie_TRANSLUCENT;
iPieData = 0;
}
psShape = (leftFirst ? getRightPropulsionIMD(psDroid) : getLeftPropulsionIMD(psDroid));
if(psShape!=NULL)
{
pie_Draw3DShape(psShape, 0, colour, brightness, specular, pieFlag, iPieData);
}
}
void destroyFXDroid(DROID *psDroid, unsigned impactTime)
{
for (int i = 0; i < 5; ++i)
{
iIMDShape *psImd = nullptr;
int maxHorizontalScatter = TILE_UNITS / 4;
int heightScatter = TILE_UNITS / 5;
Vector2i horizontalScatter = iSinCosR(rand(), rand() % maxHorizontalScatter);
Vector3i pos = (psDroid->pos + Vector3i(horizontalScatter, 16 + heightScatter)).xzy;
switch (i)
{
case 0:
switch (psDroid->droidType)
{
case DROID_DEFAULT:
case DROID_CYBORG:
case DROID_CYBORG_SUPER:
case DROID_CYBORG_CONSTRUCT:
case DROID_CYBORG_REPAIR:
case DROID_WEAPON:
case DROID_COMMAND:
if (psDroid->numWeaps > 0)
{
if (psDroid->asWeaps[0].nStat > 0)
{
psImd = WEAPON_MOUNT_IMD(psDroid, 0);
}
}
break;
default:
break;
}
break;
case 1:
switch (psDroid->droidType)
{
case DROID_DEFAULT:
case DROID_CYBORG:
case DROID_CYBORG_SUPER:
case DROID_CYBORG_CONSTRUCT:
case DROID_CYBORG_REPAIR:
case DROID_WEAPON:
case DROID_COMMAND:
if (psDroid->numWeaps)
{
// get main weapon
psImd = WEAPON_IMD(psDroid, 0);
}
break;
default:
break;
}
break;
}
if (psImd == nullptr)
{
psImd = getRandomDebrisImd();
}
// Tell the effect system that it needs to use this player's color for the next effect
SetEffectForPlayer(psDroid->player);
addEffect(&pos, EFFECT_GRAVITON, GRAVITON_TYPE_EMITTING_DR, true, psImd, getPlayerColour(psDroid->player), impactTime);
}
}
// ////////////////////////////////////////////////////////////////////////////
bool saveConfig(void)
{
debug( LOG_WZ, "Writing prefs to registry\n" );
if(!openWarzoneKey())
{
return false;
}
// //////////////////////////
// voicevol, fxvol and cdvol
setWarzoneKeyNumeric("voicevol", (int)(sound_GetUIVolume() * 100.0));
setWarzoneKeyNumeric("fxvol", (int)(sound_GetEffectsVolume() * 100.0));
setWarzoneKeyNumeric("cdvol", (int)(sound_GetMusicVolume() * 100.0));
setWarzoneKeyNumeric("music_enabled", war_GetMusicEnabled());
setWarzoneKeyNumeric("width", war_GetWidth());
setWarzoneKeyNumeric("height", war_GetHeight());
setWarzoneKeyNumeric("bpp", pie_GetVideoBufferDepth());
setWarzoneKeyNumeric("fullscreen", war_getFullscreen());
setWarzoneKeyString("language", getLanguage());
// dont save out the cheat mode.
if(getDifficultyLevel()==DL_KILLER || getDifficultyLevel()== DL_TOUGH)
{
setDifficultyLevel(DL_NORMAL);
}
setWarzoneKeyNumeric("debugmode", bAllowDebugMode);
setWarzoneKeyNumeric("framerate", (SDWORD)getFramerateLimit());
setWarzoneKeyNumeric("showFPS", (SDWORD)showFPS);
setWarzoneKeyNumeric("scroll",(SDWORD)scroll_speed_accel); // scroll
setWarzoneKeyNumeric("difficulty", getDifficultyLevel()); // level
setWarzoneKeyNumeric("visfog",(SDWORD)(!war_GetFog())); // fogtype
setWarzoneKeyNumeric("shake",(SDWORD)(getShakeStatus())); // screenshake
setWarzoneKeyNumeric("mouseflip",(SDWORD)(getInvertMouseStatus())); // flipmouse
setWarzoneKeyNumeric("RightClickOrders",(SDWORD)(getRightClickOrders()));
setWarzoneKeyNumeric("MiddleClickRotate",(SDWORD)(getMiddleClickRotate()));
setWarzoneKeyNumeric("shadows",(SDWORD)(getDrawShadows())); // shadows
setWarzoneKeyNumeric("sound", (SDWORD)war_getSoundEnabled());
setWarzoneKeyNumeric("FMVmode",(SDWORD)(war_GetFMVmode())); // sequences
setWarzoneKeyNumeric("subtitles",(SDWORD)(seq_GetSubtitles())); // subtitles
setWarzoneKeyNumeric("radarObjectMode",(SDWORD)bEnemyAllyRadarColor); // enemy/allies radar view
setWarzoneKeyNumeric("radarTerrainMode",(SDWORD)radarDrawMode);
setWarzoneKeyNumeric("trapCursor", war_GetTrapCursor());
setWarzoneKeyNumeric("vsync", war_GetVsync());
setWarzoneKeyNumeric("textureSize", getTextureSize());
setWarzoneKeyNumeric("rotateRadar", rotateRadar);
setWarzoneKeyNumeric("PauseOnFocusLoss", war_GetPauseOnFocusLoss());
setWarzoneKeyNumeric("ColouredCursor", war_GetColouredCursor());
setWarzoneKeyString("masterserver_name", NETgetMasterserverName());
setWarzoneKeyNumeric("masterserver_port", NETgetMasterserverPort());
setWarzoneKeyNumeric("gameserver_port", NETgetGameserverPort());
if(!bMultiPlayer)
{
setWarzoneKeyNumeric("colour",(SDWORD)getPlayerColour(0)); // favourite colour.
}
else
{
debug( LOG_NEVER, "Writing multiplay prefs to registry\n" );
if (NetPlay.isHost && ingame.localJoiningInProgress)
{
if (bMultiPlayer && NetPlay.bComms)
{
setWarzoneKeyString("gameName", game.name); // last hosted game
}
setWarzoneKeyString("mapName", game.map); // map name
setWarzoneKeyNumeric("maxPlayers",game.maxPlayers); // maxPlayers
setWarzoneKeyNumeric("power", game.power); // power
setWarzoneKeyNumeric("base", game.base); // size of base
setWarzoneKeyNumeric("fog", game.fog); // fog 'o war
setWarzoneKeyNumeric("alliance", game.alliance); // allow alliances
}
setWarzoneKeyString("playerName",(char*)sPlayer); // player name
setWarzoneKeyString("phrase0", ingame.phrases[0]); // phrases
setWarzoneKeyString("phrase1", ingame.phrases[1]);
setWarzoneKeyString("phrase2", ingame.phrases[2]);
setWarzoneKeyString("phrase3", ingame.phrases[3]);
setWarzoneKeyString("phrase4", ingame.phrases[4]);
}
return closeWarzoneKey();
}
// ////////////////////////////////////////////////////////////////////////////
bool saveConfig()
{
QSettings ini(PHYSFS_getWriteDir() + QString("/") + fileName, QSettings::IniFormat);
if (ini.status() != QSettings::NoError)
{
debug(LOG_ERROR, "Could not open configuration file \"%s\"", fileName);
return false;
}
debug(LOG_WZ, "Writing prefs to registry \"%s\"", ini.fileName().toUtf8().constData());
// //////////////////////////
// voicevol, fxvol and cdvol
ini.setValue("voicevol", (int)(sound_GetUIVolume() * 100.0));
ini.setValue("fxvol", (int)(sound_GetEffectsVolume() * 100.0));
ini.setValue("cdvol", (int)(sound_GetMusicVolume() * 100.0));
ini.setValue("music_enabled", war_GetMusicEnabled());
ini.setValue("width", war_GetWidth());
ini.setValue("height", war_GetHeight());
ini.setValue("bpp", pie_GetVideoBufferDepth());
ini.setValue("fullscreen", war_getFullscreen());
ini.setValue("language", getLanguage());
// dont save out the cheat mode.
if (getDifficultyLevel() != DL_KILLER && getDifficultyLevel() != DL_TOUGH)
{
ini.setValue("difficulty", getDifficultyLevel()); // level
}
ini.setValue("showFPS", (SDWORD)showFPS);
ini.setValue("scroll",(SDWORD)scroll_speed_accel); // scroll
ini.setValue("shake",(SDWORD)(getShakeStatus())); // screenshake
ini.setValue("mouseflip",(SDWORD)(getInvertMouseStatus())); // flipmouse
ini.setValue("nomousewarp", (SDWORD)getMouseWarp()); // mouse warp
ini.setValue("RightClickOrders",(SDWORD)(getRightClickOrders()));
ini.setValue("MiddleClickRotate",(SDWORD)(getMiddleClickRotate()));
ini.setValue("showFPS", (SDWORD)showFPS);
ini.setValue("shadows",(SDWORD)(getDrawShadows())); // shadows
ini.setValue("sound", (SDWORD)war_getSoundEnabled());
ini.setValue("FMVmode",(SDWORD)(war_GetFMVmode())); // sequences
ini.setValue("scanlines", (SDWORD)war_getScanlineMode());
ini.setValue("subtitles",(SDWORD)(seq_GetSubtitles())); // subtitles
ini.setValue("radarObjectMode",(SDWORD)bEnemyAllyRadarColor); // enemy/allies radar view
ini.setValue("radarTerrainMode",(SDWORD)radarDrawMode);
ini.setValue("trapCursor", war_GetTrapCursor());
ini.setValue("vsync", war_GetVsync());
ini.setValue("textureSize", getTextureSize());
ini.setValue("FSAA", war_getFSAA());
ini.setValue("UPnP", (SDWORD)NetPlay.isUPNP);
ini.setValue("rotateRadar", rotateRadar);
ini.setValue("PauseOnFocusLoss", war_GetPauseOnFocusLoss());
ini.setValue("masterserver_name", NETgetMasterserverName());
ini.setValue("masterserver_port", NETgetMasterserverPort());
ini.setValue("gameserver_port", NETgetGameserverPort());
if (!bMultiPlayer)
{
ini.setValue("colour", getPlayerColour(0)); // favourite colour.
}
else
{
if (NetPlay.isHost && ingame.localJoiningInProgress)
{
if (bMultiPlayer && NetPlay.bComms)
{
ini.setValue("gameName", game.name); // last hosted game
}
ini.setValue("mapName", game.map); // map name
ini.setValue("mapHash", game.hash.toString().c_str()); // map hash
ini.setValue("maxPlayers", game.maxPlayers); // maxPlayers
ini.setValue("power", game.power); // power
ini.setValue("base", game.base); // size of base
ini.setValue("alliance", game.alliance); // allow alliances
ini.setValue("scavengers", game.scavengers);
}
ini.setValue("playerName", (char*)sPlayer); // player name
}
ini.setValue("colourMP", war_getMPcolour());
ini.sync();
return true;
}
static void sharedStructureButton(STRUCTURE_STATS *Stats, iIMDShape *strImd, const Vector3i *Rotation, const Vector3i *Position, int scale)
{
iIMDShape *baseImd, *mountImd[STRUCT_MAXWEAPS], *weaponImd[STRUCT_MAXWEAPS];
Vector3i pos = *Position;
/* HACK HACK HACK!
if its a 'tall thin (ie tower)' structure stat with something on the top - offset the position to show the object on top */
if (strImd->nconnectors && scale == SMALL_STRUCT_SCALE && getStructureStatHeight(Stats) > TOWER_HEIGHT)
{
pos.y -= 20;
}
setMatrix(&pos, Rotation, scale);
/* Draw the building's base first */
baseImd = Stats->pBaseIMD;
if (baseImd != NULL)
{
pie_Draw3DShape(baseImd, 0, getPlayerColour(selectedPlayer), WZCOL_WHITE, pie_BUTTON, 0);
}
pie_Draw3DShape(strImd, 0, getPlayerColour(selectedPlayer), WZCOL_WHITE, pie_BUTTON, 0);
//and draw the turret
if (strImd->nconnectors)
{
weaponImd[0] = NULL;
mountImd[0] = NULL;
for (int i = 0; i < Stats->numWeaps; i++)
{
weaponImd[i] = NULL;//weapon is gun ecm or sensor
mountImd[i] = NULL;
}
//get an imd to draw on the connector priority is weapon, ECM, sensor
//check for weapon
//can only have the STRUCT_MAXWEAPS
for (int i = 0; i < MAX(1, Stats->numWeaps); i++)
{
//can only have the one
if (Stats->psWeapStat[i] != NULL)
{
weaponImd[i] = Stats->psWeapStat[i]->pIMD;
mountImd[i] = Stats->psWeapStat[i]->pMountGraphic;
}
if (weaponImd[i] == NULL)
{
//check for ECM
if (Stats->pECM != NULL)
{
weaponImd[i] = Stats->pECM->pIMD;
mountImd[i] = Stats->pECM->pMountGraphic;
}
}
if (weaponImd[i] == NULL)
{
//check for sensor
if (Stats->pSensor != NULL)
{
weaponImd[i] = Stats->pSensor->pIMD;
mountImd[i] = Stats->pSensor->pMountGraphic;
}
}
}
//draw Weapon/ECM/Sensor for structure
if (weaponImd[0] != NULL)
{
for (int i = 0; i < MAX(1, Stats->numWeaps); i++)
{
pie_MatBegin();
pie_TRANSLATE(strImd->connectors[i].x, strImd->connectors[i].z, strImd->connectors[i].y);
if (mountImd[i] != NULL)
{
pie_Draw3DShape(mountImd[i], 0, getPlayerColour(selectedPlayer), WZCOL_WHITE, pie_BUTTON, 0);
if (mountImd[i]->nconnectors)
{
pie_TRANSLATE(mountImd[i]->connectors->x, mountImd[i]->connectors->z, mountImd[i]->connectors->y);
}
}
pie_Draw3DShape(weaponImd[i], 0, getPlayerColour(selectedPlayer), WZCOL_WHITE, pie_BUTTON, 0);
//we have a droid weapon so do we draw a muzzle flash
pie_MatEnd();
}
}
}
unsetMatrix();
}
