bool Map::CanMoveTo(const GameObject* movingObject, const Rectangle& position, const std::list<GameObject*>& objects) const
{
if (IsInMapBounds(position) == false)
return false;
const MapCell* cell = GetCellFromRealPosition(position.Left(), position.Top());
if (cell->GetIsObstacle() == true)
return false;
cell = GetCellFromRealPosition(position.Right() - 1, position.Top());
if (cell->GetIsObstacle() == true)
return false;
cell = GetCellFromRealPosition(position.Left(), position.Bottom() - 1);
if (cell->GetIsObstacle() == true)
return false;
cell = GetCellFromRealPosition(position.Right() - 1, position.Bottom() - 1);
if (cell->GetIsObstacle() == true)
return false;
for (std::list<GameObject*>::const_iterator it = objects.cbegin(); it != objects.cend(); ++it)
{
if ((*it != movingObject) && ((*it)->IsCollidable() == true) && (*it)->IsCollidingWith(position) == true)
return false;
}
return true;
}
bool IrisWind::SetActiveScaling (long lZoom)
{
ObjContainer OC (0, 0, 0, 0);
ObjContainer oldOC = DBO().GetExtend(); // alten Ausschnitt merken
bool fResult = false;
Rectangle rcC (0, 0, 0, 0);
for (int i = 0; i < 2; i++) {
rcC = CanvasRect();
Rectangle rc;
if (NULL != m_pDRO) {
rc = ((DragRectangleObject *)m_pDRO) -> GetRect();
// Koordinaten kippen
CoOrd tmpC = CoOrd(rc.Bottom() - rc.Top());
rc.Bottom() = CoOrd(rc.Top() - tmpC);
} else
rc = rcC;
fResult = DBO().SetActiveScaling (lZoom, rc, rcC, OC);
if (!fResult) break;
// neuen Ausschnitt einstellen
SetExtend (OC, lZoom);
// bei Bedarf ScrollBars einblenden und initialisieren
if (!InitWndScrollBars())
break; // einmal reicht, wenn Scrollbars nicht geändert wurden
}
// wenn Erfolgreich, dann alles neu einstellen
if (fResult) {
DELETE_OBJ (m_pDRO);
// Übersichtsfenster bedienen
if (OverViewCFlag && pOverView)
pOverView -> SetActVP (CanvasRect());
actClip.Push (oldOC);
// neu zeichnen
LegendToRepaint = true;
m_fRePaintFlag = true;
RePaint();
}
return fResult;
}
// --------------------------------------------------------------------------------------------
// eine evtl. geparkte EditOperation "vergessen"
void CGeoEditExtension::TerminateParkedOperation (void)
{
DeleteRestrictLines();
m_bOpParked = false; // eine evt. geparkte IEditOperation ignorieren
// rudimentäre temporäre Objekte auf dem Bildschirm löschen
KoOrd lXmin, lXmax, lYmin, lYmax;
if (S_FALSE == m_wTopObjs->GetTopicalObjectsRectangle (FALSE, &lXmin, &lXmax, &lYmin, &lYmax))
return; // es gibt keine temporären Objekte
Point PLU = BSKoordinaten (lXmin, lYmin);
Point PRO = BSKoordinaten (lXmax, lYmax);
int iMarkGr;
m_wTopObjs->GetMarkerSizeBS (&iMarkGr);
Rectangle Rec;
Rec.Left() = PLU.X() - iMarkGr - iSicher;
Rec.Right() = PRO.X() + iMarkGr + iSicher;
Rec.Top() = PRO.Y() + iMarkGr + iSicher;
Rec.Bottom() = PLU.Y() - iMarkGr - iSicher;
DEX_RePaintRectWait (Rec);
MWind()->Update(); // sofort löschen
// rudimentäre temporäre Objekte aus den Topical-Objekten löschen
m_wTopObjs->DeleteTopicalObjects (FALSE);
} // TerminateParkedOperation
bool Rectangle::Intersect(const Rectangle& other) const
{
return (Left() < other.Right())
&& (Right() > other.Left())
&& (Top() < other.Bottom())
&& (Bottom() > other.Top());
}
// --------------------------------------------------------------------------------------------
// Konstruktionshilfslinie auf dem Bildschirm löschen
HRESULT CRestrictLine::UnDraw (void)
{
HRESULT hrRet = S_OK;
Rectangle rcUnDraw; // Rechteck der zu löschenden Konstruktionshilfslinie
if (RESTRTYPE_GERADE == m_ResType || RESTRTYPE_STRECKE == m_ResType)
{
rcUnDraw.Left() = min (m_EPt1.X(), m_EPt2.X()) - iZug;
rcUnDraw.Right() = max (m_EPt1.X(), m_EPt2.X()) + iZug;
rcUnDraw.Top() = max (m_EPt1.Y(), m_EPt2.Y()) + iZug;
rcUnDraw.Bottom() = min (m_EPt1.Y(), m_EPt2.Y()) - iZug;
}
else if (RESTRTYPE_KREIS == m_ResType)
{
rcUnDraw.Left() = m_RefPt.X() - iZug;
rcUnDraw.Right() = m_RefPt.X() + 2*m_iRad + iZug;
rcUnDraw.Top() = m_RefPt.Y() + 2*m_iRad + iZug;
rcUnDraw.Bottom() = m_RefPt.Y() - iZug;
}
else
{
if (RESTRTYPE_UNKNOWN != m_ResType)
_ASSERTE (m_ResType == RESTRTYPE_GERADE || m_ResType == RESTRTYPE_KREIS ||
m_ResType == RESTRTYPE_STRECKE || m_ResType == RESTRTYPE_UNKNOWN);
Window MWnd(__hWndM); // TRiAS-Hauptfenster
Dimension dimMWin = MWnd.GetSize(); // Größe (im Point-Format) des Hauptfensters
rcUnDraw.Left() = 0;
rcUnDraw.Right() = dimMWin.Width();
rcUnDraw.Top() = dimMWin.Height();
rcUnDraw.Bottom() = 0;
hrRet = E_UNEXPECTED;
}
m_bUnDraw = true; // Konstruktionshilfslinie wird auf dem Bildschirm gelöscht
DEX_RePaintRectWait (rcUnDraw);
m_pVWnd->Update();
return hrRet;
} // UnDraw
void GrowCanvas::DoForce(Point &ptStart, Point &ptEnd,
PointArray2D *gridPoints, Rectangle &boundary)
{
float fCrossDistance = (float)std::min(
std::min(ptEnd.X - boundary.X, boundary.Right() - ptEnd.X),
std::min(ptEnd.Y - boundary.Y, boundary.Bottom() - ptEnd.Y));
Point *ptTmp;
float r;
if (m_GrowFactor < 1)
m_GrowFactor += GROWSTEP;
if (m_bGrow)
{
// Calculating the new coordinate of the grid points.
for (int i = gridPoints->GetWidth() - 1; i >= 0; --i)
{
for (int j = gridPoints->GetHeight() - 1; j >= 0; --j)
{
ptTmp = gridPoints->GetItem(i, j);
r = Distance(*ptTmp, ptEnd.X, ptEnd.Y)/fCrossDistance;
if (r < 1)
{
r = pow(r, m_GrowFactor);
ptTmp->X = ptEnd.X + (int)((ptTmp->X - ptEnd.X)*r);
// __android_log_print(ANDROID_LOG_FATAL, "LOG", "grow canvas: %d", (int)((ptTmp->X - ptEnd.X)*r));
// ptTmp->X = ptStart.X + 15.005;
ptTmp->Y = ptEnd.Y + (int)((ptTmp->Y - ptEnd.Y)*r);
// ptTmp->Y = ptStart.Y + 15.005;
}
}
}
}
else
{
// Calculating the new coordinate of the grid points.
for (int i = gridPoints->GetWidth() - 1; i >= 0; --i)
{
for (int j = gridPoints->GetHeight() - 1; j >= 0; --j)
{
ptTmp = gridPoints->GetItem(i, j);
r = Distance(*ptTmp, ptEnd.X, ptEnd.Y)/fCrossDistance;
if (r < 1 && r > 0.01)
{
r = pow(r, m_GrowFactor);
ptTmp->X = ptEnd.X + (int)((ptTmp->X - ptEnd.X)/r);
ptTmp->Y = ptEnd.Y + (int)((ptTmp->Y - ptEnd.Y)/r);
}
}
}
}
}
TextureRect::TextureRect(const Point2& textureSize, const Rectangle& sourceRectangle)
: mTextureSize(textureSize)
, mSourceRectangle(sourceRectangle)
{
assert( textureSize.X >= 0 );
assert( textureSize.Y >= 0 );
assert( sourceRectangle.Left() >= 0 );
assert( sourceRectangle.Top() >= 0 );
assert( sourceRectangle.Right() <= textureSize.X );
assert( sourceRectangle.Bottom() <= textureSize.Y );
}
// --------------------------------------------------------------------------------------------
// Bildausschnitt vergrößern, so daß die BS-Punkte ExtPt1 und ExtPt2 mit enthalten sind
void CRestrictLine::ExpandingSreenSection (Point ExtPt1, Point ExtPt2)
{
Rectangle rcOldView = m_pVWnd->CanvasRect(); // derzeiteiges TRiAS-ViewFenster
Rectangle rcNewView; // neues vergrößertes TRiAS-ViewFenster
CoOrd MinX = min (ExtPt1.X(), ExtPt2.X());
CoOrd MaxX = max (ExtPt1.X(), ExtPt2.X());
CoOrd MinY = min (ExtPt1.Y(), ExtPt2.Y());
CoOrd MaxY = max (ExtPt1.Y(), ExtPt2.Y());
// Faktor 1.1 ist eine Zugabe, damit ExtPt1 bzw. ExtPt2 im neuen Bildausschnitt nicht genau
// auf dem Rand sitzt
if (MinY < rcOldView.Bottom()) rcNewView.Bottom() = 1.1 * MinY;
else rcNewView.Bottom() = rcOldView.Bottom();
if (MaxY > rcOldView.Top()) rcNewView.Top() = 1.1 * MaxY;
else rcNewView.Top() = rcOldView.Top();
if (MinX < rcOldView.Left()) rcNewView.Left() = 1.1 * MinX;
else rcNewView.Left() = rcOldView.Left();
if (MaxX > rcOldView.Right()) rcNewView.Right() = 1.1 * MaxX;
else rcNewView.Right() = rcOldView.Right();
EPunkt PLU = DBKoordinaten (Point(rcNewView.Left(),rcNewView.Bottom()));
EPunkt PRO = DBKoordinaten (Point(rcNewView.Right(),rcNewView.Top()));
KoOrd lCO[4]; // Koordinaten des neuen Sichtausschnittes (lCO[0] = xmin, lCO[1] = xmax,
// lCO[2] = ymin, lCO[3] = ymax)
lCO[0] = PLU.X();
lCO[1] = PRO.X();
lCO[2] = PLU.Y();
lCO[3] = PRO.Y();
DEX_SetActiveSightContainer (lCO);
DEX_RePaintRectWait (rcNewView);
m_pVWnd->Update();
} // ExpandingSreenSection
static EClip ComputeLocationCode( const Point2I & pt, const Rectangle & rect )
{
int code = ClipNone;
if ( pt.X() < rect.Left() )
code |= ClipLeft;
if ( pt.Y() < rect.Top() )
code |= ClipTop;
if ( rect.Right() < pt.X() )
code |= ClipRight;
if ( rect.Bottom() < pt.Y() )
code |= ClipBottom;
return EClip( code );
}
void CCheckTreeView::HandleCheckMark(Point point, UINT uiMsg)
{
Rectangle rc = CanvasRect();
CoOrd dY = rc.Top()-rc.Bottom();
TV_HITTESTINFO ht;
ht.pt.x = point.X();
ht.pt.y = dY-point.Y();
HTREEITEM hNewTarget = HitTest (&ht);
if (hNewTarget && (ht.flags & TVHT_ONITEMSTATEICON)) {
UINT uiState = ChangingCheckState (hNewTarget, uiMsg);
if (TV_CHECK_NOCHANGE != uiState) {
if (TV_CHECK_NOMARK != uiState)
SetCheckState (hNewTarget, uiState);
else
ToggleCheckMark (hNewTarget);
NotifyChecked (hNewTarget, uiMsg, GetCheckState(hNewTarget));
}
}
}
//
// Intersects
// Check if this rectangle intersects another.
//
bool Nixin::Rectangle::Intersects( const Rectangle& other ) const
{
return ( Left() < other.Right() && Right() > other.Left() && Bottom() < other.Top() && Top() > other.Bottom() );
}
//
// Contains
// Checks if another rectangle is completely contained in this one.
//
bool Nixin::Rectangle::Contains( const Rectangle& other ) const
{
return ( other.Left() > Left() && other.Right() < Right() && other.Bottom() > Bottom() && other.Top() < Top() );
}
bool Map::IsInMapBounds(const Rectangle& rectangle) const
{
return (rectangle.Left() >= 0) && (rectangle.Top() >= 0) && (rectangle.Right() <= (mapWidth_ * CellWidth)) && (rectangle.Bottom() <= (mapHeight_ * CellHeight));
}
bool
LineSegment2I::Clip( const Rectangle & rect )
{ /*Clip*/
PointPair endpoints = Endpoints();
Point2I pt0 = endpoints.first;
Point2I pt1 = endpoints.second;
float left = static_cast< float >( rect.Left() );
float top = static_cast< float >( rect.Top() );
float right = static_cast< float >( rect.Right() );
float bottom = static_cast< float >( rect.Bottom() );
EClip code0 = ComputeLocationCode( pt0, rect );
EClip code1 = ComputeLocationCode( pt1, rect );
bool inside = ( (code0 | code1) == 0 );
bool outside = ( (code0 & code1) != 0 );
while ( ! inside && ! outside )
{
if ( code0 == ClipNone ) // Swap if necessary so pt0 needs clipping.
{
std::swap( pt0, pt1 );
std::swap( code0, code1 );
}
float x, y;
if ( code0 & ClipLeft )
{
y = pt0.Y()
+ ((pt1.Y() - pt0.Y())
* (left - pt0.X()) / (pt1.X() - pt0.X()));
x = left;
}
else if ( code0 & ClipTop )
{
x = pt0.X()
+ ((pt1.X() - pt0.X())
* (top - pt0.Y()) / (pt1.Y() - pt0.Y()));
y = top;
}
else if ( code0 & ClipRight )
{
y = pt0.Y()
+ ((pt1.Y() - pt0.Y())
* (right - pt0.X()) / (pt1.X() - pt0.X()));
x = right;
}
else //ClipBottom
{
x = pt0.X()
+ ((pt1.X() - pt0.X())
* (bottom - pt0.Y()) / (pt1.Y() - pt0.Y()));
y = bottom;
}
pt0.Set( static_cast< int >( x + 0.5f ),
static_cast< int >( y + 0.5f ) );
code0 = ComputeLocationCode( pt0, rect );
inside = ( (code0 | code1) == 0 );
outside = ( (code0 & code1) != 0 );
}
Set( pt0, pt1 );
return inside;
} /*Clip*/
void ShipInfoPanel::DrawCargo(const Rectangle &bounds)
{
Color dim = *GameData::Colors().Get("medium");
Color bright = *GameData::Colors().Get("bright");
Color backColor = *GameData::Colors().Get("faint");
const Ship &ship = **shipIt;
// Cargo list.
const CargoHold &cargo = (player.Cargo().Used() ? player.Cargo() : ship.Cargo());
Table table;
table.AddColumn(0, Table::LEFT);
table.AddColumn(WIDTH - 20, Table::RIGHT);
table.SetUnderline(-5, WIDTH - 15);
table.DrawAt(bounds.TopLeft() + Point(10., 8.));
double endY = bounds.Bottom() - 30. * (cargo.Passengers() != 0);
bool hasSpace = (table.GetRowBounds().Bottom() < endY);
if((cargo.CommoditiesSize() || cargo.HasOutfits() || cargo.MissionCargoSize()) && hasSpace)
{
table.Draw("Cargo", bright);
table.Advance();
hasSpace = (table.GetRowBounds().Bottom() < endY);
}
if(cargo.CommoditiesSize() && hasSpace)
{
for(const auto &it : cargo.Commodities())
{
if(!it.second)
continue;
commodityZones.emplace_back(table.GetCenterPoint(), table.GetRowSize(), it.first);
if(it.first == selectedCommodity)
table.DrawHighlight(backColor);
table.Draw(it.first, dim);
table.Draw(to_string(it.second), bright);
// Truncate the list if there is not enough space.
if(table.GetRowBounds().Bottom() >= endY)
{
hasSpace = false;
break;
}
}
table.DrawGap(10.);
}
if(cargo.HasOutfits() && hasSpace)
{
for(const auto &it : cargo.Outfits())
{
if(!it.second)
continue;
plunderZones.emplace_back(table.GetCenterPoint(), table.GetRowSize(), it.first);
if(it.first == selectedPlunder)
table.DrawHighlight(backColor);
// For outfits, show how many of them you have and their total mass.
bool isSingular = (it.second == 1 || it.first->Get("installable") < 0.);
string name = (isSingular ? it.first->Name() : it.first->PluralName());
if(!isSingular)
name += " (" + to_string(it.second) + "x)";
table.Draw(name, dim);
double mass = it.first->Mass() * it.second;
table.Draw(Format::Number(mass), bright);
// Truncate the list if there is not enough space.
if(table.GetRowBounds().Bottom() >= endY)
{
hasSpace = false;
break;
}
}
table.DrawGap(10.);
}
if(cargo.HasMissionCargo() && hasSpace)
{
for(const auto &it : cargo.MissionCargo())
{
// Capitalize the name of the cargo.
table.Draw(Format::Capitalize(it.first->Cargo()), dim);
table.Draw(to_string(it.second), bright);
// Truncate the list if there is not enough space.
if(table.GetRowBounds().Bottom() >= endY)
break;
}
table.DrawGap(10.);
}
if(cargo.Passengers() && endY >= bounds.Top())
{
table.DrawAt(Point(bounds.Left(), endY) + Point(10., 8.));
table.Draw("passengers:", dim);
table.Draw(to_string(cargo.Passengers()), bright);
}
}
void ShipInfoPanel::DrawOutfits(const Rectangle &bounds, Rectangle &cargoBounds)
{
// Check that the specified area is big enough.
if(bounds.Width() < WIDTH)
return;
// Colors to draw with.
Color dim = *GameData::Colors().Get("medium");
Color bright = *GameData::Colors().Get("bright");
const Ship &ship = **shipIt;
// Table attributes.
Table table;
table.AddColumn(0, Table::LEFT);
table.AddColumn(WIDTH - 20, Table::RIGHT);
table.SetUnderline(0, WIDTH - 20);
Point start = bounds.TopLeft() + Point(10., 8.);
table.DrawAt(start);
// Draw the outfits in the same order used in the outfitter.
for(const string &category : Outfit::CATEGORIES)
{
auto it = outfits.find(category);
if(it == outfits.end())
continue;
// Skip to the next column if there is not space for this category label
// plus at least one outfit.
if(table.GetRowBounds().Bottom() + 40. > bounds.Bottom())
{
start += Point(WIDTH, 0.);
if(start.X() + WIDTH - 20 > bounds.Right())
break;
table.DrawAt(start);
}
// Draw the category label.
table.Draw(category, bright);
table.Advance();
for(const Outfit *outfit : it->second)
{
// Check if we've gone below the bottom of the bounds.
if(table.GetRowBounds().Bottom() > bounds.Bottom())
{
start += Point(WIDTH, 0.);
if(start.X() + WIDTH - 20 > bounds.Right())
break;
table.DrawAt(start);
table.Draw(category, bright);
table.Advance();
}
// Draw the outfit name and count.
table.Draw(outfit->Name(), dim);
string number = to_string(ship.OutfitCount(outfit));
table.Draw(number, bright);
}
// Add an extra gap in between categories.
table.DrawGap(10.);
}
// Check if this information spilled over into the cargo column.
if(table.GetPoint().X() >= cargoBounds.Left())
{
double startY = table.GetRowBounds().Top() - 8.;
cargoBounds = Rectangle::WithCorners(
Point(cargoBounds.Left(), startY),
Point(cargoBounds.Right(), max(startY, cargoBounds.Bottom())));
}
}
