netserver_clients.cpp File Reference

#include "networking/netserver.h"
#include "networking/zonemgr.h"
#include "networking/lowlevel/vsnet_debug.h"
#include "networking/lowlevel/netbuffer.h"
#include "universe_util.h"
#include "universe_generic.h"
#include "cmd/unit_factory.h"
#include "networking/savenet_util.h"
#include "networking/prediction.h"
#include "networking/lowlevel/vsnet_sockethttp.h"
#include "lin_time.h"
#include "vs_random.h"
#include "save_util.h"

Go to the source code of this file.

Functions
StarSystem *	GetLoadedStarSystem (const char *system)
void	displayUnitInfo (Unit *un, const string callsign, const char *type)
Quaternion	MinRotationFromDirections (Vector start, Vector finish, double &theta)
Vector	ApplyQuaternion (const Quaternion &quat, Vector input)
ClientState	aim_assist (ClientState cs, ClientState ocs, QVector realtargetpos, Vector realtargetvel, Vector targetpos, Vector targetvel)
ClientState	aim_assist (ClientState cs, ClientState ocs, Unit *target, Vector targetpos, Vector targetvel)
ClientState	aim_assist_debug (float x, float y, float z, float vx, float vy, float vz, float rx, float ry, float rz, float vrx, float vry, float vrz, float forex, float forey, float forez)
void	AddWriteSave (std::string &netbuf, int cpnum)
void	AcctLogout (VsnetHTTPSocket *acct_sock, ClientPtr clt)

Function Documentation

void AcctLogout	(	VsnetHTTPSocket *	acct_sock,
		ClientPtr	clt
	)

Definition at line 619 of file netserver_clients.cpp.

References _Universe, ACCT_LOGOUT, ACCT_SAVE_LOGOUT, addSimpleChar(), addSimpleString(), AddWriteSave(), COUT, Client::INGAME, VsnetHTTPSocket::sendstr(), and Universe::whichPlayerStarship().

{
    if (acct_sock == NULL) return;
    if (clt) {
        std::string netbuf;

        Unit    *un     = clt->game_unit.GetUnit();
        int      cpnum  = _Universe->whichPlayerStarship( un );
        bool     dosave = false;
        if (clt->loginstate < Client::INGAME)
            dosave = false;
        addSimpleChar( netbuf, dosave ? ACCT_SAVE_LOGOUT : ACCT_LOGOUT );
        addSimpleString( netbuf, clt->callsign );
        addSimpleString( netbuf, clt->passwd );
        if (dosave)
            AddWriteSave( netbuf, cpnum );
        if ( !acct_sock->sendstr( netbuf ) )
            COUT<<"ERROR sending LOGOUT to account server"<<endl;
    }
}

void AddWriteSave	(	std::string &	netbuf,
		int	cpnum
	)

Definition at line 611 of file netserver_clients.cpp.

References addSimpleString(), and SaveNetUtil::GetSaveStrings().

Referenced by AcctLogout().

{
    string savestr, xmlstr;
    SaveNetUtil::GetSaveStrings( cpnum, savestr, xmlstr, true );
    addSimpleString( netbuf, savestr );
    addSimpleString( netbuf, xmlstr );
}

ClientState aim_assist	(	ClientState	cs,
		ClientState	ocs,
		QVector	realtargetpos,
		Vector	realtargetvel,
		Vector	targetpos,
		Vector	targetvel
	)

Definition at line 343 of file netserver_clients.cpp.

References ApplyQuaternion(), UniverseUtil::cos(), FINITE, fprintf, Quaternion::from_vectors(), ClientState::getAngularVelocity(), ClientState::getOrientation(), ClientState::getPosition(), Matrix::getQ(), Matrix::getR(), VegaConfig::getVariable(), ClientState::getVelocity(), M_PI, MinRotationFromDirections(), XMLSupport::parse_bool(), XMLSupport::parse_float(), Quaternion::s, ClientState::setAngularVelocity(), ClientState::setOrientation(), Quaternion::to_matrix(), Quaternion::v, Vector, and vs_config.

Referenced by aim_assist(), aim_assist_debug(), and NetClient::sendPosition().

{
    float  t = 0;
    static bool debug_predict = XMLSupport::parse_bool( vs_config->getVariable( "network", "debug_prediction", "false" ) );
    double velaimtheta = 0;
    double orientaimtheta     = 0;
    Matrix trans;
    ClientState OrientationAim( cs );
    ClientState VelocityAim( cs );
    bool   VelocityAimValid    = false;
    bool   OrientationAimValid = false;
    cs.getOrientation().to_matrix( trans );
    Vector dir = trans.getR();
    targetvel     = targetvel-cs.getVelocity();
    realtargetvel = realtargetvel-cs.getVelocity();
    Vector targetperp = targetpos.Cross( targetvel );
    realtargetpos = ( realtargetpos-cs.getPosition() );
    Vector realtargetperp      = realtargetpos.Cast().Cross( realtargetvel );
    Vector targetdir  = targetpos;
    targetdir.Normalize();
    float  targetperpmag = targetperp.Magnitude();
    float  realtargetperpmag   = realtargetperp.Magnitude();
    static float cos_min_angle =
        cos( M_PI*(1./180)*XMLSupport::parse_float( vs_config->getVariable( "network", "max_lead_prediction_angle", "60" ) ) );                    //120 degree leeway for using this method
    if (targetperpmag > .001 && realtargetperpmag > .001 && targetvel.MagnitudeSquared() > .25
        && realtargetvel.MagnitudeSquared() > .25 && dir.Dot( targetdir ) >= cos_min_angle) {
        //gotta make sure target is at least in viewscreen before giving benefit of the doubt lead
        targetperp     = targetperp*(1./targetperpmag);
        realtargetperp = realtargetperp*(1./realtargetperpmag);           //compute a unit direction perpendicular to the plane made by the target and its relative velocity (to playerstarship)... we'll use this to see how far off that plane the velocity actually is
        float  distoffplane = targetperp.Dot( dir );
        Vector dirperp = targetperp.Scale( distoffplane );
        Vector dirplane     = dir-dirperp;         //this is the projection of the player's orientation direction onto the plane if the target and its velocity... if he were aligned with the arc of travel of the target he would Dot(targetperp,dir) would be zero and this wouldn't change the dir
        //now we have to figure out how far out the intersection point of dirplane and targetvel are...
        //solve for t and k    reltargetpos+targetvel*t=k*dirplane
        float  posx = targetpos.i;
        float  posy = targetpos.j;
        float  dirx = dirplane.i;
        float  diry = dirplane.j;
        float  velx = targetvel.i;
        float  vely = targetvel.j;
        if ( fabs( dirplane.i ) <= fabs( dirplane.j ) && fabs( dirplane.i ) <= fabs( dirplane.k ) ) {
            posx = targetpos.k;
            posy = targetpos.j;
            dirx = dirplane.k;
            diry = dirplane.j;
            velx = targetvel.k;
            vely = targetvel.j;
        }
        if ( fabs( dirplane.j ) <= fabs( dirplane.i ) && fabs( dirplane.j ) <= fabs( dirplane.k ) ) {
            posx = targetpos.i;
            posy = targetpos.k;
            dirx = dirplane.i;
            diry = dirplane.k;
            velx = targetvel.i;
            vely = targetvel.k;
        }
        if ( fabs( diry ) > fabs( dirx ) ) {
            float tmp = posx;
            posx = posy;
            posy = tmp;
            tmp  = dirx;
            dirx = diry;
            diry = tmp;
            tmp  = velx;
            velx = vely;
            vely = tmp;
        }
        {
            float num   = diry*posx/dirx-posy;
            float denom = vely-diry*velx/dirx;
            if (fabs( denom ) < .0001)
                t = 0;
            else
                t = num/denom;
            //if (t<=0) t=0;
        }
        static float velaimlim = XMLSupport::parse_float( vs_config->getVariable( "network", "max_lead_prediction", "10" ) );
        if (fabs( t ) < velaimlim) {
            Vector newdirplane = realtargetpos+realtargetvel*t;
            Vector newdirperp  = realtargetperp.Scale( distoffplane );
            newdirplane.Normalize();
            newdirplane *= dirplane.Magnitude();
            Vector newdir = newdirplane+newdirperp;
            newdir.Normalize();
            Vector newright, newup;
            CrossProduct( trans.getQ(), newdir, newright );
            CrossProduct( newdir, newright, newup );
            newright.Normalize();
            newup.Normalize();
            Quaternion forient = Quaternion::from_vectors( newright, newup, newdir );
            Vector     fvel    = ApplyQuaternion( MinRotationFromDirections( dir, newdir, velaimtheta ), cs.getAngularVelocity() );
            VelocityAimValid = FINITE( fvel.i ) && FINITE( fvel.j ) && FINITE( fvel.k ) && FINITE( forient.s ) && FINITE(
                forient.v.i ) && FINITE( forient.v.j ) && FINITE( forient.v.k );
            VelocityAim.setAngularVelocity( fvel );
            VelocityAim.setOrientation( forient );
        }
    }
    {
        //some other scheme for when target is still...
        targetpos.Normalize();
        realtargetpos.Normalize();
        Quaternion quat    = MinRotationFromDirections( targetpos, realtargetpos, orientaimtheta );
        Quaternion forient = cs.getOrientation()*quat;
        Vector     fvel    = ApplyQuaternion( quat, cs.getAngularVelocity() );

        OrientationAimValid = FINITE( fvel.i ) && FINITE( fvel.j ) && FINITE( fvel.k ) && FINITE( forient.s ) && FINITE(
            forient.v.i ) && FINITE( forient.v.j ) && FINITE( forient.v.k );
        OrientationAim.setOrientation( forient );
        OrientationAim.setAngularVelocity( fvel );
    }
    if (VelocityAimValid) {
        if (debug_predict)
            printf( "Velocity aim lead %f, rot %f deg\n", t, velaimtheta*180/M_PI );
        return VelocityAim;
    }
    if (OrientationAimValid) {
        if (debug_predict)
            printf( "Using orientation aim rot %f deg\n", orientaimtheta*180/M_PI );
        return OrientationAim;
    }
    fprintf( stderr, "Got non-finite result for aim_assist (client sent bad info?)\n" );
    return cs;
}

ClientState aim_assist	(	ClientState	cs,
		ClientState	ocs,
		Unit *	target,
		Vector	targetpos,
		Vector	targetvel
	)

Definition at line 472 of file netserver_clients.cpp.

References aim_assist(), Unit::Position(), and Unit::Velocity.

{
    return aim_assist( cs, ocs, target->Position(), target->Velocity, targetpos, targetvel );
}

ClientState aim_assist_debug	(	float	x,
		float	y,
		float	z,
		float	vx,
		float	vy,
		float	vz,
		float	rx,
		float	ry,
		float	rz,
		float	vrx,
		float	vry,
		float	vrz,
		float	forex,
		float	forey,
		float	forez
	)

Definition at line 477 of file netserver_clients.cpp.

References aim_assist(), Quaternion::from_vectors(), ClientState::getOrientation(), Matrix::getQ(), Matrix::getR(), QVector, Quaternion::to_matrix(), up, and Vector.

{
    Vector fore( forex, forey, forez );
    fore.Normalize();
    Vector up( 0, 1, 0 );
    if (fore.j > .9)
        up = Vector( 0, 0, 1 );
    Vector right;
    CrossProduct( up, fore, right );
    CrossProduct( fore, right, up );
    right.Normalize();
    up.Normalize();
    fore.Normalize();
    ClientState tmp( 1, QVector( 0, 0, 0 ), Quaternion::from_vectors( right, up, fore ), Vector( 0, 0, 0 ), Vector( 0,
                                                                                                                    0,
                                                                                                                    0 ), Vector(
                        0,
                        1,
                        0 ) );
    tmp = aim_assist( tmp, tmp, QVector( rx, ry, rz ), Vector( vrx, vry, vrz ), Vector( x, y, z ), Vector( vx, vy, vz ) );
    Matrix mat;
    tmp.getOrientation().to_matrix( mat );
    printf( "Final Direction %.3f %.3f %.3f (Up %.2f %.2f %.2f)\n", mat.getR().i, mat.getR().j, mat.getR().k,
            mat.getQ().i, mat.getQ().j, mat.getQ().k );
    return tmp;
}

Vector ApplyQuaternion	(	const Quaternion &	quat,
		Vector	input
	)

Definition at line 331 of file netserver_clients.cpp.

References Quaternion::to_matrix(), and TransformNormal().

Referenced by aim_assist().

{
    Matrix tmp;
    quat.to_matrix( tmp );
    return TransformNormal( tmp, input );
}

void displayUnitInfo	(	Unit *	un,
		const string	callsign,
		const char *	type
	)

Definition at line 46 of file zonemgr.cpp.

Referenced by ZoneMgr::addClient(), ZoneInfo::display(), ZoneMgr::displayNPCs(), ZoneMgr::removeClient(), NetServer::sendKill(), and NetServer::sendNewUnitQueue().

{
    cout<<type;
    if (!un) {
        cout<<"\'"<<callsign<<"\' (dead)"<<endl;
    } else {
        {
            char tmp[10];
            sprintf( tmp, "% 5d ", un->GetSerial() );
            cout<<tmp;
        }
        cout<<UnitUtil::getFactionName( un )<<" "<<un->getFullname()<<" ("<<un->name<<")";
        Flightgroup *fg = un->getFlightgroup();
        if (fg) cout<<", \'"<<fg->name<<"\' "<<un->getFgSubnumber();
        if ( !callsign.empty() && (!fg || callsign != fg->name) )
            cout<<", callsign \'"<<callsign<<"\'";
        cout<<endl;
    }
}

StarSystem* GetLoadedStarSystem

(

const char *

system)

Definition at line 786 of file star_system_generic.cpp.

Referenced by ZoneMgr::addZone(), GameUniverse::GenerateStarSystem(), and Universe::GenerateStarSystem().

{
    StarSystem *ss = star_system_table.Get( string( system ) );
    std::string ssys( string( system )+string( ".system" ) );
    if (!ss)
        ss = star_system_table.Get( ssys );
    return ss;
}

Quaternion MinRotationFromDirections	(	Vector	start,
		Vector	finish,
		double &	theta
	)

Definition at line 314 of file netserver_clients.cpp.

References UniverseUtil::asin(), UniverseUtil::cos(), e, float, identity_quaternion(), M_PI, UniverseUtil::sin(), and Vector.

Referenced by aim_assist().

{
    Vector rotation = finish.Cross( start );
    double mag = rotation.Cast().Magnitude();
    if (mag >= 1)
        mag = 1;
    if (mag < 1e-6) {
        theta = 0;
        return identity_quaternion;
    }
    theta    = asin( mag );
    if (start.Dot( finish ) < 0) theta += M_PI/2;
    float s = (float) cos( theta*.5 );
    rotation = rotation.Scale( 1./mag );
    return Quaternion( s, rotation*sin( theta*.5 ) );
}