marko10_000
/
openclonk
forked from Mirrors/openclonk
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
openclonk/src/landscape/C4PathFinder.cpp

692 lines
18 KiB
C++
Raw Blame History

/*
* OpenClonk, http://www.openclonk.org
*
* Copyright (c) 1998-2000, Matthes Bender
* Copyright (c) 2001-2009, RedWolf Design GmbH, http://www.clonk.de/
* Copyright (c) 2009-2016, The OpenClonk Team and contributors
*
* Distributed under the terms of the ISC license; see accompanying file
* "COPYING" for details.
*
* "Clonk" is a registered trademark of Matthes Bender, used with permission.
* See accompanying file "TRADEMARK" for details.
*
* To redistribute this file separately, substitute the full license texts
* for the above references.
*/
/* Finds the way through the Clonk landscape */
/* Notes
09-30-99
I have had the concept for this code for more than two years now.
Finally, it is written.
10-26-99
C4PathFinderRay::Crawl use IsCrawlAttach instead of GetCrawlAttach (which
might not correctly indicate attach loss). Otherwise 1 pixel clefts can lead
to backward crawl looping. Surprised, I haven't noticed this before.
Also do not check attach loss on first crawl for that be might diagonal.
C4PF_Ray_Crawl try new ray: don't worry about checking backwards jump if
path to target is all free.
C4PathFinderRay::FindCrawlAttachDiagonal check according to desired
direction or else might lead off to no attach.
11-24-99
TransferZones
12-11-99
SetCompletePath don't set move-to waypoint if setting use-zone waypoint (is
done by C4Command::Transfer on demand and would only cause no-good-entry-point
move-to's on crawl-zone-entries).
*/
#include "C4Include.h"
#include "landscape/C4PathFinder.h"
#include "graphics/C4Draw.h"
#include "graphics/C4FacetEx.h"
#include "game/C4GraphicsSystem.h"
#include "lib/StdColors.h"
const int32_t C4PF_MaxDepth = 35,
C4PF_MaxCrawl = 800,
C4PF_MaxRay = 350,
C4PF_Threshold = 10,
C4PF_Direction_Left = -1,
C4PF_Direction_Right = +1,
C4PF_Direction_None = 0,
C4PF_Ray_Launch = 0,
C4PF_Ray_Crawl = 1,
C4PF_Ray_Still = 2,
C4PF_Ray_Failure = 3,
C4PF_Ray_Deleted = 4,
C4PF_Crawl_NoAttach = 0,
C4PF_Crawl_Top = 1,
C4PF_Crawl_Right = 2,
C4PF_Crawl_Bottom = 3,
C4PF_Crawl_Left = 4,
C4PF_Draw_Rate = 10;
//------------------------------- C4PathFinderRay ---------------------------------------------
class C4PathFinderRay
{
friend class C4PathFinder;
public:
C4PathFinderRay();
~C4PathFinderRay();
public:
void Clear();
void Default();
protected:
int32_t Status;
int32_t X, Y, X2, Y2, TargetX, TargetY;
int32_t CrawlStartX, CrawlStartY, CrawlAttach, CrawlLength, CrawlStartAttach;
int32_t Direction, Depth;
C4TransferZone *UseZone;
C4PathFinderRay *From;
C4PathFinderRay *Next;
C4PathFinder *pPathFinder;
protected:
void SetCompletePath();
void TurnAttach(int32_t &rAttach, int32_t iDirection);
void CrawlToAttach(int32_t &rX, int32_t &rY, int32_t iAttach);
void CrawlByAttach(int32_t &rX, int32_t &rY, int32_t iAttach, int32_t iDirection);
void Draw(C4TargetFacet &cgo);
int32_t FindCrawlAttachDiagonal(int32_t iX, int32_t iY, int32_t iDirection);
int32_t FindCrawlAttach(int32_t iX, int32_t iY);
bool IsCrawlAttach(int32_t iX, int32_t iY, int32_t iAttach);
bool CheckBackRayShorten();
bool Execute();
bool CrawlTargetFree(int32_t iX, int32_t iY, int32_t iAttach, int32_t iDirection);
bool PointFree(int32_t iX, int32_t iY);
bool Crawl();
bool PathFree(int32_t &rX, int32_t &rY, int32_t iToX, int32_t iToY, C4TransferZone **ppZone = nullptr);
};
C4PathFinderRay::C4PathFinderRay()
{
Default();
}
C4PathFinderRay::~C4PathFinderRay()
{
Clear();
}
void C4PathFinderRay::Default()
{
Status=C4PF_Ray_Launch;
X=Y=X2=Y2=TargetX=TargetY=0;
Direction=0;
Depth=0;
UseZone=nullptr;
From=nullptr;
Next=nullptr;
pPathFinder=nullptr;
CrawlStartX=CrawlStartY=CrawlAttach=0;
}
void C4PathFinderRay::Clear()
{
}
bool C4PathFinderRay::Execute()
{
C4TransferZone *pZone = nullptr;
int32_t iX,iY,iLastX,iLastY;
switch (Status)
{
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
case C4PF_Ray_Launch:
// In zone: use zone
if (UseZone)
{
// Mark zone used
UseZone->Used=true;
// Target in transfer zone: success
if (UseZone->At(TargetX,TargetY))
{
// Set end point
X2=TargetX; Y2=TargetY;
// Set complete path
SetCompletePath();
// Done
pPathFinder->Success=true;
Status=C4PF_Ray_Still;
}
// Continue from other end of zone
else
{
// Find exit point
if (!UseZone->GetEntryPoint(X2,Y2,TargetX,TargetY))
{ Status=C4PF_Ray_Failure; break; }
// Launch new ray (continue direction of entrance ray)
if (!pPathFinder->AddRay(X2,Y2,TargetX,TargetY,Depth+1,Direction,this))
{ Status=C4PF_Ray_Failure; break; }
// Still
Status=C4PF_Ray_Still;
}
return true;
}
// Not in zone: check path to target
// Path free: success
else if (PathFree(X2,Y2,TargetX,TargetY,&pZone))
{
// Set complete path
SetCompletePath();
// Done
pPathFinder->Success=true;
Status=C4PF_Ray_Still;
return true;
}
// Path intersected by transfer zone
else if (pZone)
{
// Zone entry point adjust (if not already in zone)
if (!pZone->At(X,Y))
pZone->GetEntryPoint(X2,Y2,X2,Y2);
// Add use-zone ray
if (!pPathFinder->AddRay(X2,Y2,TargetX,TargetY,Depth+1,Direction,this,pZone))
{ Status=C4PF_Ray_Failure; break; }
// Still
Status=C4PF_Ray_Still;
// Continue
return true;
}
// Path intersected by solid
else
{
// Start crawling
Status=C4PF_Ray_Crawl;
CrawlStartX=X2; CrawlStartY=Y2;
CrawlAttach=FindCrawlAttach(X2,Y2);
CrawlLength=0;
if (!CrawlAttach) CrawlAttach=FindCrawlAttachDiagonal(X2,Y2,Direction);
CrawlStartAttach=CrawlAttach;
// Intersected but no attach found: unexpected failure
if (!CrawlAttach) { Status=C4PF_Ray_Failure; break; }
// Continue
return true;
}
break;
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
case C4PF_Ray_Crawl:
// Crawl
iLastX=X2; iLastY=Y2;
if (!Crawl())
{ Status=C4PF_Ray_Failure; break; }
// Back at crawl starting position: done and still
if ((X2==CrawlStartX) && (Y2==CrawlStartY) && (CrawlAttach==CrawlStartAttach))
{ Status=C4PF_Ray_Still; break; }
// Check unused zone intersection
if (pPathFinder->TransferZonesEnabled)
if (pPathFinder->TransferZones)
if ((pZone = pPathFinder->TransferZones->Find(X2,Y2)))
if (!pZone->Used)
{
// Add use-zone ray (with zone entry point adjust)
iX=X2; iY=Y2; if (pZone->GetEntryPoint(iX,iY,X2,Y2))
if (!pPathFinder->AddRay(iX,iY,TargetX,TargetY,Depth+1,Direction,this,pZone))
{ Status=C4PF_Ray_Failure; break; }
// Continue crawling
return true;
}
// Crawl length
CrawlLength++;
if (CrawlLength >= C4PF_MaxCrawl * pPathFinder->Level)
{ Status=C4PF_Ray_Still; break; }
// Check back path intersection
iX=X; iY=Y;
if (!PathFree(iX,iY,X2,Y2))
// Insert split ray
if (!pPathFinder->SplitRay(this,iLastX,iLastY))
{ Status=C4PF_Ray_Failure; break; }
// Try new ray at target
iX=X2; iY=Y2;
// If has been crawling for a while
if (CrawlLength>C4PF_Threshold)
// If all free...
if ( PathFree(iX,iY,TargetX,TargetY)
// ...or at least beyond threshold and not backwards toward crawl start
|| ((Distance(iX,iY,X2,Y2)>C4PF_Threshold) && (Distance(iX,iY,CrawlStartX,CrawlStartY)>Distance(X2,Y2,CrawlStartX,CrawlStartY))) )
{
// Still
Status=C4PF_Ray_Still;
// Launch new rays
if (!pPathFinder->AddRay(X2,Y2,TargetX,TargetY,Depth+1,C4PF_Direction_Left,this)
|| !pPathFinder->AddRay(X2,Y2,TargetX,TargetY,Depth+1,C4PF_Direction_Right,this))
{ Status=C4PF_Ray_Failure; break; }
}
break;
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
case C4PF_Ray_Still: case C4PF_Ray_Failure: case C4PF_Ray_Deleted:
return false;
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
}
return true;
}
void C4PathFinderRay::Draw(C4TargetFacet &cgo)
{
uint32_t Color=0xffff0000;
switch (Status)
{
case C4PF_Ray_Crawl: Color=C4RGB(0xff, 0, 0); break;
case C4PF_Ray_Still: Color=C4RGB(0x50, 0, 0); break;
case C4PF_Ray_Failure: Color=C4RGB(0xff, 0xff, 0); break;
case C4PF_Ray_Deleted: Color=C4RGB(0x59, 0x59, 0x59); break;
}
if (UseZone) Color=C4RGB(0, 0, 0xff);
// Crawl attachment
if (Status==C4PF_Ray_Crawl)
{
int32_t iX=0,iY=0; CrawlToAttach(iX,iY,CrawlAttach);
pDraw->DrawLineDw(cgo.Surface,
cgo.X+X2-cgo.TargetX,cgo.Y+Y2-cgo.TargetY,
cgo.X+X2-cgo.TargetX+7*iX,cgo.Y+Y2-cgo.TargetY+7*iY,
C4RGB(0xff, 0, 0));
}
// Ray line
pDraw->DrawLineDw(cgo.Surface,
cgo.X+X-cgo.TargetX,cgo.Y+Y-cgo.TargetY,
cgo.X+X2-cgo.TargetX,cgo.Y+Y2-cgo.TargetY,
Color);
// Crawler point
pDraw->DrawFrameDw(cgo.Surface,
cgo.X+X2-cgo.TargetX-1,cgo.Y+Y2-cgo.TargetY-1,
cgo.X+X2-cgo.TargetX+1,cgo.Y+Y2-cgo.TargetY+1,
(Status==C4PF_Ray_Crawl) ? ((Direction==C4PF_Direction_Left) ? C4RGB(0, 0xff, 0) : C4RGB(0, 0, 0xff)) : Color);
// Search target point
pDraw->DrawFrameDw(cgo.Surface,
cgo.X+TargetX-cgo.TargetX-2,cgo.Y+TargetY-cgo.TargetY-2,
cgo.X+TargetX-cgo.TargetX+2,cgo.Y+TargetY-cgo.TargetY+2,
C4RGB(0xff, 0xff, 0));
}
bool C4PathFinderRay::PathFree(int32_t &rX, int32_t &rY, int32_t iToX, int32_t iToY, C4TransferZone **ppZone)
{
int32_t d,dx,dy,aincr,bincr,xincr,yincr,x,y;
// Y based
if (Abs(iToX-rX)<Abs(iToY-rY))
{
xincr=(iToX>rX) ? +1 : -1; yincr=(iToY>rY) ? +1 : -1;
dy=Abs(iToY-rY); dx=Abs(iToX-rX);
d=2*dx-dy; aincr=2*(dx-dy); bincr=2*dx; x=rX; y=rY;
for (y=rY; y!=iToY; y+=yincr)
{
// Check point free
if (PointFree(x,y)) { rY=y; rX=x; }
else return false;
// Check transfer zone intersection
if (ppZone)
if (pPathFinder->TransferZonesEnabled)
if (pPathFinder->TransferZones)
if ((*ppZone = pPathFinder->TransferZones->Find(rX,rY)))
return false;
// Advance
if (d>=0) { x+=xincr; d+=aincr; }
else d+=bincr;
}
}
// X based
else
{
yincr=(iToY>rY) ? +1 : -1; xincr=(iToX>rX) ? +1 : -1;
dx=Abs(iToX-rX); dy=Abs(iToY-rY);
d=2*dy-dx; aincr=2*(dy-dx); bincr=2*dy; x=rX; y=rY;
for (x=rX; x!=iToX; x+=xincr)
{
// Check point free
if (PointFree(x,y)) { rY=y; rX=x; }
else return false;
// Check transfer zone intersection
if (ppZone)
if (pPathFinder->TransferZonesEnabled)
if (pPathFinder->TransferZones)
if ((*ppZone = pPathFinder->TransferZones->Find(rX,rY)))
return false;
// Advance
if (d>=0) { y+=yincr; d+=aincr; }
else d+=bincr;
}
}
return true;
}
bool C4PathFinderRay::Crawl()
{
// No attach: crawl failure (shouldn't ever get here)
if (!CrawlAttach)
return false;
// Last attach lost (don't check on first crawl for that might be a diagonal attach)
if (CrawlLength)
if (!IsCrawlAttach(X2,Y2,CrawlAttach))
{
// Crawl corner by last attach
CrawlToAttach(X2,Y2,CrawlAttach);
TurnAttach(CrawlAttach,-Direction);
// Safety: new attach not found - unexpected failure
if (!IsCrawlAttach(X2,Y2,CrawlAttach))
return false;
// Corner okay
return true;
}
// Check crawl target by attach
int32_t iTurned=0;
while (!CrawlTargetFree(X2,Y2,CrawlAttach,Direction))
{
// Crawl target not free: turn attach
TurnAttach(CrawlAttach,Direction); iTurned++;
// Turned four times: all enclosed, crawl failure
if (iTurned==4)
return false;
}
// Crawl by attach
CrawlByAttach(X2,Y2,CrawlAttach,Direction);
// Success
return true;
}
void C4PathFinderRay::SetCompletePath()
{
C4PathFinderRay *pRay;
// Back shorten
for (pRay=this; pRay->From; pRay=pRay->From)
while (pRay->CheckBackRayShorten()) {}
// Set all waypoints
for (pRay=this; pRay->From; pRay=pRay->From)
{
// Transfer waypoint
if (pRay->UseZone)
pPathFinder->SetWaypoint(pRay->X2,pRay->Y2,pRay->UseZone->Object);
// MoveTo waypoint
else
pPathFinder->SetWaypoint(pRay->From->X2,pRay->From->Y2,nullptr);
}
}
bool C4PathFinderRay::PointFree(int32_t iX, int32_t iY)
{
return pPathFinder->PointFree(iX,iY);
}
bool C4PathFinderRay::CrawlTargetFree(int32_t iX, int32_t iY, int32_t iAttach, int32_t iDirection)
{
CrawlByAttach(iX,iY,iAttach,iDirection);
return PointFree(iX,iY);
}
void C4PathFinderRay::CrawlByAttach(int32_t &rX, int32_t &rY, int32_t iAttach, int32_t iDirection)
{
switch (iAttach)
{
case C4PF_Crawl_Top: rX+=iDirection; break;
case C4PF_Crawl_Bottom: rX-=iDirection; break;
case C4PF_Crawl_Left: rY-=iDirection; break;
case C4PF_Crawl_Right: rY+=iDirection; break;
}
}
void C4PathFinderRay::TurnAttach(int32_t &rAttach, int32_t iDirection)
{
rAttach+=iDirection;
if (rAttach>C4PF_Crawl_Left) rAttach=C4PF_Crawl_Top;
if (rAttach<C4PF_Crawl_Top) rAttach=C4PF_Crawl_Left;
}
int32_t C4PathFinderRay::FindCrawlAttach(int32_t iX, int32_t iY)
{
if (!PointFree(iX,iY-1)) return C4PF_Crawl_Top;
if (!PointFree(iX,iY+1)) return C4PF_Crawl_Bottom;
if (!PointFree(iX-1,iY)) return C4PF_Crawl_Left;
if (!PointFree(iX+1,iY)) return C4PF_Crawl_Right;
return C4PF_Crawl_NoAttach;
}
void C4PathFinderRay::CrawlToAttach(int32_t &rX, int32_t &rY, int32_t iAttach)
{
switch (iAttach)
{
case C4PF_Crawl_Top: rY--; break;
case C4PF_Crawl_Bottom: rY++; break;
case C4PF_Crawl_Left: rX--; break;
case C4PF_Crawl_Right: rX++; break;
}
}
bool C4PathFinderRay::IsCrawlAttach(int32_t iX, int32_t iY, int32_t iAttach)
{
CrawlToAttach(iX,iY,iAttach);
return !PointFree(iX,iY);
}
int32_t C4PathFinderRay::FindCrawlAttachDiagonal(int32_t iX, int32_t iY, int32_t iDirection)
{
// Going left
if (iDirection==C4PF_Direction_Left)
{
// Top Left
if (!PointFree(iX-1,iY-1)) return C4PF_Crawl_Top;
// Bottom left
if (!PointFree(iX-1,iY+1)) return C4PF_Crawl_Left;
// Top right
if (!PointFree(iX+1,iY-1)) return C4PF_Crawl_Right;
// Bottom right
if (!PointFree(iX+1,iY+1)) return C4PF_Crawl_Bottom;
}
// Going right
if (iDirection==C4PF_Direction_Right)
{
// Top Left
if (!PointFree(iX-1,iY-1)) return C4PF_Crawl_Left;
// Bottom left
if (!PointFree(iX-1,iY+1)) return C4PF_Crawl_Bottom;
// Top right
if (!PointFree(iX+1,iY-1)) return C4PF_Crawl_Top;
// Bottom right
if (!PointFree(iX+1,iY+1)) return C4PF_Crawl_Right;
}
return C4PF_Crawl_NoAttach;
}
bool C4PathFinderRay::CheckBackRayShorten()
{
C4PathFinderRay *pRay,*pRay2;
int32_t iX,iY;
for (pRay=From; pRay; pRay=pRay->From)
{
// Don't shorten transfer over zones
if (pRay->UseZone) return false;
// Skip self
if (pRay==From) continue;
// Check shortcut
iX=X; iY=Y;
if (PathFree(iX,iY,pRay->X,pRay->Y))
{
// Delete jumped rays
for (pRay2=From; pRay2!=pRay; pRay2=pRay2->From)
pRay2->Status=C4PF_Ray_Deleted;
// Shorten pRay to this
pRay->X2=X; pRay->Y2=Y;
From=pRay;
// Success
return true;
}
}
return false;
}
//------------------------------- C4PathFinder ---------------------------------------------
C4PathFinder::C4PathFinder()
{
Default();
}
C4PathFinder::~C4PathFinder()
{
Clear();
}
void C4PathFinder::Default()
{
PointFree=nullptr;
SetWaypoint=nullptr;
FirstRay=nullptr;
Success=false;
TransferZones=nullptr;
TransferZonesEnabled=true;
Level=1;
}
void C4PathFinder::Clear()
{
C4PathFinderRay *pRay,*pNext;
for (pRay=FirstRay; pRay; pRay=pNext) { pNext=pRay->Next; delete pRay; }
FirstRay=nullptr;
}
void C4PathFinder::Init(PointFreeFn fnPointFree, C4TransferZones* pTransferZones)
{
// Set data
PointFree = fnPointFree;
TransferZones = pTransferZones;
}
void C4PathFinder::EnableTransferZones(bool fEnabled)
{
TransferZonesEnabled = fEnabled;
}
void C4PathFinder::SetLevel(int iLevel)
{
Level = Clamp(iLevel, 1, 10);
}
void C4PathFinder::Draw(C4TargetFacet &cgo)
{
if (TransferZones) TransferZones->Draw(cgo);
for (C4PathFinderRay *pRay=FirstRay; pRay; pRay=pRay->Next) pRay->Draw(cgo);
}
void C4PathFinder::Run()
{
if (TransferZones) TransferZones->ClearUsed();
Success=false;
while (!Success && Execute()) {}
// Notice that ray zone-pointers might be invalid after run
}
bool C4PathFinder::Execute()
{
// Execute & count rays
bool fContinue=false;
int32_t iRays=0;
for (C4PathFinderRay *pRay=FirstRay; pRay && !Success; pRay=pRay->Next,iRays++)
if (pRay->Execute())
fContinue=true;
// Max ray limit
if (iRays>=C4PF_MaxRay) return false;
// Draw
if (::GraphicsSystem.ShowPathfinder)
{
static int32_t iDelay=0;
iDelay++; if (iDelay>C4PF_Draw_Rate)
{
iDelay=0;
::GraphicsSystem.Execute();
}
}
return fContinue;
}
bool C4PathFinder::Find(int32_t iFromX, int32_t iFromY, int32_t iToX, int32_t iToY, SetWaypointFn fnSetWaypoint)
{
// Prepare
Clear();
// Parameter safety
if (!fnSetWaypoint) return false;
SetWaypoint=fnSetWaypoint;
// Start & target coordinates must be free
if (!PointFree(iFromX,iFromY) || !PointFree(iToX,iToY)) return false;
// Add the first two rays
if (!AddRay(iFromX,iFromY,iToX,iToY,0,C4PF_Direction_Left,nullptr)) return false;
if (!AddRay(iFromX,iFromY,iToX,iToY,0,C4PF_Direction_Right,nullptr)) return false;
// Run
Run();
// Success
return Success;
}
bool C4PathFinder::AddRay(int32_t iFromX, int32_t iFromY, int32_t iToX, int32_t iToY, int32_t iDepth, int32_t iDirection, C4PathFinderRay *pFrom, C4TransferZone *pUseZone)
{
// Max depth
if (iDepth >= C4PF_MaxDepth * Level) return false;
// Allocate and set new ray
C4PathFinderRay *pRay;
if (!(pRay = new C4PathFinderRay)) return false;
pRay->X=iFromX; pRay->Y=iFromY;
pRay->X2=iFromX; pRay->Y2=iFromY;
pRay->TargetX=iToX; pRay->TargetY=iToY;
pRay->Depth=iDepth;
pRay->Direction=iDirection;
pRay->From=pFrom;
pRay->pPathFinder=this;
pRay->Next=FirstRay;
pRay->UseZone=pUseZone;
FirstRay=pRay;
return true;
}
bool C4PathFinder::SplitRay(C4PathFinderRay *pRay, int32_t iAtX, int32_t iAtY)
{
// Max depth
if (pRay->Depth >= C4PF_MaxDepth * Level) return false;
// Allocate and set new ray
C4PathFinderRay *pNewRay;
if (!(pNewRay = new C4PathFinderRay)) return false;
pNewRay->Status=C4PF_Ray_Still;
pNewRay->X=pRay->X; pNewRay->Y=pRay->Y;
pNewRay->X2=iAtX; pNewRay->Y2=iAtY;
pNewRay->TargetX=pRay->TargetX; pNewRay->TargetY=pRay->TargetY;
pNewRay->Depth=pRay->Depth;
pNewRay->Direction=pRay->Direction;
pNewRay->From=pRay->From;
pNewRay->pPathFinder=this;
pNewRay->Next=FirstRay;
FirstRay=pNewRay;
// Adjust split ray
pRay->From=pNewRay;
pRay->X=iAtX; pRay->Y=iAtY;
return true;
}
Reference in New Issue View Git Blame Copy Permalink