예제 #1
0
//////////////////////////////////////////////////////////////////////////
// findDistanceByAttenuation
BcF32 ScnLightComponent::findDistanceByAttenuation( BcF32 Attenuation ) const
{
	// If we want it at a low value, return max distance.
	if( Attenuation < 0.05f )
	{
		Attenuation = 0.05f;
	}

	BcF32 A = AttnQ_;
	BcF32 B = AttnL_;
	BcF32 C = AttnC_ - ( 1.0f / Attenuation );

	// 0 = Ax2 + Bx + C
	if( A > 0.0f )
	{
		BcF32 Discriminant = ( ( B * B ) - ( 4.0f * A * C ) );
		if( Discriminant < 0.0f )
		{
			return 1e24f;
		}
		return BcAbs( ( -B + BcSqrt( Discriminant ) ) / ( 2.0f * A ) );
	}
	// 0 = Bx + C
	else if( B > 0.0f )
	{
		return BcAbs( -C / B );
	}
	// 0 = C
	else
	{
		return 1e24f;
	}
}
예제 #2
0
//////////////////////////////////////////////////////////////////////////
// buildNormals
void MdlMesh::buildNormals()
{
	for ( BcU32 i = 0; i < ( aIndices_.size() / 3 ); ++i )
	{
		BcU32 TA = aIndices_[ ( i * 3 ) + 0 ].iVertex_;
		BcU32 TB = aIndices_[ ( i * 3 ) + 1 ].iVertex_;
		BcU32 TC = aIndices_[ ( i * 3 ) + 2 ].iVertex_;

		MdlVertex& VertA = aVertices_[ TA ];
		MdlVertex& VertB = aVertices_[ TB ];
		MdlVertex& VertC = aVertices_[ TC ];

		BcVec3d VertPosA( VertA.Position_.x(), VertA.Position_.y(), VertA.Position_.z() );
		BcVec3d VertPosB( VertB.Position_.x(), VertB.Position_.y(), VertB.Position_.z() );
		BcVec3d VertPosC( VertC.Position_.x(), VertC.Position_.y(), VertC.Position_.z() );

		BcVec3d Normal = ( VertPosA - VertPosB ).cross( ( VertPosB - VertPosC ) );

		VertA.Normal_ += Normal;
		VertB.Normal_ += Normal;
		VertC.Normal_ += Normal;
	}

	for ( BcU32 i = 0; i < aVertices_.size(); ++i )
	{
		MdlVertex& Vert = aVertices_[ i ];
		Vert.bNormal_ = BcTrue;
		Vert.Normal_.normalise();

		BcReal Mag = Vert.Normal_.magnitude(); 
		BcAssert( BcAbs( Mag - 1.0f ) < 0.00001f );
	}
}
예제 #3
0
////////////////////////////////////////////////////////////////////////////////
// pointOnNode
BcBool MaBSPTree::pointOnNode( const MaVec3d& Point, MaBSPNode* pNode )
{
	// Check if point is coincident.
	if( pNode->Plane_.classify( Point, 1e-3f ) != MaPlane::bcPC_COINCIDING )
	{
		return BcFalse;
	}

	//
	if( pNode->Vertices_.size() == 2 )
	{
		// If we only have 2 verts, test we are on the defining line.
		MaVec3d Origin = pNode->Vertices_[ 0 ];
		MaVec3d Direction = pNode->Vertices_[ 1 ] - pNode->Vertices_[ 0 ];
		MaVec3d Vector = Point - Origin;
		BcF32 T = Direction.dot( Vector );

		// Check its on the line.
		return ( T >= 0.0f ) && ( T <= 1.0f );
	}
	else
	{
		BcS32 Sign = 0;
		for( BcU32 Idx = 0; Idx < pNode->Vertices_.size(); ++Idx )
		{
			const MaVec3d& PointA = pNode->Vertices_[ Idx ];
			const MaVec3d& PointB = pNode->Vertices_[ ( Idx + 1 ) % pNode->Vertices_.size() ];
			const MaVec3d AffineSegment = PointB - PointA;
			const MaVec3d AffinePoint = Point - PointA;
			BcF32 K = AffineSegment.dot( AffinePoint );
			BcS32 KSign = BcAbs( K ) > 1e-3f ? static_cast< BcS32 >( K / BcAbs( K ) ) : 0;
			if( Sign == 0 )
			{
				Sign = KSign;
			}
			else if( KSign != Sign )
			{
				return BcFalse;
			}
		}

		return BcTrue;
	}
}
예제 #4
0
////////////////////////////////////////////////////////////////////////////////
// Ctor
GaMatchmakingState::GaMatchmakingState()
{
	name( "GaMatchmakingState" );

	SocketFileDescriptor_ = 0;
	ClientID_ = BcErrorCode;
	RemoteHandshakeAddr_ = 0;
	RemoteHandshakePort_ = 0;
	LocalHandshakeAddr_ = 0;
	LocalHandshakePort_ = 0;
	//MappedHandshakeAddr_ = 0;
	//MappedHandshakePort_ = 0;
	LANHandshakeAddr_ = 0;
	LANHandshakePort_ = 0;

	HandshakeState_ = HSS_STUN;

	BcMemZero( &Callbacks_, sizeof( Callbacks_ ) );
	Callbacks_.event_connect = event_connect;
	Callbacks_.event_nick = event_nick;
	Callbacks_.event_nick = event_quit;
	Callbacks_.event_join = event_join;
	Callbacks_.event_part = event_part;
	Callbacks_.event_mode = event_mode;
	Callbacks_.event_umode = event_umode;
	Callbacks_.event_topic = event_topic;
	Callbacks_.event_kick = event_kick;
	Callbacks_.event_channel = event_channel;
	Callbacks_.event_privmsg = event_privmsg;
	Callbacks_.event_notice = event_notice;
	Callbacks_.event_channel_notice = event_channel_notice;
	Callbacks_.event_invite = event_invite;
	Callbacks_.event_ctcp_req = event_ctcp_req;
	Callbacks_.event_ctcp_rep = event_ctcp_rep;
	Callbacks_.event_ctcp_action = event_ctcp_action;
	Callbacks_.event_unknown = event_unknown;
	Callbacks_.event_numeric = event_numeric;
	Callbacks_.event_dcc_chat_req = event_dcc_chat_req;
	Callbacks_.event_dcc_send_req = event_dcc_send_req;

	ConnectTimer_ = 0.0f;
	InviteTimer_ = BcAbs( BcRandom::Global.randReal() ) * 5.0f + 5.0f;
	HandshakeTimer_ = 0.0f;

	pSession_ = NULL;

#if PLATFORM_WINDOWS
	BcRandom::Global = BcRandom( ::GetTickCount() );
#endif
}
예제 #5
0
//////////////////////////////////////////////////////////////////////////
// Ctor
GaGameUnit::GaGameUnit( GaGameSimulator* pSimulator, const GaGameUnitDescriptor& Desc, BcU32 TeamID, BcU32 ID, const BcFixedVec2d& Position ):
	pSimulator_( pSimulator ),
	Desc_( Desc ),
	TeamID_( TeamID ),
	ID_( ID ),
	Behaviour_( BEHAVIOUR_IDLE )
{
	CurrState_.Position_ = Position;
	PrevState_ = CurrState_;
	NextState_ = CurrState_;

	Health_ = Desc_.Health_;
	IsAttackMove_ = BcFalse;

	TargetUnitID_ = BcErrorCode;

	WalkTimer_ = ( BcAbs( BcRandom::Global.randReal() ) * Desc_.MoveSpeed_ ) * 0.2f;
}
예제 #6
0
////////////////////////////////////////////////////////////////////////////////
// update
eSysStateReturn GaMatchmakingState::main()
{
	BcScopedLock< BcMutex > Lock( Lock_ );
	BcReal Delta = SysKernel::pImpl()->getFrameTime();

	switch( HandshakeState_ )
	{
	case HSS_STUN:
		{
			// Only do once.
			if( MappedHandshakeAddr_ == 0 )
			{
				if( doSTUN() )
				{
					SysID_ = static_cast< BcU32 >( BcHash( (BcU8*)&MappedHandshakeAddr_, sizeof( MappedHandshakeAddr_ ) ) ); // Hash the mapped address to we don't broadcast it.
					if( MappedHandshakeAddr_ != 0 )
					{
						HandshakeState_ = HSS_IDLE;
					}
				}
				else
				{
					HandshakeState_ = HSS_STUN;
				}
			}
			else
			{
				HandshakeState_ = HSS_IDLE;
			}
		}
		break;
	case HSS_IDLE:
		{
			ConnectTimer_ -= Delta;

			if( ConnectTimer_ < 0.0f )
			{
				if( pSession_ == NULL )
				{
					pSession_ = irc_create_session( &Callbacks_ );
				}

				if( pSession_ != NULL && !irc_is_connected( pSession_ ) )
				{
					irc_set_ctx( pSession_, this );

					std::string Channel = "#testchannel";
					BcFile File;
					if( File.open( "config.json" ) )
					{
						char* pData = new char[ File.size() ];
						File.read( pData, File.size() );
						Json::Reader Reader;
		
						Json::Value Root;
						if( Reader.parse( pData, pData + File.size(), Root ) )
						{
							Channel = Root["channel"].asCString();
						}
						delete [] pData;
					}

					BcSPrintf( ScreenName_, "%s_%x", "PSY", BcRandom::Global.rand() );
					BcSPrintf( Channel_, Channel.c_str() );

					// Connect to the server.
					int RetVal = irc_connect( pSession_, "www.neilo.gd", 8000, NULL, ScreenName_, ScreenName_, ScreenName_ );

					if( RetVal == 0 )
					{
						// Start the thread to tick the client.
						BcThread::start( "EvtBridgeIRC" );

						ClientID_ = BcErrorCode;
						RemoteHandshakeAddr_ = 0;
						RemoteHandshakePort_ = 0;
						//LocalHandshakeAddr_ = 0;
						//LocalHandshakePort_ = 0;
						//MappedHandshakeAddr_ = 0;
						//MappedHandshakePort_ = 0;
						HandshakeState_ = HSS_WAIT_INVITE;
					}
					else
					{
						BcThread::join();

						irc_destroy_session( pSession_ );
						pSession_ = NULL;
					}
				}
			}
		}
		break;

	case HSS_WAIT_INVITE:
		{
			InviteTimer_ -= Delta;

			if( InviteTimer_ < 0.0f )
			{
				InviteTimer_ = BcAbs( BcRandom::Global.randReal() ) * 5.0f + 5.0f;

				// Send play with me message to channel.

				BcChar PlayBuffer[256];
				BcSPrintf( PlayBuffer, "REQ:%u", SysID_ );
				irc_cmd_msg( pSession_, Channel_, PlayBuffer );
			}
		}
		break;

	case HSS_WAIT_ADDR:
		{
			HandshakeTimer_ -= Delta;

			if( HandshakeTimer_ < 0.0f )
			{
				HandshakeState_ = HSS_WAIT_INVITE;
			}
		}
		break;

	case HSS_COMPLETE:
		{
			BcPrintf("GaMatchmakingState: Complete! ClientID of ours is %u\n", ClientID_);
			return sysSR_FINISHED;
		}
		break;
	}

	if( HandshakeState_ != HSS_STUN )
	{
		if( HandshakeState_ != HSS_IDLE && ( pSession_ == NULL || !irc_is_connected( pSession_ ) ) )
		{
			BcSleep( 0.1f );
			BcThread::join();
			BcSleep( 0.1f );
			if( pSession_ != NULL )
			{
				irc_destroy_session( pSession_ );
				pSession_ = NULL;
			}
			HandshakeState_ = HSS_IDLE;
			ConnectTimer_ = 10.0f;
		}
	}

	return sysSR_CONTINUE;
}
예제 #7
0
//////////////////////////////////////////////////////////////////////////
// tickState
void GaGameUnit::tickState( BcFixed Delta )
{
	PrevState_ = CurrState_;
	NextState_ = CurrState_;

	//if( NextState_.Velocity_.magnitudeSquared() > 0.0f )
	{
		NextState_.Position_ += NextState_.Velocity_ * Delta;

		if( Behaviour_ != BEHAVIOUR_DAMAGE )
		{
			// Check new state is valid.
			BcFixedVec2d Min( NextState_.Position_ - ( Desc_.Size_ * 0.9f ) );
			BcFixedVec2d Max( NextState_.Position_ + ( Desc_.Size_ * 0.9f ) );
			
			GaGameUnitIDList FoundUnits;
			
			pSimulator_->findUnits( FoundUnits, Min, Max, ID_, 0x3 );

			// Move unit away from it's nearest one.
			if( FoundUnits.size() != 0 )
			{
				BcU32 NearestUnit = pSimulator_->findNearestUnit( CurrState_.Position_, ID_, 0x3 );
				GaGameUnit* pGameUnit = pSimulator_->getUnit( NearestUnit );

				if( pGameUnit != NULL )
				{
					BcFixedVec2d Direction = ( CurrState_.Position_ - pGameUnit->CurrState_.Position_ ).normal();

					if( Direction.dot( NextState_.Velocity_.normal() ) > 0.0f || NextState_.Velocity_.magnitudeSquared() == 0.0f )
					{
						BcFixedVec2d RandomOffset( (int)( pSimulator_->rand() % 64 ), (int)( pSimulator_->rand() % 64 ) );
						NextState_ = CurrState_;
						NextState_.Velocity_ = NextState_.Velocity_ * 0.4f + ( Direction * Desc_.MoveSpeed_ ) * 0.6f;
						NextState_.Position_ += NextState_.Velocity_ * Delta + ( RandomOffset / 4096.0f );
					}
				}
				else
				{
					NextState_ = CurrState_;
				}
			}
		}
	}

	//
	WalkTimer_ -= NextState_.Velocity_.magnitude() * Delta;

	if( WalkTimer_ < 0.0f )
	{
		GaTopState::pImpl()->playSound( "Walk", getPosition() );
		WalkTimer_ += ( Desc_.MoveSpeed_ + (BcAbs( BcRandom::Global.randReal() ) * 0.02f ) ) * 0.2f;
	}

	// Clamp position and move away.
	BcFixed HW = ( 1280.0f * 0.5f ) / 32.0f - 1.0f;
	BcFixed HH = ( 720.0f * 0.5f ) / 32.0f - 1.0f;
	BcFixedVec2d ClampedPosition;
	ClampedPosition.x( BcClamp( NextState_.Position_.x(), -HW, HW ) );
	ClampedPosition.y( BcClamp( NextState_.Position_.y(), -HH, HH ) );
	if( NextState_.Position_ != ClampedPosition )
	{
		BcFixedVec2d RandomOffset( (int)( pSimulator_->rand() % 64 ), (int)( pSimulator_->rand() % 64 ) );
		NextState_.Velocity_ += RandomOffset / 4096.0f;
		NextState_.Position_ = ClampedPosition;
	}
}
예제 #8
0
파일: MdlMesh.cpp 프로젝트: Dezzles/Psybrus
//////////////////////////////////////////////////////////////////////////
// buildTangents
void MdlMesh::buildTangents()
{
	MaVec3d* pTan1 = new MaVec3d[ aVertices_.size() * 2 ];
	MaVec3d* pTan2 = pTan1 + aVertices_.size();

	memset( pTan1, 0, sizeof( MaVec3d ) * aVertices_.size() * 2 );

	for ( BcU32 i = 0; i < ( aIndices_.size() / 3 ); ++i )
	{
		BcU32 TA = aIndices_[ ( i * 3 ) + 0 ].iVertex_;
		BcU32 TB = aIndices_[ ( i * 3 ) + 1 ].iVertex_;
		BcU32 TC = aIndices_[ ( i * 3 ) + 2 ].iVertex_;

		MdlVertex& VertA = aVertices_[ TA ];
		MdlVertex& VertB = aVertices_[ TB ];
		MdlVertex& VertC = aVertices_[ TC ];

		MaVec3d VertPosA = VertA.Position_;
		MaVec3d VertPosB = VertB.Position_;
		MaVec3d VertPosC = VertC.Position_;

		MaVec2d VertUVA = VertA.UV_;
		MaVec2d VertUVB = VertB.UV_;
		MaVec2d VertUVC = VertC.UV_;

		BcF32 X1 = VertPosB.x() - VertPosA.x();
		BcF32 X2 = VertPosC.x() - VertPosA.x();
		BcF32 Y1 = VertPosB.y() - VertPosA.y();
		BcF32 Y2 = VertPosC.y() - VertPosA.y();
		BcF32 Z1 = VertPosB.z() - VertPosA.z();
		BcF32 Z2 = VertPosC.z() - VertPosA.z();

		BcF32 S1 = VertUVB.x() - VertUVA.x();
		BcF32 S2 = VertUVC.x() - VertUVA.x();
		BcF32 T1 = VertUVB.y() - VertUVA.y();
		BcF32 T2 = VertUVC.y() - VertUVA.y();

		BcF32 InvR = ( S1 * T2 - S2 * T1 );
		BcF32 R = 1.0f / InvR;

		// Validation so it doesn't break everything, just set to a dummy value.
		if( BcAbs( InvR ) < 1e-6f )
		{
			R = 0.0f;
		}

		MaVec3d SDir( ( T2 * X1 - T1 * X2 ) * R, ( T2 * Y1 - T1 * Y2 ) * R, ( T2 * Z1 - T1 * Z2 ) * R );
		MaVec3d TDir( ( S1 * X2 - S2 * X1 ) * R, ( S1 * Y2 - S2 * Y1 ) * R, ( S1 * Z2 - S2 * Z1 ) * R );

		pTan1[ TA ] += SDir;
		pTan1[ TB ] += SDir;
		pTan1[ TC ] += SDir;

		pTan2[ TA ] += TDir;
		pTan2[ TB ] += TDir;
		pTan2[ TC ] += TDir;
	}

	for ( BcU32 i = 0; i < aVertices_.size(); ++i )
	{
		MdlVertex& Vert = aVertices_[ i ];
		MaVec3d Tangent;

		const MaVec3d N = Vert.Normal_;
		const MaVec3d& T = pTan1[ i ];

		Tangent = ( T - N * N.dot( T ) );
		Tangent.normalise();

		// Calculate handedness
		BcF32 W = ( N.cross( T ).dot( pTan2[ i ] ) < 0.0f ) ? -1.0f : 1.0f;

		if ( W < 0.0f )
		{
			Tangent = -Tangent;
		}

		Vert.bTangent_ = BcTrue;
		Vert.Tangent_ = Tangent;

		// Validate, and create a dummy value.
		BcF32 Mag = Tangent.magnitude(); 
		if( BcAbs( Mag - 1.0f ) > 0.0001f )
		{
			Vert.Tangent_.set( 0.0f, 0.0f, 0.0f );
		}
	}

	delete[] pTan1;
}
예제 #9
0
//////////////////////////////////////////////////////////////////////////
// initialise
void GaGameComponent::initialise( BcU32 TeamID,  BcBool Networked )
{
	Super::initialise();

	if( TeamID == BcErrorCode )
	{
		TeamID = 0;
	}

	MouseDown_ = BcFalse;
	BoxSelection_ = BcFalse;
	CtrlDown_ = BcFalse; 
	AttackMove_ = BcFalse;
	TeamID_ = TeamID;
	Networked_ = Networked;
	GameState_ = GS_PLAYING;

	// Randomly decide for some variation.
	AITickTime_ = 0.0f;
	AITickMaxTime_ = BcAbs( BcRandom::Global.randReal() * 0.4f ) + 0.1f;

	// Setup control groups.
	for( BcU32 Idx = 0; Idx < 10; ++Idx )
	{
		ControlGroups_.push_back( GaGameUnitIDList() );
	}

	pSimulator_ = new GaGameSimulator( 1.0f / 15.0f, 1.0f, TeamID, Networked );

	pSimulator_->addUnit( GGameUnit_Trebuchet, 0, BcFixedVec2d( -19.0f,  0.0f ) );

	pSimulator_->addUnit( GGameUnit_Archer, 0, BcFixedVec2d( -17.0f, -2.0f  ) );
	pSimulator_->addUnit( GGameUnit_Archer, 0, BcFixedVec2d( -17.0f, -1.0f  ) );
	pSimulator_->addUnit( GGameUnit_Archer, 0, BcFixedVec2d( -17.0f,  0.0f  ) );
	pSimulator_->addUnit( GGameUnit_Archer, 0, BcFixedVec2d( -17.0f,  1.0f  ) );
	pSimulator_->addUnit( GGameUnit_Archer, 0, BcFixedVec2d( -17.0f,  2.0f  ) );

	pSimulator_->addUnit( GGameUnit_Soldier, 0, BcFixedVec2d( -15.0f, -2.0f  ) );
	pSimulator_->addUnit( GGameUnit_Soldier, 0, BcFixedVec2d( -15.0f, -1.0f  ) );
	pSimulator_->addUnit( GGameUnit_Soldier, 0, BcFixedVec2d( -15.0f,  0.0f  ) );
	pSimulator_->addUnit( GGameUnit_Soldier, 0, BcFixedVec2d( -15.0f,  1.0f  ) );
	pSimulator_->addUnit( GGameUnit_Soldier, 0, BcFixedVec2d( -15.0f,  2.0f  ) );

	pSimulator_->addUnit( GGameUnit_Soldier, 0, BcFixedVec2d( -14.0f, -2.0f  ) );
	pSimulator_->addUnit( GGameUnit_Soldier, 0, BcFixedVec2d( -14.0f, -1.0f  ) );
	pSimulator_->addUnit( GGameUnit_Soldier, 0, BcFixedVec2d( -14.0f,  0.0f  ) );
	pSimulator_->addUnit( GGameUnit_Soldier, 0, BcFixedVec2d( -14.0f,  1.0f  ) );
	pSimulator_->addUnit( GGameUnit_Soldier, 0, BcFixedVec2d( -14.0f,  2.0f  ) );

	pSimulator_->addUnit( GGameUnit_Trebuchet, 1, BcFixedVec2d(  19.0f,  0.0f ) );
	
	pSimulator_->addUnit( GGameUnit_Archer, 1, BcFixedVec2d(  17.0f, -2.0f  ) );
	pSimulator_->addUnit( GGameUnit_Archer, 1, BcFixedVec2d(  17.0f, -1.0f  ) );
	pSimulator_->addUnit( GGameUnit_Archer, 1, BcFixedVec2d(  17.0f,  0.0f  ) );
	pSimulator_->addUnit( GGameUnit_Archer, 1, BcFixedVec2d(  17.0f,  1.0f  ) );
	pSimulator_->addUnit( GGameUnit_Archer, 1, BcFixedVec2d(  17.0f,  2.0f  ) );

	pSimulator_->addUnit( GGameUnit_Soldier, 1, BcFixedVec2d(  15.0f, -2.0f  ) );
	pSimulator_->addUnit( GGameUnit_Soldier, 1, BcFixedVec2d(  15.0f, -1.0f  ) );
	pSimulator_->addUnit( GGameUnit_Soldier, 1, BcFixedVec2d(  15.0f,  0.0f  ) );
	pSimulator_->addUnit( GGameUnit_Soldier, 1, BcFixedVec2d(  15.0f,  1.0f  ) );
	pSimulator_->addUnit( GGameUnit_Soldier, 1, BcFixedVec2d(  15.0f,  2.0f  ) );

	pSimulator_->addUnit( GGameUnit_Soldier, 1, BcFixedVec2d(  14.0f, -2.0f  ) );
	pSimulator_->addUnit( GGameUnit_Soldier, 1, BcFixedVec2d(  14.0f, -1.0f  ) );
	pSimulator_->addUnit( GGameUnit_Soldier, 1, BcFixedVec2d(  14.0f,  0.0f  ) );
	pSimulator_->addUnit( GGameUnit_Soldier, 1, BcFixedVec2d(  14.0f,  1.0f  ) );
	pSimulator_->addUnit( GGameUnit_Soldier, 1, BcFixedVec2d(  14.0f,  2.0f  ) );
}