597 replies to this topic

[Whiskey87]

I've always used a mouse and keyboard for MechWarrior games. Immersion? Meh. You're still sitting in front of a computer in your home, regardless of how cool your controllers are. I'd rather be fast and accurate.

[mabo]

Turbo, on 16 July 2012 - 11:44 AM, said:

I got an X52 Pro and love it, Im even grabbing a set of pedals shortly to round out the setup.

Just bought both myself and am hoping it's competitive because if my wife notices I'm using a mouse instead of my new fancy toys then I'll be getting 'The Look'.

[Bongo TauKat]

For those who claim that mouse aiming with a joystick control is better, try using a control yolk with a twist base and spring feed back rocker plate. It seems unusual at first, but within a few games it seem like you just think the crosshairs on target, even in a circle of death. To each his own obviously but you might be surprised.

[Terror Teddy]

My only concern might be that my HOTAS might be a bit...jerky in the torso movement axis as its deadzone seems...quirky somehow. Its either on or off, there is a lack of smooth motion from standstill to motion.

[Soulvoid]

thontor, on 16 July 2012 - 11:33 AM, said:

Because it just feels wrong to pilot a mech with a mouse imo.

A lot of it is just the immersion factor...

I remember when Mechwarrior 2 came out... I had to rush to CompUSA (now defunct) and buy a Phoenix before I would even try to play it. Currently have an X52Pro and will never go back to mouse targeting in a mech or flight-sim, ever...



P.S. To answer the OPs question... Because it was.

Edited by Soulvoid, 16 July 2012 - 11:55 AM.

[Bongo TauKat]

Whiskey87, on 16 July 2012 - 11:50 AM, said:

I've always used a mouse and keyboard for MechWarrior games. Immersion? Meh. You're still sitting in front of a computer in your home, regardless of how cool your controllers are. I'd rather be fast and accurate.

That sounds horribly un-fun. I making pew pew noises and death rattles when I shot or get killed.

[Game_Overture]

I plan on using a joystick, and I plan on playing competitively.

I think most people denounce joysticks after realizing that there's a learning curve. They want to be able to pick one up and use it with the same proficiency as a mouse. After using a joystick after a while there's no reason you can't achieve close to the same accuracy as a mouse.

There are also advantages in using a joystick. You can apply constant linear movement in an axis with a joystick, whereas with a mouse you will eventually have to pick it up. I also have more accessible buttons (without moving my hands) on my joystick/throttle/pedals than I would with keyboard and mouse.

Edit [11/12/12]:

My stance on this subject has changed since my original post back in July. I have put forth a large effort into trying to make joysticks a viable option. I've gone as far as to write a comprehensive TARGET script that essentially gave me full control to manipulate raw joystick input which I then used to emulate mouse movement. I've tried a variety of techniques to some success, but even though this isn't a "twitch" FPS, it does require very small precise aiming adjustments to be competitive. Something a joystick, even with specialized programming is incapable of doing.

I'm not trying to be arrogant, but I don't believe PGI will be able to achieve much better results either when they get around to implementing joystick support.

Sorry for those who "Liked This", but the reality of the situation is that PGI didn't factor joystick usage into the design pipeline of MWO. For anyone who is interesting in checking out my script, i'll post it below in the spolier. It has some nuances to be used, and if anyone has any questions feel free to PM me about it. It only works with the Thrustmaster Warthog, and it has some nice features on the throttle.

Spoiler

 
//**************************************************************************
//  UNOFFICIAL MECHWARRIOR JOYSTICK SUPPORT
//      - For the Thrustmaster Warthog
//
//
//      Written by Jason 'Crescent Fresh' Knobler
//   (http://mwomercs.com/forums/user/164331-crescent-fresh/)
//
//  MechWarrior Online Joystick -> Mouse/Keyboard override
//
//**************************************************************************
include "target.tmh"
 
float fJOYAXIS_LIMIT = 32767.0;
float fDEFAULT_SENSITIVITY = 10.0;
 
define UPDATE_RATE 20   // In miliseconds
 
int g_iAxisXDir;    // X-Axis input direction. '-1' = inverted X axis; '1' = normal X axis
int g_iAxisYDir;    // Y-Axis input direction. '-1' = inverted Y axis; '1' = normal Y axis
 
int  g_bIsShutdown;     // While true, Warthog throttle considers the mech shutdown, and must use Throttle[EORIGN] to power on.
                        // While false, Warthog thottle considers the mech powered up, and must use Throttle[EORMOTOR] to shut down.
 
float g_fSensMod;       // Sensitivity modifier on FC Throttle.
int   g_iSlugStage;     // What stage [1-5] on how to apply procedural sensitiviy. Indicated by LED lights.
float g_fDeadZone;      // User setting centering deadzone variable
 
int g_bPercisionToggle;
int g_bPercisionToggleXtra;
 
struct sMWOAxis
{
    //
    // All the below data members belong to each X and Y axis
    //
    float fJoy;         // The basic (converted) input value from the joystick
    float fJoyPrev;     // 'fJoy's previous value in the last update
    float fJoyPerc; // Procentage of joystick is pressed in this axis from -1.0 -> 1.0
    
    int iMouse;         // The emulated, absolute coordinate of the mouse
 
    float fSlugTime;    // The elapsed time that has passed to help calculate fSlugPerc, when in 'JOYSTATE_SLUGGISH' 
    float fSlugPerc;    // Procedural sensitivity that gains as input persists when in 'JOYSTATE_SLUGGISH' 
    
    int bSnapDir;       // Determines whether the joystick is moving away or towards the center when in 'JOYSTATE_SNAP' state. [1 == away; 0 == centering]
    
    int bHasPulseCenter;// Used in 'JOYSTATE_ABSOLUTE' to determine when to center torso
    float fAbs; // The amount of torso turn in 'JOYSTATE_ABSOLUTE'
}
 
define AXIS_X 0
define AXIS_Y 1
define NUM_AXIS 2
sMWOAxis g_AxisData[NUM_AXIS]; // Stores per axis data used to manipulate raw joystick input (X and Y axis)
 
define SLUG_INCREMENTS 0.25 // Sluggish inc/dec amount per stage. Defaults at stage/LED '3'
define SLUG_DEFAULT_STAGE 3
 
//////////////////////////
// JOYSTICK STATES
//  - NORM:     Simply taking raw joystick values and converting them 1:1 to "MWO Units".
//  - SLUGGISH: Over a specified duration, a linearly increasing percentage of the input is applied. This resets anytime the joystick is centered.
//  - SNAP:     Input motions moving away from joystick center are accelerated, and moving back towards center are slowed.
//  - ABSOLUTE: The current input of the joystick maps directly to the yaw/pitch of the torso
//
// NOTE: All joystick states can be tweeked by applying a global sensitiviy modifer using Throttle[THR_FC].
//////////////////////////
define JOYSTATE_NORM (1 << 0) // = 1
define JOYSTATE_SLUGGISH (1 << 1) // = 2
define JOYSTATE_SNAP (1 << 2) // = 4
define JOYSTATE_ABSOLUTE (1 << 3) // = 8
 
// The negates of the states above. (no '~' operator?)
define JOYSTATE_NORM_OFF        4294967294  // = ~JOYSTATE_NORM
define JOYSTATE_SLUGGISH_OFF    4294967293  // = ~JOYSTATE_SLUGGISH
define JOYSTATE_SNAP_OFF        4294967291  // = ~JOYSTATE_SNAP
define JOYSTATE_ABSOLUTE_OFF    4294967287  // = ~JOYSTATE_ABSOLUTE
 
int g_iJoyStates; // A bitmask to represent what JOYSTATE_*'s are enabled
 
 
int InitAxis(int iIndex)
{
    g_AxisData[iIndex].fJoy = 0.0;
    g_AxisData[iIndex].fJoyPrev = 0.0;
    g_AxisData[iIndex].fJoyPerc = 0.0;
    
    g_AxisData[iIndex].fAbs = 0.0;
    
    g_AxisData[iIndex].iMouse = 0;
 
g_AxisData[iIndex].fSlugTime = 0.0;
    g_AxisData[iIndex].fSlugPerc = 0.0;
    
    g_AxisData[iIndex].bSnapDir = 0;
    
    g_AxisData[iIndex].bHasPulseCenter = 0;
}
 
// Program Startup
int main()
{
    if(Init(&EventHandle)) return 1; // declare the event handler, return on error
    
    //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    // Initialization code is below:
    //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    
    g_iAxisXDir = 1; // X-Axis defaults to NOT inverted
    g_iAxisYDir = -1; // Y-Axis defaults to inverted
    
    g_bPercisionToggle = 0;
    g_bPercisionToggleXtra = 0;
    
    g_iJoyStates = JOYSTATE_NORM;
    
    // Start, assuming mech is not shutdown
    g_bIsShutdown = 0;
    
    g_fSensMod = fDEFAULT_SENSITIVITY;
    
    g_iSlugStage = SLUG_DEFAULT_STAGE;
    
    ActKey(PULSE+KEYON+LED(&Throttle, LED_ONOFF, LED_CURRENT-LED1-LED2-LED3-LED4-LED5));
    
    g_fDeadZone = 0.25;
    
    InitAxis(AXIS_X);
    InitAxis(AXIS_Y);
    
    
    //--------------------------------------------
    // AXIS MAPPINGS
    //--------------------------------------------
 
    // We only need to assign the main throttle to be interpreted by MWO, which will control the mech's velocity. 
    // The joystick and THR_FC will be handled in (this) software. Joystick values are converted and used to move mouse.
    
    MapAxis(&Throttle, THR_RIGHT, DX_Z_AXIS);
    
    
    //--------------------------------------------
    // JOYSTICK MAPPINGS
    //--------------------------------------------
    
    // Firing weapons
    MapKey(&Joystick, TG1, '1');  // Wep. group #1
    MapKey(&Joystick, H2U, '2');  // Wep. group #2
    MapKey(&Joystick, H2D, '3');  // Wep. group #3
    MapKey(&Joystick, S1, '4');  // Wep. group #4
    MapKey(&Joystick, S2, USB[0x31]);  // Alpha Strike ('\' backslash)
    
    // Target Enemy
    //MapKey(&Joystick, S3, PULSE+'r');
    
    // Weapon group toggles
    MapKey(&Joystick, H4U, PULSE+USB[0x52]);  // Up
    MapKey(&Joystick, H4R, PULSE+USB[0x4F]);  // Right
    MapKey(&Joystick, H4D, PULSE+USB[0x51]);  // Down
    MapKey(&Joystick, H4L, PULSE+USB[0x50]);  // Left
    MapKey(&Joystick, H4P, PULSE+R_CTL);  // Press -TOGGLE-
    
    // Jump Jets
    //MapKey(&Joystick, S4, USB[0x2C]); // Spacebar
    
    // Hold for cockpit look
    //MapKey(&Joystick, S3, L_CTL);
    MapKey(&Joystick, S3, EXEC("g_bPercisionToggleXtra = 1;"));
    MapKeyR(&Joystick, S3, EXEC("g_bPercisionToggleXtra = 0;"));
    
    MapKey(&Joystick, S4, EXEC("g_bPercisionToggle = 1;"));
    MapKeyR(&Joystick, S4, EXEC("g_bPercisionToggle = 0;"));
    
    // Digital aimmer --Joystick round HAT
    MapKey(&Joystick, H1U, REXEC(3, UPDATE_RATE, "g_AxisData[AXIS_Y].iMouse = g_AxisData[AXIS_Y].iMouse - (g_iAxisYDir * g_fSensMod * 0.5); DXAxis(MOUSE_Y_AXIS, g_AxisData[AXIS_Y].iMouse);"));
    MapKey(&Joystick, H1D, REXEC(3, UPDATE_RATE, "g_AxisData[AXIS_Y].iMouse = g_AxisData[AXIS_Y].iMouse + (g_iAxisYDir * g_fSensMod * 0.5); DXAxis(MOUSE_Y_AXIS, g_AxisData[AXIS_Y].iMouse);"));
    MapKey(&Joystick, H1L, REXEC(3, UPDATE_RATE, "g_AxisData[AXIS_X].iMouse = g_AxisData[AXIS_X].iMouse - (g_iAxisXDir * g_fSensMod * 0.5); DXAxis(MOUSE_X_AXIS, g_AxisData[AXIS_X].iMouse);"));
    MapKey(&Joystick, H1R, REXEC(3, UPDATE_RATE, "g_AxisData[AXIS_X].iMouse = g_AxisData[AXIS_X].iMouse + (g_iAxisXDir * g_fSensMod * 0.5); DXAxis(MOUSE_X_AXIS, g_AxisData[AXIS_X].iMouse);"));
 
    // Fine percision aimmer  --Joystick DPAD
    MapKey(&Joystick, H3U, REXEC(3, UPDATE_RATE, "g_AxisData[AXIS_Y].iMouse = g_AxisData[AXIS_Y].iMouse - g_iAxisYDir; DXAxis(MOUSE_Y_AXIS, g_AxisData[AXIS_Y].iMouse);"));
    MapKey(&Joystick, H3D, REXEC(3, UPDATE_RATE, "g_AxisData[AXIS_Y].iMouse = g_AxisData[AXIS_Y].iMouse + g_iAxisYDir; DXAxis(MOUSE_Y_AXIS, g_AxisData[AXIS_Y].iMouse);"));
    MapKey(&Joystick, H3L, REXEC(3, UPDATE_RATE, "g_AxisData[AXIS_X].iMouse = g_AxisData[AXIS_X].iMouse - g_iAxisXDir; DXAxis(MOUSE_X_AXIS, g_AxisData[AXIS_X].iMouse);"));
    MapKey(&Joystick, H3R, REXEC(3, UPDATE_RATE, "g_AxisData[AXIS_X].iMouse = g_AxisData[AXIS_X].iMouse + g_iAxisXDir; DXAxis(MOUSE_X_AXIS, g_AxisData[AXIS_X].iMouse);"));
    
    
    //--------------------------------------------
    // THROTTLE MAPPINGS
    //--------------------------------------------
    
    // Turning the mech  --Thottle side HAT
    MapKey(&Throttle, MSL, 'a'); // left
    MapKey(&Throttle, MSR, 'd'); // right
    
// Toggle zoom
    MapKey(&Throttle, CSD, PULSE+'z');
    
    // Toggle Special Zoom
    MapKey(&Throttle, CSR, PULSE+'v');
    
    // Jump Jets
    MapKey(&Throttle, SC, USB[0x2C]); // Spacebar
    
    // Target Enemy
    MapKey(&Throttle, CHF, PULSE+'r');
    MapKey(&Throttle, LTB, PULSE+'r');
    
    // Show all known target information
    MapKey(&Throttle, CHB, CHAIN(EXEC("ActKey(KEYON+'q');"), D(5000), EXEC("ActKey('q');")));
    
    // Show scores
    MapKey(&Throttle, SPDF, USB[0x2B]); // TAB
    
    // TEAM SPEAK chat toggle (F8)
    MapKey(&Throttle, SPDB, USB[0x41]); // F8
    MapKey(&Throttle, CSU, USB[0x41]); // F8
    
    // Chain Fire
    MapKey(&Throttle, EACON, PULSE+USB[0x2A]); // Backspace
    MapKeyR(&Throttle, EACON, PULSE+USB[0x2A]);
    
    // Show map
    MapKey(&Throttle, RDRNRM, PULSE+'b');
    MapKeyR(&Throttle, RDRNRM, PULSE+'b');
 
    
    // Thermal vision toggle
    MapKey(&Throttle, BSF, PULSE+'h');
    MapKeyR(&Throttle, BSF, PULSE+'h');
    
    // Night vision toggle
    MapKey(&Throttle, BSB, PULSE+'n');
    MapKeyR(&Throttle, BSB, PULSE+'n');
    
    // Shutdown switch toggle
    MapKey(&Throttle, EORMOTOR, EXEC("if(!g_bIsShutdown){ ActKey(PULSE+KEYON+'p'); g_bIsShutdown = 1; }"));
    MapKey(&Throttle, EORIGN, EXEC("if(g_bIsShutdown){ ActKey(PULSE+KEYON+'p'); g_bIsShutdown = 0; }"));
    
    // Activate 'Shutdown Override' repeat (flip down for always 'ON')
    ActKey(PULSE+KEYON+REXEC(1, 700, "ActKey(PULSE+KEYON+'o');"));
    MapKey(&Throttle, EFROVER, REXEC(0, 700, "ActKey(PULSE+KEYON+'o');"));
    MapKey(&Throttle, EFRNORM, EXEC("StopHeatOverrideRepeat();"));
    
    // Toggle 'JOYSTATE_SLUGGISH' indicated by shutting off all LED sluggish state lights.
    MapKey(&Throttle, EFLNORM, EXEC("SlugToggle(1);"));
    MapKey(&Throttle, EFLOVER, EXEC("SlugToggle(0);"));
    
    // Cycle 'JOYSTATE_SLUGGISH's duration parameter, indicated by LED lights. 
    MapKey(&Throttle, LDGH, EXEC("SlugDuration(1);"));
    
    // Set text chat COMMS to associate with auto-pilot controls. 
    MapKey(&Throttle, APENG, SEQ('y', ENT)); // Default
    MapKey(&Throttle, APPAT, EXEC("MapKey(&Throttle, APENG, SEQ('t', ENT));"));
    MapKey(&Throttle, APAH, EXEC("MapKey(&Throttle, APENG, SEQ('y', ENT));"));
    MapKey(&Throttle, APALT, EXEC("MapKey(&Throttle, APENG, SEQ('u', ENT));"));
    
    // User settings for how much "deadzone" when stick is centered.
    MapKey(&Throttle, PSF, EXEC("g_fDeadZone = 0.3;"));
    MapKey(&Throttle, PSM, EXEC("g_fDeadZone = 0.25;"));
    MapKey(&Throttle, PSB, EXEC("g_fDeadZone = 0.15;"));
    
    // User settings for which JOYSTATE's to enable
    MapKey(&Throttle, FLAPU, EXEC("SetJoyState(JOYSTATE_SNAP);"));
    MapKey(&Throttle, FLAPM, EXEC("SetJoyState(JOYSTATE_NORM);"));
    MapKey(&Throttle, FLAPD, EXEC("SetJoyState(JOYSTATE_ABSOLUTE);"));
    
    // User settings for Joystick Axis directions
    MapKey(&Throttle, EOLMOTOR, EXEC("g_iAxisYDir = 1;")); // Set Y-Axis to normal direction
    MapKey(&Throttle, EOLNORM, EXEC("g_iAxisYDir = -1;")); // Set Y-Axis to inverted diection
    MapKey(&Throttle, EOLIGN, EXEC("g_iAxisXDir = g_iAxisXDir * -1;")); // Toggle/Flip X-Axis direction
    
    //--------------------------------------------
    // START UPDATE LOOP
    //--------------------------------------------
 
    // Enable Joystick->Mouse  - Throttle[APU]
    MapKey(&Throttle, APUON, REXEC(2, UPDATE_RATE, "UpdateJoystick();"));
    
    printf("All systems nominal!");
}
 
int SetJoyState(int iState)
{
    if(0 != (iState & JOYSTATE_NORM))// Throttle[FLAPM]
    {
        // Disable JOYSTATE_SNAP and JOYSTATE_ABSOLUTE
        g_iJoyStates = g_iJoyStates & JOYSTATE_SNAP_OFF;
        g_iJoyStates = g_iJoyStates & JOYSTATE_ABSOLUTE_OFF;
        
        // Enable JOYSTATE_NORM
        g_iJoyStates = g_iJoyStates | JOYSTATE_NORM;
    }
    else if(iState == JOYSTATE_SNAP)// Throttle[FLAPU]
    {
        // Disable JOYSTATE_ABSOLUTE
        g_iJoyStates = g_iJoyStates & JOYSTATE_ABSOLUTE_OFF;
        
        // Enable JOYSTATE_SNAP and JOYSTATE_NORM
        g_iJoyStates = g_iJoyStates | JOYSTATE_SNAP | JOYSTATE_NORM;
    }
    
    if(iState == JOYSTATE_ABSOLUTE)// Throttle[FLAPD]
    {
        // Disable JOYSTATE_NORM and JOYSTATE_SNAP 
        g_iJoyStates = g_iJoyStates & JOYSTATE_NORM_OFF;
        g_iJoyStates = g_iJoyStates & JOYSTATE_SNAP_OFF;
        
        // Enable JOYSTATE_ABSOLUTE
        g_iJoyStates = g_iJoyStates | JOYSTATE_ABSOLUTE;
        
        g_AxisData[AXIS_X].bHasPulseCenter = 0;
        g_AxisData[AXIS_Y].bHasPulseCenter = 0;
    }
}
 
int SlugDuration(int iStageOffset)
{
    g_iSlugStage = g_iSlugStage + iStageOffset;
    
    // Loop stages 
    if(g_iSlugStage > 5)
        g_iSlugStage = 1;
        
    if(0 != (g_iJoyStates & JOYSTATE_SLUGGISH))
    { 
        // Set appropriate LED light indicator // No 'switch' statement available in TARGET :)
        if(1 == g_iSlugStage)
            ActKey(PULSE+KEYON+LED(&Throttle, LED_ONOFF, LED_CURRENT-LED1-LED2-LED3-LED4+LED5));
        else if(2 == g_iSlugStage)
            ActKey(PULSE+KEYON+LED(&Throttle, LED_ONOFF, LED_CURRENT-LED1-LED2-LED3+LED4+LED5));
        else if(3 == g_iSlugStage)
            ActKey(PULSE+KEYON+LED(&Throttle, LED_ONOFF, LED_CURRENT-LED1-LED2+LED3+LED4+LED5));
        else if(4 == g_iSlugStage)
            ActKey(PULSE+KEYON+LED(&Throttle, LED_ONOFF, LED_CURRENT-LED1+LED2+LED3+LED4+LED5));
        else
            ActKey(PULSE+KEYON+LED(&Throttle, LED_ONOFF, LED_CURRENT+LED1+LED2+LED3+LED4+LED5));
    }
}
 
int SlugToggle(int bEnable)
{
    if(bEnable == 1)
    {
        g_iJoyStates = g_iJoyStates | JOYSTATE_SLUGGISH;
        
        SlugDuration(0);
    }
    else
    {
        // Disable the Sluggish effect and turn off all LED's
        g_iJoyStates = g_iJoyStates & JOYSTATE_SLUGGISH_OFF;
        ActKey(PULSE+KEYON+LED(&Throttle, LED_ONOFF, LED_CURRENT-LED1-LED2-LED3-LED4-LED5));
    }
}
 
int StopHeatOverrideRepeat()
{
    StopAutoRepeat(1);
}
 
int UpdateJoystick()
{
    UpdateJoystickAxis(AXIS_X);
    UpdateJoystickAxis(AXIS_Y);
    
    // Store current fJoy into fJoyPrev to be used next Update()
    g_AxisData[AXIS_X].fJoyPrev = g_AxisData[AXIS_X].fJoy;
    g_AxisData[AXIS_Y].fJoyPrev = g_AxisData[AXIS_Y].fJoy;
}
 
int UpdateJoystickAxis(int iIndex)
{
    // Whether or not to apply this Update()
    int bUpdateAxis = 1;
    
    // How much to move the mouse this Update()
    float fMouseDelta = 0.0;
    float fAimAdj = 0.0;
    
    //--------------------------------------------
    // Check to see if this axis's input value (fJoy) 
    // is lower than the user specified deadzone (g_fDeadZone)
    //--------------------------------------------
    if(abs(g_AxisData[iIndex].fJoy) < g_fDeadZone)
    {    
     g_AxisData[iIndex].fSlugTime = 0.0;
        g_AxisData[iIndex].fSlugPerc = 0.0;
        
        g_AxisData[iIndex].bSnapDir = 0;
        
        if(0 != (g_iJoyStates & JOYSTATE_ABSOLUTE))
        {
            // Only center torso if both X and Y axis hasn't Pulsed and both X and Y are centered
            if(g_AxisData[AXIS_X].bHasPulseCenter == 0 & g_AxisData[AXIS_Y].bHasPulseCenter == 0)
            {
                if(abs(g_AxisData[AXIS_X].fJoy) < g_fDeadZone & abs(g_AxisData[AXIS_Y].fJoy) < g_fDeadZone)
                {
                    ActKey(PULSE+KEYON+'c');
                    
                    g_AxisData[AXIS_X].bHasPulseCenter = 1;
                    g_AxisData[AXIS_Y].bHasPulseCenter = 1;
                }
            }
        }
        
        bUpdateAxis = 0;
    }
    else
    { 
        //--------------------------------------------
        // Apply 'SLUGGISH' if state enabled
        //--------------------------------------------
        if(0 != (g_iJoyStates & JOYSTATE_SLUGGISH))
        {
         // Update elapsed time
         g_AxisData[iIndex].fSlugTime = (g_AxisData[iIndex].fSlugTime + (UPDATE_RATE / 1000.0));
         
         // QUADRATIC EASE-IN
         g_AxisData[iIndex].fSlugPerc = (g_AxisData[iIndex].fSlugTime / (g_iSlugStage * SLUG_INCREMENTS)) * (g_AxisData[iIndex].fSlugTime / (g_iSlugStage * SLUG_INCREMENTS));
        
         // LINEAR INCREASE
            //g_AxisData[iIndex].fSlugPerc = g_AxisData[iIndex].fSlugTime / (g_iSlugStage * SLUG_INCREMENTS);
            
            if(g_AxisData[iIndex].fSlugPerc > 1.0)
            {
                g_AxisData[iIndex].fSlugPerc = 1.0; // clamp proc sens at 1.0
            }
            
            //printf("SlugPerc: %f \xa", g_AxisData[iIndex].fSlugPerc);
 
            fMouseDelta = fMouseDelta + (g_AxisData[iIndex].fJoy * g_AxisData[iIndex].fSlugPerc);
        }
        else if(0 != (g_iJoyStates & JOYSTATE_NORM))
            fMouseDelta = fMouseDelta + g_AxisData[iIndex].fJoy;
            
        //--------------------------------------------
        // Apply 'SNAP' if state enabled
        //--------------------------------------------
        if(0 != (g_iJoyStates & JOYSTATE_SNAP))
        { 
            if(g_AxisData[iIndex].fJoy > 0.0)
            {
                if(g_AxisData[iIndex].fJoy >= g_AxisData[iIndex].fJoyPrev)
                    g_AxisData[iIndex].bSnapDir = 1; // Moving away from center
                else
                    g_AxisData[iIndex].bSnapDir = 0; // Moving towards from center
            }
            else
            {
                if(g_AxisData[iIndex].fJoy <= g_AxisData[iIndex].fJoyPrev)
                    g_AxisData[iIndex].bSnapDir = 1; // Moving away from center
                else
                    g_AxisData[iIndex].bSnapDir = 0; // Moving towards from center
            }
            
            // Apply minor aiming adjustment modifier
            fAimAdj = abs(g_AxisData[iIndex].fJoy) / g_fSensMod;
            if(fAimAdj < 0.5)
            {
             fMouseDelta = fMouseDelta * (fAimAdj / 0.5);
            }
            
            if(g_AxisData[iIndex].bSnapDir == 1)
                fMouseDelta = fMouseDelta * 2.0;
            else
                fMouseDelta = fMouseDelta * 0.5;
        }
        
        //--------------------------------------------
        // Apply 'ABSOLUTE' if state enabled
        //--------------------------------------------
        if(0 != (g_iJoyStates & JOYSTATE_ABSOLUTE))
        {
            g_AxisData[iIndex].bHasPulseCenter = 0;
            
            
            g_AxisData[iIndex].fAbs = g_AxisData[iIndex].fJoyPerc * (100.0 * g_fSensMod);
            
            //fMouseDelta = g_AxisData[iIndex].fJoy - g_AxisData[iIndex].fJoyPrev;
            //fMouseDelta = fMouseDelta * 100.0;
        }
    }
    
    // Manually set mouse position if passes above checks
    if(bUpdateAxis)
    {
     if(0 != (g_iJoyStates & JOYSTATE_ABSOLUTE))
     {
     if(iIndex == AXIS_X)
             DXAxis(MOUSE_X_AXIS, g_AxisData[iIndex].fAbs);
         else
             DXAxis(MOUSE_Y_AXIS, g_AxisData[iIndex].fAbs);
     }
     else
     {
     
     // PERCISION TOGGLES
     if(g_bPercisionToggle)
     {
     fMouseDelta = fMouseDelta * 0.5;
     }
     else if(g_bPercisionToggleXtra)
     {
     fMouseDelta = fMouseDelta * 0.3;
     }
     
     
         g_AxisData[iIndex].iMouse = g_AxisData[iIndex].iMouse + fMouseDelta;
        
         if(iIndex == AXIS_X)
             DXAxis(MOUSE_X_AXIS, g_AxisData[iIndex].iMouse);
         else
             DXAxis(MOUSE_Y_AXIS, g_AxisData[iIndex].iMouse);
        }
    }
    
    return 0;
}
 
//event handler
int EventHandle(int type, alias o, int x)
{
    if(&o == &Joystick & (x == JOYX | x == JOYY)) // if the event came from Joystick X or Y axis
    {
        g_AxisData[AXIS_X].fJoy = Joystick[JOYX] * g_iAxisXDir;
        g_AxisData[AXIS_X].fJoyPerc = g_AxisData[AXIS_X].fJoy / fJOYAXIS_LIMIT;
        g_AxisData[AXIS_X].fJoy = g_AxisData[AXIS_X].fJoyPerc * g_fSensMod;
        
        g_AxisData[AXIS_Y].fJoy = Joystick[JOYY] * g_iAxisYDir;
        g_AxisData[AXIS_Y].fJoyPerc = g_AxisData[AXIS_Y].fJoy / fJOYAXIS_LIMIT;
        g_AxisData[AXIS_Y].fJoy = g_AxisData[AXIS_Y].fJoyPerc * g_fSensMod;
    }
    else if(&o == &Throttle & x == THR_FC) // if the event came from the Throttle's friction control trim wheel
    {
        g_fSensMod = -Throttle[THR_FC];
        g_fSensMod = g_fSensMod / fJOYAXIS_LIMIT;
        g_fSensMod = (g_fSensMod * fDEFAULT_SENSITIVITY) + fDEFAULT_SENSITIVITY;
    }
 
    // Allow the system to handle incoming events and do its thing.
    DefaultMapping(&o, x);
}
 

Edited by Crescent Fresh, 12 November 2012 - 07:42 PM.

[Oy of MidWorld]

If you play with a good joystick for a while, eventually you'll become really good with it. It will never aim as fast as a mouse, not recommendable for a straight fps shooter. But you can get close to that accuracy. and at that point, in a game like MW, the advantages come into play. Like muscle memory for a LOT of functions, weapon groups, stuff. Plus, in a turning fight, the mouse sucks.

I used to play MW Living Legends with a my x52 Pro, two years ago, for immersion. It was a PAIN at first. After a while i got real good, even leading the killboard once or twice. Now i haven't played in a while and suck again...

But I'm retraining, getting ready for MWO. And from the videos, MWO really looks even a little slower and more sim like than MWLL. Which is a good thing. If arms and torsos don't turn instantly, joystick will be very playable.

Edited by Oy of MidWorld, 16 July 2012 - 11:59 AM.

[Riffleman]

It seems that if you tell some people about your joystick plans for the game, they get upset over it, like they just KNOW your always going to end up on their team and cost them the match.

[PoPuP]

i want one of these to drive my mech with

[River McCain]

Someone should make a Poll.

[Bongo TauKat]

Terror Teddy, on 16 July 2012 - 11:53 AM, said:

My only concern might be that my HOTAS might be a bit...jerky in the torso movement axis as its deadzone seems...quirky somehow. Its either on or off, there is a lack of smooth motion from standstill to motion.

I thought the same thing. With the X45, you controlled all torso axis from the joystick and used the rudder controls on the throttle to steer. It took me a few games, but I got used to it pretty quickly.

The X52 has no rudder controls on the throttle, so now I will have to get used to using the joystick to steer and tilt forwards or backwards while using the joystick "twist" base to traverse the torso. I about screamed the first time I used in MW4, but I found the movement to be almost intuitive, as I have stated above.

Also if you are getting a little rough on throttling up or moving the stick, most of them have resistance screws on the base that let you loosen or tighten up the play in both controls. I messed around with them for awhile on both and found that tuning those in did wonders for smoothing out my aim and throttle control.

[Soulvoid]

Oy of MidWorld, on 16 July 2012 - 11:54 AM, said:

If you play with a good joystick for a while, eventually you'll become really good with it. It will never aim as fast as a mouse, not recommendable for a straight fps shooter. But you can get close to that accuracy. and at that point, in a game like MW, the advantages come into play. Like muscle memory for a LOT of functions, weapon groups, stuff. Plus, in a turning fight, the mouse sucks.

The thing is, if you are not limited in your aim/rotation speed, then a mouse is a better option. But Mechwarrior has so many options with the torso and arms having differing motion speeds, torso twisting, multiple weapon groups, and control insanity, that a good programmable multibutton joystick control system will always be superior.


Again taken from the publicly available videos and commentaries.

[JessterC]

Joystick is more fun... and a mouse will only be superior if the targeting reticule can track faster than a joystick can input... i.e. your mouse can't make your torso twist any faster, and (realistically) any weapon tracking that has a machine driven aim has a delay from it's input to it's final compliance with said input... so... so long as your joystick can move as fast as the mechanical limitations of weapon systems aiming will allow a joystick will not only be more immersive (fun), but will not be a "hindrance" insomuch as a mouse will cause annoyance in the CoD/BF/FPS crowds, because your weapons will not react as fast as your twitch reflexes can aim your mouse.

[Egomane]

ollo, on 16 July 2012 - 11:41 AM, said:

IIRC the mechwarrior didn't use the joystick to aim really, it was more mind-controlled via the neurohelmet (perhaps a little eye-tracking thrown in for good measure?), but i may be completely wrong.

You are completely wrong!
The neurohelmet is there to connect the sense of balance of the pilot to the mechs gyro to keep the machine upright. It can also be used as a security tool by matching the brainwaves with a stored record to recognize an authorized pilot. It has no further functions.

Steel Prophet, on 16 July 2012 - 11:42 AM, said:

I just don't get it... i always played Mechwarrior with a Joystick and never noticed any difference between my accuracy and that of a known mouse player. It all comes down to what you are used to.

Same for me! There is no difference, it's just what you are used to. I have beaten, and got beaten by, many mouse players in MPBT:3025 and MW4 with my trusted joysticks. It is an equal control setup for this type of game. Neither is superior over the other.

Mechwarrior agmes will have limited reaction speeds due to restrictions of the different mech chassis. On one you might have a relativ fast mech and/or torso turning rates, on others they may be very slow. To adapt between those with a mouse I found to be challenging, while it came almost naturaly to me with a stick.

[Bongo TauKat]

I just realized with this forum, that we have no idea what the controls are going to be like. Now I will staring at my controller setup wondering "what will I map to this button and this button and this button and this button?"

I have inadvertently given myself a self generated aspie moment. Meh.

[El Death Smurf]

thontor, on 16 July 2012 - 11:44 AM, said:

I've had this thing for years.. this is what I choose to handicap myself with:


sad i know

but i'm poor

Honestly though, as much as it it feels wrong to use a mouse, I'll probably try both ways and see if the mouse precision outweighs the "precision 2" immersion factor

i say joystick. especially since i prefer mechs without lower arm actuators (look at the heavy class video, and notice that the catapults arms dont move freely like the assault's atlas does) so mouse has no advantage. I also like the instant throttel controll and and better torso twist action. if i get the response time and controll i did in past titles with this game i will assuredly be up grading from my sidewinder 2 to something simmilar (only becaus my trigger is glitchy, loved that thing, but i need to be able to have my different wepon groups)

[CeeKay Boques]

thontor, on 16 July 2012 - 11:55 AM, said:

My issue with that is.. both my mouse and my joystick are made for the right hand..

That's an Equipment problem!

The Thrustmaster T.16000M joystick is a common USB connection with 12 buttons on the base of the joystick and 3 buttons on the handle. The hat switch for various views is also on the handle as well as the trigger with the slider usually used for throttle on the base. The base on the front also has a small switch to change the handedness of the stick from right to left for ambidextrous use. The joystick comes with an extra pad set so you can swap out the small pads that comfort your thumb on the joystick handle so you can set the joystick up for right or left handed quickly.

[Xant]

joystick _{theres no other choice for me.
i wanna feel the mech.}

here it is.

p.s
sorry for my bad english.

Edited by Xant, 16 July 2012 - 12:17 PM.

[Captain Fabulous]

Good luck trying to torso twist and move your crosshairs at the same time with a mouse.... Chances are you're going be stuck facing forward and people will just come up and blind side you.