예제 #1
0
파일: field.cpp 프로젝트: 001100/turbo-meme
void Field::MakeLabyrinth()
{
    srand (time(NULL));
    for (int iii = 1; iii < g_HEIGHT-1; iii++)
    {
        for (int jjj = 1; jjj < g_WIDTH-1; jjj++)
        {
        int placePercentValue = rand() % 100;
        // 30% chance to place obstacle
        if (placePercentValue < 40) {
                F(iii, jjj).SetTileChar("╳");
                // Random color
                //F(iii, jjj).SetColor(static_cast<Color>(rand() % (COLOR_COUNT - 1) + 1));
                F(iii, jjj).SetTilePassability(false);
                DebugDraw(iii, jjj);
            }
        }
    }

    for (int iii = 0; iii < g_HEIGHT; iii++)
    {
        for (int jjj = 0; jjj < g_WIDTH; jjj++)
        {
            SmothWalls(iii, jjj);
        }
    }
}
예제 #2
0
void CDeflectorShield::Update(SEntityUpdateContext& ctx, int updateSlot)
{
	if (updateSlot != 0)
		return;
	UpdateDeflectedEnergies(ctx.fFrameTime);
	DebugDraw();
}
void CPlayerStateSwim_WaterTestProxy::UpdateInWater(const CPlayer& player, const float frameTime)
{
	FUNCTION_PROFILER(GetISystem(), PROFILE_GAME);

	const Matrix34& playerWorldTM = player.GetEntity()->GetWorldTM();
	const Vec3 playerWorldPos = playerWorldTM.GetTranslation();

	const Vec3 localReferencePos = GetLocalReferencePosition(player);
	const Vec3 worldReferencePos = playerWorldPos + (Quat(playerWorldTM) * localReferencePos);

	const bool shouldUpdate  = 
		((gEnv->pTimer->GetCurrTime() - m_timeWaterLevelLastUpdated) > 0.3f ) || 
		((m_lastWaterLevelCheckPosition - playerWorldPos).len2() >= sqr(0.35f)) ||
			(m_lastInternalState != m_internalState && m_internalState == eProxyInternalState_PartiallySubmerged); //Just entered partially emerged state

	if (shouldUpdate && !IsWaitingForBottomLevelResults())
	{
		RayTestBottomLevel(player, worldReferencePos, s_rayLength);

		IPhysicalEntity* piPhysEntity = player.GetEntity()->GetPhysics();

		UpdateWaterLevel( worldReferencePos, playerWorldPos, piPhysEntity );

		if (m_waterLevel > WATER_LEVEL_UNKNOWN)
		{
			m_playerWaterLevel = (worldReferencePos.z - m_waterLevel);
		}
		else
		{
			m_playerWaterLevel = -WATER_LEVEL_UNKNOWN;
			m_bottomLevel = BOTTOM_LEVEL_UNKNOWN;
			m_headUnderwater = false;
			m_headComingOutOfWater = false;
		}
	}

	m_relativeBottomLevel = (m_bottomLevel > BOTTOM_LEVEL_UNKNOWN) ? m_waterLevel - m_bottomLevel : 0.0f;

	const float localHeadZ = player.GetLocalEyePos().z + 0.2f;
	const float worldHeadZ = playerWorldPos.z + localHeadZ;

	const bool headWasUnderWater = m_headUnderwater;
	m_headUnderwater = ((worldHeadZ - m_waterLevel) < 0.0f);

	m_headComingOutOfWater = headWasUnderWater && (!m_headUnderwater);

	if (m_internalState == eProxyInternalState_Swimming)
	{
		m_shouldSwim = ShouldSwim(max(localReferencePos.z, 1.3f));
	}
	else
	{
		UpdateSubmergedFraction(localReferencePos.z, playerWorldPos.z, m_waterLevel);

		m_shouldSwim = ShouldSwim(max(localReferencePos.z, 1.3f)) && (m_swimmingTimer < - 0.5f);
	}
#ifdef STATE_DEBUG
	DebugDraw(player, worldReferencePos);
#endif
}
예제 #4
0
void CBurnEffectManager::Update(float deltaTime)
{
	TBurnPoints::iterator it = m_burnPoints.begin();
	for (; it != m_burnPoints.end();)
	{
		SBurnPoint& burnPoint = *it;
		if (burnPoint.m_accumulationDelay > 0.0f)
			burnPoint.m_accumulationDelay -= deltaTime;
		else
			burnPoint.m_accumulation -= deltaTime * burnPoint.m_pBurnParams->m_dissipation;
		burnPoint.m_accumulation = SATURATE(burnPoint.m_accumulation);

		if (burnPoint.m_accumulation <= 0)
		{
			DestroyBurnEffect(&burnPoint);
			it = m_burnPoints.erase(it);
		}
		else
		{
			UpdateBurnEffect(&burnPoint);
			++it;
		}
	}

	ApplySurroundingDamage(deltaTime);

	if (g_pGameCVars->pl_mike_debug)
		DebugDraw();
}
예제 #5
0
파일: field.cpp 프로젝트: 001100/turbo-meme
void Field::FillField()
{
    for (int iii = 0; iii < g_HEIGHT; iii++)
    {
        for (int jjj = 0; jjj < g_WIDTH; jjj++)
        {
            //Corners drawing.
            if (iii == 0 && jjj == 0) {
                F(iii, jjj).SetTileChar("╔");
                F(iii, jjj).SetTilePassability(false);
                DebugDraw(iii, jjj);
                continue;
            }
            if (iii == 0 && jjj == g_WIDTH-1) {
                F(iii, jjj).SetTileChar("╗");
                F(iii, jjj).SetTilePassability(false);
                DebugDraw(iii, jjj);
                continue;
            }
            if (iii == g_HEIGHT-1 && jjj == 0) {
                F(iii, jjj).SetTileChar("╚");
                F(iii, jjj).SetTilePassability(false);
                DebugDraw(iii, jjj);
                continue;
            }
            if (iii == g_HEIGHT-1 && jjj == g_WIDTH-1) {
                F(iii, jjj).SetTileChar("╝");
                F(iii, jjj).SetTilePassability(false);
                DebugDraw(iii, jjj);
                continue;
            }
            //Horizontal pipes drawing.
            if ((iii == 0 || iii == g_HEIGHT-1) && (jjj > 0 && jjj < g_WIDTH-1)) {
                F(iii, jjj).SetTileChar("═");
                F(iii, jjj).SetTilePassability(false);
                DebugDraw(iii, jjj);
                continue;
            }
            //Vertical pipes drawing.
            if ((jjj == 0 || jjj == g_WIDTH-1) && (iii > 0 && iii < g_HEIGHT-1)) {
                F(iii, jjj).SetTileChar("║");
                F(iii, jjj).SetTilePassability(false);
                DebugDraw(iii, jjj);
                continue;
            }
            //All other floor tiles.
            F(iii, jjj).SetTileChar("+");
            F(iii, jjj).SetTilePassability(true);
        }
    }
    MakeLabyrinth();
}
예제 #6
0
void CAutoAimManager::Update(float dt)
{
	FUNCTION_PROFILER(GetISystem(), PROFILE_GAME);

	const int numAutoaimTargets = m_autoaimTargets.size();

	//Update the autoaim positions for the entities
	for(int i = 0; i < numAutoaimTargets; i++)
	{
		UpdateTargetInfo(m_autoaimTargets[i], dt);
	}

#if DEBUG_AUTOAIM_MANAGER
	if (g_autoAimManagerDebug)
	{
		DebugDraw();
	}
#endif
}
예제 #7
0
// Description:
//
// Arguments:
//
// Return:
//
bool CPersonalRangeSignaling::Update( float fElapsedTime, uint32 uDebugOrder )
{
  CRY_ASSERT( m_bInit == true );

  bool  bRet = false;

  if(m_bEnabled)
  {
    if( uDebugOrder > 0 )
    {
      DebugDraw( uDebugOrder );
    }

    // Iterate all actors and check range to them
    IActorIteratorPtr pActorIt = CCryAction::GetCryAction()->GetIActorSystem()->CreateActorIterator();
    while( IActor * pActor = pActorIt->Next() )
    {
      EntityId entityId = pActor->GetEntityId();
      if( entityId != GetEntityId() )
      {
        // Skip over if not enabled
        IAIObject const* pAIObject = GetEntityAI(entityId);
        if (!pAIObject || pAIObject->IsEnabled())
        {
          CheckActorRanges( pActor );
          CheckActorAngles( pActor );

		  // Do check on target ranges
		  MapTargetRanges::iterator itTargetRanges = m_mapTargetRanges.find(entityId);
		  if (itTargetRanges != m_mapTargetRanges.end())
		  {
		    CheckActorTargetRanges( pActor );
		  }
        }
      }
    }

    bRet = true;
  }

  return( bRet );
}
update_status ModuleCollision::Update()
{
	Collider* c1;
	Collider* c2;

	for (uint i = 0; i < MAX_COLLIDERS; ++i)
	{
		// skip empty colliders
		if (colliders[i] == nullptr)
			continue;

		c1 = colliders[i];

		// avoid checking collisions already checked
		for (uint k = i + 1; k < MAX_COLLIDERS; ++k)
		{
			// skip empty colliders
			if (colliders[k] == nullptr)
				continue;

			c2 = colliders[k];

			if (c1->CheckCollision(c2->rect) == true)
			{
				c1->Checkparticle(c1, c2);
				if (matrix[c1->type][c2->type] && c1->callback)
					c1->callback->OnCollision(c1, c2);

				if (matrix[c2->type][c1->type] && c2->callback)
					c2->callback->OnCollision(c2, c1);
			}
		}
	}

	DebugDraw();

	return UPDATE_CONTINUE;
}
예제 #9
0
// Description:
//
// Arguments:
//
// Return:
//
bool CPersonalSignalTimer::Update( float fElapsedTime, uint32 uDebugOrder )
{
  CRY_ASSERT( m_bInit == true );

  bool  bRet = true;
  if( m_bEnabled == true )
  {
    m_fTimer -= fElapsedTime;
    m_fTimerSinceLastReset += fElapsedTime;

    if( m_fTimer < 0.0f )
    {
      SendSignal();
      Reset();
    }
  }

  if( uDebugOrder > 0 )
  {
    DebugDraw( uDebugOrder );
  }

  return( bRet );
}
예제 #10
0
/*
================
idPhysics_RigidBody::Evaluate

  Evaluate the impulse based rigid body physics.
  When a collision occurs an impulse is applied at the moment of impact but
  the remaining time after the collision is ignored.
================
*/
bool idPhysics_RigidBody::Evaluate( int timeStepMSec, int endTimeMSec ) {
	rigidBodyPState_t next;
	idAngles angles;
	trace_t collision;
	idVec3 impulse;
	idEntity *ent;
	idVec3 oldOrigin, masterOrigin;
	idMat3 oldAxis, masterAxis;
	float timeStep;
	bool collided, cameToRest = false;

	timeStep = MS2SEC( timeStepMSec );
	current.lastTimeStep = timeStep;

	if ( hasMaster ) {
		oldOrigin = current.i.position;
		oldAxis = current.i.orientation;
		self->GetMasterPosition( masterOrigin, masterAxis );
		current.i.position = masterOrigin + current.localOrigin * masterAxis;
		if ( isOrientated ) {
			current.i.orientation = current.localAxis * masterAxis;
		}
		else {
			current.i.orientation = current.localAxis;
		}
		clipModel->Link( gameLocal.clip, self, clipModel->GetId(), current.i.position, current.i.orientation );
		current.i.linearMomentum = mass * ( ( current.i.position - oldOrigin ) / timeStep );
		current.i.angularMomentum = inertiaTensor * ( ( current.i.orientation * oldAxis.Transpose() ).ToAngularVelocity() / timeStep );
		current.externalForce.Zero();
		current.externalTorque.Zero();

		return ( current.i.position != oldOrigin || current.i.orientation != oldAxis );
	}

	// if the body is at rest
	if ( current.atRest >= 0 || timeStep <= 0.0f ) {
		DebugDraw();
		return false;
	}

	// if putting the body to rest
	if ( dropToFloor ) {
		DropToFloorAndRest();
		current.externalForce.Zero();
		current.externalTorque.Zero();
		return true;
	}

#ifdef RB_TIMINGS
	timer_total.Start();
#endif

	// move the rigid body velocity into the frame of a pusher
//	current.i.linearMomentum -= current.pushVelocity.SubVec3( 0 ) * mass;
//	current.i.angularMomentum -= current.pushVelocity.SubVec3( 1 ) * inertiaTensor;

	clipModel->Unlink();

	next = current;

	// calculate next position and orientation
	Integrate( timeStep, next );

#ifdef RB_TIMINGS
	timer_collision.Start();
#endif

	// check for collisions from the current to the next state
	collided = CheckForCollisions( timeStep, next, collision );

#ifdef RB_TIMINGS
	timer_collision.Stop();
#endif

	// set the new state
	current = next;

	if ( collided ) {
		// apply collision impulse
		if ( CollisionImpulse( collision, impulse ) ) {
			current.atRest = gameLocal.time;
		}
	}

	// update the position of the clip model
	clipModel->Link( gameLocal.clip, self, clipModel->GetId(), current.i.position, current.i.orientation );

	DebugDraw();

	if ( !noContact ) {

#ifdef RB_TIMINGS
		timer_collision.Start();
#endif
		// get contacts
		EvaluateContacts();

#ifdef RB_TIMINGS
		timer_collision.Stop();
#endif

		// check if the body has come to rest
		if ( TestIfAtRest() ) {
			// put to rest
			Rest();
			cameToRest = true;
		}  else {
			// apply contact friction
			ContactFriction( timeStep );
		}
	}

	if ( current.atRest < 0 ) {
		ActivateContactEntities();
	}

	if ( collided ) {
		// if the rigid body didn't come to rest or the other entity is not at rest
		ent = gameLocal.entities[collision.c.entityNum];
		if ( ent && ( !cameToRest || !ent->IsAtRest() ) ) {
			// apply impact to other entity
			ent->ApplyImpulse( self, collision.c.id, collision.c.point, -impulse );
		}
	}

	// move the rigid body velocity back into the world frame
//	current.i.linearMomentum += current.pushVelocity.SubVec3( 0 ) * mass;
//	current.i.angularMomentum += current.pushVelocity.SubVec3( 1 ) * inertiaTensor;
	current.pushVelocity.Zero();

	current.lastTimeStep = timeStep;
	current.externalForce.Zero();
	current.externalTorque.Zero();

	if ( IsOutsideWorld() ) {
		gameLocal.Warning( "rigid body moved outside world bounds for entity '%s' type '%s' at (%s)",
					self->name.c_str(), self->GetType()->classname, current.i.position.ToString(0) );
		Rest();
	}

#ifdef RB_TIMINGS
	timer_total.Stop();

	if ( rb_showTimings->integer == 1 ) {
		gameLocal.Printf( "%12s: t %u cd %u\n",
						self->name.c_str(),
						timer_total.Milliseconds(), timer_collision.Milliseconds() );
		lastTimerReset = 0;
	}
	else if ( rb_showTimings->integer == 2 ) {
		numRigidBodies++;
		if ( endTimeMSec > lastTimerReset ) {
			gameLocal.Printf( "rb %d: t %u cd %u\n",
							numRigidBodies,
							timer_total.Milliseconds(), timer_collision.Milliseconds() );
		}
	}
	if ( endTimeMSec > lastTimerReset ) {
		lastTimerReset = endTimeMSec;
		numRigidBodies = 0;
		timer_total.Clear();
		timer_collision.Clear();
	}
#endif

	return true;
}
예제 #11
0
/*
================
rvPhysics_Particle::Evaluate

  Evaluate the impulse based rigid body physics.
  When a collision occurs an impulse is applied at the moment of impact but
  the remaining time after the collision is ignored.
================
*/
bool rvPhysics_Particle::Evaluate( int timeStepMSec, int endTimeMSec ) {
	particlePState_t next;
	float			 timeStep;
	float			 upspeed;

	timeStep = MS2SEC( timeStepMSec );

	// if bound to a master
	if ( hasMaster ) {
		idVec3	masterOrigin;
		idMat3	masterAxis;
		idVec3	oldOrigin;		
		
		oldOrigin = current.origin;
		
		self->GetMasterPosition( masterOrigin, masterAxis );
		current.origin = masterOrigin + current.localOrigin * masterAxis;
// RAVEN BEGIN
// ddynerman: multiple clip worlds
		clipModel->Link( self, clipModel->GetId(), current.origin, current.localAxis * masterAxis );
// RAVEN END

		trace_t tr;
		gameLocal.Translation( self, tr, oldOrigin, current.origin, clipModel, clipModel->GetAxis(), clipMask, self );
		
		if ( tr.fraction < 1.0f ) {
			self->Collide ( tr, current.origin - oldOrigin );
		}
		
		DebugDraw();
		
		return true;
	}

	// if the body is at rest
	if ( current.atRest >= 0 || timeStep <= 0.0f ) {
		DebugDraw();
		return false;
	}

	// if putting the body to rest
	if ( dropToFloor ) {
		DropToFloorAndRest();
		return true;
	}

	clipModel->Unlink();

	// Determine if currently on the ground
	CheckGround ( );
	
	// Determine the current upward velocity
	if ( gravityNormal != vec3_zero ) {
		upspeed = -( current.velocity * gravityNormal );
	} else {
		upspeed = current.velocity.z;
	}

	// If not on the ground, or moving upwards, or bouncing and moving toward gravity then do a straight 
	// forward slide move and gravity.		
	if ( !current.onGround || upspeed > 1.0f || (bouncyness > 0.0f && upspeed < -PRT_BOUNCESTOP && !current.inWater) ) {
		// Force ground off when moving upward
		if ( upspeed > 0.0f ) {
			current.onGround = false;
		}
		SlideMove( current.origin, current.velocity, current.velocity * timeStep );		
		if ( current.onGround && upspeed < PRT_BOUNCESTOP ) {
			current.velocity -= ( current.velocity * gravityNormal ) * gravityNormal;
		} else {
			current.velocity += (gravityVector * timeStep);	
		}
	} else {
		idVec3 delta;

		// Slow down due to friction
		ApplyFriction ( timeStep );
	
		delta = current.velocity * timeStep;
		current.velocity -= ( current.velocity * gravityNormal ) * gravityNormal;
		if ( delta == vec3_origin ) {
			PutToRest( );
		} else {
			SlideMove( current.origin, current.velocity, delta );
		}
	}

	// update the position of the clip model
// RAVEN BEGIN
// ddynerman: multiple clip worlds
	clipModel->Link( self, clipModel->GetId(), current.origin, clipModel->GetAxis() );
// RAVEN END

	DebugDraw();

	// get all the ground contacts
	EvaluateContacts();

	current.pushVelocity.Zero();

	if ( IsOutsideWorld() ) {
		gameLocal.Warning( "clip model outside world bounds for entity '%s' at (%s)", self->name.c_str(), current.origin.ToString(0) );
		PutToRest();
	}

	return true;
}
예제 #12
0
/*
 * DebugDraw.cpp
 *
 *  Created on: 17.09.2012
 *      Author: nopper
 */

#include "../../UsedLibs.h"

#include "../../layer0/math/Matrix4x4.h"
#include "LineGeometry.h"
#include "LineGeometryManager.h"

#include "DebugDraw.h"

const DebugDraw DebugDraw::drawer = DebugDraw();

DebugDraw::DebugDraw()
{
}

DebugDraw::~DebugDraw()
{
}

void DebugDraw::draw(const Point4& start, const Point4& end, const Color& color) const
{
	if (!LineGeometryManager::getInstance()->getLineGeometry("SingleLine").get())
	{
		return;
	}
예제 #13
0
void CAICorpseManager::Update( const float frameTime )
{
	const uint32 maxCorpsesToUpdateThisFrame = 4;

	const float cullPhysicsDistanceSqr = g_pGameCVars->g_aiCorpses_CullPhysicsDistance * g_pGameCVars->g_aiCorpses_CullPhysicsDistance;
	const float forceDeleteDistanceSqr = g_pGameCVars->g_aiCorpses_ForceDeleteDistance * g_pGameCVars->g_aiCorpses_ForceDeleteDistance;

	if (m_lastUpdatedCorpseIdx >= (uint32)m_corpsesArray.size())
		m_lastUpdatedCorpseIdx = 0;

	const CCamera& viewCamera = gEnv->pSystem->GetViewCamera();

	CryFixedArray<EntityId, maxCorpsesToUpdateThisFrame> corpsesToDelete;
	const uint32 corpsesEndIdx = min(m_lastUpdatedCorpseIdx + maxCorpsesToUpdateThisFrame, (uint32)m_corpsesArray.size());

	for(uint32 i = m_lastUpdatedCorpseIdx; i < corpsesEndIdx; ++i)
	{
		CorpseInfo& corpseInfo = m_corpsesArray[i];

		IEntity* pCorpseEntity = corpseInfo.GetCorpseEntity();
		if(pCorpseEntity != NULL)
		{
			AABB corpseBbox;
			pCorpseEntity->GetWorldBounds(corpseBbox);
			corpseBbox.Expand(Vec3(0.1f, 0.1f, 0.1f));

			const Vec3 corpsePosition = corpseBbox.GetCenter();
			const float distanceSqr = (corpsePosition - viewCamera.GetPosition()).len2();

			const bool attemptDeleteFarAway = (distanceSqr > forceDeleteDistanceSqr);
			const bool cullPhysics = (distanceSqr > cullPhysicsDistanceSqr);
			const bool isVisible = viewCamera.IsAABBVisible_F(corpseBbox);
			
			corpseInfo.flags.SetFlags( CorpseInfo::eFlag_FarAway, attemptDeleteFarAway );
			
			if(attemptDeleteFarAway && !isVisible)
			{
				corpsesToDelete.push_back(corpseInfo.corpseId);
			}
			else if(cullPhysics != corpseInfo.flags.AreAllFlagsActive( CorpseInfo::eFlag_PhysicsDisabled ))
			{
				IEntityPhysicalProxy* pCorpsePhysicsProxy = static_cast<IEntityPhysicalProxy*>(pCorpseEntity->GetProxy( ENTITY_PROXY_PHYSICS ));
				if (pCorpsePhysicsProxy != NULL)
				{
					//Simulate entity event to enable/disable physics
					SEntityEvent visibilityEvent;
					visibilityEvent.event = cullPhysics ? ENTITY_EVENT_HIDE : ENTITY_EVENT_UNHIDE;
					pCorpsePhysicsProxy->ProcessEvent( visibilityEvent );
					
					if(cullPhysics == false)
					{
						IPhysicalEntity* pCorpsePhysics = pCorpseEntity->GetPhysics();
						if(pCorpsePhysics != NULL)
						{
							pe_action_awake awakeAction;
							awakeAction.bAwake = 0;
							pCorpsePhysics->Action( &awakeAction );
						}
					}
				}

				corpseInfo.flags.SetFlags( CorpseInfo::eFlag_PhysicsDisabled, cullPhysics );
			}
		}
		else
		{
			//This should not happen, but in case remove the entity from the list
			GameWarning("AICorpseManager - Detected corpse with no entity, removing from list");
			corpsesToDelete.push_back(corpseInfo.corpseId);
		}
	}

	m_lastUpdatedCorpseIdx = corpsesEndIdx;

	for(uint32 i = 0; i < (uint32)corpsesToDelete.size(); ++i)
	{
		RemoveCorpse(corpsesToDelete[i]);
	}

	DebugDraw();
}
예제 #14
0
파일: mihail.cpp 프로젝트: AdrianGin/ivan
int main(int argc, char** argv)
{
  if(argc == 3)
  {
    festring Arg = festring(argv[1]);

    if(Arg == "-l")
    {
      highscore Input(argv[2]);

      if(!Input.GetSize()) {
        std::cout << "No games. No winners.\n";
      }
      std::cout << std::endl;

      for(festring::sizetype c = 0; c < Input.GetSize(); ++c)
        std::cout << c + 1 << " " << Input.GetEntry(c).CStr() << " " << Input.GetScore(c) << "\n";

      return 0;
    } else if(Arg == "-h")
    {
      return OutputHTML(argv[2]);
    }
    else if(Arg == "-d")
    {
      if(!DebugDraw(argv[2]))
      {
        std::cout << "\nProblem showing version number\n";
        return 1;
      }
      return 0;
    }
    else
      return 1;
  }

  if(argc == 4)
  {
    highscore Input;
    Input.Load(argv[1]);

    if(!Input.CheckVersion())
    {
      std::cout << "Version check not ok with " << argv[1] << std::endl;
      return 2;
    }

    highscore Output;
    Output.Load(argv[2]);

    if(!Output.CheckVersion())
    {
      std::cout << "Version check not ok with " << argv[2] << std::endl;
      return 2;
    }
    if(!Input.MergeToFile(&Output))
      std::cout << "\n All entries also found in " << argv[2] << ". Oh well.\n";

    Output.Save(argv[3]);
    return 0;
  }

  std::cout << "\nTo list scores in highscore file:\n"
               "    mihail -l [filename]"
               "\n\nTo merge 2 files\n"
               "    mihail [1st input filename] [2nd input filename] [output filename]"
               "\n\nTo give version number of highscore file\n"
               "    mihail -d [filename]\n"
               "Notice that first filename in merges gives also version number\n";
  return 1;
}
예제 #15
0
//------------------------------------------------------------------------
void CViewSystem::Update(float frameTime)
{
	FUNCTION_PROFILER(GetISystem(), PROFILE_ACTION);

	if (gEnv->IsDedicated())
		return;

	CView* const __restrict pActiveView = static_cast<CView*>(GetActiveView());

	TViewMap::const_iterator       Iter(m_views.begin());
	TViewMap::const_iterator const IterEnd(m_views.end());

	for (; Iter != IterEnd; ++Iter)
	{
		CView* const __restrict pView = Iter->second;

		bool const bIsActive = (pView == pActiveView);

		pView->Update(frameTime, bIsActive);

		if (bIsActive)
		{
			CCamera &rCamera = pView->GetCamera();
			pView->UpdateAudioListener(rCamera.GetMatrix());
			SViewParams currentParams = *(pView->GetCurrentParams());

			rCamera.SetJustActivated(currentParams.justActivated);

			currentParams.justActivated = false;
			pView->SetCurrentParams(currentParams);

			if (m_bOverridenCameraRotation)
			{
				// When camera rotation is overridden.
				Vec3     pos = rCamera.GetMatrix().GetTranslation();
				Matrix34 camTM(m_overridenCameraRotation);
				camTM.SetTranslation(pos);
				rCamera.SetMatrix(camTM);
			}
			else
			{
				// Normal setting of the camera

				if (m_fCameraNoise > 0)
				{
					Matrix33 m = Matrix33(rCamera.GetMatrix());
					m.OrthonormalizeFast();
					Ang3 aAng1 = Ang3::GetAnglesXYZ(m);
					//Ang3 aAng2 = RAD2DEG(aAng1);

					Matrix34 camTM = rCamera.GetMatrix();
					Vec3     pos   = camTM.GetTranslation();
					camTM.SetIdentity();

					const float fScale = 0.1f;
					CPNoise3*   pNoise = m_pSystem->GetNoiseGen();
					float       fRes   = pNoise->Noise1D(gEnv->pTimer->GetCurrTime() * m_fCameraNoiseFrequency);
					aAng1.x += fRes * m_fCameraNoise * fScale;
					pos.z   -= fRes * m_fCameraNoise * fScale;
					fRes     = pNoise->Noise1D(17 + gEnv->pTimer->GetCurrTime() * m_fCameraNoiseFrequency);
					aAng1.y -= fRes * m_fCameraNoise * fScale;

					//aAng1.z+=fRes*0.025f; // left / right movement should be much less visible

					camTM.SetRotationXYZ(aAng1);
					camTM.SetTranslation(pos);
					rCamera.SetMatrix(camTM);
				}
			}

			m_pSystem->SetViewCamera(rCamera);
		}
	}

	// Display debug info on screen
	if (m_nViewSystemDebug)
	{
		DebugDraw();
	}

	// perform dynamic color grading
	// Beni - Commented for console demo stuff
	/******************************************************************************************
	   if (!IsPlayingCutScene() && gEnv->pAISystem)
	   {
	   SAIDetectionLevels detection;
	   gEnv->pAISystem->GetDetectionLevels(nullptr, detection);
	   float factor = detection.puppetThreat;

	   // marcok: magic numbers taken from Maciej's tweaked values (final - initial)
	   {
	    float percentage = (0.0851411f - 0.0509998f)/0.0509998f * factor;
	    float amount = 0.0f;
	    gEnv->p3DEngine->GetPostEffectParam("ColorGrading_GrainAmount", amount);
	    gEnv->p3DEngine->SetPostEffectParam("ColorGrading_GrainAmount_Offset", amount*percentage);
	   }
	   {
	    float percentage = (0.405521f - 0.256739f)/0.256739f * factor;
	    float amount = 0.0f;
	    gEnv->p3DEngine->GetPostEffectParam("ColorGrading_SharpenAmount", amount);
	    //gEnv->p3DEngine->SetPostEffectParam("ColorGrading_SharpenAmount_Offset", amount*percentage);
	   }
	   {
	    float percentage = (0.14f - 0.11f)/0.11f * factor;
	    float amount = 0.0f;
	    gEnv->p3DEngine->GetPostEffectParam("ColorGrading_PhotoFilterColorDensity", amount);
	    gEnv->p3DEngine->SetPostEffectParam("ColorGrading_PhotoFilterColorDensity_Offset", amount*percentage);
	   }
	   {
	    float percentage = (234.984f - 244.983f)/244.983f * factor;
	    float amount = 0.0f;
	    gEnv->p3DEngine->GetPostEffectParam("ColorGrading_maxInput", amount);
	    //gEnv->p3DEngine->SetPostEffectParam("ColorGrading_maxInput_Offset", amount*percentage);
	   }
	   {
	    float percentage = (239.984f - 247.209f)/247.209f * factor;
	    float amount = 0.0f;
	    gEnv->p3DEngine->GetPostEffectParam("ColorGrading_maxOutput", amount);
	    //gEnv->p3DEngine->SetPostEffectParam("ColorGrading_maxOutput_Offset", amount*percentage);
	   }
	   {
	    Vec4 dest(0.0f/255.0f, 22.0f/255.0f, 33.0f/255.0f, 1.0f);
	    Vec4 initial(2.0f/255.0f, 154.0f/255.0f, 226.0f/255.0f, 1.0f);
	    Vec4 percentage = (dest - initial)/initial * factor;
	    Vec4 amount;
	    gEnv->p3DEngine->GetPostEffectParamVec4("clr_ColorGrading_SelectiveColor", amount);
	    //gEnv->p3DEngine->SetPostEffectParamVec4("clr_ColorGrading_SelectiveColor_Offset", amount*percentage);
	   }
	   {
	    float percentage = (-5.0083 - -1.99999)/-1.99999 * factor;
	    float amount = 0.0f;
	    gEnv->p3DEngine->GetPostEffectParam("ColorGrading_SelectiveColorCyans", amount);
	    //gEnv->p3DEngine->SetPostEffectParam("ColorGrading_SelectiveColorCyans_Offset", amount*percentage);
	   }
	   {
	    float percentage = (10.0166 - -5.99999)/-5.99999 * factor;
	    float amount = 0.0f;
	    gEnv->p3DEngine->GetPostEffectParam("ColorGrading_SelectiveColorMagentas", amount);
	    //gEnv->p3DEngine->SetPostEffectParam("ColorGrading_SelectiveColorMagentas_Offset", amount*percentage);
	   }
	   {
	    float percentage = (10.0166 - 1.99999)/1.99999 * factor;
	    float amount = 0.0f;
	    gEnv->p3DEngine->GetPostEffectParam("ColorGrading_SelectiveColorYellows", amount);
	    //gEnv->p3DEngine->SetPostEffectParam("ColorGrading_SelectiveColorYellows_Offset", amount*percentage);
	   }
	   }
	 ********************************************************************************************/
}