/*
============
idAASLocal::ShowArea
============
*/
void idAASLocal::ShowArea(const idVec3 &origin) const
{
	static int lastAreaNum;
	int areaNum;
	const aasArea_t *area;
	idVec3 org;

	areaNum = PointReachableAreaNum(origin, DefaultSearchBounds(), (AREA_REACHABLE_WALK|AREA_REACHABLE_FLY));
	org = origin;
	PushPointIntoAreaNum(areaNum, org);

	if (aas_goalArea.GetInteger()) {
		int travelTime;
		idReachability *reach;

		RouteToGoalArea(areaNum, org, aas_goalArea.GetInteger(), TFL_WALK|TFL_AIR, travelTime, &reach);
		gameLocal.Printf("\rtt = %4d", travelTime);

		if (reach) {
			gameLocal.Printf(" to area %4d", reach->toAreaNum);
			DrawArea(reach->toAreaNum);
		}
	}

	if (areaNum != lastAreaNum) {
		area = &file->GetArea(areaNum);
		gameLocal.Printf("area %d: ", areaNum);

		if (area->flags & AREA_LEDGE) {
			gameLocal.Printf("AREA_LEDGE ");
		}

		if (area->flags & AREA_REACHABLE_WALK) {
			gameLocal.Printf("AREA_REACHABLE_WALK ");
		}

		if (area->flags & AREA_REACHABLE_FLY) {
			gameLocal.Printf("AREA_REACHABLE_FLY ");
		}

		if (area->contents & AREACONTENTS_CLUSTERPORTAL) {
			gameLocal.Printf("AREACONTENTS_CLUSTERPORTAL ");
		}

		if (area->contents & AREACONTENTS_OBSTACLE) {
			gameLocal.Printf("AREACONTENTS_OBSTACLE ");
		}

		gameLocal.Printf("\n");
		lastAreaNum = areaNum;
	}

	if (org != origin) {
		idBounds bnds = file->GetSettings().boundingBoxes[ 0 ];
		bnds[ 1 ].z = bnds[ 0 ].z;
		gameRenderWorld->DebugBounds(colorYellow, bnds, org);
	}

	DrawArea(areaNum);
}
Exemple #2
0
Local
VOID FreeErase( FRAME *frame )
{
    struct Selection *selection = &frame->selection;

    DrawArea( frame, selection->vertices, selection->nVertices );
}
Exemple #3
0
void CBackground::Draw (bool bDrawBox, bool bUpdate)
{
paletteManager.SetEffect (0, 0, 0);
if (!(gameStates.menus.bNoBackground || (gameStates.app.bGameRunning && !gameStates.app.bNostalgia))) {
	if (m_filename && (MODERN_STYLE || m_bTopMenu)) {
		CCanvas::Push ();
		CCanvas::SetCurrent (m_canvas [0]);
		m_background->RenderStretched ();
		PrintVersionInfo ();
		CCanvas::Pop ();
		}
	}
if (bDrawBox && !((gameStates.app.bNostalgia && m_bTopMenu) || backgroundManager.IsDefault (m_filename))) {
	CCanvas::Push ();
	CCanvas::SetCurrent (m_canvas [1]);
	if (m_bMenuBox)
		backgroundManager.DrawBox (0, 0, m_canvas [1]->Width (), m_canvas [1]->Height (), gameData.menu.nLineWidth, 1.0f, 0);
	else 
		DrawArea (0, 0, m_canvas [1]->Width (), m_canvas [1]->Height ());
		CCanvas::Pop ();
					//0, 0, CCanvas::Current ()->Right (), CCanvas::Current ()->Bottom ());
		//CCanvas::Current ()->Left (), CCanvas::Current ()->Top (), 
		//			 CCanvas::Current ()->Right (), CCanvas::Current ()->Bottom ());
	}
paletteManager.LoadEffect ();
if (bUpdate && !gameStates.app.bGameRunning)
	GrUpdate (0);
}
Exemple #4
0
/// Draw&Erase
Local
VOID FreeDraw( FRAME *frame, ULONG flags )
{
    struct Selection *selection = &frame->selection;

    DrawArea( frame, selection->vertices, selection->nVertices );
}
Exemple #5
0
/*
============
idAASLocal::ShowObstaclePVS
============
*/
void idAASLocal::ShowObstaclePVS( const int areaNum ) const {
	const byte *pvs = GetObstaclePVS( areaNum );

	for ( int i = 0; i < file->GetNumAreas(); i++ ) {
		if ( !IsInObstaclePVS( pvs, i ) ) {
			continue;
		}
		DrawArea( i );
	}
}
Exemple #6
0
/*
============
idAASLocal::ShowAASBadAreas
============
*/
void idAASLocal::ShowAASBadAreas( int mode ) const {

	if ( file == NULL ) {
		return;
	}

	float height = file->GetSettings().boundingBox[1][2] - file->GetSettings().boundingBox[0][2];

	for ( int i = 0; i < file->GetNumAreas(); i++ ) {
		const aasArea_t &area = file->GetArea( i );

		idVec3 mid;
		mid.Zero();

		for ( int j = 0; j < area.numEdges; j++ ) {
			int edgeNum = file->GetEdgeIndex( area.firstEdge + j );
			const aasEdge_t &edge = file->GetEdge( abs( edgeNum ) );
			mid += file->GetVertex( edge.vertexNum[ INT32_SIGNBITSET( edgeNum ) ] );
		}

		mid /= area.numEdges;

		bool bad = false;

		if ( mode == 1 || mode == 3 ) {
			int j;
			for ( j = 0; j < 4; j++ ) {
				int areaNum = file->PointAreaNum( mid + file->GetSettings().invGravityDir * ( j * height )  );
				if ( areaNum == i ) {
					break;
				}
			}
			if ( j >= 4 ) {
				bad = true;
			}
		}

		if ( mode == 2 || mode == 3 ) {
#if 1
			if ( ( area.flags & AAS_AREA_NOPUSH ) != 0 ) {
				bad = true;
			}
#else
			idVec3 pushed = mid;
			if ( file->PushPointIntoArea( i, pushed ) ) {
				bad = true;
			}
#endif
		}

		if ( bad ) {
			DrawArea( i );
		}
	}
}
Exemple #7
0
/*
============
idAASLocal::ShowNearestInsideArea
============
*/
void idAASLocal::ShowNearestInsideArea( const idVec3 &origin ) const {
	int areaNum = PointReachableAreaNum( origin, DefaultSearchBounds(), AAS_AREA_REACHABLE_WALK, TravelFlagInvalidForTeam() );

	idAASCallback_FindFlaggedArea findInside( AAS_AREA_OUTSIDE, false );
	idAASGoal goal;
	if ( FindNearestGoal( goal, areaNum, origin, TravelFlagForTeam(), findInside ) ) {
		DrawArea( goal.areaNum );
		ShowWalkPath( areaNum, origin, goal.areaNum, goal.origin, TravelFlagForTeam(), TravelFlagWalkForTeam() );
		DrawCone( goal.origin, idVec3( 0, 0, 1 ), 16.0f, colorWhite );
	}
}
Exemple #8
0
/*
============
idAASLocal::ShowWalkPath
============
*/
void idAASLocal::ShowWalkPath( int startAreaNum, const idVec3 &startOrigin, int goalAreaNum, const idVec3 &goalOrigin, int travelFlags, int walkTravelFlags ) const {

	if ( file == NULL ) {
		return;
	}

	int curAreaNum = startAreaNum;

	idVec3 org = startOrigin;
	for ( int i = 0; i < 100; i++ ) {

		int travelTime;
		const aasReachability_t *reach;

		if ( !RouteToGoalArea( curAreaNum, org, goalAreaNum, travelFlags, travelTime, &reach ) ) {
			break;
		}

		if ( !reach ) {
			break;
		}

		gameRenderWorld->DebugArrow( colorGreen, org, reach->GetStart(), 2, 0 );
		DrawReachability( reach, NULL );
		if ( aas_showAreas.GetBool() ) {
			DrawArea( curAreaNum );
		}

		if ( reach->toAreaNum == goalAreaNum ) {
			break;
		}

		curAreaNum = reach->toAreaNum;
		org = reach->GetEnd();
	}

	idAASPath path;
	if ( !WalkPathToGoal( path, startAreaNum, startOrigin, goalAreaNum, goalOrigin, travelFlags, walkTravelFlags ) ) {
		return;
	}

	gameRenderWorld->DebugArrow( colorBlue, startOrigin, path.moveGoal, 2, 0 );

//	idObstacleAvoidance::obstaclePath_t obstaclePath;
//	idObstacleAvoidance obstacleAvoidance;
//	botThreadData.BuildObstacleList( obstacleAvoidance, startOrigin, startAreaNum, false );
//	obstacleAvoidance.FindPathAroundObstacles( file->GetSettings().boundingBox, file->GetSettings().obstaclePVSRadius, this, startOrigin, path.moveGoal, obstaclePath );

//	if ( obstaclePath.firstObstacle != idObstacleAvoidance::OBSTACLE_ID_INVALID ) {
//		path.moveGoal = obstaclePath.seekPos;
//		gameRenderWorld->DebugArrow( colorOrange, startOrigin, path.moveGoal, 2, 0 );
//	}
}
Exemple #9
0
/*
============
idAASLocal::ShowNearestCoverArea
============
*/
void idAASLocal::ShowNearestCoverArea( const idVec3 &origin, int targetAreaNum ) const {
	int areaNum = PointReachableAreaNum( origin, DefaultSearchBounds(), AAS_AREA_REACHABLE_WALK, TravelFlagInvalidForTeam() );
	idVec3 target = AreaCenter( targetAreaNum );

	DrawCone( target, idVec3(0,0,1), 16.0f, colorYellow );

	idAASCallback_FindCoverArea findCover( target );
	idAASGoal goal;
	if ( FindNearestGoal( goal, areaNum, origin, TravelFlagInvalidForTeam(), findCover ) ) {
		DrawArea( goal.areaNum );
		ShowWalkPath( areaNum, origin, goal.areaNum, goal.origin, TravelFlagForTeam(), TravelFlagWalkForTeam() );
		DrawCone( goal.origin, idVec3( 0, 0, 1 ), 16.0f, colorWhite );
	}
}
Exemple #10
0
/*
============
idAASLocal::ShowHideArea
============
*/
void idAASLocal::ShowHideArea( const idVec3 &origin, int targetAreaNum ) const {
	int areaNum, numObstacles;
	idVec3 target;
	aasGoal_t goal;
	aasObstacle_t obstacles[10];
	areaNum = PointReachableAreaNum( origin, DefaultSearchBounds(), ( AREA_REACHABLE_WALK | AREA_REACHABLE_FLY ) );
	target = AreaCenter( targetAreaNum );
	// consider the target an obstacle
	obstacles[0].absBounds = idBounds( target ).Expand( 16 );
	numObstacles = 1;
	DrawCone( target, idVec3( 0, 0, 1 ), 16.0f, colorYellow );
	idAASFindCover findCover( target );
	if( FindNearestGoal( goal, areaNum, origin, target, TFL_WALK | TFL_AIR, obstacles, numObstacles, findCover ) ) {
		DrawArea( goal.areaNum );
		ShowWalkPath( origin, goal.areaNum, goal.origin );
		DrawCone( goal.origin, idVec3( 0, 0, 1 ), 16.0f, colorWhite );
	}
}
Exemple #11
0
/*
============
idAASLocal::ShowHopPath
============
*/
void idAASLocal::ShowHopPath( int startAreaNum, const idVec3 &startOrigin, int goalAreaNum, const idVec3 &goalOrigin, int travelFlags, int walkTravelFlags, const idAASHopPathParms &parms ) const {

	if ( file == NULL ) {
		return;
	}

	int curAreaNum = startAreaNum;

	idVec3 org = startOrigin;
	for ( int i = 0; i < 100; i++ ) {

		int travelTime;
		const aasReachability_t *reach;

		if ( !RouteToGoalArea( curAreaNum, org, goalAreaNum, travelFlags, travelTime, &reach ) ) {
			break;
		}

		if ( !reach ) {
			break;
		}

		gameRenderWorld->DebugArrow( colorGreen, org, reach->GetStart(), 2, 0 );
		DrawReachability( reach, NULL );
		if ( aas_showAreas.GetBool() ) {
			DrawArea( curAreaNum );
		}

		if ( reach->toAreaNum == goalAreaNum ) {
			break;
		}

		curAreaNum = reach->toAreaNum;
		org = reach->GetEnd();
	}

	idAASPath path;
	if ( WalkPathToGoal( path, startAreaNum, startOrigin, goalAreaNum, goalOrigin, travelFlags, walkTravelFlags ) ) {
		gameRenderWorld->DebugArrow( colorBlue, startOrigin, path.moveGoal, 2 );
		if ( ExtendHopPathToGoal( path, startAreaNum, startOrigin, goalAreaNum, goalOrigin, travelFlags, walkTravelFlags, parms ) ) {
			gameRenderWorld->DebugArrow( colorCyan, startOrigin, path.moveGoal, 2 );
		}
	}
}
void CGuiHandler::DrawMapStuff(void)
{
	if(activeMousePress){
		int cc=-1;
		int button=SDL_BUTTON_LEFT;
		if(inCommand!=-1){
			cc=inCommand;
		} else {
			if(mouse->buttons[SDL_BUTTON_RIGHT].pressed && mouse->activeReceiver==this){
				cc=defaultCmdMemory;//GetDefaultCommand(mouse->lastx,mouse->lasty);
				button=SDL_BUTTON_RIGHT;
			}
		}

		if(cc>=0 && cc<commands.size()){
			switch(commands[cc].type){
			case CMDTYPE_ICON_FRONT:
				if(mouse->buttons[button].movement>30){
					if(commands[cc].params.size()>0)
						if(commands[cc].params.size()>1)
							DrawFront(button,atoi(commands[cc].params[0].c_str()),atof(commands[cc].params[1].c_str()));
						else
							DrawFront(button,atoi(commands[cc].params[0].c_str()),0);
					else
						DrawFront(button,1000,0);
				}
				break;
			case CMDTYPE_ICON_UNIT_OR_AREA:
			case CMDTYPE_ICON_UNIT_FEATURE_OR_AREA:
			case CMDTYPE_ICON_AREA:{
				float maxRadius=100000;
				if(commands[cc].params.size()==1)
					maxRadius=atof(commands[cc].params[0].c_str());
				if(mouse->buttons[button].movement>4){
					float dist=ground->LineGroundCol(mouse->buttons[button].camPos,mouse->buttons[button].camPos+mouse->buttons[button].dir*9000);
					if(dist<0){
						break;
					}
					float3 pos=mouse->buttons[button].camPos+mouse->buttons[button].dir*dist;
					dist=ground->LineGroundCol(camera->pos,camera->pos+mouse->dir*9000);
					if(dist<0){
						break;
					}
					float3 pos2=camera->pos+mouse->dir*dist;
					DrawArea(pos,min(maxRadius,pos.distance2D(pos2)));
				}
				break;}
			default:
				break;
			}
		}
	}
	//draw buildings we are about to build
	if(inCommand>=0 && inCommand<commands.size() && commands[guihandler->inCommand].type==CMDTYPE_ICON_BUILDING){
		float dist=ground->LineGroundCol(camera->pos,camera->pos+mouse->dir*9000);
		if(dist>0){
			string s=commands[guihandler->inCommand].name;
			UnitDef *unitdef = unitDefHandler->GetUnitByName(s);

			if(unitdef){
				float3 pos=camera->pos+mouse->dir*dist;
				std::vector<float3> buildPos;
				if(keys[SDLK_LSHIFT] && mouse->buttons[SDL_BUTTON_LEFT].pressed){
					float dist=ground->LineGroundCol(mouse->buttons[SDL_BUTTON_LEFT].camPos,mouse->buttons[SDL_BUTTON_LEFT].camPos+mouse->buttons[SDL_BUTTON_LEFT].dir*9000);
					float3 pos2=mouse->buttons[SDL_BUTTON_LEFT].camPos+mouse->buttons[SDL_BUTTON_LEFT].dir*dist;
					buildPos=GetBuildPos(pos2,pos,unitdef);
				} else {
					buildPos=GetBuildPos(pos,pos,unitdef);
				}

				for(std::vector<float3>::iterator bpi=buildPos.begin();bpi!=buildPos.end();++bpi){
					float3 pos=*bpi;
					if(uh->ShowUnitBuildSquare(pos,unitdef))
						glColor4f(0.7,1,1,0.4);
					else
						glColor4f(1,0.5,0.5,0.4);

					unitDrawer->SetupForGhostDrawing ();
					S3DOModel* model=modelParser->Load3DO((unitdef->model.modelpath).c_str() ,1, gu->myTeam);
					glPushMatrix();
					glTranslatef3(pos);
					//glCallList(model->displist);
					model->DrawStatic();
					unitDrawer->CleanUpGhostDrawing();
					glPopMatrix();
					if(unitdef->weapons.size()>0){	//draw range
						glDisable(GL_TEXTURE_2D);
						glColor4f(1,0.3,0.3,0.7);
						glBegin(GL_LINE_STRIP);
						for(int a=0;a<=40;++a){
							float3 wpos(cos(a*2*PI/40)*unitdef->weapons[0].def->range,0,sin(a*2*PI/40)*unitdef->weapons[0].def->range);
							wpos+=pos;
							float dh=ground->GetHeight(wpos.x,wpos.z)-pos.y;
							float modRange=unitdef->weapons[0].def->range-dh*unitdef->weapons[0].def->heightmod;
							wpos=float3(cos(a*2*PI/40)*(modRange),0,sin(a*2*PI/40)*(modRange));
							wpos+=pos;
							wpos.y=ground->GetHeight(wpos.x,wpos.z)+8;
							glVertexf3(wpos);
						}
						glEnd();
					}
					if(unitdef->extractRange>0){	//draw range
						glDisable(GL_TEXTURE_2D);
						glColor4f(1,0.3,0.3,0.7);
						glBegin(GL_LINE_STRIP);
						for(int a=0;a<=40;++a){
							float3 wpos(cos(a*2*PI/40)*unitdef->extractRange,0,sin(a*2*PI/40)*unitdef->extractRange);
							wpos+=pos;
							wpos.y=ground->GetHeight(wpos.x,wpos.z)+8;
							glVertexf3(wpos);
						}
						glEnd();
					}
				}
			}
		}
	}

	if(keys[SDLK_LSHIFT]){
		CUnit* unit=0;
		float dist2=helper->GuiTraceRay(camera->pos,mouse->dir,9000,unit,20,false);
		if(unit && ((unit->losStatus[gu->myAllyTeam] & LOS_INLOS) || gu->spectating)){		//draw weapon range
			if(unit->maxRange>0){
				glDisable(GL_TEXTURE_2D);
				glColor4f(1,0.3,0.3,0.7);
				glBegin(GL_LINE_STRIP);
				float h=unit->pos.y;
				for(int a=0;a<=40;++a){
					float3 pos(cos(a*2*PI/40)*unit->maxRange,0,sin(a*2*PI/40)*unit->maxRange);
					pos+=unit->pos;
					float dh=ground->GetHeight(pos.x,pos.z)-h;
					pos=float3(cos(a*2*PI/40)*(unit->maxRange-dh*unit->weapons.front()->heightMod),0,sin(a*2*PI/40)*(unit->maxRange-dh*unit->weapons.front()->heightMod));
					pos+=unit->pos;
					pos.y=ground->GetHeight(pos.x,pos.z)+8;
					glVertexf3(pos);
				}
				glEnd();
			}
			if(unit->unitDef->decloakDistance>0){			//draw decloak distance
				glDisable(GL_TEXTURE_2D);
				glColor4f(0.3,0.3,1,0.7);
				glBegin(GL_LINE_STRIP);
				for(int a=0;a<=40;++a){
					float3 pos(cos(a*2*PI/40)*unit->unitDef->decloakDistance,0,sin(a*2*PI/40)*unit->unitDef->decloakDistance);
					pos+=unit->pos;
					pos.y=ground->GetHeight(pos.x,pos.z)+8;
					glVertexf3(pos);
				}
				glEnd();
			}
			if(unit->unitDef->kamikazeDist>0){			//draw self destruct and damage distance
				glDisable(GL_TEXTURE_2D);
				glColor4f(0.8,0.8,0.1,0.7);
				glBegin(GL_LINE_STRIP);
				for(int a=0;a<=40;++a){
					float3 pos(cos(a*2*PI/40)*unit->unitDef->kamikazeDist,0,sin(a*2*PI/40)*unit->unitDef->kamikazeDist);
					pos+=unit->pos;
					pos.y=ground->GetHeight(pos.x,pos.z)+8;
					glVertexf3(pos);
				}
				glEnd();
				if(!unit->unitDef->selfDExplosion.empty()){
					glColor4f(0.8,0.1,0.1,0.7);
					WeaponDef* wd=weaponDefHandler->GetWeapon(unit->unitDef->selfDExplosion);

					glBegin(GL_LINE_STRIP);
					for(int a=0;a<=40;++a){
						float3 pos(cos(a*2*PI/40)*wd->areaOfEffect,0,sin(a*2*PI/40)*wd->areaOfEffect);
						pos+=unit->pos;
						pos.y=ground->GetHeight(pos.x,pos.z)+8;
						glVertexf3(pos);
					}
					glEnd();
				}
			}
		}
	}
	//draw range circles if attack orders are imminent
	int defcmd=GetDefaultCommand(mouse->lastx,mouse->lasty);
	if((inCommand>0 && inCommand<commands.size() && commands[inCommand].id==CMD_ATTACK) || (inCommand==-1 && defcmd>0 && commands[defcmd].id==CMD_ATTACK)){
		for(std::set<CUnit*>::iterator si=selectedUnits.selectedUnits.begin();si!=selectedUnits.selectedUnits.end();++si){
			CUnit* unit=*si;
			if(unit->maxRange>0 && ((unit->losStatus[gu->myAllyTeam] & LOS_INLOS) || gu->spectating)){
				glDisable(GL_TEXTURE_2D);
				glColor4f(1,0.3,0.3,0.7);
				glBegin(GL_LINE_STRIP);
				float h=unit->pos.y;
				for(int a=0;a<=40;++a){
					float3 pos(cos(a*2*PI/40)*unit->maxRange,0,sin(a*2*PI/40)*unit->maxRange);
					pos+=unit->pos;
					float dh=ground->GetHeight(pos.x,pos.z)-h;
					pos=float3(cos(a*2*PI/40)*(unit->maxRange-dh*unit->weapons.front()->heightMod),0,sin(a*2*PI/40)*(unit->maxRange-dh*unit->weapons.front()->heightMod));
					pos+=unit->pos;
					pos.y=ground->GetHeight(pos.x,pos.z)+8;
					glVertexf3(pos);
				}
				glEnd();
			}
		}
	}
}
Exemple #13
0
/*
============
idAASLocal::Test
============
*/
void idAASLocal::Test( const idVec3 &origin ) {
	int areaNum;
	idVec3 location;

	if ( file == NULL ) {
		return;
	}

	if ( GetAreaNumAndLocation( aas_locationMemory, origin, areaNum, location ) ) {
	}
	if ( GetAreaNumAndLocation( aas_showPath, origin, areaNum, location ) ) {
		ShowWalkPath( origin, areaNum, location );
	}
	if ( GetAreaNumAndLocation( aas_showHopPath, origin, areaNum, location ) ) {
		ShowHopPath( origin, areaNum, location );
	}
	if ( GetAreaNumAndLocation( aas_pullPlayer, origin, areaNum, location ) ) {
		int startAreaNum, travelTime;
		ShowWalkPath( origin, areaNum, location );
		PullPlayer( origin, areaNum, location, startAreaNum, travelTime );
	} else {
		UnFreezePlayer();
	}
	if ( aas_randomPullPlayer.GetInteger() != 0 ) {
		RandomPullPlayer( origin, aas_randomPullPlayer.GetInteger() );
	}
	if ( aas_showAreas.GetInteger() != 0 ) {
		ShowArea( origin, aas_showAreas.GetInteger() );
	}

	if ( aas_showAreaNumber.GetInteger() != 0 ) {
		DrawArea( aas_showAreaNumber.GetInteger() );
	}

	if ( ( aas_showNearestCoverArea.GetInteger() > 0 ) && ( aas_showNearestCoverArea.GetInteger() < file->GetNumAreas() ) ) {
		ShowNearestCoverArea( origin, aas_showNearestCoverArea.GetInteger() );
	}
	if ( aas_showNearestInsideArea.GetBool() ) {
		ShowNearestInsideArea( origin );
	}
	if ( aas_showWallEdges.GetInteger() != 0 ) {
		ShowWallEdges( origin, aas_showWallEdges.GetInteger(), aas_showWallEdgeNums.GetBool() );
	}
	if ( aas_showPushIntoArea.GetBool() ) {
		ShowPushIntoArea( origin );
	}
	if ( aas_showFloorTrace.GetBool() ) {
		ShowFloorTrace( origin );
	}
	if ( GetAreaNumAndLocation( aas_showObstaclePVS, origin, areaNum, location ) ) {
		ShowObstaclePVS( areaNum );
	}
	if ( aas_showManualReachabilities.GetBool() ) {
		ShowManualReachabilities();
	}
	if ( aas_showFuncObstacles.GetBool() ) {
		ShowAASObstacles();
	}
	if ( aas_showBadAreas.GetInteger() != 0 ) {
		ShowAASBadAreas( aas_showBadAreas.GetInteger() );
	}
}
Exemple #14
0
/*
============
idAASLocal::ShowArea
============
*/
void idAASLocal::ShowArea( const idVec3 &origin, int mode ) const {
	static int lastAreaNum;
	int areaNum;
	const aasArea_t *area;
	idVec3 org;

	org = origin;
	if ( mode == 1 ) {
		areaNum = PointReachableAreaNum( origin, DefaultSearchBounds(), AAS_AREA_REACHABLE_WALK, TravelFlagInvalidForTeam() );
		PushPointIntoArea( areaNum, org );
	} else {
		areaNum = PointAreaNum( origin );
	}

	if ( aas_showTravelTime.GetInteger() ) {
		int travelTime;
		const aasReachability_t *reach;
		
		RouteToGoalArea( areaNum, org, aas_showTravelTime.GetInteger(), TFL_WALK|TFL_AIR, travelTime, &reach );
		gameLocal.Printf( "\rtt = %4d", travelTime );
		if ( reach ) {
			gameLocal.Printf( " to area %4d", reach->toAreaNum );
			DrawArea( reach->toAreaNum );
		}
	}

	if ( areaNum != lastAreaNum ) {
		area = &file->GetArea( areaNum );
		gameLocal.Printf( "area %d:", areaNum );
		if ( area->flags & AAS_AREA_LEDGE ) {
			gameLocal.Printf( " ledge" );
		}
		if ( area->flags & AAS_AREA_CONTENTS_CLUSTERPORTAL ) {
			gameLocal.Printf( " clusterportal" );
		}
		if ( area->flags & AAS_AREA_CONTENTS_OBSTACLE ) {
			gameLocal.Printf( " obstacle" );
		}
		if ( area->flags & AAS_AREA_OUTSIDE ) {
			gameLocal.Printf( " outside" );
		}
		if ( area->flags & AAS_AREA_HIGH_CEILING ) {
			gameLocal.Printf( " highceiling" );
		}
		if ( area->travelFlags & ( TFL_INVALID | TFL_INVALID_GDF | TFL_INVALID_STROGG ) ) {
			gameLocal.Printf( " /" );
			if ( area->travelFlags & TFL_INVALID ) {
				gameLocal.Printf( " invalid" );
			}
			if ( area->travelFlags & TFL_INVALID_GDF ) {
				gameLocal.Printf( " invalidgdf" );
			}
			if ( area->travelFlags & TFL_INVALID_STROGG ) {
				gameLocal.Printf( " invalidstrogg" );
			}
		}
		gameLocal.Printf( "\n" );
		lastAreaNum = areaNum;
	}

	if ( org != origin ) {
		idBounds bnds = file->GetSettings().boundingBox;
		bnds[ 1 ].z = bnds[ 0 ].z;
		gameRenderWorld->DebugBounds( colorYellow, bnds, org );
		gameRenderWorld->DebugArrow( colorYellow, origin, org, 1 );
	}

	DrawArea( areaNum );
}