View Javadoc

1   /*
2    * Created on Aug 25, 2004 
3    * 
4    *   Magic-Project is a turn based strategy simulator
5    *   Copyright (C) 2003-2007 Fabrice Daugan
6    *
7    *   This program is free software; you can redistribute it and/or modify it 
8    * under the terms of the GNU General Public License as published by the Free 
9    * Software Foundation; either version 2 of the License, or (at your option) any
10   * later version.
11   *
12   *   This program is distributed in the hope that it will be useful, but WITHOUT 
13   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
14   * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more 
15   * details.
16   *
17   *   You should have received a copy of the GNU General Public License along  
18   * with this program; if not, write to the Free Software Foundation, Inc., 
19   * 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
20   * 
21   */
22  package net.sf.magicproject.modifier;
23  
24  import java.util.List;
25  
26  import net.sf.magicproject.clickable.ability.Ability;
27  import net.sf.magicproject.clickable.targetable.card.MCard;
28  import net.sf.magicproject.event.MEventListener;
29  import net.sf.magicproject.expression.Expression;
30  import net.sf.magicproject.operation.Operation;
31  import net.sf.magicproject.stack.StackManager;
32  import net.sf.magicproject.test.Test;
33  
34  /***
35   * @author <a href="mailto:fabdouglas@users.sourceforge.net">Fabrice Daugan </a>
36   */
37  public class RegisterIndirection extends Modifier {
38  
39  	/***
40  	 * Creates a new instance of RegisterIndirection <br>
41  	 * 
42  	 * @param name
43  	 *          the modifier name
44  	 * @param to
45  	 *          the component to be attached to
46  	 * @param ability
47  	 *          is the ability owning this test. The card component of this
48  	 *          ability should correspond to the card owning this test too.
49  	 * @param whileCondition
50  	 *          the test conditionning the activation of this modifier.
51  	 * @param linkedEvents
52  	 *          the events to be registered. This events would cause this modifier
53  	 *          to be updated.
54  	 * @param until
55  	 *          this modifier exists while this test is true.
56  	 * @param linked
57  	 *          is the creator is linked to this modifier.
58  	 * @param layer
59  	 *          is the strategy used to add this modifier within the existing
60  	 *          chain.
61  	 * @param index
62  	 *          the modified index
63  	 * @param rightExpression
64  	 *          the expression used to modify the register
65  	 * @param op
66  	 *          the operation applied to previous value with the value of this
67  	 *          modifier.
68  	 */
69  	RegisterIndirection(String name, MCard to, Ability ability,
70  			Test whileCondition, List<MEventListener> linkedEvents,
71  			List<MEventListener> until, boolean linked, int layer, int index,
72  			Expression rightExpression, Operation op) {
73  		super(name, to, ability, whileCondition, linkedEvents, until, linked, layer);
74  		this.rightExpression = rightExpression;
75  		this.op = op;
76  		this.index = index;
77  	}
78  
79  	@Override
80  	public final void removeFromManager() {
81  		super.removeFromManager();
82  		if (!unregisteredModifier) {
83  			to.removeModifier(this, index);
84  		}
85  		unregisteredModifier = true;
86  	}
87  
88  	@Override
89  	public Modifier removeModifier(Modifier modifier) {
90  		if (this == modifier) {
91  			if (activated) {
92  				StackManager.postRefreshRegisters(to, index);
93  			}
94  			return next;
95  		}
96  		return super.removeModifier(modifier);
97  	}
98  
99  	/***
100 	 * Return the modified value of the specified one. This value is only modified
101 	 * if the while condition test succeed.
102 	 * 
103 	 * @param oldValue
104 	 *          the old value
105 	 * @return the modified value.
106 	 */
107 	public int getValue(int oldValue) {
108 		if (activated) {
109 			if (next != null) {
110 				return ((RegisterIndirection) next).getValue(op.process(oldValue,
111 						rightValue));
112 			}
113 			return op.process(oldValue, rightValue);
114 		}
115 		if (next != null) {
116 			return ((RegisterIndirection) next).getValue(oldValue);
117 		}
118 		return oldValue;
119 	}
120 
121 	@Override
122 	public void refresh() {
123 		boolean oldActivated = activated;
124 		if (whileCondition.test(ability, to)) {
125 			activated = true;
126 			int oldValue = rightValue;
127 			// evaluate the counter
128 			rightValue = rightExpression.getValue(ability, to, null);
129 			if (oldValue != rightValue || !oldActivated) {
130 				StackManager.postRefreshRegisters(to, index);
131 			}
132 		} else {
133 			activated = false;
134 
135 			if (oldActivated) {
136 				// this register has changed
137 				StackManager.postRefreshRegisters(to, index);
138 			}
139 		}
140 	}
141 
142 	/***
143 	 * The looked for register index
144 	 */
145 	private int index;
146 
147 	/***
148 	 * right integer value The complex expression to use for the right value. Is
149 	 * null if the IdToken number is not a complex expression.
150 	 */
151 	private Expression rightExpression = null;
152 
153 	/***
154 	 * The associated operation of this indirection
155 	 */
156 	private Operation op;
157 
158 	/***
159 	 * right integer value
160 	 */
161 	private int rightValue;
162 
163 }