예제 #1
0
파일: npc_ai.cpp 프로젝트: CCNHsK-Dev/SyPB
void NPC::TaskBase(void)
{
	if (m_goalWaypointAPI != -1)
	{
		if (m_goalWaypointAPI != m_goalWaypoint)
		{
			DeleteSearchNodes();
			m_goalWaypoint = m_goalWaypointAPI;
		}
	}

	if (DoWaypointNav())
	{
		m_goalWaypoint = -1;

		if (m_goalWaypointAPI != -1 && m_goalWaypointAPI == m_currentWaypointIndex)
			m_goalWaypointAPI = -1;
	}

	if (!GoalIsValid())
	{
		if (m_goalWaypoint == -1)
			m_goalWaypoint = RANDOM_LONG(0, g_numWaypoints - 1);

		FindWaypoint();

		DeleteSearchNodes();
		FindShortestPath(m_currentWaypointIndex, m_goalWaypoint);
	}
}
예제 #2
0
파일: cprofile.c 프로젝트: sharkcz/xtrkcad
static int FindProfileShortestPath(
		track_p trkN,
		EPINX_T epN )
{
LOG( log_profile, 4, ( "Searching from T%d:%d to T%d:%d or T%d:%d\n",
		GetTrkIndex(trkN), epN,
		pathStartTrk?GetTrkIndex(pathStartTrk):-1, pathStartTrk?pathStartEp:-1,
		pathEndTrk?GetTrkIndex(pathEndTrk):-1, pathEndTrk?pathEndEp:-1 ) )
	profileShortestPathMatch = -1;
	return FindShortestPath( trkN, epN, TRUE, ProfileShortestPathFunc, NULL );
}
예제 #3
0
파일: npc_ai.cpp 프로젝트: CCNHsK-Dev/SyPB
void NPC::TaskMoveTarget(void)
{
	if (FNullEnt(m_moveTargetEntity))
		return;

	if (DoWaypointNav())
		DeleteSearchNodes();

	int destIndex = g_waypoint->GetEntityWpIndex(m_moveTargetEntity);
	if (destIndex >= 0 && destIndex < g_numWaypoints)
	{
		bool moveToTarget = false;
		if (&m_navNode[0] != null)
		{
			PathNode *node = m_navNode;

			while (node->next != null)
				node = node->next;

			if (node->index == destIndex)
				moveToTarget = true;
		}

		if (!GoalIsValid() || (m_goalWaypoint != destIndex && !moveToTarget))
		{
			int srcIndex = m_currentWaypointIndex;
			if (m_currentWaypointIndex != g_waypoint->GetEntityWpIndex(GetEntity()))
			{
				if (*(g_waypoint->m_distMatrix + (m_currentWaypointIndex * g_numWaypoints) + destIndex) <=
					*(g_waypoint->m_distMatrix + (g_waypoint->GetEntityWpIndex(GetEntity()) * g_numWaypoints) + destIndex))
					srcIndex = m_currentWaypointIndex;
				else
					srcIndex = g_waypoint->GetEntityWpIndex(GetEntity());
			}

			DeleteSearchNodes();
			m_currentWaypointIndex = srcIndex;
			m_navTime = gpGlobals->time + 5.0f;
			SetWaypointOrigin();

			m_goalWaypoint = destIndex;
			FindShortestPath(m_currentWaypointIndex, m_goalWaypoint);
		}

		if (m_currentWaypointIndex == m_goalWaypoint)
			SetEnemy(m_moveTargetEntity);
	}
}
예제 #4
0
void CriticalPoint::TraceLine()
{
        /* TraceLine : from each saddle point, find its corresponding four max-min points */
        for(set<size_t>::iterator it=p_SadPointID->begin(); it!=p_SadPointID->end(); ++it)
        {
                M_Point& sadPoint = *(m_vtx[*it]);
                TraceLineFromSaddle(dynamic_cast<SadPoint&>(sadPoint));
                TraceLine4MaxMin(dynamic_cast<SadPoint&>(sadPoint));
        }


        for(map<MaxMinPair,IndexArray>::iterator im = p_DualConn->begin(); im!=p_DualConn->end(); ++im)
        {
                //Global::mesh->m_BasicOp.GetShortestPath(
                //      (VertexID)(im->first).first, (VertexID)(im->first).second, im->second);
                FindShortestPath(m_vtx,(im->first).first, (im->first).second, im->second);
        }
}
예제 #5
0
파일: Lee.cpp 프로젝트: GordonSmith/eclide
bool LeeRoutePlannerImpl::GetShortestPath( 
	const GraphTypes::PointF& start,
	const GraphTypes::PointF& end,
	GraphTypes::PointFVector& path )
{
	bool bSuccess=m_bgrid;

	if ( bSuccess ) // make sure EndAddPoints was called
	{
		grid_vertex_descriptor from, to;

		from=PointF2Descriptor(start);
		to=PointF2Descriptor(end);

		if ( from!=to )
		{
			grid_vertex_descriptor_vector vpath;
			grid_vertex_descriptor_vector::reverse_iterator ri, rend;

			FindShortestPath( from, to, vpath );
			SetPathWeight( vpath );

			if (vpath.size() >= 3)
			{
				grid_vertex_descriptor first;
				GraphTypes::PointF pt;
				Direction dir = dirNotSet, lastDir=dirNotSet;

				path.clear();
				ri=vpath.rbegin();
				rend=vpath.rend();

				// don't store first and last points - they belong to vertices
				++ri;
				--rend;
				first=from;

				for ( ; ri!=rend; ++ri)
				{
					Descriptor2PointF(*ri, pt);
					dir=GetDirection(first, *ri);
					if (dir==lastDir) // don't store colinear points
						path.pop_back(); 

					path.push_back(pt);
					lastDir=dir;
					first=*ri;
				}

				dir=GetDirection(first, to);
				if (dir==lastDir) // don't store colinear points
					path.pop_back();

			}
			else
			{
				bSuccess=false;
			}
		} 
	}

	return bSuccess;
}
예제 #6
0
void DoNonCombatAI(void)
{
	static boolean waitpwall;
	word nowon, nexton, mypos, nx, ny;
	fixed nxd, nyd;
	byte tile;
	int tangle, dangle;
	boolean tryuse;
	objtype* check;
	static int inc;
	inc++;

	if(!destination)
		destination = FindShortestPath();
	if(!destination)
		return;
	if(pwallstate)
		waitpwall = true;
	mypos = TILE_ENCODE(player->tilex, player->tiley);
	nowon = nexton = WORD_MAX;
	for(nowon = destination; nowon != WORD_MAX;
	    nexton = nowon, nowon = path_prev[nowon])
	{
		if(nowon == mypos)
			break;
	}
	if(nowon == WORD_MAX || (!pwallstate && waitpwall))
	{
		waitpwall = false;
		destination = 0;
		return;
	}
	if(nexton == WORD_MAX)
	{
//		prevon = path_prev[nowon];
		destination = 0;
		nx = pushtargetx;
		ny = pushtargety;
	}
	else
	{
		nx = TILE_DECODE_X(nexton);
		ny = TILE_DECODE_Y(nexton);
		tile = tilemap[nx][ny];
		if(tile & 0x80)
		{
			tile &= ~0x80;
			if(!CanGoThruLockedDoor(tile))
			{
				destination = 0;
				return;
			}
			tryuse = (doorobjlist[tile].action == dr_closed
			       || doorobjlist[tile].action == dr_closing);
		}
	}
	tangle = DirAngle(player->x, player->y, ((fixed)nx << TILESHIFT)
	    + TILEGLOBAL/2, ((fixed)ny << TILESHIFT) + TILEGLOBAL / 2);
	dangle = CentreAngle(tangle, player->angle);
	if(dangle > -ANGLE_FOV && dangle < ANGLE_FOV)
	{
		controly = -RUNMOVE * tics;
		if(tryuse)
		{
			check = actorat[nx][ny];
			if(check && check < objlist && inc % 2)
				buttonstate[bt_use] = true;
		}
	}
	TurnToAngle(dangle);
}