[Rails-commits] 18xx/rails/game/correct CorrectionModeAction.java, NONE, 1.1 CashCorrectionAction.java, NONE, 1.1 CorrectionManager.java, NONE, 1.1 CorrectionType.java, NONE, 1.1 CashCorrectionManager.java, NONE, 1.1 CorrectionAction.java, 1.3, 1.4 CorrectCash.java, 1.4, NONE CorrectCashI.java, 1.1, NONE

[Stefan F. <ste...@us...>]

Update of /cvsroot/rails/18xx/rails/game/correct
In directory sfp-cvsdas-1.v30.ch3.sourceforge.com:/tmp/cvs-serv3705/rails/game/correct

Modified Files:
	CorrectionAction.java 
Added Files:
	CorrectionModeAction.java CashCorrectionAction.java 
	CorrectionManager.java CorrectionType.java 
	CashCorrectionManager.java 
Removed Files:
	CorrectCash.java CorrectCashI.java 
Log Message:
Added CorrectionMode - first part Cash Correction

--- NEW FILE: CorrectionModeAction.java ---
package rails.game.correct;

import rails.game.action.PossibleAction;
import rails.util.*;

import java.io.IOException;
import java.io.ObjectInputStream;


/**
 * Action class to request specific correction actions
 * @author freystef
 *
 */

public class CorrectionModeAction extends PossibleAction {
    
    public static final long serialVersionUID = 1L;

    // pre-conditions: type and state
    transient protected CorrectionType correction;
    protected String correctionName;
    
    protected boolean active;
    
    // post-conditions: none (except isActed!)
    
    /** 
     * Initializes with all possible correction types
     */
    public CorrectionModeAction(CorrectionType correction, boolean active) {
        this.correction = correction;
        correctionName = correction.name();
        this.active = active;
    }

    public CorrectionType getCorrection() {
        return correction;
    }

    public String getCorrectionName() {
        return correctionName;
    }
    
    public boolean isActive() {
        return active;
    }
    
    public String getInfo(){
        return (LocalText.getText(correctionName));
    }
    
    @Override
    public boolean equals(PossibleAction action) {
        if (!(action instanceof CorrectionModeAction)) return false;
        CorrectionModeAction a = (CorrectionModeAction) action;
        return (a.correction == this.correction && a.active == this.active);
    }

    @Override
    public String toString() {
        StringBuffer b = new StringBuffer("CorrectionModeAction");
        if (!acted) {
            b.append(" (not acted)");
            if (correction != null)
                b.append(", correction="+correction);
                b.append(", current state="+active);
        } else {
            b.append(" (acted)");
            if (correction != null)
                b.append(", correction="+correction);
                b.append(", previous state="+active);
        }
        return b.toString();
    }

    /** Deserialize */
    private void readObject(ObjectInputStream in) throws IOException,
            ClassNotFoundException {
        in.defaultReadObject();
        if (Util.hasValue(correctionName))
                correction = CorrectionType.valueOf(correctionName);
    }

    
//   a version with enumsets:
//    // pre-conditions
//    transient protected EnumSet<CorrectionType> possibleCorrections;
//    
//    // post-conditions
//    transient protected CorrectionType selectedCorrection;
//    
//    /** 
//     * Initializes with all possible correction types
//     */
//    public RequestCorrectionAction() {
//        possibleCorrections = EnumSet.allOf(CorrectionType.class);
//    }
//
//    /** 
//     * Initializes with a specific set of correction types
//     */
//    public RequestCorrectionAction(EnumSet<CorrectionType> possibleCorrections) {
//        this.possibleCorrections = possibleCorrections;
//    }
//
//    public EnumSet<CorrectionType> getPossibleCorrections() {
//        return possibleCorrections;
//    }
//    
//    public CorrectionType getSelectedCorrection() {
//        return selectedCorrection;
//    }
//    
//    public void setSelectedCorrection(CorrectionType selectedCorrection) {
//        this.selectedCorrection = selectedCorrection;
//    }
    

}

--- CorrectCashI.java DELETED ---

Index: CorrectionAction.java
===================================================================
RCS file: /cvsroot/rails/18xx/rails/game/correct/CorrectionAction.java,v
retrieving revision 1.3
retrieving revision 1.4
diff -C2 -d -r1.3 -r1.4
*** CorrectionAction.java	22 Feb 2010 22:48:18 -0000	1.3
--- CorrectionAction.java	3 Mar 2010 00:44:28 -0000	1.4
***************
*** 3,8 ****
  import rails.game.action.PossibleAction;;
  /**
!  * Base class for all actions that correct the state of the game
!  * that violate the ruleset.
   * 
   * @author freystef
--- 3,7 ----
  import rails.game.action.PossibleAction;;
  /**
!  * Base class for all actions that correct the state of the game. 
   * 
   * @author freystef
***************
*** 12,26 ****
  public abstract class CorrectionAction extends PossibleAction {
      
!     /** shows in correction menu */
!     protected boolean inCorrectionMenu;
! 
      
!     public boolean isInCorrectionMenu(){
!             return inCorrectionMenu;
      }
!     
!     public void setCorrectionMenu(boolean menu){
!         inCorrectionMenu = menu;
      }
-     
  }
--- 11,21 ----
  public abstract class CorrectionAction extends PossibleAction {
      
!     private CorrectionType correctionType;
      
!     public CorrectionType getCorrectionType() {
!         return correctionType;
      }
!     public void setCorrectionType(CorrectionType correctionType) {
!         this.correctionType = correctionType;
      }
  }

--- CorrectCash.java DELETED ---

--- NEW FILE: CorrectionType.java ---
package rails.game.correct;

import rails.game.GameManager;

/**
 * Enumerates the possible Corrections
*/
public enum CorrectionType {
    CORRECT_CASH {
        public CorrectionManager getManager(GameManager gm)
            {return CashCorrectionManager.getInstance(gm);}
        };
//     CORRECT_MAP ("CorrectName") {
//            CorrectionManager getManager(GameManager gm)
//                {return MapCorrectionManager.getInstance(gm);}
//            };

    public abstract CorrectionManager getManager(GameManager gm);

}

--- NEW FILE: CashCorrectionAction.java ---
package rails.game.correct;

import rails.game.*;
import rails.game.action.PossibleAction;
import rails.util.Util;

import java.io.IOException;
import java.io.ObjectInputStream;

/**
 * Correction action that changes the cash position of a cashholder.
 * 
 * @author Stefan Frey
 */
public class CashCorrectionAction extends CorrectionAction {

    /** The Constant serialVersionUID. */
    public static final long serialVersionUID = 1L;
    
    /* Preconditions */
   
    /** cash holder */
    transient private CashHolder correctCashHolder; 

    /** converted to name */
    private String cashHolderName; 
    private String cashHolderType;

    /** maximum Amount to deduct */
    private int maximumNegative; 
        
    /* Postconditions */

    /** selected cash amount */
    private int correctAmount; 
    
   /**
    * Instantiates a new correct cash
    * 
    * @param pl Player
    */
   public CashCorrectionAction(Player pl) {
       correctCashHolder = pl;
       cashHolderName = pl.getName();
       cashHolderType = "Player";
       maximumNegative = pl.getCash();
       setCorrectionType(CorrectionType.CORRECT_CASH);
   }
   /**
    * Instantiates a new correct cash
    * 
    * @param pc Public Company
    */
   public CashCorrectionAction(PublicCompanyI pc) {
       correctCashHolder = pc;
       cashHolderName = pc.getName();
       cashHolderType = "PublicCompany";
       maximumNegative = pc.getCash();
       setCorrectionType(CorrectionType.CORRECT_CASH);
   }
   
   
   public CashHolder getCashHolder() {
       return correctCashHolder;
   }

   public String getCashHolderName() {
       return cashHolderName;
   }

   public int getMaximumNegative(){
       return maximumNegative;
   }

   public int getAmount() {
       return correctAmount;
   }

   public void setAmount(int amount) {
       correctAmount = amount;
   }
    
    @Override
    public boolean equals(PossibleAction action) {
        if (!(action instanceof CashCorrectionAction)) return false;
        CashCorrectionAction a = (CashCorrectionAction) action;
        return (a.correctCashHolder == this.correctCashHolder &&
                a.maximumNegative == this.maximumNegative
        );
    }
    @Override
    public String toString() {
        StringBuffer b = new StringBuffer("CashCorrectionAction ");
        if (acted) {
            b.append("(Acted)");
            if (correctCashHolder != null)
                b.append(", correctCashHolder="+correctCashHolder);
            b.append(", correctAmount="+correctAmount);
        } else {
            b.append("(Not Acted)");
            if (correctCashHolder != null)
                b.append(", correctCashHolder="+correctCashHolder);
            b.append(", maximumNegative="+maximumNegative);
        }
        return b.toString();
    }

    /** Deserialize */
    private void readObject(ObjectInputStream in) throws IOException,
            ClassNotFoundException {
        in.defaultReadObject();
        if (Util.hasValue(cashHolderType) && Util.hasValue(cashHolderName)) {
            if (cashHolderType.equals("Player"))
                correctCashHolder = getGameManager().getPlayerManager().getPlayerByName(cashHolderName);
            else if (cashHolderType.equals("PublicCompany"))
                correctCashHolder = getCompanyManager().getCompanyByName(cashHolderName);
        }
    }
}

--- NEW FILE: CorrectionManager.java ---
package rails.game.correct;

import rails.game.GameManager;
import java.util.List;

/**
 * CorrectionManager is the interface for the specific CorrectionManagers
 * Corrections use the (abstract) factory pattern.
 * @author freystef
 *
 */

public interface CorrectionManager {
    
    public List<CorrectionAction> createCorrections();
    
    public boolean executeCorrection(CorrectionAction action);
    
}

--- NEW FILE: CashCorrectionManager.java ---
package rails.game.correct;

import rails.game.*;
import rails.game.move.CashMove;
import rails.util.*;
import java.util.*;

public final class CashCorrectionManager implements CorrectionManager {

    private GameManager gameManager;

    private CashCorrectionManager() {
    }
    
    public static CorrectionManager getInstance(GameManager gm) {
        CashCorrectionManager manager = new CashCorrectionManager();
        manager.gameManager = gm;
        return manager;
    }
    
    public List<CorrectionAction> createCorrections() {
        List<CorrectionAction> actions = new ArrayList<CorrectionAction>();
        
        List<Player> players = gameManager.getPlayers();
        for(Player pl:players){
            actions.add(new CashCorrectionAction(pl));
        }

        List<PublicCompanyI> publicCompanies = gameManager.getAllPublicCompanies();
        for(PublicCompanyI pc:publicCompanies){
            if (pc.hasFloated())
                actions.add(new CashCorrectionAction(pc));
        }
        
        return actions;
    }

    public boolean executeCorrection(CorrectionAction action) {

        boolean result = false;
        
        if (action instanceof CashCorrectionAction) {
            CashCorrectionAction cashAction=(CashCorrectionAction)action;

            CashHolder ch = cashAction.getCashHolder();
            int amount = cashAction.getAmount();
            
            String errMsg = null;

            if ((amount + ch.getCash()) < 0) {
                errMsg =
                    LocalText.getText("NotEnoughMoney", 
                            ch.getName(),
                            Bank.format(ch.getCash()),
                            Bank.format(-amount) 
                    );
            }

            if (errMsg != null) {
                DisplayBuffer.add(LocalText.getText("CorrectCashError",
                        ch.getName(),
                        errMsg));
                result = true;
            } else {
                // no error occured 
                gameManager.getMoveStack().start(false);

                Bank bank = gameManager.getBank();

                if (amount < 0) {
                    // negative amounts: remove cash from cashholder
                    new CashMove(ch, bank , -amount);
                    ReportBuffer.add(LocalText.getText("CorrectCashSubstractMoney",
                            ch.getName(),
                            Bank.format(-amount) ));
                } else if (amount > 0) {
                    // positive amounts: add cash to cashholder
                    new CashMove(bank, ch, amount);
                    ReportBuffer.add(LocalText.getText("CorrectCashAddMoney",
                            ch.getName(),
                            Bank.format(amount) ));
                }
                result = true;
            }
        }
    
       return result;
    }

}