void CUnitDrawProxy::Draw(const CViewport *vp) const
{
int x = this->IX + vp->Map2ViewportX(this->X);
int y = this->IY + vp->Map2ViewportY(this->Y);
/* FIXME: check if we have to push real type here?*/
if (state == 1 && cframe) {
DrawConstructionShadow(*Type, cframe, frame, x, y);
} else {
if (IsAlive) {
DrawShadow(*Type, frame, x, y);
}
}
//
// Show that the unit is selected
//
DrawSelectionAt(x, y);
//
// Adjust sprite for Harvesters.
//
CPlayerColorGraphic *sprite = Type->Sprite;
if (Type->Harvester && this->CurrentResource) {
ResourceInfo *resinfo = Type->ResInfo[this->CurrentResource];
if (this->ResourcesHeld) {
if (resinfo->SpriteWhenLoaded) {
sprite = resinfo->SpriteWhenLoaded;
}
} else {
if (resinfo->SpriteWhenEmpty) {
sprite = resinfo->SpriteWhenEmpty;
}
}
}
//
// Now draw!
// Buildings under construction/upgrade/ready.
//
if (state == 1) {
if (cframe) {
DrawConstruction(Player->Index, cframe, *Type, frame,
x + (Type->TileWidth * TileSizeX) / 2,
y + (Type->TileHeight * TileSizeY) / 2);
}
//
// Draw the future unit type, if upgrading to it.
//
} else if (state == 2) {
// FIXME: this frame is hardcoded!!!
DrawUnitType(*Type, sprite, Player->Index, frame < 0 ? /*-1*/ - 1 : 1, x, y);
} else {
DrawUnitType(*Type, sprite, Player->Index, frame, x, y);
}
// Unit's extras not fully supported.. need to be decorations themselves.
// FIXME: johns: ugly check here, should be removed!
if (IsAlive /*unit->IsVisible(ThisPlayer)*/) {
DrawDecorationAt(x, y);
}
//DrawInformations(this, type, x, y);
}
/**
** Draw unit on map.
*/
void CUnit::Draw(const CViewport *vp) const
{
int x;
int y;
int frame;
int state;
int constructed;
CPlayerColorGraphic *sprite;
ResourceInfo *resinfo;
CConstructionFrame *cframe;
CUnitType *type;
/*
* Since we can draw in parallel to game logic units may be already destroyed
* or removed (this->Container != NULL) most dangerus is destroyed state
* but due existence of UnitCashe, unit memory is always valid only we need check
* Destroyed flag... the hack is that this->Type == NULL but 'or' logic
* should secure this scenario and retir before this->Type->Revealer check
*/
if (this->Destroyed || this->Container || this->Type->Revealer) { // Revealers are not drawn
return;
}
bool IsVisible = this->IsVisible(ThisPlayer);
// Those should have been filtered. Check doesn't make sense with ReplayRevealMap
Assert(ReplayRevealMap || this->Type->VisibleUnderFog || IsVisible);
int player = this->RescuedFrom ? this->RescuedFrom->Index : this->Player->Index;
int action = this->CurrentAction();
if (ReplayRevealMap || IsVisible) {
type = this->Type;
frame = this->Frame;
y = this->IY;
x = this->IX;
x += vp->Map2ViewportX(this->tilePos.x);
y += vp->Map2ViewportY(this->tilePos.y);
state = (action == UnitActionBuilt) |
((action == UnitActionUpgradeTo) << 1);
constructed = this->Constructed;
// Reset Type to the type being upgraded to
if (state == 2) {
type = this->CurrentOrder()->Arg1.Type;
}
// This is trash unless the unit is being built, and that's when we use it.
cframe = this->Data.Built.Frame;
} else {
y = this->Seen.IY;
x = this->Seen.IX;
x += vp->Map2ViewportX(this->Seen.X);
y += vp->Map2ViewportY(this->Seen.Y);
frame = this->Seen.Frame;
type = this->Seen.Type;
constructed = this->Seen.Constructed;
state = this->Seen.State;
cframe = this->Seen.CFrame;
}
#ifdef DYNAMIC_LOAD
if (!type->Sprite) {
LoadUnitTypeSprite(*type);
}
#endif
if (!IsVisible && frame == UnitNotSeen) {
DebugPrint("FIXME: Something is wrong, unit %d not seen but drawn time %lu?.\n" _C_
this->Slot _C_ GameCycle);
return;
}
if (state == 1 && constructed) {
DrawConstructionShadow(*type, cframe, frame, x, y);
} else {
if (action != UnitActionDie) {
DrawShadow(*type, frame, x, y);
}
}
//
// Show that the unit is selected
//
DrawUnitSelection(vp, *this);
//
// Adjust sprite for Harvesters.
//
sprite = type->Sprite;
if (type->Harvester && this->CurrentResource) {
resinfo = type->ResInfo[this->CurrentResource];
if (this->ResourcesHeld) {
if (resinfo->SpriteWhenLoaded) {
sprite = resinfo->SpriteWhenLoaded;
}
} else {
if (resinfo->SpriteWhenEmpty) {
sprite = resinfo->SpriteWhenEmpty;
}
}
}
//
// Now draw!
// Buildings under construction/upgrade/ready.
//
if (state == 1) {
if (constructed) {
DrawConstruction(player, cframe, *type, frame,
x + (type->TileWidth * TileSizeX) / 2,
y + (type->TileHeight * TileSizeY) / 2);
}
//
// Draw the future unit type, if upgrading to it.
//
} else if (state == 2) {
// FIXME: this frame is hardcoded!!!
DrawUnitType(*type, sprite, player, frame < 0 ? /*-1*/ - 1 : 1, x, y);
} else {
DrawUnitType(*type, sprite, player, frame, x, y);
}
// Unit's extras not fully supported.. need to be decorations themselves.
DrawInformations(*this, type, x, y);
}
/**
** Draw unit on map.
*/
void CUnit::Draw(const CViewport &vp) const
{
int frame;
int state;
int constructed;
const CConstructionFrame *cframe;
const CUnitType *type;
if (this->Destroyed || this->Container || this->Type->Revealer) { // Revealers are not drawn
return;
}
bool IsVisible = this->IsVisible(*ThisPlayer);
// Those should have been filtered. Check doesn't make sense with ReplayRevealMap
Assert(ReplayRevealMap || this->Type->VisibleUnderFog || IsVisible);
int player = this->RescuedFrom ? this->RescuedFrom->Index : this->Player->Index;
int action = this->CurrentAction();
PixelPos screenPos;
if (ReplayRevealMap || IsVisible) {
screenPos = vp.MapToScreenPixelPos(this->GetMapPixelPosTopLeft());
type = this->Type;
frame = this->Frame;
state = (action == UnitActionBuilt) | ((action == UnitActionUpgradeTo) << 1);
constructed = this->Constructed;
// Reset Type to the type being upgraded to
if (action == UnitActionUpgradeTo) {
const COrder_UpgradeTo &order = *static_cast<COrder_UpgradeTo *>(this->CurrentOrder());
type = &order.GetUnitType();
}
if (this->CurrentAction() == UnitActionBuilt) {
COrder_Built &order = *static_cast<COrder_Built *>(this->CurrentOrder());
cframe = &order.GetFrame();
} else {
cframe = NULL;
}
} else {
screenPos = vp.TilePosToScreen_TopLeft(this->Seen.tilePos);
screenPos.x += this->Seen.IX;
screenPos.y += this->Seen.IY;
frame = this->Seen.Frame;
type = this->Seen.Type;
constructed = this->Seen.Constructed;
state = this->Seen.State;
cframe = this->Seen.CFrame;
}
#ifdef DYNAMIC_LOAD
if (!type->Sprite) {
LoadUnitTypeSprite(type);
}
#endif
if (!IsVisible && frame == UnitNotSeen) {
DebugPrint("FIXME: Something is wrong, unit %d not seen but drawn time %lu?.\n" _C_
UnitNumber(*this) _C_ GameCycle);
return;
}
if (state == 1 && constructed && cframe) {
DrawConstructionShadow(*type, cframe, frame, screenPos);
} else {
if (action != UnitActionDie) {
DrawShadow(*type, frame, screenPos);
}
}
//
// Show that the unit is selected
//
DrawUnitSelection(vp, *this);
//
// Adjust sprite for Harvesters.
//
CPlayerColorGraphic *sprite = type->Sprite;
if (type->Harvester && this->CurrentResource) {
ResourceInfo *resinfo = type->ResInfo[this->CurrentResource];
if (this->ResourcesHeld) {
if (resinfo->SpriteWhenLoaded) {
sprite = resinfo->SpriteWhenLoaded;
}
} else {
if (resinfo->SpriteWhenEmpty) {
sprite = resinfo->SpriteWhenEmpty;
}
}
}
//
// Now draw!
// Buildings under construction/upgrade/ready.
//
if (state == 1) {
if (constructed && cframe) {
const PixelPos pos(screenPos + (type->GetPixelSize()) / 2);
DrawConstruction(GameSettings.Presets[player].PlayerColor, cframe, *type, frame, pos);
} else {
DrawUnitType(*type, sprite, GameSettings.Presets[player].PlayerColor, frame, screenPos);
}
//
// Draw the future unit type, if upgrading to it.
//
} else {
DrawUnitType(*type, sprite, GameSettings.Presets[player].PlayerColor, frame, screenPos);
}
// Unit's extras not fully supported.. need to be decorations themselves.
DrawInformations(*this, *type, screenPos);
}
/**
** Draw building on map.
**
** @param unit Pointer to the building
*/
local void DrawBuilding(Unit* unit)
{
int x;
int y;
UnitType* type;
int frame;
int n_frame;
// FIXME: This should I rewrite, without checks here!!
type=unit->Type;
x = unit->X;
y = unit->Y;
// FIXME: johns: this isn't 100% correct, building which are partly
// FIXME: johns: under the fog are shown partly.
// FIXME: There is already a check in the main loop UnitVisibile!
if ( !MAPEXPLORED( x, y ) ) {
return;
}
if ( !TheMap.NoFogOfWar && !MAPVISIBLE( x, y ) ) {
frame = unit->SeenFrame;
if (frame == 255) {
return;
}
} else {
frame = unit->SeenFrame = unit->Frame;
}
#if 0
if( type->Type==UnitOilPlatformHuman || type->Type==UnitOilPlatformOrc ) {
DebugLevel0("%d -> %d\n",unit->Frame,frame);
}
#endif
n_frame = 0;
if ((frame & 128) == 0 && unit->Rs > 50) {
n_frame = 128; // fancy buildings
}
PlayerPixels(unit->Player);
x=Map2ScreenX(unit->X)+unit->IX;
y=Map2ScreenY(unit->Y)+unit->IY;
//
// Buildings under construction/upgrade/ready.
//
if( unit->Command.Action==UnitActionBuilded ) {
if( unit->Constructed || type->RleSprite->NumFrames<=1 ) {
DrawConstruction(type->OverlapFrame
,frame
,x+(type->TileWidth*TileSizeX)/2
,y+(type->TileHeight*TileSizeY)/2);
} else {
#if 0
DebugLevel0("Remove this %d\n",n_frame);
if ( strcmp(type->Ident,"dark-portal") == 0
|| strcmp(type->Ident,"runestone") == 0 )
//FIXME: dark-portal and runestone haven't reqiured frames, so we draw construction instead
DrawConstruction(type->OverlapFrame
,frame
,x+(type->TileWidth*TileSizeX)/2
,y+(type->TileHeight*TileSizeY)/2);
else
#endif
DrawUnitType(type,frame+n_frame,x,y);
}
} else if( unit->Command.Action==UnitActionUpgradeTo ) {
DrawUnitType(unit->Command.Data.UpgradeTo.What,1+n_frame,x,y);
} else {
DrawUnitType(type,frame+n_frame,x,y);
}
// FIXME: johns: ugly check here should be removed!
if( unit->Command.Action!=UnitActionDie ) {
DrawDecoration(unit,type,x,y);
DrawSelectionRectangle(unit,type,x,y);
}
}
/**
** Draw unit on map.
*/
void CUnit::Draw() const
{
int x;
int y;
int frame;
int state;
int constructed;
CPlayerColorGraphic *sprite;
ResourceInfo *resinfo;
CConstructionFrame *cframe;
CUnitType *type;
if (this->Type->Revealer) { // Revealers are not drawn
return;
}
// Those should have been filtered. Check doesn't make sense with ReplayRevealMap
Assert(ReplayRevealMap || this->Type->VisibleUnderFog || this->IsVisible(ThisPlayer));
if (ReplayRevealMap || this->IsVisible(ThisPlayer)) {
type = this->Type;
frame = this->Frame;
y = this->IY;
x = this->IX;
x += CurrentViewport->Map2ViewportX(this->X);
y += CurrentViewport->Map2ViewportY(this->Y);
state = (this->Orders[0]->Action == UnitActionBuilt) |
((this->Orders[0]->Action == UnitActionUpgradeTo) << 1);
constructed = this->Constructed;
// Reset Type to the type being upgraded to
if (state == 2) {
type = this->Orders[0]->Type;
}
// This is trash unless the unit is being built, and that's when we use it.
cframe = this->Data.Built.Frame;
} else {
y = this->Seen.IY;
x = this->Seen.IX;
x += CurrentViewport->Map2ViewportX(this->Seen.X);
y += CurrentViewport->Map2ViewportY(this->Seen.Y);
frame = this->Seen.Frame;
type = this->Seen.Type;
constructed = this->Seen.Constructed;
state = this->Seen.State;
cframe = this->Seen.CFrame;
}
#ifdef DYNAMIC_LOAD
if (!type->Sprite) {
LoadUnitTypeSprite(type);
}
#endif
if (!this->IsVisible(ThisPlayer) && frame == UnitNotSeen) {
DebugPrint("FIXME: Something is wrong, unit %d not seen but drawn time %lu?.\n" _C_
this->Slot _C_ GameCycle);
return;
}
if (state == 1 && constructed) {
DrawConstructionShadow(this, cframe, frame, x, y);
} else {
DrawShadow(this, NULL, frame, x, y);
}
//
// Show that the unit is selected
//
DrawUnitSelection(this);
//
// Adjust sprite for Harvesters.
//
sprite = type->Sprite;
if (type->Harvester && this->CurrentResource) {
resinfo = type->ResInfo[this->CurrentResource];
if (this->ResourcesHeld) {
if (resinfo->SpriteWhenLoaded) {
sprite = resinfo->SpriteWhenLoaded;
}
} else {
if (resinfo->SpriteWhenEmpty) {
sprite = resinfo->SpriteWhenEmpty;
}
}
}
//
// Now draw!
// Buildings under construction/upgrade/ready.
//
if (state == 1) {
if (constructed) {
DrawConstruction(this, cframe, type, frame,
x + (type->TileWidth * TileSizeX) / 2,
y + (type->TileHeight * TileSizeY) / 2);
}
//
// Draw the future unit type, if upgrading to it.
//
} else if (state == 2) {
// FIXME: this frame is hardcoded!!!
DrawUnitType(type, sprite,
this->RescuedFrom ? this->RescuedFrom->Index : this->Player->Index,
frame < 0 ? -1 - 1 : 1, x, y);
} else {
DrawUnitType(type, sprite,
this->RescuedFrom ? this->RescuedFrom->Index : this->Player->Index,
frame, x, y);
}
// Unit's extras not fully supported.. need to be decorations themselves.
DrawInformations(this, type, x, y);
}
