task main()
{
  while (1 == 1)
  {
    motor [left motor] = vexRT [Ch2];
    motor [rihgt motor] = vexRT [ch2];//you spelled "right motor" wrong here
    //Technically, it should be "Ch2" instead of ch2, but I don't know if that will stop it from compiling
    //I don't know if you're reflected your motors, but if they're symmetrical on both sides of the robot, then they should be reflected.

    if (vexRT[Ch1] == 1)
    {
      motor [left motor] = -100;
      motor [right motor] = 100;
    }
    //What are you trying to do here? Turn the robot left and right? If so, then the second that the joystick deviates from 0,
      your robot will start jerking depending on whether you're pushing up on the joystick. I'll post how I think that this should be handled below.

    if (vexRT[Btn6U]== 1) //This works is fine but you don't need to include the "== 1" part if you don't want to.
    // I don't know what exactly is going on here, so I can't comment, but It looks alright.
    {
      motor [armmotorleft] = -40;
      motor [armmotorright] = 40;
    }
    else if (vexRT[Btn6D])
    {
      motor [armmotorleft] = 40;
      motor [armmotorright] = -40;
    }
    else
    {
      motor [armmotorleft] = 0;
      motor [armmotorright] = 0;
    }
  }
}

while(true){
    motor [leftmotor] = vexRT[Ch2] + vexRT[Ch1];
    motor [rightmotor] = vexRT[ch2] - vexRT[Ch1];
}

/**
 *  The BOUND macro limits the value (n) within the bounds between the given
 *  low (l) and high (h).
 */
#define BOUND(n,l,h)            (((n) < (l))? (l): ((n) > (h))? (h): (n))

//
// Joystick input macros.
//
#ifndef DEADBAND_INPUT_THRESHOLD
    #define DEADBAND_INPUT_THRESHOLD 20
#endif

/**
 *  These macros ignore input value (n) that is within the DEADBAND_THRESHOLD.
 *  This is necessary because analog joysticks do not always centered at zero.
 *  So if the joystick is at the rest position, we will consider it zero even
 *  though the value is non-zero but within DEADBAND_THRESHOLD.
 */
#define DEADBAND(n,t)           ((abs(n) > (t))? (n): 0)
#define DEADBAND_INPUT(n)       DEADBAND(n, DEADBAND_INPUT_THRESHOLD)

/**
 *  The NORMALIZE macro transforms a value (n) in the range between (sl) and
 *  (sh) to the range between (tl) and (th).
 */
#define MOTOR_MIN_VALUE         -100
#define MOTOR_MAX_VALUE         100

#define NORMALIZE(n,sl,sh,tl,th) (int)(((long)(n) - (sl))*((th) - (tl))/((sh) - (sl)) + (tl))
#define NORMALIZE_DRIVE(x,m,n)  NORMALIZE(x, m, n, \
                                          MOTOR_MIN_VALUE, MOTOR_MAX_VALUE)
#define JOYSTICK_POWER(n)       NORMALIZE_DRIVE(DEADBAND_INPUT(n), -128, 127)

/**
 *  This function sets power of the motors for arcade drive.
 *
 *  @param drivePower Specifies the drive power.
 *  @param turnPower Specifies the turn power.
 */
void
DriveArcade(
    int drivePower,
    int turnPower
    )
{
    int leftPower, rightPower;

    drivePower = BOUND(drivePower, MOTOR_MIN_VALUE, MOTOR_MAX_VALUE);
    turnPower = BOUND(turnPower, MOTOR_MIN_VALUE, MOTOR_MAX_VALUE);
    if (drivePower + turnPower > MOTOR_MAX_VALUE)
    {
        //
        // Forward right:
        //  left = drive + turn - (drive + turn - MOTOR_MAX_VALUE)
        //  right = drive - turn - (drive + turn - MOTOR_MAX_VALUE)
        //
        leftPower = MOTOR_MAX_VALUE;
        rightPower = -2*turnPower + MOTOR_MAX_VALUE;
    }
    else if (drivePower - turnPower > MOTOR_MAX_VALUE)
    {
        //
        // Forward left:
        //  left = drive + turn - (drive - turn - MOTOR_MAX_VALUE)
        //  right = drive - turn - (drive - turn - MOTOR_MAX_VALUE)
        //
        leftPower = 2*turnPower + MOTOR_MAX_VALUE;
        rightPower = MOTOR_MAX_VALUE;
    }
    else if (drivePower + turnPower < MOTOR_MIN_VALUE)
    {
        //
        // Backward left:
        //  left = drive + turn - (drive + turn - MOTOR_MIN_VALUE)
        //  right = drive - turn - (drive + turn - MOTOR_MIN_VALUE)
        //
        leftPower = MOTOR_MIN_VALUE;
        rightPower = -2*turnPower + MOTOR_MIN_VALUE;
    }
    else if (drivePower - turnPower < MOTOR_MIN_VALUE)
    {
        //
        // Backward right:
        //  left = drive + turn - (drive - turn - MOTOR_MIN_VALUE)
        //  right = drive - turn - (drive - turn - MOTOR_MIN_VALUE)
        //
        leftPower = 2*turnPower + MOTOR_MIN_VALUE;
        rightPower = MOTOR_MIN_VALUE;
    }
    else
    {
        leftPower = drivePower + turnPower;
        rightPower = drivePower - turnPower;
    }

    motor[leftMotor] = leftPower;
    motor[rightMotor] = rightPower;

    return;
}   //DriveArcade

task main()
{
    while (true)
    {
        getJoystickSettings(joystick);
        DriveArcade(JOYSTICK_POWER(joystick.joy1_y1), JOYSTICK_POWER(joystick.joy1_x1);
        wait1Msec(100);
    }
}