VadaVaka - Programming

Universal Mouse Movement Transformer (Natural Acceleration)

Thu, 21 Apr 2022 17:18:05 +0000

MOUSE_DIMENSION.h

Code:
#pragma once

#define MOUSE_PI 3.14159265358979323846264338327950f

class MOUSE_DIMENSION

{

private:

    unsigned long long m_CALLS_PER_INSTANCE;

    unsigned long long m_INSTANCES_PER_LOSS;

    long long m_TOTAL_ANGLE;

    //TODO: Change to double

    //unsigned long long m_INFLATION_FACTOR;

    double m_INFLATION_FACTOR;

    float m_RESOLUTION;

    float m_FOV;

    float m_SENSITIVITY;

    float m_CIRCUMFERENCE;

    float m_RADIUS;

    float RESOLUTION_AND_FOV_TO_RADIUS(float RESOLUTION, float FOV);

public:

    MOUSE_DIMENSION(float RESOLUTION, float FOV, float SENSITIVITY, unsigned long long CALLS_PER_INSTANCE, unsigned long long INSTANCES_PER_LOSS, int MAXIMUM_SENSITIVITY, int STATIC_SENSITIVITY_INCREMENT_SIZE);

    void UPDATE_RESOLUTION(float RESOLUTION);

    void UPDATE_FOV(float FOV);

    void UPDATE_SENSITIVITY(float SENSITIVITY);

    long INPUT(float INPUT);

};

MOUSE_DIMENSION.cpp

Code:
#include "MOUSE_DIMENSION.h"

float MOUSE_DIMENSION::RESOLUTION_AND_FOV_TO_RADIUS(float RESOLUTION, float FOV)

{

    //TODO: return RADIUS from FOV in PIXELS instead of DEGREES

    return (RESOLUTION / sin(MOUSE_PI / (360 / FOV))) / 2;

}

MOUSE_DIMENSION::MOUSE_DIMENSION(float RESOLUTION = 800, float FOV = 90, float SENSITIVITY = 1, unsigned long long CALLS_PER_INSTANCE = 1, unsigned long long INSTANCES_PER_LOSS = 360000, int MAXIMUM_SENSITIVTY = 10, int INCREMENTS_PER_UNIT_OF_SENSITIVITY = 5)

{

    this->m_RESOLUTION = RESOLUTION;

    this->m_RADIUS = this->RESOLUTION_AND_FOV_TO_RADIUS(RESOLUTION, FOV);

    this->m_CIRCUMFERENCE = this->m_RADIUS * MOUSE_PI * 2;

    this->m_FOV = FOV;

    this->m_SENSITIVITY = SENSITIVITY;

    this->m_CALLS_PER_INSTANCE = CALLS_PER_INSTANCE;

    this->m_INSTANCES_PER_LOSS = INSTANCES_PER_LOSS;

    // this accounts for maximum transduced input of PI radians (THE RESULT OF TRANSDUCTION IS ALWAYS BETWEEN -PI AND PI RADIANS)

    this->m_INFLATION_FACTOR = m_CALLS_PER_INSTANCE * m_INSTANCES_PER_LOSS * (MOUSE_PI * 1);

    this->m_TOTAL_ANGLE = 0;

}

void MOUSE_DIMENSION::UPDATE_RESOLUTION(float RESOLUTION)

{

    m_TOTAL_ANGLE = (m_TOTAL_ANGLE / (m_RESOLUTION / (m_RESOLUTION = RESOLUTION)));

    m_RADIUS = this->RESOLUTION_AND_FOV_TO_RADIUS(RESOLUTION, this->m_FOV);

    m_CIRCUMFERENCE = m_RADIUS * MOUSE_PI * 2;

}

void MOUSE_DIMENSION::UPDATE_FOV(float FOV)

{

    m_RADIUS = this->RESOLUTION_AND_FOV_TO_RADIUS(m_RESOLUTION, m_FOV);

    m_CIRCUMFERENCE = m_RADIUS * MOUSE_PI * 2;

    //TODO: UPDATE CIRCUMFERENCE, INFLATION_FACTOR, and TOTAL_ANGLE

}

void MOUSE_DIMENSION::UPDATE_SENSITIVITY(float SENSITIVITY)

{

    this->m_SENSITIVITY = SENSITIVITY;

}

float ABSN(float INPUT)

{

    return sqrt(INPUT * INPUT);

}

float ATANN(float INPUT) 

{

    return INPUT / ABSN(INPUT);

}

inline float MODULO(float x, float y)

{

    return fmod(x, y);

}

inline float INTEGERIZE(float input)

{

    return input - MODULO(input, 1);

}

inline float CLAMP(float rotations_in_n_units, float half_n_unit)

{

    return MODULO(INTEGERIZE(rotations_in_n_units / half_n_unit), 2) * -1 * half_n_unit + MODULO(rotations_in_n_units, half_n_unit);

}

float TRANSDUCE(float INPUT, float SENSITIVITY) 

{

    return ATANN(INPUT) * 2 * asinf(ABSN(CLAMP(INPUT * SENSITIVITY, 2)) / 2);

}

float FORMAT_INPUT(float INPUT, float SENSITIVITY)

{

    return TRANSDUCE(INPUT, SENSITIVITY);

}

long MOUSE_DIMENSION::INPUT(float INPUT)

{

    long TOTAL_ANGLE = this->m_TOTAL_ANGLE;

    m_TOTAL_ANGLE = static_cast(fmod(m_TOTAL_ANGLE + (FORMAT_INPUT(INPUT, this->m_SENSITIVITY) * this->m_RADIUS * this->m_INFLATION_FACTOR ),m_CIRCUMFERENCE * m_INFLATION_FACTOR));

    std::cout << "m_RESOLUTION: " << m_RESOLUTION << ", m_INFLATION_FACTOR: " << m_INFLATION_FACTOR << ", NEW_TOTAL: " << TOTAL_ANGLE << "\n";

    return static_cast(TOTAL_ANGLE / m_INFLATION_FACTOR);

}

An Idea of Mine

Wed, 16 Jan 2008 21:54:43 +0000

I was thinking about finding a way for ricochet bots to shoot something other than simple targets, and I thought, "why not just have the bot develop its own method?" But, instead of trying to learn how to use a neural net, or other complicated arrangement, why not use an option that's been proven effective over 3.7 billion years?

I am of course referring to evolution. If the bot has dynamic AI code, and is subject to selection pressures, it will eventually become well-suited to those pressures, and thus a smarter, tougher bot is born--provided you specify the right pressures.

Right now I'm just trying to come up with rough methods to achieve the key effects: Mutation, selection, inheritability, and how not to crash the game while doing it.

Any interest?

Ricochet HLTV Support

Sun, 16 Sep 2007 22:18:56 +0000

This code will prevent an HLTV Proxy from being entered into matches while on arena (it already worked in deathmatch):

In disc_arena.cpp (Line 93):

Code:
if (pPlayer && (pPlayer->m_pCurrentArena == this) && pPlayer->m_bHasDisconnected != TRUE && (stricmp(GETPLAYERAUTHID(pPlayer->edict()), "HLTV") != 0))

This is what the function CDiscArena::Reset will look like after the code has been added (starting on line 86):

Code:
void CDiscArena::Reset( void )

{

    // Remove all clients in the queue

    for ( int i = 1; i <= gpGlobals->maxClients; i++ )

    {

        CBasePlayer *pPlayer = (CBasePlayer *)UTIL_PlayerByIndex( i );

        if (pPlayer && (pPlayer->m_pCurrentArena == this) && pPlayer->m_bHasDisconnected != TRUE && (stricmp(GETPLAYERAUTHID(pPlayer->edict()), "HLTV") != 0))

        {

            RemoveClient( pPlayer );

            // Move her into spectator mode

            //MoveToSpectator( pPlayer );

        }

    }

    m_pPlayerQueue = NULL;

    m_iPlayers = 0;

    m_flTimeLimitOver = 0;

    m_bShownTimeWarning = FALSE;

    m_iArenaState = ARENA_WAITING_FOR_PLAYERS;

    memset( m_hCombatants, 0, sizeof( m_hCombatants ) );

    SetThink( NULL );

    pev->nextthink = 0;

}

Any HLTV Proxy that connects to a server has the SteamID of HLTV, which makes it easier to distinguish from real players.

String Sorting Algorithm

Mon, 27 Feb 2006 15:10:57 +0000

I've been trying to write a string sorting algorithm for the past few days.

I'm using a lanugage that does not have any built-in functions that sort the way I want to sort.

The strings will contain alpha and numeric characters.

Here's an example of what I want to do:

Let's say we have a file with the following strings:

TEST, BELT, 40E, A1, A2, 1, 2,3, 4, 1A, 1D, 2D, 65A, 3D, 4D, 10D, 1E, 20D, 30D, 40D, 41D, 1D1

The user is able to choose a minimum and maximum.

For example, user enters
Min: 1D
Max: 40D

and it should pull the following:
1D, 2D, 3D, 4D, 10D, 20D, 30D, 40D

(in that order)

I'm guessing it would be similar to the StrCmpLogicalW function, but I would like it to not be case sensitive.

I would appreciate the help.

my pic

Thu, 06 Oct 2005 23:42:36 +0000

see

notworking.JPG (Size: 109.11 KB / Downloads: 2)

Third person

Mon, 05 Sep 2005 22:24:40 +0000

This is the entire view.cpp since I made a few changes that will keep thirdperson off for those who don't want it on when they die.

Code:
// view/refresh setup functions

#include "hud.h"

#include "cl_util.h"

#include "cvardef.h"

#include "usercmd.h"

#include "const.h"

#include "entity_state.h"

#include "cl_entity.h"

#include "ref_params.h"

#include "in_defs.h" // PITCH YAW ROLL

#include "pm_movevars.h"

#include "pm_shared.h"

#include "pmtrace.h"

#include "screenfade.h"

#include "shake.h"

// Spectator Mode

extern "C" 

{

    float    vecNewViewAngles[3];

    int Â iHasNewViewAngles;

    float    vecNewViewOrigin[3];

    int Â iHasNewViewOrigin;

    int Â iIsSpectator;

}

extern float g_flStartScaleTime;

extern int iMouseInUse;

void CAM_ToThirdPerson(void);

void CAM_ToFirstPerson(void);

#ifndef M_PI

#define M_PI Â 3.14159265358979323846    // matches value in gcc v2 math.h

#endif

extern "C" 

{

    int CL_IsThirdPerson( void );

    void CL_CameraOffset( float *ofs );

    void DLLEXPORT V_CalcRefdef( struct ref_params_s *pparams );

    void PM_ParticleLine( float *start, float *end, int pcolor, float life, float vert);

    int PM_GetInfo( int ent );

}

void V_DropPunchAngle ( float frametime, float *ev_punchangle );

void VectorAngles( const float *forward, float *angles );

/*

The view is allowed to move slightly from it's true position for bobbing,

but if it exceeds 8 pixels linear distance (spherical, not box), the list of

entities sent from the server may not include everything in the pvs, especially

when crossing a water boudnary.

*/

extern cvar_t    *cl_forwardspeed;

extern cvar_t    *chase_active;

extern cvar_t    *scr_ofsx, *scr_ofsy, *scr_ofsz;

extern cvar_t    *cl_vsmoothing;

vec3_t v_origin, v_angles;

vec3_t ev_punchangle;

cvar_t    *scr_ofsx;

cvar_t    *scr_ofsy;

cvar_t    *scr_ofsz;

cvar_t    *v_centermove;

cvar_t    *v_centerspeed;

cvar_t    *cl_bobcycle;

cvar_t    *cl_bob;

cvar_t    *cl_bobup;

cvar_t    *cl_waterdist;

// These cvars are not registered (so users can't cheat), so set the ->value field directly

// Register these cvars in V_Init() if needed for easy tweaking

cvar_t    v_iyaw_cycle Â = {"v_iyaw_cycle", "2", 0, 2};

cvar_t    v_iroll_cycle Â = {"v_iroll_cycle", "0.5", 0, 0.5};

cvar_t    v_ipitch_cycle Â = {"v_ipitch_cycle", "1", 0, 1};

cvar_t    v_iyaw_level Â = {"v_iyaw_level", "0.3", 0, 0.3};

cvar_t    v_iroll_level Â = {"v_iroll_level", "0.1", 0, 0.1};

cvar_t    v_ipitch_level Â = {"v_ipitch_level", "0.3", 0, 0.3};

float    v_idlescale; Â // used by TFC for concussion grenade effect

//=============================================================================

void V_NormalizeAngles( float *angles )

{

    int i;

    // Normalize angles

    for ( i = 0; i < 3; i++ )

    {

 Â if ( angles[i] > 180.0 )

 Â {

 Â     angles[i] -= 360.0;

 Â }

 Â else if ( angles[i] < -180.0 )

 Â {

 Â     angles[i] += 360.0;

 Â }

    }

}

/*

===================

V_InterpolateAngles

Interpolate Euler angles.

FIXME: Â Use Quaternions to avoid discontinuities

Frac is 0.0 to 1.0 ( i.e., should probably be clamped, but doesn't have to be )

===================

*/

void V_InterpolateAngles( float *start, float *end, float *output, float frac )

{

    int i;

    float ang1, ang2;

    float d;

    V_NormalizeAngles( start );

    V_NormalizeAngles( end );

    for ( i = 0; i < 3; i++ )

    {

 Â ang1 = start[i];

 Â ang2 = end[i];

 Â d = ang2 - ang1;

 Â if ( d > 180 )

 Â {

 Â     d -= 360;

 Â }

 Â else if ( d < -180 )

 Â {    

 Â     d += 360;

 Â }

 Â output[i] = ang1 + d * frac;

    }

    V_NormalizeAngles( output );

}

// Quakeworld bob code, this fixes jitters in the mutliplayer since the clock (pparams->time) isn't quite linear

float V_CalcBob ( struct ref_params_s *pparams )

{

    static    double    bobtime;

    static float    bob;

    float    cycle;

    static float    lasttime;

    vec3_t    vel;

    if ( pparams->spectator || iIsSpectator )

 Â return 0;

    if ( pparams->onground == -1 ||

 Â  pparams->time == lasttime )

    {

 Â // just use old value

 Â return bob;    

    }

    lasttime = pparams->time;

    bobtime += pparams->frametime;

    cycle = bobtime - (int)( bobtime / cl_bobcycle->value ) * cl_bobcycle->value;

    cycle /= cl_bobcycle->value;

    if ( cycle < cl_bobup->value )

    {

 Â cycle = M_PI * cycle / cl_bobup->value;

    }

    else

    {

 Â cycle = M_PI + M_PI * ( cycle - cl_bobup->value )/( 1.0 - cl_bobup->value );

    }

    // bob is proportional to simulated velocity in the xy plane

    // (don't count Z, or jumping messes it up)

    VectorCopy( pparams->simvel, vel );

    vel[2] = 0;

    bob = sqrt( vel[0] * vel[0] + vel[1] * vel[1] ) * cl_bob->value;

    bob = bob * 0.3 + bob * 0.7 * sin(cycle);

    bob = min( bob, 4 );

    bob = max( bob, -7 );

    return bob;

}

/*

===============

V_CalcRoll

Used by view and sv_user

===============

*/

float V_CalcRoll (vec3_t angles, vec3_t velocity, float rollangle, float rollspeed )

{

 Â  Â float Â  sign;

 Â  Â float Â  side;

 Â  Â float Â  value;

    vec3_t Â forward, right, up;

 Â  Â 

    AngleVectors ( angles, forward, right, up );

 Â  Â 

    side = DotProduct (velocity, right);

 Â  Â sign = side < 0 ? -1 : 1;

 Â  Â side = fabs( side );

 Â  Â 

    value = rollangle;

 Â  Â if (side < rollspeed)

    {

 Â side = side * value / rollspeed;

    }

 Â  Â else

    {

 Â side = value;

    }

    return side * sign;

}

typedef struct pitchdrift_s

{

    float Â pitchvel;

    int Â     nodrift;

    float Â driftmove;

    double Â laststop;

} pitchdrift_t;

static pitchdrift_t pd;

void V_StartPitchDrift( void )

{

    if ( pd.laststop == gEngfuncs.GetClientTime() )

    {

 Â return; Â // something else is keeping it from drifting

    }

    if ( pd.nodrift || !pd.pitchvel )

    {

 Â pd.pitchvel = v_centerspeed->value;

 Â pd.nodrift = 0;

 Â pd.driftmove = 0;

    }

}

void V_StopPitchDrift ( void )

{

    pd.laststop = gEngfuncs.GetClientTime();

    pd.nodrift = 1;

    pd.pitchvel = 0;

}

/*

===============

V_DriftPitch

Moves the client pitch angle towards idealpitch sent by the server.

If the user is adjusting pitch manually, either with lookup/lookdown,

mlook and mouse, or klook and keyboard, pitch drifting is constantly stopped.

===============

*/

void V_DriftPitch ( struct ref_params_s *pparams )

{

    float Â delta, move;

    if ( gEngfuncs.IsNoClipping() || !pparams->onground || pparams->demoplayback || pparams->spectator )

    {

 Â pd.driftmove = 0;

 Â pd.pitchvel = 0;

 Â return;

    }

    // don't count small mouse motion

    if (pd.nodrift)

    {

 Â if ( fabs( pparams->cmd->forwardmove ) < cl_forwardspeed->value )

 Â     pd.driftmove = 0;

 Â else

 Â     pd.driftmove += pparams->frametime;

 Â if ( pd.driftmove > v_centermove->value)

 Â {

 Â     V_StartPitchDrift ();

 Â }

 Â return;

    }

    delta = pparams->idealpitch - pparams->cl_viewangles[PITCH];

    if (!delta)

    {

 Â pd.pitchvel = 0;

 Â return;

    }

    move = pparams->frametime * pd.pitchvel;

    pd.pitchvel += pparams->frametime * v_centerspeed->value;

//Con_Printf ("move: %f (%f)\n", move, pparams->frametime);

    if (delta > 0)

    {

 Â if (move > delta)

 Â {

 Â     pd.pitchvel = 0;

 Â     move = delta;

 Â }

 Â pparams->cl_viewangles[PITCH] += move;

    }

    else if (delta < 0)

    {

 Â if (move > -delta)

 Â {

 Â     pd.pitchvel = 0;

 Â     move = -delta;

 Â }

 Â pparams->cl_viewangles[PITCH] -= move;

    }

}

/* 

============================================================================== 

 Â  Â  Â VIEW RENDERING 

============================================================================== 

*/ 

/*

==================

V_CalcGunAngle

==================

*/

void V_CalcGunAngle ( struct ref_params_s *pparams )

{    

    cl_entity_t *viewent;

    viewent = gEngfuncs.GetViewModel();

    if ( !viewent )

 Â return;

    viewent->angles[YAW] Â  = Â pparams->viewangles[YAW] Â  + pparams->crosshairangle[YAW];

    viewent->angles[PITCH] = -pparams->viewangles[PITCH] + pparams->crosshairangle[PITCH] * 0.25;

    viewent->angles[ROLL] Â -= v_idlescale * sin(pparams->time*v_iroll_cycle.value) * v_iroll_level.value;

    // don't apply all of the v_ipitch to prevent normally unseen parts of viewmodel from coming into view.

    viewent->angles[PITCH] -= v_idlescale * sin(pparams->time*v_ipitch_cycle.value) * (v_ipitch_level.value * 0.5);

    viewent->angles[YAW] Â  -= v_idlescale * sin(pparams->time*v_iyaw_cycle.value) * v_iyaw_level.value;

    VectorCopy( viewent->angles, viewent->curstate.angles );

    VectorCopy( viewent->angles, viewent->latched.prevangles );

}

/*

==============

V_AddIdle

Idle swaying

==============

*/

void V_AddIdle ( struct ref_params_s *pparams )

{

    pparams->viewangles[ROLL] += v_idlescale * sin(pparams->time*v_iroll_cycle.value) * v_iroll_level.value;

    pparams->viewangles[PITCH] += v_idlescale * sin(pparams->time*v_ipitch_cycle.value) * v_ipitch_level.value;

    pparams->viewangles[YAW] += v_idlescale * sin(pparams->time*v_iyaw_cycle.value) * v_iyaw_level.value;

}

/*

==============

V_CalcViewRoll

Roll is induced by movement and damage

==============

*/

void V_CalcViewRoll ( struct ref_params_s *pparams )

{

    float Â side;

    cl_entity_t *viewentity;

    viewentity = gEngfuncs.GetEntityByIndex( pparams->viewentity );

    if ( !viewentity )

 Â return;

    side = V_CalcRoll ( viewentity->angles, pparams->simvel, pparams->movevars->rollangle, pparams->movevars->rollspeed );

    pparams->viewangles[ROLL] += side;

    if ( pparams->health <= 0 && ( pparams->viewheight[2] != 0 ) )

    {

 Â // only roll the view if the player is dead and the viewheight[2] is nonzero 

 Â // this is so deadcam in multiplayer will work.

 Â pparams->viewangles[ROLL] = 80;    // dead view angle

 Â return;

    }

}

/*

==================

V_CalcIntermissionRefdef

==================

*/

void V_CalcIntermissionRefdef ( struct ref_params_s *pparams )

{

    cl_entity_t    *ent, *view;

    float Â old;

// don't allow cheats in multiplayer

#if !defined( _DEBUG )

    if ( pparams->maxclients > 1 )

    {

 Â gEngfuncs.Cvar_SetValue ("scr_ofsx", 0);

 Â gEngfuncs.Cvar_SetValue ("scr_ofsy", 0);

 Â gEngfuncs.Cvar_SetValue ("scr_ofsz", 0);

    }

#endif

    // ent is the player model ( visible when out of body )

    ent = gEngfuncs.GetLocalPlayer();

    // view is the weapon model (only visible from inside body )

    view = gEngfuncs.GetViewModel();

    VectorCopy ( pparams->simorg, pparams->vieworg );

    VectorCopy ( pparams->cl_viewangles, pparams->viewangles );

    view->model = NULL;

    // allways idle in intermission

    old = v_idlescale;

    v_idlescale = 1;

    V_AddIdle ( pparams );

    v_idlescale = old;

    v_origin = pparams->vieworg;

    v_angles = pparams->viewangles;

}

#define ORIGIN_BACKUP 64

#define ORIGIN_MASK ( ORIGIN_BACKUP - 1 )

typedef struct 

{

    float Origins[ ORIGIN_BACKUP ][3];

    float OriginTime[ ORIGIN_BACKUP ];

    float Angles[ ORIGIN_BACKUP ][3];

    float AngleTime[ ORIGIN_BACKUP ];

    int CurrentOrigin;

    int CurrentAngle;

} viewinterp_t;

/*

==================

V_CalcRefdef

==================

*/

void V_CalcNormalRefdef ( struct ref_params_s *pparams )

{

    cl_entity_t Â *ent, *view;

    int Â  Â i;

    vec3_t Â     angles;

    float Â     bob, waterOffset;

    static viewinterp_t Â ViewInterp;

    static float oldz = 0;

    static float lasttime;

    static float lastang[3];

    vec3_t angdelta;

    vec3_t camAngles, camForward, camRight, camUp;

    cl_entity_t *pwater;

    //Miagi to store flag

    static float cam_gotofirstperson;

    // don't allow cheats in multiplayer

    if ( pparams->maxclients > 1 )

    {

 Â scr_ofsx->value = 0.0;

 Â scr_ofsy->value = 0.0;

 Â scr_ofsz->value = 0.0;

    }

    V_DriftPitch ( pparams );

    // ent is the player model ( visible when out of body )

    ent = gEngfuncs.GetLocalPlayer();

    // view is the weapon model (only visible from inside body )

    view = gEngfuncs.GetViewModel();

    // transform the view offset by the model's matrix to get the offset from

    // model origin for the view

    bob = V_CalcBob ( pparams );

    // Observer angle capturing and smoothing

    if ( iHasNewViewOrigin )

    {

 Â // Get the angles from the physics code

 Â VectorCopy( vecNewViewOrigin, pparams->vieworg );

 Â VectorCopy( vecNewViewOrigin, pparams->simorg );

    }

    // refresh position

    VectorCopy ( pparams->simorg, pparams->vieworg );

    pparams->vieworg[2] += ( bob );

    VectorAdd( pparams->vieworg, pparams->viewheight, pparams->vieworg );

    // Observer angle capturing and smoothing

    if ( iHasNewViewAngles )

    {

 Â // Get the angles from the physics code

 Â VectorCopy( vecNewViewAngles, pparams->cl_viewangles );

    }

    else if ( pparams->health == -5 )

    {

 Â //Miagi saving view

 Â if ( !CL_IsThirdPerson() )

 Â { 

 Â  Â cam_gotofirstperson = 1;

 Â }

 Â //End Miagi saving

 Â CAM_ToThirdPerson();

 Â // Lock mouse movement Â  Miagi-Dont lock

 Â iMouseInUse=0;

 Â pparams->cl_viewangles[0] = 89;

 Â // Spin the view

 Â float flTimeDelta = (pparams->time - g_flStartScaleTime);

 Â if ( flTimeDelta > 0 )

 Â {

 Â     float flROFSpin = 1.0 + (flTimeDelta * 2.0);

 Â     float flSpin = flTimeDelta * 45;

 Â     pparams->cl_viewangles[1] = flSpin * flROFSpin;

 Â }

 Â 

    }

    //Miagi Go back to first if in first

    else

    {

 Â if ( cam_gotofirstperson == 1 )

 Â {

 Â     cam_gotofirstperson = 0;

 Â     CAM_ToFirstPerson();

 Â }

    }

    //End Miagi

/*    else Â  Â causing the problem.. Miagi

    {

 Â //CAM_ToFirstPerson();

 Â // Unlock mouse movement

 Â //iMouseInUse=0;

 Â CAM_ToThirdPerson();

 Â // Lock mouse movement

 Â iMouseInUse=0;

    }*/

    VectorSubtract( pparams->cl_viewangles, lastang, angdelta );

    if ( Length( angdelta ) != 0.0 )

    {

 Â VectorCopy( pparams->cl_viewangles, ViewInterp.Angles[ ViewInterp.CurrentAngle & ORIGIN_MASK ] );

 Â ViewInterp.AngleTime[ ViewInterp.CurrentAngle & ORIGIN_MASK ] = pparams->time;

 Â ViewInterp.CurrentAngle++;

 Â VectorCopy( pparams->cl_viewangles, lastang );

    }

    if ( cl_vsmoothing && cl_vsmoothing->value && ( iIsSpectator & SPEC_SMOOTH_ANGLES ) )

    {

 Â int foundidx;

 Â int i;

 Â float t;

 Â if ( cl_vsmoothing->value < 0.0 )

 Â {

 Â     gEngfuncs.Cvar_SetValue( "cl_vsmoothing", 0.0 );

 Â }

 Â t = pparams->time - cl_vsmoothing->value;

 Â for ( i = 1; i < ORIGIN_MASK; i++ )

 Â {

 Â     foundidx = ViewInterp.CurrentAngle - 1 - i;

 Â     if ( ViewInterp.AngleTime[ foundidx & ORIGIN_MASK ] <= t )

 Â  Â break;

 Â }

 Â if ( i < ORIGIN_MASK && ViewInterp.AngleTime[ foundidx & ORIGIN_MASK ] != 0.0 )

 Â {

 Â     // Interpolate

 Â     double dt;

 Â     dt = ViewInterp.AngleTime[ (foundidx + 1) & ORIGIN_MASK ] - ViewInterp.AngleTime[ foundidx & ORIGIN_MASK ];

 Â     if ( dt > 0.0 )

 Â     {

 Â  Â double frac;

 Â  Â frac = ( t - ViewInterp.AngleTime[ foundidx & ORIGIN_MASK] ) / dt;

 Â  Â frac = min( 1.0, frac );

 Â  Â // interpolate angles

 Â  Â V_InterpolateAngles( ViewInterp.Angles[ foundidx & ORIGIN_MASK ], ViewInterp.Angles[ (foundidx + 1) & ORIGIN_MASK ], pparams->cl_viewangles, frac );

 Â  Â VectorCopy( pparams->cl_viewangles, vecNewViewAngles );

 Â     }

 Â }

    }

    VectorCopy ( pparams->cl_viewangles, pparams->viewangles );

    gEngfuncs.V_CalcShake();

    gEngfuncs.V_ApplyShake( pparams->vieworg, pparams->viewangles, 1.0 );

    // never let view origin sit exactly on a node line, because a water plane can

    // dissapear when viewed with the eye exactly on it.

    // FIXME, we send origin at 1/128 now, change this?

    // the server protocol only specifies to 1/16 pixel, so add 1/32 in each axis

    pparams->vieworg[0] += 1.0/32;

    pparams->vieworg[1] += 1.0/32;

    pparams->vieworg[2] += 1.0/32;

    // Check for problems around water, move the viewer artificially if necessary 

    // -- this prevents drawing errors in GL due to waves

    waterOffset = 0;

    if ( pparams->waterlevel >= 2 )

    {

 Â int Â i, contents, waterDist, waterEntity;

 Â vec3_t    point;

 Â waterDist = cl_waterdist->value;

 Â if ( pparams->hardware )

 Â {

 Â     waterEntity = gEngfuncs.PM_WaterEntity( pparams->simorg );

 Â     if ( waterEntity >= 0 && waterEntity < pparams->max_entities )

 Â     {

 Â  Â pwater = gEngfuncs.GetEntityByIndex( waterEntity );

 Â  Â if ( pwater && ( pwater->model != NULL ) )

 Â  Â {

 Â  Â     waterDist += ( pwater->curstate.scale * 16 );    // Add in wave height

 Â  Â }

 Â     }

 Â }

 Â else

 Â {

 Â     waterEntity = 0;    // Don't need this in software

 Â }

 Â 

 Â VectorCopy( pparams->vieworg, point );

 Â // Eyes are above water, make sure we're above the waves

 Â if ( pparams->waterlevel == 2 )    

 Â {

 Â     point[2] -= waterDist;

 Â     for ( i = 0; i < waterDist; i++ )

 Â     {

 Â  Â contents = gEngfuncs.PM_PointContents( point, NULL );

 Â  Â if ( contents > CONTENTS_WATER )

 Â  Â     break;

 Â  Â point[2] += 1;

 Â     }

 Â     waterOffset = (point[2] + waterDist) - pparams->vieworg[2];

 Â }

 Â else

 Â {

 Â     // eyes are under water. Â Make sure we're far enough under

 Â     point[2] += waterDist;

 Â     for ( i = 0; i < waterDist; i++ )

 Â     {

 Â  Â contents = gEngfuncs.PM_PointContents( point, NULL );

 Â  Â if ( contents <= CONTENTS_WATER )

 Â  Â     break;

 Â  Â point[2] -= 1;

 Â     }

 Â     waterOffset = (point[2] - waterDist) - pparams->vieworg[2];

 Â }

    }

    pparams->vieworg[2] += waterOffset;

    V_CalcViewRoll ( pparams );

    V_AddIdle ( pparams );

    // offsets

    VectorCopy( pparams->cl_viewangles, angles );

    AngleVectors ( angles, pparams->forward, pparams->right, pparams->up );

    for ( i=0; i<3; i++ )

    {

 Â pparams->vieworg[i] += scr_ofsx->value*pparams->forward[i] + scr_ofsy->value*pparams->right[i] + scr_ofsz->value*pparams->up[i];

    }

    // Treating cam_ofs[2] as the distance

    if( CL_IsThirdPerson() )

    {

 Â vec3_t ofs;

 Â ofs[0] = ofs[1] = ofs[2] = 0.0;

 Â CL_CameraOffset( (float *)&ofs );

 Â VectorCopy( ofs, camAngles );

 Â camAngles[ ROLL ]    = 0;

 Â AngleVectors( camAngles, camForward, camRight, camUp );

 Â // Is the player in a falling anim? If so, raise camera above and look down

 Â if ( pparams->health == -5 )

 Â {

 Â     pparams->vieworg[2] += 92;

 Â }

 Â else

 Â {

 Â     for ( i = 0; i < 3; i++ )

 Â     {

 Â  Â pparams->vieworg[ i ] += -ofs[2] * camForward[ i ];

 Â     }

 Â     pparams->vieworg[2] += 20;

 Â }

    }

    // Give gun our viewangles

    VectorCopy ( pparams->cl_viewangles, view->angles );

    // set up gun position

    V_CalcGunAngle ( pparams );

    // Use predicted origin as view origin.

    VectorCopy ( pparams->simorg, view->origin ); Â  Â  Â 

    view->origin[2] += ( waterOffset );

    VectorAdd( view->origin, pparams->viewheight, view->origin );

    // Let the viewmodel shake at about 10% of the amplitude

    gEngfuncs.V_ApplyShake( view->origin, view->angles, 0.9 );

    for ( i = 0; i < 3; i++ )

    {

 Â view->origin[ i ] += bob * 0.4 * pparams->forward[ i ];

    }

    view->origin[2] += bob;

    // throw in a little tilt.

    view->angles[YAW] Â  -= bob * 0.5;

    view->angles[ROLL] Â -= bob * 1;

    view->angles[PITCH] -= bob * 0.3;

    // pushing the view origin down off of the same X/Z plane as the ent's origin will give the

    // gun a very nice 'shifting' effect when the player looks up/down. If there is a problem

    // with view model distortion, this may be a cause. (SJB). 

    view->origin[2] -= 1;

    // fudge position around to keep amount of weapon visible

    // roughly equal with different FOV

    if (pparams->viewsize == 110)

    {

 Â view->origin[2] += 1;

    }

    else if (pparams->viewsize == 100)

    {

 Â view->origin[2] += 2;

    }

    else if (pparams->viewsize == 90)

    {

 Â view->origin[2] += 1;

    }

    else if (pparams->viewsize == 80)

    {

 Â view->origin[2] += 0.5;

    }

    // Add in the punchangle, if any

    VectorAdd ( pparams->viewangles, pparams->punchangle, pparams->viewangles );

    // Include client side punch, too

    VectorAdd ( pparams->viewangles, (float *)&ev_punchangle, pparams->viewangles);

    V_DropPunchAngle ( pparams->frametime, (float *)&ev_punchangle );

    // smooth out stair step ups

#if 1

    if ( !pparams->smoothing && pparams->onground && pparams->simorg[2] - oldz > 0)

    {

 Â float steptime;

 Â 

 Â steptime = pparams->time - lasttime;

 Â if (steptime < 0)

    //FIXME Â I_Error ("steptime < 0");

 Â     steptime = 0;

 Â oldz += steptime * 150;

 Â if (oldz > pparams->simorg[2])

 Â     oldz = pparams->simorg[2];

 Â if (pparams->simorg[2] - oldz > 18)

 Â     oldz = pparams->simorg[2]- 18;

 Â pparams->vieworg[2] += oldz - pparams->simorg[2];

 Â view->origin[2] += oldz - pparams->simorg[2];

    }

    else

    {

 Â oldz = pparams->simorg[2];

    }

#endif

    {

 Â static float lastorg[3];

 Â vec3_t delta;

 Â VectorSubtract( pparams->simorg, lastorg, delta );

 Â if ( Length( delta ) != 0.0 )

 Â {

 Â     VectorCopy( pparams->simorg, ViewInterp.Origins[ ViewInterp.CurrentOrigin & ORIGIN_MASK ] );

 Â     ViewInterp.OriginTime[ ViewInterp.CurrentOrigin & ORIGIN_MASK ] = pparams->time;

 Â     ViewInterp.CurrentOrigin++;

 Â     VectorCopy( pparams->simorg, lastorg );

 Â }

    }

    // Smooth out whole view in multiplayer when on trains, lifts

    if ( cl_vsmoothing && cl_vsmoothing->value &&

 Â ( ( iIsSpectator & SPEC_SMOOTH_ORIGIN ) || (pparams->smoothing && ( pparams->maxclients > 1 ) ) ) )

    {

 Â int foundidx;

 Â int i;

 Â float t;

 Â if ( cl_vsmoothing->value < 0.0 )

 Â {

 Â     gEngfuncs.Cvar_SetValue( "cl_vsmoothing", 0.0 );

 Â }

 Â t = pparams->time - cl_vsmoothing->value;

 Â for ( i = 1; i < ORIGIN_MASK; i++ )

 Â {

 Â     foundidx = ViewInterp.CurrentOrigin - 1 - i;

 Â     if ( ViewInterp.OriginTime[ foundidx & ORIGIN_MASK ] <= t )

 Â  Â break;

 Â }

 Â if ( i < ORIGIN_MASK && Â ViewInterp.OriginTime[ foundidx & ORIGIN_MASK ] != 0.0 )

 Â {

 Â     // Interpolate

 Â     vec3_t delta;

 Â     double frac;

 Â     double dt;

 Â     vec3_t neworg;

 Â     dt = ViewInterp.OriginTime[ (foundidx + 1) & ORIGIN_MASK ] - ViewInterp.OriginTime[ foundidx & ORIGIN_MASK ];

 Â     if ( dt > 0.0 )

 Â     {

 Â  Â frac = ( t - ViewInterp.OriginTime[ foundidx & ORIGIN_MASK] ) / dt;

 Â  Â frac = min( 1.0, frac );

 Â  Â VectorSubtract( ViewInterp.Origins[ ( foundidx + 1 ) & ORIGIN_MASK ], ViewInterp.Origins[ foundidx & ORIGIN_MASK ], delta );

 Â  Â VectorMA( ViewInterp.Origins[ foundidx & ORIGIN_MASK ], frac, delta, neworg );

 Â  Â // Dont interpolate large changes

 Â  Â if ( Length( delta ) < 64 )

 Â  Â {

 Â  Â     VectorSubtract( neworg, pparams->simorg, delta );

 Â  Â     VectorAdd( pparams->simorg, delta, pparams->simorg );

 Â  Â     VectorAdd( pparams->vieworg, delta, pparams->vieworg );

 Â  Â     VectorAdd( view->origin, delta, view->origin );

 Â  Â     VectorCopy( pparams->simorg, vecNewViewOrigin );

 Â  Â }

 Â     }

 Â }

    }

    // Store off v_angles before munging for third person

    v_angles = pparams->viewangles;

    if ( CL_IsThirdPerson() )

    {

 Â VectorCopy( camAngles, pparams->viewangles);

    }

    // override all previous settings if the viewent isn't the client

    if ( pparams->viewentity > pparams->maxclients )

    {

 Â cl_entity_t *viewentity;

 Â viewentity = gEngfuncs.GetEntityByIndex( pparams->viewentity );

 Â if ( viewentity )

 Â {

 Â     VectorCopy( viewentity->origin, pparams->vieworg );

 Â     VectorCopy( viewentity->angles, pparams->viewangles );

 Â     // Store off overridden viewangles

 Â     v_angles = pparams->viewangles;

 Â }

    }

    lasttime = pparams->time;

    v_origin = pparams->vieworg;

}

void DLLEXPORT V_CalcRefdef( struct ref_params_s *pparams )

{

    // intermission / finale rendering

    if ( pparams->intermission )

    {    

 Â V_CalcIntermissionRefdef ( pparams );    

    }

    else if ( !pparams->paused )

    {

 Â V_CalcNormalRefdef ( pparams );

    }

/*

// Example of how to overlay the whole screen with red at 50 % alpha

#define SF_TEST

#if defined SF_TEST

    {

 Â screenfade_t sf;

 Â gEngfuncs.pfnGetScreenFade( &sf );

 Â sf.fader = 255;

 Â sf.fadeg = 0;

 Â sf.fadeb = 0;

 Â sf.fadealpha = 128;

 Â sf.fadeFlags = FFADE_STAYOUT | FFADE_OUT;

 Â gEngfuncs.pfnSetScreenFade( &sf );

    }

#endif

*/

}

/*

=============

V_DropPunchAngle

=============

*/

void V_DropPunchAngle ( float frametime, float *ev_punchangle )

{

    float    len;

    len = VectorNormalize ( ev_punchangle );

    len -= (10.0 + len * 0.5) * frametime;

    len = max( len, 0.0 );

    VectorScale ( ev_punchangle, len, ev_punchangle );

}

/*

=============

V_PunchAxis

Client side punch effect

=============

*/

void V_PunchAxis( int axis, float punch )

{

    ev_punchangle[ axis ] = punch;

}

/*

=============

V_Init

=============

*/

void V_Init (void)

{

    gEngfuncs.pfnAddCommand ("centerview", V_StartPitchDrift );

    scr_ofsx Â     = gEngfuncs.pfnRegisterVariable( "scr_ofsx","0", 0 );

    scr_ofsy Â     = gEngfuncs.pfnRegisterVariable( "scr_ofsy","0", 0 );

    scr_ofsz Â     = gEngfuncs.pfnRegisterVariable( "scr_ofsz","0", 0 );

    v_centermove Â = gEngfuncs.pfnRegisterVariable( "v_centermove", "0.15", 0 );

    v_centerspeed Â = gEngfuncs.pfnRegisterVariable( "v_centerspeed","500", 0 );

    cl_bobcycle Â     = gEngfuncs.pfnRegisterVariable( "cl_bobcycle","0.8", 0 );// best default for my experimental gun wag (sjb)

    cl_bob Â  Â = gEngfuncs.pfnRegisterVariable( "cl_bob","0.01", 0 );// best default for my experimental gun wag (sjb)

    cl_bobup Â     = gEngfuncs.pfnRegisterVariable( "cl_bobup","0.5", 0 );

    cl_waterdist Â = gEngfuncs.pfnRegisterVariable( "cl_waterdist","4", 0 );

}

//#define TRACE_TEST

#if defined( TRACE_TEST )

extern float in_fov;

/*

====================

CalcFov

====================

*/

float CalcFov (float fov_x, float width, float height)

{

    float    a;

    float    x;

    if (fov_x < 1 || fov_x > 179)

 Â fov_x = 90;    // error, set to 90

    x = width/tan(fov_x/360*M_PI);

    a = atan (height/x);

    a = a*360/M_PI;

    return a;

}

int hitent = -1;

void V_Move( int mx, int my )

{

    float fov;

    float fx, fy;

    float dx, dy;

    float c_x, c_y;

    float dX, dY;

    vec3_t forward, up, right;

    vec3_t newangles;

    vec3_t farpoint;

    pmtrace_t tr;

    fov = CalcFov( in_fov, (float)ScreenWidth, (float)ScreenHeight );

    c_x = (float)ScreenWidth / 2.0;

    c_y = (float)ScreenHeight / 2.0;

    dx = (float)mx - c_x;

    dy = (float)my - c_y;

    // Proportion we moved in each direction

    fx = dx / c_x;

    fy = dy / c_y;

    dX = fx * in_fov / 2.0;

    dY = fy * fov / 2.0;

    newangles = v_angles;

    newangles[ YAW ] -= dX;

    newangles[ PITCH ] += dY;

    // Now rotate v_forward around that point

    AngleVectors ( newangles, forward, right, up );

    farpoint = v_origin + 8192 * forward;

    // Trace

    tr = *(gEngfuncs.PM_TraceLine( (float *)&v_origin, (float *)&farpoint, PM_TRACELINE_PHYSENTSONLY, 2 /*point sized hull*/, -1 ));

    if ( tr.fraction != 1.0 && tr.ent != 0 )

    {

 Â hitent = PM_GetInfo( tr.ent );

 Â PM_ParticleLine( (float *)&v_origin, (float *)&tr.endpos, 5, 1.0, 0.0 );

    }

    else

    {

 Â hitent = -1;

    }

}

#endif

Colour Switch

Mon, 05 Sep 2005 02:26:05 +0000

If you play DM, you're well aware of the seventh player who is indistinguishable from the first. I did some digging through the source, and there's no way to *fix* this; though there is a painless workaround.

These are the disc colours:

Code:
//disc_weapon_disc.cpp, line 32

float g_iaDiscColors[33][3] =

{

    { 255, 255, 255, },

    { 250, 0, 0 },

    { 0, 0, 250 },

    { 0, 250, 0 },

    { 128, 128, 0 },

    { 128, 0, 128 },

    { 0, 128, 128 },

    { 128, 128, 128 },

    { 64, 128, 0 },

    { 128, 64, 0 },

    { 128, 0, 64 },

    { 64, 0, 128 },

    { 0, 64, 128 },

    { 64, 64, 128 },

    { 128, 64, 64 },

    { 64, 128, 64 },

    { 128, 128, 64 },

    { 128, 64, 128 },

    { 64, 128, 128 },

    { 250, 128, 0 },

    { 128, 250, 0 },

    { 128, 0, 250 },

    { 250, 0, 128 },

    { 0, 250, 128 },

    { 250, 250, 128 },

    { 250, 128, 250 },

    { 128, 250, 250 },

    { 250, 128, 64 },

    { 250, 64, 128 },

    { 128, 250, 64 },

    { 64, 128, 250 },

    { 128, 64, 250 },

};

And this is how they map out:
NOTE: g_iaDiscColors[32][] is left empty. Not sure why, or what happens to player 32.

rico_disc_colours.JPG (Size: 23.49 KB / Downloads: 2)

Mirc dictionary script

Wed, 10 Aug 2005 20:08:33 +0000

Here's a little script I made that utilizes dictionary.com and webster to check spelling/definitions/thesaurus.

Download and put the wordtools.mrc file into your mirc folder.

While in Mirc, type /load -rs wordtools.mrc

To use it, you can copy the word you want to look up, right click in the chat window, goto word tools, and choose one of the tools, and either paste or type the word in the box that will popup and it should open a browser to the site you chose.

wordtools.mrc (Size: 803 bytes / Downloads: 7)

Rico fixes

Sun, 05 Jun 2005 16:55:39 +0000

Here's the windows version with the up-to-date fixes.

Server-side fixes.

12/08/05: [DTC]Miagi
- Fixed arena float bug, removed old white disc fix
- Stopped players from exploding on spawn/team switch
in Deathmatch Teamplay

9/18/05:
- Added Team DM Support :: [DTC]Miagi && [CAKE]Wha?
+ Change teams with 'team teamname' in console
+ Add "mp_teamlist" "red;blue" to game.cfg
+ Enable permanently in game.cfg "mp_teamplay" "1"

9/9/05:
- DM Spawn Protection :: [CAKE]Wha?
- DM Respawn command
+ Type "ready" in console

Unknown dates:
- Model Switching :: Evil_admin (desnotes)
- Reconnector :: .ASM
- White disc :: .ASM
- Use key :: Evil_admin (desnotes) && .ASM
- DM Double Kill :: .ASM && netniV
- DM Spectate with disc bug && disconnect :: Miagi
- Arena Floating :: Miagi
- Arena Spectate :: Miagi
- 2v2 White Disc and Scoreboard :: Miagi

====================
Commands/How to:
====================
If you are using this on a windows machine, make mp.dll read-only. Otherwise steam will overwrite mp.dll.

Respawn:
- ready : Console command to respawn self in DM

Team Deathmatch:
- Create/modify game.cfg in ricochet directory
- Add/modify "mp_teamlist" "red;blue"
- To enable permanently, in game.cfg add "mp_teamplay" "1"

If I miscredited any fixes, pm me .

Comments/Questions, make a new topic.

[attachment=2305:attachment]

mp_12_08_05.zip (Size: 226.93 KB / Downloads: 50)

DM Spectating bug fixed

Sun, 05 Jun 2005 15:24:32 +0000

I fixed one bug in dm having to do with a players disc rotate around them while they are spectating.

I just added this to the beginning of discthink of disc_weapon_disc.cpp

Code:
void CDisc::DiscThink()

{

//Miagi prevent disc returning to spectators

    if ( ((CBasePlayer*)(CBaseEntity*)m_hOwner)->IsObserver() )

    {

 Â 

 Â //UTIL_ClientPrintAll( HUD_PRINTNOTIFY, "Observer is true" );

 Â ReturnToThrower();

 Â return;

    }

    //End miagi

Now onto making a respawn command.

2v2

Sun, 05 Jun 2005 05:23:00 +0000

not sure if this is ricochet or programming but whatever

2v2 NOW WORKS!!!!!
There are still some obvious bugs as the scoreboard messes up a lot. The Teams dont get changed up until they lose. And the titles.txt needs some serious work. Also the map isn't great either, now i need to fix it up.

BUT TEAMPLAY IS NOW FUNCTIONABLE!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
MUHAHAHHAHAHAHHAHHAHHAHHA

Miagi is a godsend.

heres a screen for all you non-believers

haha what great news for my 300th post

2v2.JPG (Size: 19.29 KB / Downloads: 0)

Arena Floating Bug

Sun, 05 Jun 2005 03:41:35 +0000

We believe we fixed another bug in arena. The floating bug. It's on my linux server and pique tested it out and said it worked. PNG also helped test it out and he.. well... he fell out of the sky proving that it worked.

Pique pointed me to the right direction on fixing it. I was close in my other attempt except I put the stopobserver in the wrong spot :x.

Code:
for ( int i = 0; i < (m_iPlayersPerTeam * 2); i++ )

 Â {

 Â     //.asm - white disc haxxx...

 Â     // if the player is "dead" during countdown and they are not NULL

 Â  Â  Â 

 Â     CBasePlayer *pPlayer = ((CBasePlayer*)(CBaseEntity*)m_hCombatants[i]);

 Â     if( m_hCombatants[i] != NULL && !m_hCombatants[i]->IsAlive() )

 Â  Â  Â  Â  Â  Â 

 Â     {

 Â  Â //SpawnCombatant( pPlayer );

 Â  Â pPlayer->Spawn();

 Â  Â //Miagi Stop floaters

 Â  Â pPlayer->StopObserver();

 Â  Â  Â 

 Â  Â //UTIL_ClientPrintAll( HUD_PRINTNOTIFY, "Spawned" );

 Â     }

 Â     // end hax

 Â     if (m_hCombatants[i])

 Â  Â ((CBaseEntity*)m_hCombatants[i])->pev->maxspeed = 320;

 Â }

Sigh C++ is teh suck

Wed, 23 Feb 2005 15:00:08 +0000

For those of you who have mircosoft visual CPP I seriously need help on hell 2 programs.... My AIM name is Coldmetal14

program1.txt (Size: 2.16 KB / Downloads: 18)

HL2 Source Compiling

Thu, 13 Jan 2005 23:07:54 +0000

For those interested in compiling hl2 source code in VC 6.0 instead of having to get .NET version here's a great site with instructions.

http://www.sourcewiki.org/wiki/index.php/Compiling

Following the instructions is the most important part

Everything compiles correctly.

Though there is no Multiplayer code in it yet.

Also if you are planning to mess around in it here are fixes to some of the bugs.

http://www.hl2dev.tk/

server crash bug

Sat, 25 Sep 2004 04:11:22 +0000

This is what makes the server reset "randomly"

Player A plays Player B, Player B falls during a round and leaves before the next round commences (newbs do this a lot when they get frustrated). Server keeps playing the round thinking a player is still there, it shows Player A vs. (blank). Server crashes.

Fix this if possible.