int computeRotationalVelocity()
{
    int currTV = State[38];
    int currRV = State[39];

    // always loop if possible
    if(canTurn(1)) return 450;        // try to full-loop left
    if(canTurn(-1)) return -450;      // try to full-loop right

    // in tunnel or narrow.  try to wall-follow
    if(can90(1, currTV)) return 1;    // predict hard left turn coming up
    if(can90(-1, currTV)) return -1;  // predict hard right turn coming up
    if(currRV == 1) return 450;       // was predicting hard left, do it
    if(currRV == -1) return -450;     // was predicting hard right, do it

    // in a turn, see when to straighten out
    int close = closestPt();
    if(((close == 21) || (close == 29)) && (currRV < 430) && (currRV > -430))
        return 0;                     // closest pt is to side and we've been
                                      // turning at least 20 times in row, so
                                      // go straight

    // can't straighten yet, tick "counter"
    if(currRV >= 430) return currRV - 1;
    return currRV + 1;
}

bool canTurn(int curDir)
{
    int sens1, sens2, sens3, sens4, sens5, sens6, sens7, sens8, sens9;

    sens1 = State[17];      // front
    sens9 = State[25];      // back

    if (curDir < 0)         // curDir < 0 means look right
    {
        sens2 = State[32];
        sens3 = State[31];
        sens4 = State[30];
        sens5 = State[29];
        sens6 = State[28];
        sens7 = State[27];
        sens8 = State[26];
    }
    else                    // curDir > 0 means look left
    {
        sens2 = State[18];
        sens3 = State[19];
        sens4 = State[20];
        sens5 = State[21];
        sens6 = State[22];
        sens7 = State[23];
        sens8 = State[24];
    }

    // Basically, test all sensors to see if their readings are >= the minimum
    // value we think we need.  "ok" returns true if the sensor is bigger than
    // the value we're testing (also supposed to be true if the value is >255,
    // because that's beyond our sensor range, but our code has a bug...)

    if (ok(sens1, one) && ok(sens9, one) &&
        ok(sens2, two) && ok(sens8, two) &&
        ok(sens3, three) && ok(sens7, three) &&
        ok(sens4, four) && ok(sens6, four) &&
        ok(sens5, five)) return true;
    return false;

    // "one" through "five" are precomputed in the main function.
    // If our sensors are >= these readings, then hopefully we have just
    // just barely enough room to make a full loop.  Performance is better the
    // closer these values are to the minimum needed.
    // Here are their values:
/*
    radius = tv * 0.4 / PI;  // radius of tightest circle we turn, in inches
    // robRad == robot radius in inches
    one = 0.5 * radius + robRad;  // this is a guess on our part :)
    two = 2 * radius * cos(0.375 * PI) + robRad;   // actual trig for rest of
    three = 2 * radius * cos(0.25 * PI) + robRad;  // these values :)
    four = 2 * radius * cos(0.125 * PI) + robRad;
    five = 2 * radius + robRad;
*/
}

bool can90(int currDir, int currTV)
{
    double sens1, sens2, sens3;

    double predict = currTV * LOOKAHEAD_SECONDS;  // amount of forward
                                                  // movement to predict, in
                                                  // inches

    // look at front sensor and two sensors just to one side of front
    sens1 = State[17];
    if(currDir < 0)         // curDir < 0 means look right
    {
        sens2 = State[32];
        sens3 = State[31];
    }
    else                    // curDir < 0 means look left
    {
        sens2 = State[18];
        sens3 = State[19];
    }

    // try to "adjust" sensor values to match what they'd look like after
    // we moved forward a bit.  This is not totally accurate but close for
    // small predictions.  PROBLEM: we don't check sensor just to OPPOSITE
    // side of forward, so if we're about to scrape a wall on one side we
    // may miss it-- this causes us to get in a lot of collisions
    sens1 -= predict;
    double opp = sens2 * sin(0.125 * PI);  // don't try to figure this out :)
    double adj = sens2 * cos(0.125 * PI) - predict;
    sens2 = sqrt(opp * opp + adj * adj);
    opp = sens3 * sin(0.25 * PI);
    adj = sens2 * cos(0.25 * PI) - predict;
    sens3 = sqrt(opp * opp + adj * adj);

    // true means we think we can make the turn even after moving forward
    if(ok(sens1, one) && ok(sens2, two) && ok(sens3, three)) return true;
    return false;
}