mech.java

MegaMek is a networked Java clone of BattleTech, a turn-based sci-fi boardgame for 2+ players. Fight

                    case 5:
                        return new HitData(Mech.LOC_RLEG, true);
                    case 6:
                        return new HitData(Mech.LOC_RT, true);
                    case 7:
                        return new HitData(Mech.LOC_CT, true);
                    case 8:
                        return new HitData(Mech.LOC_LT, true);
                    case 9:
                        return new HitData(Mech.LOC_LLEG, true);
                    case 10:
                    case 11:
                        return new HitData(Mech.LOC_LARM, true);
                    case 12:
                        if (crew.hasEdgeRemaining() 
                                && crew.getOptions().booleanOption("edge_when_headhit")) {
                            crew.decreaseEdge();
                            HitData result =  rollHitLocation(table, side, aimedLocation, aimingMode);
                            result.setUndoneLocation(new HitData(Mech.LOC_HEAD, true));
                            return result;
                        } // if
                        return new HitData(Mech.LOC_HEAD, true);
                    }
                }
            }
        }
        if (table == ToHitData.HIT_PUNCH) {
            roll = Compute.d6(1);
            try {
                PrintWriter pw = PreferenceManager.getClientPreferences().getMekHitLocLog();
                if ( pw!= null ) {
                    pw.print( table );
                    pw.print( "\t" );
                    pw.print( side );
                    pw.print( "\t" );
                    pw.println( roll );
                }
            } catch ( Throwable thrown ) {
                thrown.printStackTrace();
            }
            if (side == ToHitData.SIDE_FRONT) {
                // front punch hits
                switch( roll ) {
                case 1:
                    return new HitData(Mech.LOC_LARM);
                case 2:
                    return new HitData(Mech.LOC_LT);
                case 3:
                    return new HitData(Mech.LOC_CT);
                case 4:
                    return new HitData(Mech.LOC_RT);
                case 5:
                    return new HitData(Mech.LOC_RARM);
                case 6:
                    if (crew.hasEdgeRemaining()
                            && crew.getOptions().booleanOption("edge_when_headhit")) {
                        crew.decreaseEdge();
                        HitData result =  rollHitLocation(table, side, aimedLocation, aimingMode);
                        result.setUndoneLocation(new HitData(Mech.LOC_HEAD));
                        return result;
                    } // if
                    return new HitData(Mech.LOC_HEAD);
                }
            }
            if (side == ToHitData.SIDE_LEFT) {
                // left side punch hits
                switch( roll ) {
                case 1:
                case 2:
                    return new HitData(Mech.LOC_LT);
                case 3:
                    return new HitData(Mech.LOC_CT);
                case 4:
                case 5:
                    return new HitData(Mech.LOC_LARM);
                case 6:
                    if (crew.hasEdgeRemaining()
                            && crew.getOptions().booleanOption("edge_when_headhit")) {
                        crew.decreaseEdge();
                        HitData result =  rollHitLocation(table, side, aimedLocation, aimingMode);
                        result.setUndoneLocation(new HitData(Mech.LOC_HEAD));
                        return result;
                    } // if
                    return new HitData(Mech.LOC_HEAD);
                }
            }
            if (side == ToHitData.SIDE_RIGHT) {
                // right side punch hits
                switch( roll ) {
                case 1:
                case 2:
                    return new HitData(Mech.LOC_RT);
                case 3:
                    return new HitData(Mech.LOC_CT);
                case 4:
                case 5:
                    return new HitData(Mech.LOC_RARM);
                case 6:
                    if (crew.hasEdgeRemaining() 
                            && crew.getOptions().booleanOption("edge_when_headhit")) {
                        crew.decreaseEdge();
                        HitData result =  rollHitLocation(table, side, aimedLocation, aimingMode);
                        result.setUndoneLocation(new HitData(Mech.LOC_HEAD));
                        return result;
                    } // if
                    return new HitData(Mech.LOC_HEAD);
                }
            }
            if (side == ToHitData.SIDE_REAR) {
                // rear punch hits
                switch( roll ) {
                case 1:
                    return new HitData(Mech.LOC_LARM, true);
                case 2:
                    return new HitData(Mech.LOC_LT, true);
                case 3:
                    return new HitData(Mech.LOC_CT, true);
                case 4:
                    return new HitData(Mech.LOC_RT, true);
                case 5:
                    return new HitData(Mech.LOC_RARM, true);
                case 6:
                    if (crew.hasEdgeRemaining() 
                            && crew.getOptions().booleanOption("edge_when_headhit")) {
                        crew.decreaseEdge();
                        HitData result =  rollHitLocation(table, side, aimedLocation, aimingMode);
                        result.setUndoneLocation(new HitData(Mech.LOC_HEAD, true));
                        return result;
                    } // if
                    return new HitData(Mech.LOC_HEAD, true);
                }
            }
        }
        if (table == ToHitData.HIT_KICK) {
            roll = Compute.d6(1);
            try {
                PrintWriter pw = PreferenceManager.getClientPreferences().getMekHitLocLog();                
                if ( pw != null ) {
                    pw.print( table );
                    pw.print( "\t" );
                    pw.print( side );
                    pw.print( "\t" );
                    pw.println( roll );
                }
            } catch ( Throwable thrown ) {
                thrown.printStackTrace();
            }
            if (side == ToHitData.SIDE_FRONT || side == ToHitData.SIDE_REAR) {
                // front/rear kick hits
                switch( roll ) {
                case 1:
                case 2:
                case 3:
                    return new HitData(Mech.LOC_RLEG,
                                       (side == ToHitData.SIDE_REAR));
                case 4:
                case 5:
                case 6:
                    return new HitData(Mech.LOC_LLEG,
                                       (side == ToHitData.SIDE_REAR));
                }
            }
            if (side == ToHitData.SIDE_LEFT) {
                // left side kick hits
                return new HitData(Mech.LOC_LLEG);
            }
            if (side == ToHitData.SIDE_RIGHT) {
                // right side kick hits
                return new HitData(Mech.LOC_RLEG);
            }
        }
        if (table == ToHitData.HIT_SWARM) {
            roll = Compute.d6(2);
            try {
                PrintWriter pw = PreferenceManager.getClientPreferences().getMekHitLocLog();
                if ( pw != null ) {
                    pw.print( table );
                    pw.print( "\t" );
                    pw.print( side );
                    pw.print( "\t" );
                    pw.println( roll );
                }
            } catch ( Throwable thrown ) {
                thrown.printStackTrace();
            }
            // Swarm attack locations.
            switch( roll ) {
            case 2:
                if (crew.hasEdgeRemaining() 
                        && crew.getOptions().booleanOption("edge_when_headhit")) {
                    crew.decreaseEdge();
                    HitData result =  rollHitLocation(table, side, aimedLocation, aimingMode);
                    result.setUndoneLocation(new HitData(Mech.LOC_HEAD, false, HitData.EFFECT_CRITICAL));
                    return result;
                } // if
                return new HitData(Mech.LOC_HEAD, false, HitData.EFFECT_CRITICAL);
            case 3:
                return new HitData(Mech.LOC_CT, true,
                                   HitData.EFFECT_CRITICAL);
            case 4:
                return new HitData(Mech.LOC_RT, true,
                                   HitData.EFFECT_CRITICAL);
            case 5:
                return new HitData(Mech.LOC_RT, false,
                                   HitData.EFFECT_CRITICAL);
            case 6:
                return new HitData(Mech.LOC_RARM, false,
                                   HitData.EFFECT_CRITICAL);
            case 7:
                return new HitData(Mech.LOC_CT, false,
                                   HitData.EFFECT_CRITICAL);
            case 8:
                return new HitData(Mech.LOC_LARM, false,
                                   HitData.EFFECT_CRITICAL);
            case 9:
                return new HitData(Mech.LOC_LT, false,
                                   HitData.EFFECT_CRITICAL);
            case 10:
                return new HitData(Mech.LOC_LT, true,
                                   HitData.EFFECT_CRITICAL);
            case 11:
                return new HitData(Mech.LOC_CT, true,
                                   HitData.EFFECT_CRITICAL);
            case 12:
                if (crew.hasEdgeRemaining()
                        && crew.getOptions().booleanOption("edge_when_headhit")) {
                    crew.decreaseEdge();
                    HitData result =  rollHitLocation(table, side, aimedLocation, aimingMode);
                    result.setUndoneLocation(new HitData(Mech.LOC_HEAD, false, HitData.EFFECT_CRITICAL));
                    return result;
                } // if
                return new HitData(Mech.LOC_HEAD, false, HitData.EFFECT_CRITICAL);
            }
        }
        if (table == ToHitData.HIT_ABOVE) {
            roll = Compute.d6(1);
            try {
                PrintWriter pw = PreferenceManager.getClientPreferences().getMekHitLocLog();
                if ( pw != null ) {
                    pw.print( table );
                    pw.print( "\t" );
                    pw.print( side );
                    pw.print( "\t" );
                    pw.println( roll );
                }
            } catch ( Throwable thrown ) {
                thrown.printStackTrace();
            }
            // Hits from above.
            switch( roll ) {
            case 1:
                return new HitData( Mech.LOC_LARM,
                                    (side == ToHitData.SIDE_REAR)  );
            case 2:
                return new HitData( Mech.LOC_LT,
                                    (side == ToHitData.SIDE_REAR) );
            case 3:
                return new HitData( Mech.LOC_CT,
                                    (side == ToHitData.SIDE_REAR) );
            case 4:
                return new HitData( Mech.LOC_RT,
                                    (side == ToHitData.SIDE_REAR) );
            case 5:
                return new HitData( Mech.LOC_RARM,
                                    (side == ToHitData.SIDE_REAR)  );
            case 6:
                if (crew.hasEdgeRemaining() 
                        && crew.getOptions().booleanOption("edge_when_headhit")) {
                    crew.decreaseEdge();
                    HitData result =  rollHitLocation(table, side, aimedLocation, aimingMode);
                    result.setUndoneLocation(new HitData(Mech.LOC_HEAD, (side == ToHitData.SIDE_REAR)));
                    return result;
                } // if
                return new HitData(Mech.LOC_HEAD, (side == ToHitData.SIDE_REAR));
            }
        }
        if (table == ToHitData.HIT_BELOW) {
            roll = Compute.d6(1);
            try {
                PrintWriter pw = PreferenceManager.getClientPreferences().getMekHitLocLog();
                if ( pw != null ) {
                    pw.print( table );
                    pw.print( "\t" );
                    pw.print( side );
                    pw.print( "\t" );
                    pw.println( roll );
                }
            } catch ( Throwable thrown ) {
                thrown.printStackTrace();
            }
            // Hits from below.
            switch( roll ) {
            case 1:
                return new HitData( Mech.LOC_LLEG,
                                    (side == ToHitData.SIDE_REAR)  );
            case 2:
                return new HitData( Mech.LOC_LLEG,
                                    (side == ToHitData.SIDE_REAR)  );
            case 3:
                return new HitData( Mech.LOC_LT,
                                    (side == ToHitData.SIDE_REAR) );
            case 4:
                return new HitData( Mech.LOC_RT,
                                    (side == ToHitData.SIDE_REAR) );
            case 5:
                return new HitData( Mech.LOC_RLEG,
                                    (side == ToHitData.SIDE_REAR)  );
            case 6:
                return new HitData( Mech.LOC_RLEG,
                                    (side == ToHitData.SIDE_REAR)  );
            }
        }
        return null;
    }
    
    /**
     * Called when a thru-armor-crit is rolled.  Checks the game options and
     * either returns no critical hit, rolls a floating crit, or returns a TAC 
     * in the specified location.
     */
    protected HitData tac(int table, int side, int location, boolean rear) {
        if (game.getOptions().booleanOption("no_tac")) {
            return new HitData(location, rear);
        } else if (game.getOptions().booleanOption("floating_crits")) {
            HitData hd = rollHitLocation(table, side);
            return new HitData(hd.getLocation(), hd.isRear(), HitData.EFFECT_CRITICAL);
        } else {
            return new HitData(location, rear, HitData.EFFECT_CRITICAL);
        }
    }

    
    /**
     * Gets the location that excess damage transfers to
     */
    public HitData getTransferLocation(HitData hit) {
        switch(hit.getLocation()) {
        case LOC_RT :
        case LOC_LT :
            return new HitData(LOC_CT, hit.isRear());
        case LOC_LLEG :
        case LOC_LARM :
            return new HitData(LOC_LT, hit.isRear());
        case LOC_RLEG :
        case LOC_RARM :
            return new HitData(LOC_RT, hit.isRear());
        case