diff --git a/org.eclipse.amp/doc/org.eclipse.amp.doc/build/amp.mediawiki b/org.eclipse.amp/doc/org.eclipse.amp.doc/build/amp.mediawiki
index 21528d7..3305dcf 100644
--- a/org.eclipse.amp/doc/org.eclipse.amp.doc/build/amp.mediawiki
+++ b/org.eclipse.amp/doc/org.eclipse.amp.doc/build/amp.mediawiki
@@ -98,9 +98,9 @@
 
 Metascape, LLC is the primary contributor to AMP and provides Agent-Based Modeling tools, including sophisticated tools based on the AMF platform, and comprehensive consulting services. For more information on Metascape products and services visit http://metascapeabm.com.
 
-The AMF meta-model started life as [[http://www.agent2005.anl.gov/2006procpdf/Parker_Agent_2006.pdf|"score"]], a component of the Repast Simphony environment. Argonne National Labs supported the initial development in 2007 and agreed to contribute the relevant IP to the Eclipse project in 2009. It wasn't fully utilized within Simphony, and migrated from there to the MetaABM project supported by Metascape. The MetaABM project defined a complete editor, code-generation and model execution suite that formed the initial AMP AMF contribution. Metascape has sponsored the development of AMF from 2007 through the present.
+The AMF meta-model started life in 2007 as [[http://www.agent2005.anl.gov/2006procpdf/Parker_Agent_2006.pdf|"score"]], a component of the Repast Simphony environment and was contributed under the EPL by Argonne National Labs. AMF was further developed by Metascape starting in 2007 as the MetaABM project, and it along with what becase AMP where was contributed by Metascape to Eclipse in 2009. Metascape continues to be the primary sponsor and contributor to the project.
 
-The AMP logo was inspired by the [[http://swarm.org Swarm logo]] with their kind permission.
+The AMP logo was inspired by the [[http://swarm.org Swarm logo]] and is used with their kind permission.
 =Modeler Guide=
 
 ==Overview==
@@ -2039,7 +2039,7 @@
 
 [[Image:images/edit_tutorial/SimpleTutorial13BuildGridAgents.png]]
 
-===Actions===
+===Actions Part I===
 
 ====Create Initialize Rule====
 
@@ -2112,7 +2112,7 @@
 [[Image:images/edit_tutorial/SimpleTutorial25FinishStyle.png | right]]
 
 
-===Actions 2 Movement Rule===
+===Actions Part II===
 
 To make our agents move randomly every iteration, we will create a Rule. (For those familiar with Repast or other scheduling oriented AM platforms, a rule is just a schedule that gets activated each and every period for all agents.) At this point in the tutorial, we'll show screenshots only for aspects of the modeling process that haven't already been covered.
 
@@ -2126,13 +2126,13 @@
 
 Often, we would pick the "Spatial: Neighbor" function to take a random walk, but according to the specification, we actually want to move into some random Cell within distance four (4). So we will pick "Spatial: Within" from the list of functions.
 
-=====Model Error Handling=====
+=====Fixing Model Errors=====
 
 Instead of specifying the actual distance now, let's see how the Agent Modeling Framework error checking capabilities can help us in model development. Save the model by selecting '''File > Save''' from the application menu. Notice that a red marker appears next to the StupidModel1.metaabm file. If you reveal the '''Problems View''' you'll see a list of current errors and warnings and if you open the errors node in that list, you'll see an item reporting that the input has no value. If you double-click on that item, you'll be taken to the input for the Within query and you'll be able to edit it.
 
 [[Image:images/edit_tutorial/SimpleTutorial27NoValue.png | right]]
     
-In addition to error markers, metaABM provides warnings designed to help you avoid common design mistakes. For example, a warning will be issued if you attempt to move an agent from its selection to the same selection; this is not strictly speaking an error, but it doesn't make much sense. You'll also recieve warning for default values that have not been specified. You might notice that the Demographic Prisonner's Dilemma model has warning markers, this is because we were happy with the '0' default values for the attributes and didn't provide any. (By the way, you might also notice a number of Java warnings. By default the Eclipse IDE is very conservative when it comes to warnings, and expects the usage of language constructs that we choose not to use. A full discussion of all of this is beyond the scope of the tutorial, but see the Eclipse documentation on problem views for more ideas about how to customize these views.)
+In addition to error markers, metaABM provides warnings designed to help you avoid common design mistakes. For example, a warning will be issued if you attempt to move an agent from its selection to the same selection; this is not strictly speaking an error, but it doesn't make much sense. You'll also receive a warning for default values that have not been specified. You might notice that the Demographic Prisonner's Dilemma model has warning markers, this is because we were happy with the '0' default values for the attributes and didn't provide any. (By the way, you might also notice a number of Java warnings. By default the Eclipse IDE is very conservative when it comes to warnings, and expects the usage of language constructs that we choose not to use. A full discussion of all of this is beyond the scope of the tutorial, but see the Eclipse documentation on problem views for more ideas about how to customize these views.)
 
 To fix this error we just need to assign a value for search distance. We '''could''' simply create a literal for the Spatial: Within Query but that isn't really good practice. (Originally the Agent Modeling Framework didn't even support Literal values, but we added them for convenience.) Now, we will create our first Attribute. In this case, we want the Attribute to belong to the Stupid Model as it will be the same value for all Agents for now. So right-click on the Stupid Model context Attributes node and create a new one.
 
@@ -2146,14 +2146,20 @@
 
 [[Image:images/edit_tutorial/SimpleTutorial30AttributeInput.png | right]]
 
-Now, we need to combine the requirement that the cell be available with the requirement that it be within 4 cell's distance. To accomplish this, we'll add an Intersection Action. The Logical Actions, including "Intersection", "Union" and "None" define how Query Actions work together. So create an Intersection Actions as a target of the Spatial Available Query. (Not the Within Query).
+=====Create Intersection Action=====
+
+Now, we need to combine the requirement that the cell be available with the requirement that it be within 4 cell's distance. To accomplish this, we'll add an Intersection Action. The Logical Actions, including "Intersection", "Union" and "None" define how Query Actions work together. The Intersection Action needs to be a target of ''both'' the Available and Within targets. This means that the action has two sources. See the Modeler's Guide for more information about how action flow works.
+
+Editing actions with multiple sources and targets is the most complex aspect of the model editor so you may need to work with this example a bit in order to get a feel for how it should work. First, we create the Intersection Action as a target of the Spatial Available Query. (Not the Within Query).
 
 [[Image:images/edit_tutorial/SimpleTutorial31Intersect.png | right]]
 
-The Intersection Action needs to be a target of ''both'' the Available and Within targets. To accomplish this, drag the Intersection Action over the Within Query. It's a bit hard to see this in a static image, but you simply need to click on the Intersection Action, move it so that it is over the Within target, and release the mouse.
+Then we need to make the Intersection Action a target of the Within Query as well. To accomplish this, we drag the Intersection Action over the Within Query while holding down the ctrl-key. Depending on your environment, you may need to begin dragging before you click the control key -- otherwise, your initial control click will bring up the context menu. It's a bit hard to see this in a static image, but you simply need to click on the Intersection Action, begin dragging, hold down the ctrl key, move the mouse so that it is over the Within target, and release the mouse. It sounds more complicated then it is!
 
 [[Image:images/edit_tutorial/SimpleTutorial32IntersectAdd.png | right]]
 
+=====Add Move Action=====
+
 Finally, add a Move target to the Intersection.
 
 [[Image:images/edit_tutorial/SimpleTutorial33Move.png | right]]
@@ -2519,7 +2525,7 @@
 {| style="border-top: 1px solid #aaa; width: 100%" cellpadding="20"
 |-valign="top"
 | '''Parameter Management Support'''
-| AMP now has full support for editing and launching of parameter files, including code completion. There is also support for creation of tests and analysis of test results. Finally, data can now be generated to a common EMD based (adata) data format.
+| AMP now has full support for editing and launching of parameter files, including code completion and all of the other editor niceties.
 |-valign="top"
 | &nbsp;
 | [[Image:images/params/Edit.png]]
diff --git a/org.eclipse.amp/doc/org.eclipse.amp.doc/build/amp.xml b/org.eclipse.amp/doc/org.eclipse.amp.doc/build/amp.xml
index eb6851a..42239ac 100644
--- a/org.eclipse.amp/doc/org.eclipse.amp.doc/build/amp.xml
+++ b/org.eclipse.amp/doc/org.eclipse.amp.doc/build/amp.xml
@@ -132,11 +132,11 @@
 			<para>Metascape, LLC is the primary contributor to AMP and provides Agent-Based Modeling tools, including sophisticated tools based on the AMF platform, and comprehensive consulting services. For more information on Metascape products and services visit 
 				<ulink url="http://metascapeabm.com">http://metascapeabm.com</ulink>.
 			</para>
-			<para>The AMF meta-model started life as 
-				<ulink url="/wiki/http://www.agent2005.anl.gov/2006procpdf/Parker_Agent_2006.pdf">"score"</ulink>, a component of the Repast Simphony environment. Argonne National Labs supported the initial development in 2007 and agreed to contribute the relevant IP to the Eclipse project in 2009. It wasn't fully utilized within Simphony, and migrated from there to the MetaABM project supported by Metascape. The MetaABM project defined a complete editor, code-generation and model execution suite that formed the initial AMP AMF contribution. Metascape has sponsored the development of AMF from 2007 through the present.
+			<para>The AMF meta-model started life in 2007 as 
+				<ulink url="/wiki/http://www.agent2005.anl.gov/2006procpdf/Parker_Agent_2006.pdf">"score"</ulink>, a component of the Repast Simphony environment and was contributed under the EPL by Argonne National Labs. AMF was further developed by Metascape starting in 2007 as the MetaABM project, and it along with what becase AMP where was contributed by Metascape to Eclipse in 2009. Metascape continues to be the primary sponsor and contributor to the project.
 			</para>
 			<para>The AMP logo was inspired by the 
-				<ulink url="/wiki/http://swarm.org_Swarm_logo">http://swarm.org Swarm logo</ulink> with their kind permission.
+				<ulink url="/wiki/http://swarm.org_Swarm_logo">http://swarm.org Swarm logo</ulink> and is used with their kind permission.
 			</para>
 		</section>
 	</chapter>
@@ -3180,8 +3180,8 @@
 					</section>
 				</section>
 			</section>
-			<section id="Actions_4">
-				<title>Actions</title>
+			<section id="Actions_Part_I">
+				<title>Actions Part I</title>
 				<section id="Create_Initialize_Rule">
 					<title>Create Initialize Rule</title>
 					<para>Now we can make these bugs do something. Let's create our first rule. In this case we're going to create a special Initialize Action that executes once when the model is first created for each agent. All Actions begin from the agent (or style) Actions list and there are only a few Actions that can serve as roots. See the Design section of this guide for much more on that. Open the Bug node by clicking the triangle icon, right-click on the Actions node and select the '''Create Member &gt; Initialize Action.</para>
@@ -3319,8 +3319,8 @@
 					</section>
 				</section>
 			</section>
-			<section id="Actions_2_Movement_Rule">
-				<title>Actions 2 Movement Rule</title>
+			<section id="Actions_Part_II">
+				<title>Actions Part II</title>
 				<para>To make our agents move randomly every iteration, we will create a Rule. (For those familiar with Repast or other scheduling oriented AM platforms, a rule is just a schedule that gets activated each and every period for all agents.) At this point in the tutorial, we'll show screenshots only for aspects of the modeling process that haven't already been covered.</para>
 				<section id="Create_Select_and_Query_Actions">
 					<section>
@@ -3341,8 +3341,8 @@
 						</para>
 						<para>Often, we would pick the "Spatial: Neighbor" function to take a random walk, but according to the specification, we actually want to move into some random Cell within distance four (4). So we will pick "Spatial: Within" from the list of functions.</para>
 					</section>
-					<section id="Model_Error_Handling">
-						<title>Model Error Handling</title>
+					<section id="Fixing_Model_Errors">
+						<title>Fixing Model Errors</title>
 						<para>Instead of specifying the actual distance now, let's see how the Agent Modeling Framework error checking capabilities can help us in model development. Save the model by selecting 
 							<emphasis role="bold">File &gt; Save</emphasis> from the application menu. Notice that a red marker appears next to the StupidModel1.metaabm file. If you reveal the 
 							<emphasis role="bold">Problems View</emphasis> you'll see a list of current errors and warnings and if you open the errors node in that list, you'll see an item reporting that the input has no value. If you double-click on that item, you'll be taken to the input for the Within query and you'll be able to edit it.
@@ -3354,7 +3354,7 @@
 								</imageobject>
 							</mediaobject>
 						</para>
-						<para>In addition to error markers, metaABM provides warnings designed to help you avoid common design mistakes. For example, a warning will be issued if you attempt to move an agent from its selection to the same selection; this is not strictly speaking an error, but it doesn't make much sense. You'll also recieve warning for default values that have not been specified. You might notice that the Demographic Prisonner's Dilemma model has warning markers, this is because we were happy with the '0' default values for the attributes and didn't provide any. (By the way, you might also notice a number of Java warnings. By default the Eclipse IDE is very conservative when it comes to warnings, and expects the usage of language constructs that we choose not to use. A full discussion of all of this is beyond the scope of the tutorial, but see the Eclipse documentation on problem views for more ideas about how to customize these views.)</para>
+						<para>In addition to error markers, metaABM provides warnings designed to help you avoid common design mistakes. For example, a warning will be issued if you attempt to move an agent from its selection to the same selection; this is not strictly speaking an error, but it doesn't make much sense. You'll also receive a warning for default values that have not been specified. You might notice that the Demographic Prisonner's Dilemma model has warning markers, this is because we were happy with the '0' default values for the attributes and didn't provide any. (By the way, you might also notice a number of Java warnings. By default the Eclipse IDE is very conservative when it comes to warnings, and expects the usage of language constructs that we choose not to use. A full discussion of all of this is beyond the scope of the tutorial, but see the Eclipse documentation on problem views for more ideas about how to customize these views.)</para>
 						<para>To fix this error we just need to assign a value for search distance. We 
 							<emphasis role="bold">could</emphasis> simply create a literal for the Spatial: Within Query but that isn't really good practice. (Originally the Agent Modeling Framework didn't even support Literal values, but we added them for convenience.) Now, we will create our first Attribute. In this case, we want the Attribute to belong to the Stupid Model as it will be the same value for all Agents for now. So right-click on the Stupid Model context Attributes node and create a new one.
 						</para>
@@ -3381,7 +3381,13 @@
 								</imageobject>
 							</mediaobject>
 						</para>
-						<para>Now, we need to combine the requirement that the cell be available with the requirement that it be within 4 cell's distance. To accomplish this, we'll add an Intersection Action. The Logical Actions, including "Intersection", "Union" and "None" define how Query Actions work together. So create an Intersection Actions as a target of the Spatial Available Query. (Not the Within Query).</para>
+					</section>
+					<section id="Create_Intersection_Action">
+						<title>Create Intersection Action</title>
+						<para>Now, we need to combine the requirement that the cell be available with the requirement that it be within 4 cell's distance. To accomplish this, we'll add an Intersection Action. The Logical Actions, including "Intersection", "Union" and "None" define how Query Actions work together. The Intersection Action needs to be a target of 
+							<emphasis role="italic">both</emphasis> the Available and Within targets. This means that the action has two sources. See the Modeler's Guide for more information about how action flow works.
+						</para>
+						<para>Editing actions with multiple sources and targets is the most complex aspect of the model editor so you may need to work with this example a bit in order to get a feel for how it should work. First, we create the Intersection Action as a target of the Spatial Available Query. (Not the Within Query).</para>
 						<para>
 							<mediaobject>
 								<imageobject>
@@ -3389,9 +3395,7 @@
 								</imageobject>
 							</mediaobject>
 						</para>
-						<para>The Intersection Action needs to be a target of 
-							<emphasis role="italic">both</emphasis> the Available and Within targets. To accomplish this, drag the Intersection Action over the Within Query. It's a bit hard to see this in a static image, but you simply need to click on the Intersection Action, move it so that it is over the Within target, and release the mouse.
-						</para>
+						<para>Then we need to make the Intersection Action a target of the Within Query as well. To accomplish this, we drag the Intersection Action over the Within Query while holding down the ctrl-key. Depending on your environment, you may need to begin dragging before you click the control key -- otherwise, your initial control click will bring up the context menu. It's a bit hard to see this in a static image, but you simply need to click on the Intersection Action, begin dragging, hold down the ctrl key, move the mouse so that it is over the Within target, and release the mouse. It sounds more complicated then it is!</para>
 						<para>
 							<mediaobject>
 								<imageobject>
@@ -3399,6 +3403,9 @@
 								</imageobject>
 							</mediaobject>
 						</para>
+					</section>
+					<section id="Add_Move_Action">
+						<title>Add Move Action</title>
 						<para>Finally, add a Move target to the Intersection.</para>
 						<para>
 							<mediaobject>
@@ -3952,7 +3959,7 @@
 						<td>
 							<emphasis role="bold">Parameter Management Support</emphasis>
 						</td>
-						<td>AMP now has full support for editing and launching of parameter files, including code completion. There is also support for creation of tests and analysis of test results. Finally, data can now be generated to a common EMD based (adata) data format.</td>
+						<td>AMP now has full support for editing and launching of parameter files, including code completion and all of the other editor niceties.</td>
 					</tr>
 					<tr>
 						<td>&nbsp;</td>
diff --git a/org.eclipse.amp/doc/org.eclipse.amp.doc/build/ampPDF.xml b/org.eclipse.amp/doc/org.eclipse.amp.doc/build/ampPDF.xml
index 123098e..f30dee5 100644
--- a/org.eclipse.amp/doc/org.eclipse.amp.doc/build/ampPDF.xml
+++ b/org.eclipse.amp/doc/org.eclipse.amp.doc/build/ampPDF.xml
@@ -131,11 +131,11 @@
 			<para>Metascape, LLC is the primary contributor to AMP and provides Agent-Based Modeling tools, including sophisticated tools based on the AMF platform, and comprehensive consulting services. For more information on Metascape products and services visit 
 				<ulink url="http://metascapeabm.com">http://metascapeabm.com</ulink>.
 			</para>
-			<para>The AMF meta-model started life as 
-				<ulink url="/wiki/http://www.agent2005.anl.gov/2006procpdf/Parker_Agent_2006.pdf">"score"</ulink>, a component of the Repast Simphony environment. Argonne National Labs supported the initial development in 2007 and agreed to contribute the relevant IP to the Eclipse project in 2009. It wasn't fully utilized within Simphony, and migrated from there to the MetaABM project supported by Metascape. The MetaABM project defined a complete editor, code-generation and model execution suite that formed the initial AMP AMF contribution. Metascape has sponsored the development of AMF from 2007 through the present.
+			<para>The AMF meta-model started life in 2007 as 
+				<ulink url="/wiki/http://www.agent2005.anl.gov/2006procpdf/Parker_Agent_2006.pdf">"score"</ulink>, a component of the Repast Simphony environment and was contributed under the EPL by Argonne National Labs. AMF was further developed by Metascape starting in 2007 as the MetaABM project, and it along with what becase AMP where was contributed by Metascape to Eclipse in 2009. Metascape continues to be the primary sponsor and contributor to the project.
 			</para>
 			<para>The AMP logo was inspired by the 
-				<ulink url="/wiki/http://swarm.org_Swarm_logo">http://swarm.org Swarm logo</ulink> with their kind permission.
+				<ulink url="/wiki/http://swarm.org_Swarm_logo">http://swarm.org Swarm logo</ulink> and is used with their kind permission.
 			</para>
 		</section>
 	</chapter>
@@ -3179,8 +3179,8 @@
 					</section>
 				</section>
 			</section>
-			<section id="Actions_4">
-				<title>Actions</title>
+			<section id="Actions_Part_I">
+				<title>Actions Part I</title>
 				<section id="Create_Initialize_Rule">
 					<title>Create Initialize Rule</title>
 					<para>Now we can make these bugs do something. Let's create our first rule. In this case we're going to create a special Initialize Action that executes once when the model is first created for each agent. All Actions begin from the agent (or style) Actions list and there are only a few Actions that can serve as roots. See the Design section of this guide for much more on that. Open the Bug node by clicking the triangle icon, right-click on the Actions node and select the '''Create Member &gt; Initialize Action.</para>
@@ -3318,8 +3318,8 @@
 					</section>
 				</section>
 			</section>
-			<section id="Actions_2_Movement_Rule">
-				<title>Actions 2 Movement Rule</title>
+			<section id="Actions_Part_II">
+				<title>Actions Part II</title>
 				<para>To make our agents move randomly every iteration, we will create a Rule. (For those familiar with Repast or other scheduling oriented AM platforms, a rule is just a schedule that gets activated each and every period for all agents.) At this point in the tutorial, we'll show screenshots only for aspects of the modeling process that haven't already been covered.</para>
 				<section id="Create_Select_and_Query_Actions">
 					<section>
@@ -3340,8 +3340,8 @@
 						</para>
 						<para>Often, we would pick the "Spatial: Neighbor" function to take a random walk, but according to the specification, we actually want to move into some random Cell within distance four (4). So we will pick "Spatial: Within" from the list of functions.</para>
 					</section>
-					<section id="Model_Error_Handling">
-						<title>Model Error Handling</title>
+					<section id="Fixing_Model_Errors">
+						<title>Fixing Model Errors</title>
 						<para>Instead of specifying the actual distance now, let's see how the Agent Modeling Framework error checking capabilities can help us in model development. Save the model by selecting 
 							<emphasis role="bold">File &gt; Save</emphasis> from the application menu. Notice that a red marker appears next to the StupidModel1.metaabm file. If you reveal the 
 							<emphasis role="bold">Problems View</emphasis> you'll see a list of current errors and warnings and if you open the errors node in that list, you'll see an item reporting that the input has no value. If you double-click on that item, you'll be taken to the input for the Within query and you'll be able to edit it.
@@ -3353,7 +3353,7 @@
 								</imageobject>
 							</mediaobject>
 						</para>
-						<para>In addition to error markers, metaABM provides warnings designed to help you avoid common design mistakes. For example, a warning will be issued if you attempt to move an agent from its selection to the same selection; this is not strictly speaking an error, but it doesn't make much sense. You'll also recieve warning for default values that have not been specified. You might notice that the Demographic Prisonner's Dilemma model has warning markers, this is because we were happy with the '0' default values for the attributes and didn't provide any. (By the way, you might also notice a number of Java warnings. By default the Eclipse IDE is very conservative when it comes to warnings, and expects the usage of language constructs that we choose not to use. A full discussion of all of this is beyond the scope of the tutorial, but see the Eclipse documentation on problem views for more ideas about how to customize these views.)</para>
+						<para>In addition to error markers, metaABM provides warnings designed to help you avoid common design mistakes. For example, a warning will be issued if you attempt to move an agent from its selection to the same selection; this is not strictly speaking an error, but it doesn't make much sense. You'll also receive a warning for default values that have not been specified. You might notice that the Demographic Prisonner's Dilemma model has warning markers, this is because we were happy with the '0' default values for the attributes and didn't provide any. (By the way, you might also notice a number of Java warnings. By default the Eclipse IDE is very conservative when it comes to warnings, and expects the usage of language constructs that we choose not to use. A full discussion of all of this is beyond the scope of the tutorial, but see the Eclipse documentation on problem views for more ideas about how to customize these views.)</para>
 						<para>To fix this error we just need to assign a value for search distance. We 
 							<emphasis role="bold">could</emphasis> simply create a literal for the Spatial: Within Query but that isn't really good practice. (Originally the Agent Modeling Framework didn't even support Literal values, but we added them for convenience.) Now, we will create our first Attribute. In this case, we want the Attribute to belong to the Stupid Model as it will be the same value for all Agents for now. So right-click on the Stupid Model context Attributes node and create a new one.
 						</para>
@@ -3380,7 +3380,13 @@
 								</imageobject>
 							</mediaobject>
 						</para>
-						<para>Now, we need to combine the requirement that the cell be available with the requirement that it be within 4 cell's distance. To accomplish this, we'll add an Intersection Action. The Logical Actions, including "Intersection", "Union" and "None" define how Query Actions work together. So create an Intersection Actions as a target of the Spatial Available Query. (Not the Within Query).</para>
+					</section>
+					<section id="Create_Intersection_Action">
+						<title>Create Intersection Action</title>
+						<para>Now, we need to combine the requirement that the cell be available with the requirement that it be within 4 cell's distance. To accomplish this, we'll add an Intersection Action. The Logical Actions, including "Intersection", "Union" and "None" define how Query Actions work together. The Intersection Action needs to be a target of 
+							<emphasis role="italic">both</emphasis> the Available and Within targets. This means that the action has two sources. See the Modeler's Guide for more information about how action flow works.
+						</para>
+						<para>Editing actions with multiple sources and targets is the most complex aspect of the model editor so you may need to work with this example a bit in order to get a feel for how it should work. First, we create the Intersection Action as a target of the Spatial Available Query. (Not the Within Query).</para>
 						<para>
 							<mediaobject>
 								<imageobject>
@@ -3388,9 +3394,7 @@
 								</imageobject>
 							</mediaobject>
 						</para>
-						<para>The Intersection Action needs to be a target of 
-							<emphasis role="italic">both</emphasis> the Available and Within targets. To accomplish this, drag the Intersection Action over the Within Query. It's a bit hard to see this in a static image, but you simply need to click on the Intersection Action, move it so that it is over the Within target, and release the mouse.
-						</para>
+						<para>Then we need to make the Intersection Action a target of the Within Query as well. To accomplish this, we drag the Intersection Action over the Within Query while holding down the ctrl-key. Depending on your environment, you may need to begin dragging before you click the control key -- otherwise, your initial control click will bring up the context menu. It's a bit hard to see this in a static image, but you simply need to click on the Intersection Action, begin dragging, hold down the ctrl key, move the mouse so that it is over the Within target, and release the mouse. It sounds more complicated then it is!</para>
 						<para>
 							<mediaobject>
 								<imageobject>
@@ -3398,6 +3402,9 @@
 								</imageobject>
 							</mediaobject>
 						</para>
+					</section>
+					<section id="Add_Move_Action">
+						<title>Add Move Action</title>
 						<para>Finally, add a Move target to the Intersection.</para>
 						<para>
 							<mediaobject>
diff --git a/org.eclipse.amp/doc/org.eclipse.amp.doc/cheatsheets/LoadSampleProjectsVCS.xml b/org.eclipse.amp/doc/org.eclipse.amp.doc/cheatsheets/LoadSampleProjectsVCS.xml
index 93b4144..1ac6112 100644
--- a/org.eclipse.amp/doc/org.eclipse.amp.doc/cheatsheets/LoadSampleProjectsVCS.xml
+++ b/org.eclipse.amp/doc/org.eclipse.amp.doc/cheatsheets/LoadSampleProjectsVCS.xml
@@ -11,7 +11,7 @@
          skip="true"
          title="Get Ascape Examples Team Project Set File">
       <description>
-         Using your web browser, download the following file to any location on your hard drive: http://eclipse.org/amp/project-sets/ascape.psf. &lt;i&gt;Note that the Ascape projects we will be importing are not part of the Eclipse project itself. They are hosted seperatly on the ascape sourceforge site.&lt;/i&gt;
+         Using your web browser, download the following file to any location on your hard drive: http://eclipse.org/amp/project-sets/ascape.psf. Note that the Ascape projects we will be importing are not part of the Eclipse project itself. They are hosted seperatly on the ascape sourceforge site.
       </description>
       <command
             required="true"
@@ -22,7 +22,7 @@
          skip="true"
          title="Import Ascape Project Set">
       <description>
-         We&apos;ll use the team project set wizard to import the example from the AMP website. Open the wizard, browse to the location you just downloaded the file to, and click Finish. The examples will be loaded from the Ascape SourceForge server into your workspace.
+         We&apos;ll use the team project set wizard to import the example from the AMP website. Open the wizard, browse to the location you just downloaded the file to, and click Finish. The examples will be loaded from the Ascape SourceForge server into your workspace. IMPORTANT: Please note that the version control system (SVN) cannot be bundled with all builds for IP reasons. If it hasn&apos;t been bundled you will recieve errors and a dialog prompting you to install the SVN connectors. Just follow the prompts and try again after restarting Eclipse.
       </description>
       <command
             required="true"
diff --git a/org.eclipse.amp/doc/org.eclipse.amp.doc/customBuild.xml b/org.eclipse.amp/doc/org.eclipse.amp.doc/customBuild.xml
index cdb813d..113faa9 100644
--- a/org.eclipse.amp/doc/org.eclipse.amp.doc/customBuild.xml
+++ b/org.eclipse.amp/doc/org.eclipse.amp.doc/customBuild.xml
@@ -6,11 +6,11 @@
 -->
 <project name="org.eclipse.amp.doc" default="build-doc" basedir=".">
 
+	<property name="docbook.version" value="1.76.0" />
+	<property name="fop.version" value="1.0" />
 	<!--
 		Global vars
 	-->
-	<property name="fs" value="${file.separator}" />
-	
 	<property name="document.name" value="amp" />
 	<property name="document.stylesheet" value="styles/html.xsl" />
 	<property name="dbpdf.stylesheet" value="styles/dbpdfdb.xsl" />
@@ -21,19 +21,20 @@
 	<property name="html-css.file" value="styles/book.css" />
 
 	<property name="build.dir" value="build" />
-	<property name="download.dir" value="${java.io.tmpdir}${fs}downloads" />
+	<property name="download.dir" value="${java.io.tmpdir}${file.separator}downloads" />
+	<echo>Files downloaded to: ${java.io.tmpdir}${file.separator}downloads</echo>
 	<!-- Changed from XText version to write directly to the web dir..saves on cvs thrashing.. -->
 	<property name="website.dir" value="../../../amp" />
-	<property name="website.doc.dir" value="${website.dir}${fs}documentation" />
-	<property name="website.content.dir" value="${website.doc.dir}${fs}contents" />
+	<property name="website.doc.dir" value="${website.dir}${file.separator}documentation" />
+	<property name="website.content.dir" value="${website.doc.dir}${file.separator}contents" />
 
 	<property name="wikitext.url" value="http://download.eclipse.org/tools/mylyn/update/weekly/mylyn-wikitext-standalone-latest.zip" />
-	<property name="wikitext.dir" value="${download.dir}${fs}wikitext" />
+	<property name="wikitext.dir" value="${download.dir}${file.separator}wikitext" />
 
 	<target name="check-wikitext">
 		<condition property="hasWikiText">
 			<and>
-				<available file="${download.dir}${fs}wikitext.zip" property="hasWikiTextZIP" />
+				<available file="${download.dir}${file.separator}wikitext.zip" property="hasWikiTextZIP" />
 				<available file="${wikitext.dir}" property="hasWikiTextDir" />
 			</and>
 		</condition>
@@ -41,8 +42,8 @@
 
 	<target name="get-wikitext" description="Downloads WikiText" depends="check-wikitext" unless="hasWikiText">
 		<echo>Downloading WikiText...</echo>
-		<get dest="${download.dir}${fs}wikitext.zip" src="${wikitext.url}" />
-		<unzip src="${download.dir}${fs}wikitext.zip" dest="${wikitext.dir}">
+		<get dest="${download.dir}${file.separator}wikitext.zip" src="${wikitext.url}" />
+		<unzip src="${download.dir}${file.separator}wikitext.zip" dest="${wikitext.dir}">
 			<patternset includes="**/*.jar" />
 			<mapper type="flatten" />
 		</unzip>
@@ -51,6 +52,9 @@
 	<target name="install-wikitext" depends="get-wikitext">
 		<taskdef resource="org/eclipse/mylyn/wikitext/core/util/anttask/tasks.properties">
 			<classpath>
+				<fileset dir="${basedir}/lib/plugins">
+					<include name="org.eclipse.xtext.wikitext.core*.jar"/>
+				</fileset>
 				<fileset dir="${wikitext.dir}">
 					<include name="org.eclipse.mylyn.wikitext.*core*.jar" />
 				</fileset>
@@ -66,7 +70,7 @@
 				</tokenfilter>
 			</filterchain>
 		</loadfile>
-		<concat destfile="${build.dir}${fs}${document.name}.mediawiki" append="false" fixlastline="yes">
+		<concat destfile="${build.dir}${file.separator}${document.name}.mediawiki" append="false" fixlastline="yes">
 			<filelist dir="doc" files="${inputfiles}" />
 		</concat>
 	</target>
@@ -83,11 +87,10 @@
 		DocBook Toolchain
 	-->
 	<!-- <property name="docbook.version" value="1.73.2" /> -->
-	<property name="docbook.version" value="1.75.1" />
-	<property name="docbook.dir" value="${download.dir}${fs}docbook-xsl-${docbook.version}" />
-	<property name="docbookxsl.url" value="http://internap.dl.sourceforge.net/sourceforge/docbook/docbook-xsl-${docbook.version}.zip" />
-	<property name="fop.dir" value="${download.dir}${fs}fop-0.95" />
-	<property name="fop.url" value="http://mirrorspace.org/apache/xmlgraphics/fop/binaries/fop-0.95-bin.zip" />
+	<property name="docbook.dir" value="${download.dir}${file.separator}docbook-xsl-${docbook.version}" />
+	<property name="docbookxsl.url" value="http://downloads.sourceforge.net/project/docbook/docbook-xsl/${docbook.version}/docbook-xsl-${docbook.version}.zip"/>
+	<property name="fop.dir" value="${download.dir}${file.separator}fop-${fop.version}" />
+	<property name="fop.url" value="http://www.apache.org/dist//xmlgraphics/fop/binaries/fop-${fop.version}-bin.zip" />
 	<property name="jai.dir" value="ENTER_JAI_DIRECTORY" />
 
 	<macrodef name="docbook2pdf">
@@ -96,14 +99,14 @@
 		<sequential>
 			<taskdef name="fop" classname="org.apache.fop.tools.anttasks.Fop">
 				<classpath>
-					<pathelement location="${fop.dir}${fs}build${fs}fop.jar" />
-					<pathelement location="${fop.dir}${fs}lib${fs}avalon-framework-4.2.0.jar" />
-					<pathelement location="${fop.dir}${fs}lib${fs}commons-logging-1.0.4.jar" />
-					<pathelement location="${fop.dir}${fs}lib${fs}commons-io-1.3.1.jar" />
-					<pathelement location="${fop.dir}${fs}lib${fs}batik-all-1.7.jar" />
-					<pathelement location="${fop.dir}${fs}lib${fs}xmlgraphics-commons-1.3.1.jar" />
-					<pathelement location="${jai.dir}${fs}lib${fs}jai_core.jar" />
-					<pathelement location="${jai.dir}${fs}lib${fs}jai_codec.jar" />
+					<pathelement location="${fop.dir}${file.separator}build${file.separator}fop.jar" />
+					<pathelement location="${fop.dir}${file.separator}lib${file.separator}avalon-framework-4.2.0.jar" />
+					<pathelement location="${fop.dir}${file.separator}lib${file.separator}commons-logging-1.0.4.jar" />
+					<pathelement location="${fop.dir}${file.separator}lib${file.separator}commons-io-1.3.1.jar" />
+					<pathelement location="${fop.dir}${file.separator}lib${file.separator}batik-all-1.7.jar" />
+					<pathelement location="${fop.dir}${file.separator}lib${file.separator}xmlgraphics-commons-1.4.jar" />
+					<pathelement location="${jai.dir}${file.separator}lib${file.separator}jai_core.jar" />
+					<pathelement location="${jai.dir}${file.separator}lib${file.separator}jai_codec.jar" />
 					<pathelement location="lib/serializer.jar" />
 					<pathelement location="lib/xalan.jar" />
 					<pathelement location="lib/xercesImpl.jar" />
@@ -133,7 +136,7 @@
 	<target name="check-docbook">
 		<condition property="hasDocbook">
 			<and>
-				<available file="${download.dir}${fs}docbook.zip" property="hasDocbookZip" />
+				<available file="${download.dir}${file.separator}docbook.zip" property="hasDocbookZip" />
 				<available file="${docbook.dir}" type="dir" property="hasDocbookDir" />
 			</and>
 		</condition>
@@ -142,7 +145,7 @@
 	<target name="check-fop">
 		<condition property="hasFOP">
 			<and>
-				<available file="${download.dir}${fs}fop.zip" property="hasFOPZip" />
+				<available file="${download.dir}${file.separator}fop.zip" property="hasFOPZip" />
 				<available file="${fop.dir}" type="dir" property="hasFOPDir" />
 			</and>
 		</condition>
@@ -150,14 +153,14 @@
 
 	<target name="get-docbook-xsl" description="Downloads docbook xsl" depends="check-docbook" unless="hasDocbook">
 		<echo>Downloading DocBook XSL...</echo>
-		<get dest="${download.dir}${fs}docbook.zip" src="${docbookxsl.url}" />
-		<unzip src="${download.dir}${fs}docbook.zip" dest="${download.dir}" />
+		<get dest="${download.dir}${file.separator}docbook.zip" src="${docbookxsl.url}" />
+		<unzip src="${download.dir}${file.separator}docbook.zip" dest="${download.dir}" />
 	</target>
 
 	<target name="get-fop" description="Downloads FOP" depends="check-fop" unless="hasFOP">
 		<echo>Downloading FOP...</echo>
-		<get dest="${download.dir}${fs}fop.zip" src="${fop.url}" />
-		<unzip src="${download.dir}${fs}fop.zip" dest="${download.dir}" />
+		<get dest="${download.dir}${file.separator}fop.zip" src="${fop.url}" />
+		<unzip src="${download.dir}${file.separator}fop.zip" dest="${download.dir}" />
 	</target>
 
 	<target name="docbook2html">
@@ -171,12 +174,12 @@
 		</copy>
 		<copy file="${html-css.file}" todir="${website.content.dir}" />
 
-		<xslt in="${build.dir}${fs}${document.name}.xml" extension="xml" out="${website.content.dir}${fs}${document.name}.html" style="${document.stylesheet}">
+		<xslt in="${build.dir}${file.separator}${document.name}.xml" extension="xml" out="${website.content.dir}${file.separator}${document.name}.html" style="${document.stylesheet}">
 			<factory name="org.apache.xalan.processor.TransformerFactoryImpl">
 				<attribute name="http://xml.apache.org/xalan/features/optimize" value="true" />
 			</factory>
 			<xmlcatalog>
-				<entity publicId="docbook.xsl" location="${docbook.dir}${fs}html${fs}docbook.xsl" />
+				<entity publicId="docbook.xsl" location="${docbook.dir}${file.separator}html${file.separator}docbook.xsl" />
 			</xmlcatalog>
 			<param name="header.rule" expression="1" />
 			<param name="admon.graphics.extension" expression=".gif" />
@@ -188,8 +191,8 @@
 
 	<target name="docbook2pdf">
 		<echo>Converting article to PDF...</echo>
-		<delete file="${website.doc.dir}${fs}${document.name}.pdf" failonerror="false" />
-		<delete file="${build.dir}${fs}${document.name}.fo" />
+		<delete file="${website.doc.dir}${file.separator}${document.name}.pdf" failonerror="false" />
+		<delete file="${build.dir}${file.separator}${document.name}.fo" />
 
 		<!-- HACK! images should rather be copied to build/images -->
 		<copy todir="${basedir}">
@@ -199,21 +202,21 @@
 		</copy>
 
 
-		<xslt in="${build.dir}${fs}${document.name}.xml" extension="xml" out="${build.dir}${fs}${document.name}PDF.xml" style="${dbpdf.stylesheet}">
+		<xslt in="${build.dir}${file.separator}${document.name}.xml" extension="xml" out="${build.dir}${file.separator}${document.name}PDF.xml" style="${dbpdf.stylesheet}">
 			<factory name="org.apache.xalan.processor.TransformerFactoryImpl">
 				<attribute name="http://xml.apache.org/xalan/features/optimize" value="true" />
 			</factory>
 			<xmlcatalog>
-				<entity publicId="docbook.xsl" location="${docbook.dir}${fs}fo${fs}docbook.xsl" />
+				<entity publicId="docbook.xsl" location="${docbook.dir}${file.separator}fo${file.separator}docbook.xsl" />
 			</xmlcatalog>
 		</xslt>
 
-		<xslt in="${build.dir}${fs}${document.name}PDF.xml" extension="xml" out="${build.dir}${fs}${document.name}.fo" style="${document.pdf.stylesheet}">
+		<xslt in="${build.dir}${file.separator}${document.name}PDF.xml" extension="xml" out="${build.dir}${file.separator}${document.name}.fo" style="${document.pdf.stylesheet}">
 			<factory name="org.apache.xalan.processor.TransformerFactoryImpl">
 				<attribute name="http://xml.apache.org/xalan/features/optimize" value="true" />
 			</factory>
 			<xmlcatalog>
-				<entity publicId="docbook.xsl" location="${docbook.dir}${fs}fo${fs}docbook.xsl" />
+				<entity publicId="docbook.xsl" location="${docbook.dir}${file.separator}fo${file.separator}docbook.xsl" />
 			</xmlcatalog>
 			<param name="graphicsize.extension" expression="1" />
 			<param name="use.extensions" expression="1" />
@@ -225,13 +228,13 @@
 			<param name="admon.graphics" expression="1" />
 			<param name="scale" expression="10" />
 		</xslt>
-<echo>${build.dir}${fs}${document.name}.fo 
-	${website.doc.dir}${fs}${document.name}.pdf</echo>
-		<docbook2pdf source="${build.dir}${fs}${document.name}.fo" target="${website.doc.dir}${fs}${document.name}.pdf" />
+<echo>${build.dir}${file.separator}${document.name}.fo 
+	${website.doc.dir}${file.separator}${document.name}.pdf</echo>
+		<docbook2pdf source="${build.dir}${file.separator}${document.name}.fo" target="${website.doc.dir}${file.separator}${document.name}.pdf" />
 
 		<!-- Remove the resulting formatting object. This object isn't necessary in the
 		     result of this build. -->
-		<delete file="${build.dir}${fs}${document.name}.fo" />
+		<delete file="${build.dir}${file.separator}${document.name}.fo" />
 		<delete dir="${basedir}/images" />
 	</target>
 
@@ -262,7 +265,7 @@
 				<attribute name="http://xml.apache.org/xalan/features/optimize" value="true" />
 			</factory>
 			<xmlcatalog>
-				<entity publicId="chunk.xsl" location="${docbook.dir}${fs}html${fs}chunk.xsl" />
+				<entity publicId="chunk.xsl" location="${docbook.dir}${file.separator}html${file.separator}chunk.xsl" />
 			</xmlcatalog>
 			<param name="header.rule" expression="1" />
 			<param name="ignore.image.scaling" expression="1" />
diff --git a/org.eclipse.amp/doc/org.eclipse.amp.doc/doc/020-Guide_Credits.mediawiki b/org.eclipse.amp/doc/org.eclipse.amp.doc/doc/020-Guide_Credits.mediawiki
index 6c4dc01..4ba5f91 100644
--- a/org.eclipse.amp/doc/org.eclipse.amp.doc/doc/020-Guide_Credits.mediawiki
+++ b/org.eclipse.amp/doc/org.eclipse.amp.doc/doc/020-Guide_Credits.mediawiki
@@ -4,6 +4,6 @@
 
 Metascape, LLC is the primary contributor to AMP and provides Agent-Based Modeling tools, including sophisticated tools based on the AMF platform, and comprehensive consulting services. For more information on Metascape products and services visit http://metascapeabm.com.
 
-The AMF meta-model started life as [[http://www.agent2005.anl.gov/2006procpdf/Parker_Agent_2006.pdf|"score"]], a component of the Repast Simphony environment. Argonne National Labs supported the initial development in 2007 and agreed to contribute the relevant IP to the Eclipse project in 2009. It wasn't fully utilized within Simphony, and migrated from there to the MetaABM project supported by Metascape. The MetaABM project defined a complete editor, code-generation and model execution suite that formed the initial AMP AMF contribution. Metascape has sponsored the development of AMF from 2007 through the present.
+The AMF meta-model started life in 2007 as [[http://www.agent2005.anl.gov/2006procpdf/Parker_Agent_2006.pdf|"score"]], a component of the Repast Simphony environment and was contributed under the EPL by Argonne National Labs. AMF was further developed by Metascape starting in 2007 as the MetaABM project, and it along with what becase AMP where was contributed by Metascape to Eclipse in 2009. Metascape continues to be the primary sponsor and contributor to the project.
 
-The AMP logo was inspired by the [[http://swarm.org Swarm logo]] with their kind permission.
+The AMP logo was inspired by the [[http://swarm.org Swarm logo]] and is used with their kind permission.
diff --git a/org.eclipse.amp/doc/org.eclipse.amp.doc/doc/410-Tutorial_Setup.mediawiki b/org.eclipse.amp/doc/org.eclipse.amp.doc/doc/410-Tutorial_Setup.mediawiki
index c0490b7..de21442 100644
--- a/org.eclipse.amp/doc/org.eclipse.amp.doc/doc/410-Tutorial_Setup.mediawiki
+++ b/org.eclipse.amp/doc/org.eclipse.amp.doc/doc/410-Tutorial_Setup.mediawiki
@@ -38,7 +38,7 @@
 
 [[Image:images/edit_tutorial/SimpleTutorial3CreateModel.png]]
 
-You'll see a model creation wizard from which you can name the model. Just give it the name "StupidModel.metaabm".
+You'll see a model creation wizard from which you can name the model. Just give it the name "StupidModel1.metaabm".
 
 [[Image:images/edit_tutorial/SimpleTutorial4CreateModel.png]]
 
diff --git a/org.eclipse.amp/doc/org.eclipse.amp.doc/doc/420-Tutorial_Tree.mediawiki b/org.eclipse.amp/doc/org.eclipse.amp.doc/doc/420-Tutorial_Tree.mediawiki
index 1a11806..d9a4586 100644
--- a/org.eclipse.amp/doc/org.eclipse.amp.doc/doc/420-Tutorial_Tree.mediawiki
+++ b/org.eclipse.amp/doc/org.eclipse.amp.doc/doc/420-Tutorial_Tree.mediawiki
@@ -56,7 +56,7 @@
 
 [[Image:images/edit_tutorial/SimpleTutorial13BuildGridAgents.png]]
 
-===Actions===
+===Actions Part I===
 
 ====Create Initialize Rule====
 
@@ -129,7 +129,7 @@
 [[Image:images/edit_tutorial/SimpleTutorial25FinishStyle.png | right]]
 
 
-===Actions 2 Movement Rule===
+===Actions Part II===
 
 To make our agents move randomly every iteration, we will create a Rule. (For those familiar with Repast or other scheduling oriented AM platforms, a rule is just a schedule that gets activated each and every period for all agents.) At this point in the tutorial, we'll show screenshots only for aspects of the modeling process that haven't already been covered.
 
@@ -143,13 +143,13 @@
 
 Often, we would pick the "Spatial: Neighbor" function to take a random walk, but according to the specification, we actually want to move into some random Cell within distance four (4). So we will pick "Spatial: Within" from the list of functions.
 
-=====Model Error Handling=====
+=====Fixing Model Errors=====
 
 Instead of specifying the actual distance now, let's see how the Agent Modeling Framework error checking capabilities can help us in model development. Save the model by selecting '''File > Save''' from the application menu. Notice that a red marker appears next to the StupidModel1.metaabm file. If you reveal the '''Problems View''' you'll see a list of current errors and warnings and if you open the errors node in that list, you'll see an item reporting that the input has no value. If you double-click on that item, you'll be taken to the input for the Within query and you'll be able to edit it.
 
 [[Image:images/edit_tutorial/SimpleTutorial27NoValue.png | right]]
     
-In addition to error markers, metaABM provides warnings designed to help you avoid common design mistakes. For example, a warning will be issued if you attempt to move an agent from its selection to the same selection; this is not strictly speaking an error, but it doesn't make much sense. You'll also recieve warning for default values that have not been specified. You might notice that the Demographic Prisonner's Dilemma model has warning markers, this is because we were happy with the '0' default values for the attributes and didn't provide any. (By the way, you might also notice a number of Java warnings. By default the Eclipse IDE is very conservative when it comes to warnings, and expects the usage of language constructs that we choose not to use. A full discussion of all of this is beyond the scope of the tutorial, but see the Eclipse documentation on problem views for more ideas about how to customize these views.)
+In addition to error markers, metaABM provides warnings designed to help you avoid common design mistakes. For example, a warning will be issued if you attempt to move an agent from its selection to the same selection; this is not strictly speaking an error, but it doesn't make much sense. You'll also receive a warning for default values that have not been specified. You might notice that the Demographic Prisonner's Dilemma model has warning markers, this is because we were happy with the '0' default values for the attributes and didn't provide any. (By the way, you might also notice a number of Java warnings. By default the Eclipse IDE is very conservative when it comes to warnings, and expects the usage of language constructs that we choose not to use. A full discussion of all of this is beyond the scope of the tutorial, but see the Eclipse documentation on problem views for more ideas about how to customize these views.)
 
 To fix this error we just need to assign a value for search distance. We '''could''' simply create a literal for the Spatial: Within Query but that isn't really good practice. (Originally the Agent Modeling Framework didn't even support Literal values, but we added them for convenience.) Now, we will create our first Attribute. In this case, we want the Attribute to belong to the Stupid Model as it will be the same value for all Agents for now. So right-click on the Stupid Model context Attributes node and create a new one.
 
@@ -163,14 +163,20 @@
 
 [[Image:images/edit_tutorial/SimpleTutorial30AttributeInput.png | right]]
 
-Now, we need to combine the requirement that the cell be available with the requirement that it be within 4 cell's distance. To accomplish this, we'll add an Intersection Action. The Logical Actions, including "Intersection", "Union" and "None" define how Query Actions work together. So create an Intersection Actions as a target of the Spatial Available Query. (Not the Within Query).
+=====Create Intersection Action=====
+
+Now, we need to combine the requirement that the cell be available with the requirement that it be within 4 cell's distance. To accomplish this, we'll add an Intersection Action. The Logical Actions, including "Intersection", "Union" and "None" define how Query Actions work together. The Intersection Action needs to be a target of ''both'' the Available and Within targets. This means that the action has two sources. See the Modeler's Guide for more information about how action flow works.
+
+Editing actions with multiple sources and targets is the most complex aspect of the model editor so you may need to work with this example a bit in order to get a feel for how it should work. First, we create the Intersection Action as a target of the Spatial Available Query. (Not the Within Query).
 
 [[Image:images/edit_tutorial/SimpleTutorial31Intersect.png | right]]
 
-The Intersection Action needs to be a target of ''both'' the Available and Within targets. To accomplish this, drag the Intersection Action over the Within Query. It's a bit hard to see this in a static image, but you simply need to click on the Intersection Action, move it so that it is over the Within target, and release the mouse.
+Then we need to make the Intersection Action a target of the Within Query as well. To accomplish this, we drag the Intersection Action over the Within Query while holding down the ctrl-key. Depending on your environment, you may need to begin dragging before you click the control key -- otherwise, your initial control click will bring up the context menu. It's a bit hard to see this in a static image, but you simply need to click on the Intersection Action, begin dragging, hold down the ctrl key, move the mouse so that it is over the Within target, and release the mouse. It sounds more complicated then it is!
 
 [[Image:images/edit_tutorial/SimpleTutorial32IntersectAdd.png | right]]
 
+=====Add Move Action=====
+
 Finally, add a Move target to the Intersection.
 
 [[Image:images/edit_tutorial/SimpleTutorial33Move.png | right]]
diff --git a/org.eclipse.amp/doc/org.eclipse.amp.doc/doc/952-Support_Community.mediawiki b/org.eclipse.amp/doc/org.eclipse.amp.doc/doc/952-Support_Community.mediawiki
index dcbd4d1..34c8333 100644
--- a/org.eclipse.amp/doc/org.eclipse.amp.doc/doc/952-Support_Community.mediawiki
+++ b/org.eclipse.amp/doc/org.eclipse.amp.doc/doc/952-Support_Community.mediawiki
@@ -10,4 +10,12 @@
 
 ==Get Involved==
 
-If you find this tool valuable, please be aware that most of its development occurred through volunteer contributions from individuals and companies that have received no direct funding. You can support continual development efforts financially by purchasing related software tools from companies and organizations that help develop it, including funding for developer time in grant proposals. You can support the Eclipse platform in general by becoming a member organization of Eclipse. But the most important thing that you can contribute is your own time and enthusiasm, either through directly contributing to AMP or by promoting its use in blogs and other social media. For more detailed information about contributing to AMP, please see [http://wiki.eclipse.org/AMP/Getting_Involved our wiki].
+If you find this tool valuable, please be aware that most of its development occurred through volunteer contributions from individuals and companies that have received no direct funding. You can support continual development efforts financially by purchasing related software tools from companies and organizations that help develop it, including funding for developer time in grant proposals. You can support the Eclipse platform in general by becoming a member organization of Eclipse. But the most important thing that you can contribute is your own time and enthusiasm, either through directly contributing to AMP or by promoting its use in blogs and other social media. For more detailed information about contributing to AMP, the following sections.
+
+===Improve this Documentation!===
+
+This documentation was produced using the excellent Eclispe integrated Mylyn documentation tools. Please see [http://wiki.eclipse.org/AMP/Building this page] for how to help with documentation.
+
+===Contribute to AMP===
+
+Please see this document for some things that we could use help on: [http://wiki.eclipse.org/AMP/Getting_Involved our wiki]. But the best thing is to look at the bugzilla. Find bugs that you can help with, or add your own ideas for helpful features.
\ No newline at end of file
diff --git a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Actions_2.html b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Actions_2.html
index c518b3a..2e518f2 100644
--- a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Actions_2.html
+++ b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Actions_2.html
@@ -2,10 +2,10 @@
 <head>
 <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
 <title>Actions</title>
-<link href="book.css" rel="stylesheet" type="text/css">
-<meta content="DocBook XSL Stylesheets V1.75.1" name="generator">
+<link href="book.css" type="text/css" rel="stylesheet">
+<meta content="DocBook XSL Stylesheets V1.76.0" name="generator">
 <link rel="home" href="index.html" title="Agent Modeling Guide">
-<link rel="up" href="Modeler_Guide.html" title="Modeler Guide">
+<link rel="up" href="Modeler_Guide.html" title="Chapter&nbsp;.&nbsp;Modeler Guide">
 <link rel="prev" href="Structure.html" title="Structure">
 <link rel="next" href="Functions.html" title="Functions">
 </head>
diff --git a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Agent-Based_Modeling.html b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Agent-Based_Modeling.html
index d5d41d6..a41ad58 100644
--- a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Agent-Based_Modeling.html
+++ b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Agent-Based_Modeling.html
@@ -2,11 +2,11 @@
 <head>
 <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
 <title>Agent-Based Modeling</title>
-<link href="book.css" rel="stylesheet" type="text/css">
-<meta content="DocBook XSL Stylesheets V1.75.1" name="generator">
+<link href="book.css" type="text/css" rel="stylesheet">
+<meta content="DocBook XSL Stylesheets V1.76.0" name="generator">
 <link rel="home" href="index.html" title="Agent Modeling Guide">
-<link rel="up" href="Introduction.html" title="Introduction">
-<link rel="prev" href="Introduction.html" title="Introduction">
+<link rel="up" href="Introduction.html" title="Chapter&nbsp;.&nbsp;Introduction">
+<link rel="prev" href="Introduction.html" title="Chapter&nbsp;.&nbsp;Introduction">
 <link rel="next" href="Other_Domains.html" title="Other Domains">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
diff --git a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Building.html b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Building.html
index 67632d4..ac7dc57 100644
--- a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Building.html
+++ b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Building.html
@@ -2,10 +2,10 @@
 <head>
 <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
 <title>Building</title>
-<link href="book.css" rel="stylesheet" type="text/css">
-<meta content="DocBook XSL Stylesheets V1.75.1" name="generator">
+<link href="book.css" type="text/css" rel="stylesheet">
+<meta content="DocBook XSL Stylesheets V1.76.0" name="generator">
 <link rel="home" href="index.html" title="Agent Modeling Guide">
-<link rel="up" href="User_Guide.html" title="User Guide">
+<link rel="up" href="User_Guide.html" title="Chapter&nbsp;.&nbsp;User Guide">
 <link rel="prev" href="Modeling.html" title="Modeling">
 <link rel="next" href="Executing.html" title="Executing">
 </head>
diff --git a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Converting_Existing_Ascape_Models.html b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Converting_Existing_Ascape_Models.html
index 2a3c0e2..bcaeb85 100644
--- a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Converting_Existing_Ascape_Models.html
+++ b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Converting_Existing_Ascape_Models.html
@@ -2,12 +2,12 @@
 <head>
 <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
 <title>Converting Existing Ascape Models</title>
-<link href="book.css" rel="stylesheet" type="text/css">
-<meta content="DocBook XSL Stylesheets V1.75.1" name="generator">
+<link href="book.css" type="text/css" rel="stylesheet">
+<meta content="DocBook XSL Stylesheets V1.76.0" name="generator">
 <link rel="home" href="index.html" title="Agent Modeling Guide">
-<link rel="up" href="Programer_Guide.html" title="Programer Guide">
+<link rel="up" href="Programer_Guide.html" title="Chapter&nbsp;.&nbsp;Programer Guide">
 <link rel="prev" href="Integrating_Java_and_AMF_Models.html" title="Integrating Java and AMF Models">
-<link rel="next" href="Installation_Guide.html" title="Installation Guide">
+<link rel="next" href="Installation_Guide.html" title="Chapter&nbsp;.&nbsp;Installation Guide">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <h1 xmlns:l="http://docbook.sourceforge.net/xmlns/l10n/1.0">Converting Existing Ascape Models</h1>
diff --git a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Credits.html b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Credits.html
index 16a1c3d..8ac5aa5 100644
--- a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Credits.html
+++ b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Credits.html
@@ -2,12 +2,12 @@
 <head>
 <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
 <title>Credits</title>
-<link href="book.css" rel="stylesheet" type="text/css">
-<meta content="DocBook XSL Stylesheets V1.75.1" name="generator">
+<link href="book.css" type="text/css" rel="stylesheet">
+<meta content="DocBook XSL Stylesheets V1.76.0" name="generator">
 <link rel="home" href="index.html" title="Agent Modeling Guide">
-<link rel="up" href="Introduction.html" title="Introduction">
+<link rel="up" href="Introduction.html" title="Chapter&nbsp;.&nbsp;Introduction">
 <link rel="prev" href="The_Agent_Modeling_Platform_.28AMP.29.html" title="The Agent Modeling Platform (AMP)">
-<link rel="next" href="Modeler_Guide.html" title="Modeler Guide">
+<link rel="next" href="Modeler_Guide.html" title="Chapter&nbsp;.&nbsp;Modeler Guide">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <h1 xmlns:l="http://docbook.sourceforge.net/xmlns/l10n/1.0">Credits</h1>
@@ -24,11 +24,11 @@
 <p>Metascape, LLC is the primary contributor to AMP and provides Agent-Based Modeling tools, including sophisticated tools based on the AMF platform, and comprehensive consulting services. For more information on Metascape products and services visit 
 				<a class="ulink" href="http://metascapeabm.com" target="_new">http://metascapeabm.com</a>.
 			</p>
-<p>The AMF meta-model started life as 
-				<a class="ulink" href="/wiki/http://www.agent2005.anl.gov/2006procpdf/Parker_Agent_2006.pdf" target="_new">"score"</a>, a component of the Repast Simphony environment. Argonne National Labs supported the initial development in 2007 and agreed to contribute the relevant IP to the Eclipse project in 2009. It wasn't fully utilized within Simphony, and migrated from there to the MetaABM project supported by Metascape. The MetaABM project defined a complete editor, code-generation and model execution suite that formed the initial AMP AMF contribution. Metascape has sponsored the development of AMF from 2007 through the present.
+<p>The AMF meta-model started life in 2007 as 
+				<a class="ulink" href="/wiki/http://www.agent2005.anl.gov/2006procpdf/Parker_Agent_2006.pdf" target="_new">"score"</a>, a component of the Repast Simphony environment and was contributed under the EPL by Argonne National Labs. AMF was further developed by Metascape starting in 2007 as the MetaABM project, and it along with what becase AMP where was contributed by Metascape to Eclipse in 2009. Metascape continues to be the primary sponsor and contributor to the project.
 			</p>
 <p>The AMP logo was inspired by the 
-				<a class="ulink" href="/wiki/http://swarm.org_Swarm_logo" target="_new">http://swarm.org Swarm logo</a> with their kind permission.
+				<a class="ulink" href="/wiki/http://swarm.org_Swarm_logo" target="_new">http://swarm.org Swarm logo</a> and is used with their kind permission.
 			</p>
 </div>
 </body>
diff --git a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Developing_Models.html b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Developing_Models.html
index 225bc2d..850c4b8 100644
--- a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Developing_Models.html
+++ b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Developing_Models.html
@@ -2,10 +2,10 @@
 <head>
 <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
 <title>Developing Models</title>
-<link href="book.css" rel="stylesheet" type="text/css">
-<meta content="DocBook XSL Stylesheets V1.75.1" name="generator">
+<link href="book.css" type="text/css" rel="stylesheet">
+<meta content="DocBook XSL Stylesheets V1.76.0" name="generator">
 <link rel="home" href="index.html" title="Agent Modeling Guide">
-<link rel="up" href="Programer_Guide.html" title="Programer Guide">
+<link rel="up" href="Programer_Guide.html" title="Chapter&nbsp;.&nbsp;Programer Guide">
 <link rel="prev" href="Example_Java_Models.html" title="Example Java Models">
 <link rel="next" href="Executing_Models.html" title="Executing Models">
 </head>
diff --git a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Documentation.html b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Documentation.html
index c4171ae..2c60c66 100644
--- a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Documentation.html
+++ b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Documentation.html
@@ -2,11 +2,11 @@
 <head>
 <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
 <title>Documentation</title>
-<link href="book.css" rel="stylesheet" type="text/css">
-<meta content="DocBook XSL Stylesheets V1.75.1" name="generator">
+<link href="book.css" type="text/css" rel="stylesheet">
+<meta content="DocBook XSL Stylesheets V1.76.0" name="generator">
 <link rel="home" href="index.html" title="Agent Modeling Guide">
-<link rel="up" href="Programer_Guide.html" title="Programer Guide">
-<link rel="prev" href="Programer_Guide.html" title="Programer Guide">
+<link rel="up" href="Programer_Guide.html" title="Chapter&nbsp;.&nbsp;Programer Guide">
+<link rel="prev" href="Programer_Guide.html" title="Chapter&nbsp;.&nbsp;Programer Guide">
 <link rel="next" href="Installation.html" title="Installation">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
diff --git a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Example_Java_Models.html b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Example_Java_Models.html
index 8eb20fd..ad3890e 100644
--- a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Example_Java_Models.html
+++ b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Example_Java_Models.html
@@ -2,10 +2,10 @@
 <head>
 <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
 <title>Example Java Models</title>
-<link href="book.css" rel="stylesheet" type="text/css">
-<meta content="DocBook XSL Stylesheets V1.75.1" name="generator">
+<link href="book.css" type="text/css" rel="stylesheet">
+<meta content="DocBook XSL Stylesheets V1.76.0" name="generator">
 <link rel="home" href="index.html" title="Agent Modeling Guide">
-<link rel="up" href="Programer_Guide.html" title="Programer Guide">
+<link rel="up" href="Programer_Guide.html" title="Chapter&nbsp;.&nbsp;Programer Guide">
 <link rel="prev" href="Installation.html" title="Installation">
 <link rel="next" href="Developing_Models.html" title="Developing Models">
 </head>
diff --git a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Executing.html b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Executing.html
index 676e69b..967e8e2 100644
--- a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Executing.html
+++ b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Executing.html
@@ -2,12 +2,12 @@
 <head>
 <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
 <title>Executing</title>
-<link href="book.css" rel="stylesheet" type="text/css">
-<meta content="DocBook XSL Stylesheets V1.75.1" name="generator">
+<link href="book.css" type="text/css" rel="stylesheet">
+<meta content="DocBook XSL Stylesheets V1.76.0" name="generator">
 <link rel="home" href="index.html" title="Agent Modeling Guide">
-<link rel="up" href="User_Guide.html" title="User Guide">
+<link rel="up" href="User_Guide.html" title="Chapter&nbsp;.&nbsp;User Guide">
 <link rel="prev" href="Building.html" title="Building">
-<link rel="next" href="Tutorials.html" title="Tutorials">
+<link rel="next" href="Tutorials.html" title="Chapter&nbsp;.&nbsp;Tutorials">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <h1 xmlns:l="http://docbook.sourceforge.net/xmlns/l10n/1.0">Executing</h1>
diff --git a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Executing_Models.html b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Executing_Models.html
index 96287c6..03af783 100644
--- a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Executing_Models.html
+++ b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Executing_Models.html
@@ -2,10 +2,10 @@
 <head>
 <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
 <title>Executing Models</title>
-<link href="book.css" rel="stylesheet" type="text/css">
-<meta content="DocBook XSL Stylesheets V1.75.1" name="generator">
+<link href="book.css" type="text/css" rel="stylesheet">
+<meta content="DocBook XSL Stylesheets V1.76.0" name="generator">
 <link rel="home" href="index.html" title="Agent Modeling Guide">
-<link rel="up" href="Programer_Guide.html" title="Programer Guide">
+<link rel="up" href="Programer_Guide.html" title="Chapter&nbsp;.&nbsp;Programer Guide">
 <link rel="prev" href="Developing_Models.html" title="Developing Models">
 <link rel="next" href="Extending_and_Customizing_AMP.html" title="Extending and Customizing AMP">
 </head>
diff --git a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Extending_and_Customizing_AMP.html b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Extending_and_Customizing_AMP.html
index 2fc210c..dc99085 100644
--- a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Extending_and_Customizing_AMP.html
+++ b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Extending_and_Customizing_AMP.html
@@ -2,10 +2,10 @@
 <head>
 <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
 <title>Extending and Customizing AMP</title>
-<link href="book.css" rel="stylesheet" type="text/css">
-<meta content="DocBook XSL Stylesheets V1.75.1" name="generator">
+<link href="book.css" type="text/css" rel="stylesheet">
+<meta content="DocBook XSL Stylesheets V1.76.0" name="generator">
 <link rel="home" href="index.html" title="Agent Modeling Guide">
-<link rel="up" href="Programer_Guide.html" title="Programer Guide">
+<link rel="up" href="Programer_Guide.html" title="Chapter&nbsp;.&nbsp;Programer Guide">
 <link rel="prev" href="Executing_Models.html" title="Executing Models">
 <link rel="next" href="Integrating_Java_and_AMF_Models.html" title="Integrating Java and AMF Models">
 </head>
diff --git a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Functions.html b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Functions.html
index 610e5f5..8d21872 100644
--- a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Functions.html
+++ b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Functions.html
@@ -2,12 +2,12 @@
 <head>
 <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
 <title>Functions</title>
-<link href="book.css" rel="stylesheet" type="text/css">
-<meta content="DocBook XSL Stylesheets V1.75.1" name="generator">
+<link href="book.css" type="text/css" rel="stylesheet">
+<meta content="DocBook XSL Stylesheets V1.76.0" name="generator">
 <link rel="home" href="index.html" title="Agent Modeling Guide">
-<link rel="up" href="Modeler_Guide.html" title="Modeler Guide">
+<link rel="up" href="Modeler_Guide.html" title="Chapter&nbsp;.&nbsp;Modeler Guide">
 <link rel="prev" href="Actions_2.html" title="Actions">
-<link rel="next" href="User_Guide.html" title="User Guide">
+<link rel="next" href="User_Guide.html" title="Chapter&nbsp;.&nbsp;User Guide">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <h1 xmlns:l="http://docbook.sourceforge.net/xmlns/l10n/1.0">Functions</h1>
diff --git a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Get_Involved.html b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Get_Involved.html
index ab67637..84a8583 100644
--- a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Get_Involved.html
+++ b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Get_Involved.html
@@ -2,10 +2,10 @@
 <head>
 <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
 <title>Get Involved</title>
-<link href="book.css" rel="stylesheet" type="text/css">
-<meta content="DocBook XSL Stylesheets V1.75.1" name="generator">
+<link href="book.css" type="text/css" rel="stylesheet">
+<meta content="DocBook XSL Stylesheets V1.76.0" name="generator">
 <link rel="home" href="index.html" title="Agent Modeling Guide">
-<link rel="up" href="Support.html" title="Support">
+<link rel="up" href="Support.html" title="Chapter&nbsp;.&nbsp;Support">
 <link rel="prev" href="Other_Contacts.html" title="Other Contacts">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
diff --git a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Installation.html b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Installation.html
index 91490e9..0387b04 100644
--- a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Installation.html
+++ b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Installation.html
@@ -2,10 +2,10 @@
 <head>
 <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
 <title>Installation</title>
-<link href="book.css" rel="stylesheet" type="text/css">
-<meta content="DocBook XSL Stylesheets V1.75.1" name="generator">
+<link href="book.css" type="text/css" rel="stylesheet">
+<meta content="DocBook XSL Stylesheets V1.76.0" name="generator">
 <link rel="home" href="index.html" title="Agent Modeling Guide">
-<link rel="up" href="Programer_Guide.html" title="Programer Guide">
+<link rel="up" href="Programer_Guide.html" title="Chapter&nbsp;.&nbsp;Programer Guide">
 <link rel="prev" href="Documentation.html" title="Documentation">
 <link rel="next" href="Example_Java_Models.html" title="Example Java Models">
 </head>
diff --git a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Installation_Guide.html b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Installation_Guide.html
index aafa8ea..2f1cb39 100644
--- a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Installation_Guide.html
+++ b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Installation_Guide.html
@@ -1,9 +1,9 @@
 <html>
 <head>
 <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>Installation Guide</title>
-<link href="book.css" rel="stylesheet" type="text/css">
-<meta content="DocBook XSL Stylesheets V1.75.1" name="generator">
+<title>Chapter&nbsp;.&nbsp;Installation Guide</title>
+<link href="book.css" type="text/css" rel="stylesheet">
+<meta content="DocBook XSL Stylesheets V1.76.0" name="generator">
 <link rel="home" href="index.html" title="Agent Modeling Guide">
 <link rel="up" href="index.html" title="Agent Modeling Guide">
 <link rel="prev" href="Converting_Existing_Ascape_Models.html" title="Converting Existing Ascape Models">
@@ -11,12 +11,12 @@
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <h1 xmlns:l="http://docbook.sourceforge.net/xmlns/l10n/1.0">Installation Guide</h1>
-<div class="chapter" title="Installation Guide">
+<div class="chapter" title="Chapter&nbsp;.&nbsp;Installation Guide">
 <div class="titlepage">
 <div>
 <div>
 <h2 class="title">
-<a name="Installation_Guide"></a>Installation Guide</h2>
+<a name="Installation_Guide"></a>Chapter&nbsp;.&nbsp;Installation Guide</h2>
 </div>
 </div>
 </div>
diff --git a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Integrating_Java_and_AMF_Models.html b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Integrating_Java_and_AMF_Models.html
index c683788..671127d 100644
--- a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Integrating_Java_and_AMF_Models.html
+++ b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Integrating_Java_and_AMF_Models.html
@@ -2,10 +2,10 @@
 <head>
 <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
 <title>Integrating Java and AMF Models</title>
-<link href="book.css" rel="stylesheet" type="text/css">
-<meta content="DocBook XSL Stylesheets V1.75.1" name="generator">
+<link href="book.css" type="text/css" rel="stylesheet">
+<meta content="DocBook XSL Stylesheets V1.76.0" name="generator">
 <link rel="home" href="index.html" title="Agent Modeling Guide">
-<link rel="up" href="Programer_Guide.html" title="Programer Guide">
+<link rel="up" href="Programer_Guide.html" title="Chapter&nbsp;.&nbsp;Programer Guide">
 <link rel="prev" href="Extending_and_Customizing_AMP.html" title="Extending and Customizing AMP">
 <link rel="next" href="Converting_Existing_Ascape_Models.html" title="Converting Existing Ascape Models">
 </head>
diff --git a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Introduction.html b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Introduction.html
index e16217a..3096351 100644
--- a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Introduction.html
+++ b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Introduction.html
@@ -1,9 +1,9 @@
 <html>
 <head>
 <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>Introduction</title>
-<link href="book.css" rel="stylesheet" type="text/css">
-<meta content="DocBook XSL Stylesheets V1.75.1" name="generator">
+<title>Chapter&nbsp;.&nbsp;Introduction</title>
+<link href="book.css" type="text/css" rel="stylesheet">
+<meta content="DocBook XSL Stylesheets V1.76.0" name="generator">
 <link rel="home" href="index.html" title="Agent Modeling Guide">
 <link rel="up" href="index.html" title="Agent Modeling Guide">
 <link rel="prev" href="index.html" title="Agent Modeling Guide">
@@ -11,12 +11,12 @@
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <h1 xmlns:l="http://docbook.sourceforge.net/xmlns/l10n/1.0">Introduction</h1>
-<div class="chapter" title="Introduction">
+<div class="chapter" title="Chapter&nbsp;.&nbsp;Introduction">
 <div class="titlepage">
 <div>
 <div>
 <h2 class="title">
-<a name="Introduction"></a>Introduction</h2>
+<a name="Introduction"></a>Chapter&nbsp;.&nbsp;Introduction</h2>
 </div>
 </div>
 </div>
diff --git a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Model_Implementation.html b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Model_Implementation.html
index 5a19d38..150dcce 100644
--- a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Model_Implementation.html
+++ b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Model_Implementation.html
@@ -2,12 +2,12 @@
 <head>
 <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
 <title>Model Implementation</title>
-<link href="book.css" rel="stylesheet" type="text/css">
-<meta content="DocBook XSL Stylesheets V1.75.1" name="generator">
+<link href="book.css" type="text/css" rel="stylesheet">
+<meta content="DocBook XSL Stylesheets V1.76.0" name="generator">
 <link rel="home" href="index.html" title="Agent Modeling Guide">
-<link rel="up" href="Tutorials.html" title="Tutorials">
-<link rel="prev" href="Tutorials.html" title="Tutorials">
-<link rel="next" href="Programer_Guide.html" title="Programer Guide">
+<link rel="up" href="Tutorials.html" title="Chapter&nbsp;.&nbsp;Tutorials">
+<link rel="prev" href="Tutorials.html" title="Chapter&nbsp;.&nbsp;Tutorials">
+<link rel="next" href="Programer_Guide.html" title="Chapter&nbsp;.&nbsp;Programer Guide">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <h1 xmlns:l="http://docbook.sourceforge.net/xmlns/l10n/1.0">Model Implementation</h1>
@@ -338,12 +338,12 @@
 </div>
 </div>
 </div>
-<div class="section" title="Actions">
+<div class="section" title="Actions Part I">
 <div class="titlepage">
 <div>
 <div>
 <h3 class="title">
-<a name="Actions_4"></a>Actions</h3>
+<a name="Actions_Part_I"></a>Actions Part I</h3>
 </div>
 </div>
 </div>
@@ -566,12 +566,12 @@
 </div>
 </div>
 </div>
-<div class="section" title="Actions 2 Movement Rule">
+<div class="section" title="Actions Part II">
 <div class="titlepage">
 <div>
 <div>
 <h3 class="title">
-<a name="Actions_2_Movement_Rule"></a>Actions 2 Movement Rule</h3>
+<a name="Actions_Part_II"></a>Actions Part II</h3>
 </div>
 </div>
 </div>
@@ -604,12 +604,12 @@
 </p>
 <p>Often, we would pick the "Spatial: Neighbor" function to take a random walk, but according to the specification, we actually want to move into some random Cell within distance four (4). So we will pick "Spatial: Within" from the list of functions.</p>
 </div>
-<div class="section" title="Model Error Handling">
+<div class="section" title="Fixing Model Errors">
 <div class="titlepage">
 <div>
 <div>
 <h5 class="title">
-<a name="Model_Error_Handling"></a>Model Error Handling</h5>
+<a name="Fixing_Model_Errors"></a>Fixing Model Errors</h5>
 </div>
 </div>
 </div>
@@ -625,7 +625,7 @@
 <p>
 						
 </p>
-<p>In addition to error markers, metaABM provides warnings designed to help you avoid common design mistakes. For example, a warning will be issued if you attempt to move an agent from its selection to the same selection; this is not strictly speaking an error, but it doesn't make much sense. You'll also recieve warning for default values that have not been specified. You might notice that the Demographic Prisonner's Dilemma model has warning markers, this is because we were happy with the '0' default values for the attributes and didn't provide any. (By the way, you might also notice a number of Java warnings. By default the Eclipse IDE is very conservative when it comes to warnings, and expects the usage of language constructs that we choose not to use. A full discussion of all of this is beyond the scope of the tutorial, but see the Eclipse documentation on problem views for more ideas about how to customize these views.)</p>
+<p>In addition to error markers, metaABM provides warnings designed to help you avoid common design mistakes. For example, a warning will be issued if you attempt to move an agent from its selection to the same selection; this is not strictly speaking an error, but it doesn't make much sense. You'll also receive a warning for default values that have not been specified. You might notice that the Demographic Prisonner's Dilemma model has warning markers, this is because we were happy with the '0' default values for the attributes and didn't provide any. (By the way, you might also notice a number of Java warnings. By default the Eclipse IDE is very conservative when it comes to warnings, and expects the usage of language constructs that we choose not to use. A full discussion of all of this is beyond the scope of the tutorial, but see the Eclipse documentation on problem views for more ideas about how to customize these views.)</p>
 <p>To fix this error we just need to assign a value for search distance. We 
 							<span class="bold"><strong>could</strong></span> simply create a literal for the Spatial: Within Query but that isn't really good practice. (Originally the Agent Modeling Framework didn't even support Literal values, but we added them for convenience.) Now, we will create our first Attribute. In this case, we want the Attribute to belong to the Stupid Model as it will be the same value for all Agents for now. So right-click on the Stupid Model context Attributes node and create a new one.
 						</p>
@@ -655,7 +655,20 @@
 <p>
 						
 </p>
-<p>Now, we need to combine the requirement that the cell be available with the requirement that it be within 4 cell's distance. To accomplish this, we'll add an Intersection Action. The Logical Actions, including "Intersection", "Union" and "None" define how Query Actions work together. So create an Intersection Actions as a target of the Spatial Available Query. (Not the Within Query).</p>
+</div>
+<div class="section" title="Create Intersection Action">
+<div class="titlepage">
+<div>
+<div>
+<h5 class="title">
+<a name="Create_Intersection_Action"></a>Create Intersection Action</h5>
+</div>
+</div>
+</div>
+<p>Now, we need to combine the requirement that the cell be available with the requirement that it be within 4 cell's distance. To accomplish this, we'll add an Intersection Action. The Logical Actions, including "Intersection", "Union" and "None" define how Query Actions work together. The Intersection Action needs to be a target of 
+							<span class="italic">both</span> the Available and Within targets. This means that the action has two sources. See the Modeler's Guide for more information about how action flow works.
+						</p>
+<p>Editing actions with multiple sources and targets is the most complex aspect of the model editor so you may need to work with this example a bit in order to get a feel for how it should work. First, we create the Intersection Action as a target of the Spatial Available Query. (Not the Within Query).</p>
 <p>
 							
 </p>
@@ -664,9 +677,7 @@
 <p>
 						
 </p>
-<p>The Intersection Action needs to be a target of 
-							<span class="italic">both</span> the Available and Within targets. To accomplish this, drag the Intersection Action over the Within Query. It's a bit hard to see this in a static image, but you simply need to click on the Intersection Action, move it so that it is over the Within target, and release the mouse.
-						</p>
+<p>Then we need to make the Intersection Action a target of the Within Query as well. To accomplish this, we drag the Intersection Action over the Within Query while holding down the ctrl-key. Depending on your environment, you may need to begin dragging before you click the control key -- otherwise, your initial control click will bring up the context menu. It's a bit hard to see this in a static image, but you simply need to click on the Intersection Action, begin dragging, hold down the ctrl key, move the mouse so that it is over the Within target, and release the mouse. It sounds more complicated then it is!</p>
 <p>
 							
 </p>
@@ -675,6 +686,16 @@
 <p>
 						
 </p>
+</div>
+<div class="section" title="Add Move Action">
+<div class="titlepage">
+<div>
+<div>
+<h5 class="title">
+<a name="Add_Move_Action"></a>Add Move Action</h5>
+</div>
+</div>
+</div>
 <p>Finally, add a Move target to the Intersection.</p>
 <p>
 							
diff --git a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Modeler_Guide.html b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Modeler_Guide.html
index 1f78e68..fcabb89 100644
--- a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Modeler_Guide.html
+++ b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Modeler_Guide.html
@@ -1,9 +1,9 @@
 <html>
 <head>
 <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>Modeler Guide</title>
-<link href="book.css" rel="stylesheet" type="text/css">
-<meta content="DocBook XSL Stylesheets V1.75.1" name="generator">
+<title>Chapter&nbsp;.&nbsp;Modeler Guide</title>
+<link href="book.css" type="text/css" rel="stylesheet">
+<meta content="DocBook XSL Stylesheets V1.76.0" name="generator">
 <link rel="home" href="index.html" title="Agent Modeling Guide">
 <link rel="up" href="index.html" title="Agent Modeling Guide">
 <link rel="prev" href="Credits.html" title="Credits">
@@ -11,12 +11,12 @@
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <h1 xmlns:l="http://docbook.sourceforge.net/xmlns/l10n/1.0">Modeler Guide</h1>
-<div class="chapter" title="Modeler Guide">
+<div class="chapter" title="Chapter&nbsp;.&nbsp;Modeler Guide">
 <div class="titlepage">
 <div>
 <div>
 <h2 class="title">
-<a name="Modeler_Guide"></a>Modeler Guide</h2>
+<a name="Modeler_Guide"></a>Chapter&nbsp;.&nbsp;Modeler Guide</h2>
 </div>
 </div>
 </div>
diff --git a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Modeling.html b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Modeling.html
index a519e08..5c00c17 100644
--- a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Modeling.html
+++ b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Modeling.html
@@ -2,11 +2,11 @@
 <head>
 <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
 <title>Modeling</title>
-<link href="book.css" rel="stylesheet" type="text/css">
-<meta content="DocBook XSL Stylesheets V1.75.1" name="generator">
+<link href="book.css" type="text/css" rel="stylesheet">
+<meta content="DocBook XSL Stylesheets V1.76.0" name="generator">
 <link rel="home" href="index.html" title="Agent Modeling Guide">
-<link rel="up" href="User_Guide.html" title="User Guide">
-<link rel="prev" href="User_Guide.html" title="User Guide">
+<link rel="up" href="User_Guide.html" title="Chapter&nbsp;.&nbsp;User Guide">
+<link rel="prev" href="User_Guide.html" title="Chapter&nbsp;.&nbsp;User Guide">
 <link rel="next" href="Building.html" title="Building">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
diff --git a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Models.html b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Models.html
index 24b831d..cef9a82 100644
--- a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Models.html
+++ b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Models.html
@@ -2,12 +2,12 @@
 <head>
 <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
 <title>Models</title>
-<link href="book.css" rel="stylesheet" type="text/css">
-<meta content="DocBook XSL Stylesheets V1.75.1" name="generator">
+<link href="book.css" type="text/css" rel="stylesheet">
+<meta content="DocBook XSL Stylesheets V1.76.0" name="generator">
 <link rel="home" href="index.html" title="Agent Modeling Guide">
-<link rel="up" href="Installation_Guide.html" title="Installation Guide">
-<link rel="prev" href="Installation_Guide.html" title="Installation Guide">
-<link rel="next" href="New_and_Noteworthy.html" title="New and Noteworthy">
+<link rel="up" href="Installation_Guide.html" title="Chapter&nbsp;.&nbsp;Installation Guide">
+<link rel="prev" href="Installation_Guide.html" title="Chapter&nbsp;.&nbsp;Installation Guide">
+<link rel="next" href="New_and_Noteworthy.html" title="Chapter&nbsp;.&nbsp;New and Noteworthy">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <h1 xmlns:l="http://docbook.sourceforge.net/xmlns/l10n/1.0">Models</h1>
diff --git a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/New_and_Noteworthy.html b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/New_and_Noteworthy.html
index cd765ff..e15a403 100644
--- a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/New_and_Noteworthy.html
+++ b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/New_and_Noteworthy.html
@@ -1,22 +1,22 @@
 <html>
 <head>
 <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>New and Noteworthy</title>
-<link href="book.css" rel="stylesheet" type="text/css">
-<meta content="DocBook XSL Stylesheets V1.75.1" name="generator">
+<title>Chapter&nbsp;.&nbsp;New and Noteworthy</title>
+<link href="book.css" type="text/css" rel="stylesheet">
+<meta content="DocBook XSL Stylesheets V1.76.0" name="generator">
 <link rel="home" href="index.html" title="Agent Modeling Guide">
 <link rel="up" href="index.html" title="Agent Modeling Guide">
 <link rel="prev" href="Models.html" title="Models">
-<link rel="next" href="Resources.html" title="Resources">
+<link rel="next" href="Resources.html" title="Chapter&nbsp;.&nbsp;Resources">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <h1 xmlns:l="http://docbook.sourceforge.net/xmlns/l10n/1.0">New and Noteworthy</h1>
-<div class="chapter" title="New and Noteworthy">
+<div class="chapter" title="Chapter&nbsp;.&nbsp;New and Noteworthy">
 <div class="titlepage">
 <div>
 <div>
 <h2 class="title">
-<a name="New_and_Noteworthy"></a>New and Noteworthy</h2>
+<a name="New_and_Noteworthy"></a>Chapter&nbsp;.&nbsp;New and Noteworthy</h2>
 </div>
 </div>
 </div>
@@ -46,7 +46,7 @@
 </div>
 </div>
 </div>
-<table id="N114CD">
+<table id="N114D7">
 <tr>
 						
 <td>
@@ -112,7 +112,7 @@
 </div>
 </div>
 </div>
-<table id="N11534">
+<table id="N1153E">
 <tr>
 						
 <td>
@@ -176,7 +176,7 @@
 </div>
 </div>
 </div>
-<table id="N11597">
+<table id="N115A1">
 <tr>
 						
 <td>
@@ -223,13 +223,13 @@
 </div>
 </div>
 </div>
-<table id="N115DD">
+<table id="N115E7">
 <tr>
 						
 <td>
 							<span class="bold"><strong>Parameter Management Support</strong></span>
 						</td>
-						<td>AMP now has full support for editing and launching of parameter files, including code completion. There is also support for creation of tests and analysis of test results. Finally, data can now be generated to a common EMD based (adata) data format.</td>
+						<td>AMP now has full support for editing and launching of parameter files, including code completion and all of the other editor niceties.</td>
 					
 </tr>
 <tr>
@@ -281,7 +281,7 @@
 </div>
 </div>
 </div>
-<table id="N11634">
+<table id="N1163E">
 <tr>
 						
 <td>
diff --git a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Other_Contacts.html b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Other_Contacts.html
index a78e3b7..5ae26fd 100644
--- a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Other_Contacts.html
+++ b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Other_Contacts.html
@@ -2,11 +2,11 @@
 <head>
 <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
 <title>Other Contacts</title>
-<link href="book.css" rel="stylesheet" type="text/css">
-<meta content="DocBook XSL Stylesheets V1.75.1" name="generator">
+<link href="book.css" type="text/css" rel="stylesheet">
+<meta content="DocBook XSL Stylesheets V1.76.0" name="generator">
 <link rel="home" href="index.html" title="Agent Modeling Guide">
-<link rel="up" href="Support.html" title="Support">
-<link rel="prev" href="Support.html" title="Support">
+<link rel="up" href="Support.html" title="Chapter&nbsp;.&nbsp;Support">
+<link rel="prev" href="Support.html" title="Chapter&nbsp;.&nbsp;Support">
 <link rel="next" href="Get_Involved.html" title="Get Involved">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
diff --git a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Other_Domains.html b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Other_Domains.html
index 18ffd9e..673f71e 100644
--- a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Other_Domains.html
+++ b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Other_Domains.html
@@ -2,10 +2,10 @@
 <head>
 <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
 <title>Other Domains</title>
-<link href="book.css" rel="stylesheet" type="text/css">
-<meta content="DocBook XSL Stylesheets V1.75.1" name="generator">
+<link href="book.css" type="text/css" rel="stylesheet">
+<meta content="DocBook XSL Stylesheets V1.76.0" name="generator">
 <link rel="home" href="index.html" title="Agent Modeling Guide">
-<link rel="up" href="Introduction.html" title="Introduction">
+<link rel="up" href="Introduction.html" title="Chapter&nbsp;.&nbsp;Introduction">
 <link rel="prev" href="Agent-Based_Modeling.html" title="Agent-Based Modeling">
 <link rel="next" href="The_Agent_Modeling_Platform_.28AMP.29.html" title="The Agent Modeling Platform (AMP)">
 </head>
diff --git a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Papers.html b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Papers.html
index ce61583..e2d3143 100644
--- a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Papers.html
+++ b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Papers.html
@@ -2,12 +2,12 @@
 <head>
 <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
 <title>Papers</title>
-<link href="book.css" rel="stylesheet" type="text/css">
-<meta content="DocBook XSL Stylesheets V1.75.1" name="generator">
+<link href="book.css" type="text/css" rel="stylesheet">
+<meta content="DocBook XSL Stylesheets V1.76.0" name="generator">
 <link rel="home" href="index.html" title="Agent Modeling Guide">
-<link rel="up" href="Resources.html" title="Resources">
-<link rel="prev" href="Resources.html" title="Resources">
-<link rel="next" href="Support.html" title="Support">
+<link rel="up" href="Resources.html" title="Chapter&nbsp;.&nbsp;Resources">
+<link rel="prev" href="Resources.html" title="Chapter&nbsp;.&nbsp;Resources">
+<link rel="next" href="Support.html" title="Chapter&nbsp;.&nbsp;Support">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <h1 xmlns:l="http://docbook.sourceforge.net/xmlns/l10n/1.0">Papers</h1>
diff --git a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Programer_Guide.html b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Programer_Guide.html
index f01a9b1..05656bf 100644
--- a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Programer_Guide.html
+++ b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Programer_Guide.html
@@ -1,9 +1,9 @@
 <html>
 <head>
 <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>Programer Guide</title>
-<link href="book.css" rel="stylesheet" type="text/css">
-<meta content="DocBook XSL Stylesheets V1.75.1" name="generator">
+<title>Chapter&nbsp;.&nbsp;Programer Guide</title>
+<link href="book.css" type="text/css" rel="stylesheet">
+<meta content="DocBook XSL Stylesheets V1.76.0" name="generator">
 <link rel="home" href="index.html" title="Agent Modeling Guide">
 <link rel="up" href="index.html" title="Agent Modeling Guide">
 <link rel="prev" href="Model_Implementation.html" title="Model Implementation">
@@ -11,12 +11,12 @@
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <h1 xmlns:l="http://docbook.sourceforge.net/xmlns/l10n/1.0">Programer Guide</h1>
-<div class="chapter" title="Programer Guide">
+<div class="chapter" title="Chapter&nbsp;.&nbsp;Programer Guide">
 <div class="titlepage">
 <div>
 <div>
 <h2 class="title">
-<a name="Programer_Guide"></a>Programer Guide</h2>
+<a name="Programer_Guide"></a>Chapter&nbsp;.&nbsp;Programer Guide</h2>
 </div>
 </div>
 </div>
diff --git a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Resources.html b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Resources.html
index 3921108..7381e7e 100644
--- a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Resources.html
+++ b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Resources.html
@@ -1,22 +1,22 @@
 <html>
 <head>
 <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>Resources</title>
-<link href="book.css" rel="stylesheet" type="text/css">
-<meta content="DocBook XSL Stylesheets V1.75.1" name="generator">
+<title>Chapter&nbsp;.&nbsp;Resources</title>
+<link href="book.css" type="text/css" rel="stylesheet">
+<meta content="DocBook XSL Stylesheets V1.76.0" name="generator">
 <link rel="home" href="index.html" title="Agent Modeling Guide">
 <link rel="up" href="index.html" title="Agent Modeling Guide">
-<link rel="prev" href="New_and_Noteworthy.html" title="New and Noteworthy">
+<link rel="prev" href="New_and_Noteworthy.html" title="Chapter&nbsp;.&nbsp;New and Noteworthy">
 <link rel="next" href="Papers.html" title="Papers">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <h1 xmlns:l="http://docbook.sourceforge.net/xmlns/l10n/1.0">Resources</h1>
-<div class="chapter" title="Resources">
+<div class="chapter" title="Chapter&nbsp;.&nbsp;Resources">
 <div class="titlepage">
 <div>
 <div>
 <h2 class="title">
-<a name="Resources"></a>Resources</h2>
+<a name="Resources"></a>Chapter&nbsp;.&nbsp;Resources</h2>
 </div>
 </div>
 </div>
diff --git a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Structure.html b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Structure.html
index 1c7a692..959e3cd 100644
--- a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Structure.html
+++ b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Structure.html
@@ -2,11 +2,11 @@
 <head>
 <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
 <title>Structure</title>
-<link href="book.css" rel="stylesheet" type="text/css">
-<meta content="DocBook XSL Stylesheets V1.75.1" name="generator">
+<link href="book.css" type="text/css" rel="stylesheet">
+<meta content="DocBook XSL Stylesheets V1.76.0" name="generator">
 <link rel="home" href="index.html" title="Agent Modeling Guide">
-<link rel="up" href="Modeler_Guide.html" title="Modeler Guide">
-<link rel="prev" href="Modeler_Guide.html" title="Modeler Guide">
+<link rel="up" href="Modeler_Guide.html" title="Chapter&nbsp;.&nbsp;Modeler Guide">
+<link rel="prev" href="Modeler_Guide.html" title="Chapter&nbsp;.&nbsp;Modeler Guide">
 <link rel="next" href="Actions_2.html" title="Actions">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
diff --git a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Support.html b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Support.html
index 30a1e5d..ae3a7b8 100644
--- a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Support.html
+++ b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Support.html
@@ -1,9 +1,9 @@
 <html>
 <head>
 <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>Support</title>
-<link href="book.css" rel="stylesheet" type="text/css">
-<meta content="DocBook XSL Stylesheets V1.75.1" name="generator">
+<title>Chapter&nbsp;.&nbsp;Support</title>
+<link href="book.css" type="text/css" rel="stylesheet">
+<meta content="DocBook XSL Stylesheets V1.76.0" name="generator">
 <link rel="home" href="index.html" title="Agent Modeling Guide">
 <link rel="up" href="index.html" title="Agent Modeling Guide">
 <link rel="prev" href="Papers.html" title="Papers">
@@ -11,12 +11,12 @@
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <h1 xmlns:l="http://docbook.sourceforge.net/xmlns/l10n/1.0">Support</h1>
-<div class="chapter" title="Support">
+<div class="chapter" title="Chapter&nbsp;.&nbsp;Support">
 <div class="titlepage">
 <div>
 <div>
 <h2 class="title">
-<a name="Support"></a>Support</h2>
+<a name="Support"></a>Chapter&nbsp;.&nbsp;Support</h2>
 </div>
 </div>
 </div>
diff --git a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/The_Agent_Modeling_Platform_.28AMP.29.html b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/The_Agent_Modeling_Platform_.28AMP.29.html
index bf836f5..c8ecb6f 100644
--- a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/The_Agent_Modeling_Platform_.28AMP.29.html
+++ b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/The_Agent_Modeling_Platform_.28AMP.29.html
@@ -2,10 +2,10 @@
 <head>
 <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
 <title>The Agent Modeling Platform (AMP)</title>
-<link href="book.css" rel="stylesheet" type="text/css">
-<meta content="DocBook XSL Stylesheets V1.75.1" name="generator">
+<link href="book.css" type="text/css" rel="stylesheet">
+<meta content="DocBook XSL Stylesheets V1.76.0" name="generator">
 <link rel="home" href="index.html" title="Agent Modeling Guide">
-<link rel="up" href="Introduction.html" title="Introduction">
+<link rel="up" href="Introduction.html" title="Chapter&nbsp;.&nbsp;Introduction">
 <link rel="prev" href="Other_Domains.html" title="Other Domains">
 <link rel="next" href="Credits.html" title="Credits">
 </head>
diff --git a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Tutorials.html b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Tutorials.html
index 44ae54d..a91292c 100644
--- a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Tutorials.html
+++ b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/Tutorials.html
@@ -1,9 +1,9 @@
 <html>
 <head>
 <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>Tutorials</title>
-<link href="book.css" rel="stylesheet" type="text/css">
-<meta content="DocBook XSL Stylesheets V1.75.1" name="generator">
+<title>Chapter&nbsp;.&nbsp;Tutorials</title>
+<link href="book.css" type="text/css" rel="stylesheet">
+<meta content="DocBook XSL Stylesheets V1.76.0" name="generator">
 <link rel="home" href="index.html" title="Agent Modeling Guide">
 <link rel="up" href="index.html" title="Agent Modeling Guide">
 <link rel="prev" href="Executing.html" title="Executing">
@@ -11,12 +11,12 @@
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <h1 xmlns:l="http://docbook.sourceforge.net/xmlns/l10n/1.0">Tutorials</h1>
-<div class="chapter" title="Tutorials">
+<div class="chapter" title="Chapter&nbsp;.&nbsp;Tutorials">
 <div class="titlepage">
 <div>
 <div>
 <h2 class="title">
-<a name="Tutorials"></a>Tutorials</h2>
+<a name="Tutorials"></a>Chapter&nbsp;.&nbsp;Tutorials</h2>
 </div>
 </div>
 </div>
diff --git a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/User_Guide.html b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/User_Guide.html
index 83d9caf..1c3fb50 100644
--- a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/User_Guide.html
+++ b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/User_Guide.html
@@ -1,9 +1,9 @@
 <html>
 <head>
 <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>User Guide</title>
-<link href="book.css" rel="stylesheet" type="text/css">
-<meta content="DocBook XSL Stylesheets V1.75.1" name="generator">
+<title>Chapter&nbsp;.&nbsp;User Guide</title>
+<link href="book.css" type="text/css" rel="stylesheet">
+<meta content="DocBook XSL Stylesheets V1.76.0" name="generator">
 <link rel="home" href="index.html" title="Agent Modeling Guide">
 <link rel="up" href="index.html" title="Agent Modeling Guide">
 <link rel="prev" href="Functions.html" title="Functions">
@@ -11,12 +11,12 @@
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <h1 xmlns:l="http://docbook.sourceforge.net/xmlns/l10n/1.0">User Guide</h1>
-<div class="chapter" title="User Guide">
+<div class="chapter" title="Chapter&nbsp;.&nbsp;User Guide">
 <div class="titlepage">
 <div>
 <div>
 <h2 class="title">
-<a name="User_Guide"></a>User Guide</h2>
+<a name="User_Guide"></a>Chapter&nbsp;.&nbsp;User Guide</h2>
 </div>
 </div>
 </div>
diff --git a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/index.html b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/index.html
index da3440f..00093dd 100644
--- a/org.eclipse.amp/doc/org.eclipse.amp.doc/help/index.html
+++ b/org.eclipse.amp/doc/org.eclipse.amp.doc/help/index.html
@@ -2,10 +2,10 @@
 <head>
 <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
 <title>Agent Modeling Guide</title>
-<link href="book.css" rel="stylesheet" type="text/css">
-<meta content="DocBook XSL Stylesheets V1.75.1" name="generator">
+<link href="book.css" type="text/css" rel="stylesheet">
+<meta content="DocBook XSL Stylesheets V1.76.0" name="generator">
 <link rel="home" href="index.html" title="Agent Modeling Guide">
-<link rel="next" href="Introduction.html" title="Introduction">
+<link rel="next" href="Introduction.html" title="Chapter&nbsp;.&nbsp;Introduction">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <h1 xmlns:l="http://docbook.sourceforge.net/xmlns/l10n/1.0">Agent Modeling Guide</h1>
diff --git a/org.eclipse.amp/doc/org.eclipse.amp.doc/toc.xml b/org.eclipse.amp/doc/org.eclipse.amp.doc/toc.xml
index 12c67e6..16d0f00 100644
--- a/org.eclipse.amp/doc/org.eclipse.amp.doc/toc.xml
+++ b/org.eclipse.amp/doc/org.eclipse.amp.doc/toc.xml
@@ -506,7 +506,7 @@
 <topic href="help/Model_Implementation.html#The_Build_Grid_Action" label="The Build Grid Action"></topic>
 </topic>
 </topic>
-<topic href="help/Model_Implementation.html#Actions_4" label="Actions">
+<topic href="help/Model_Implementation.html#Actions_Part_I" label="Actions Part I">
 <topic href="help/Model_Implementation.html#Create_Initialize_Rule" label="Create Initialize Rule">
 <topic href="help/Model_Implementation.html#Create_Select_Action" label="Create Select Action"></topic>
 <topic href="help/Model_Implementation.html#Create_Query_Action" label="Create Query Action"></topic>
@@ -521,10 +521,12 @@
 <topic href="help/Model_Implementation.html#Create_Evaluations" label="Create Evaluations"></topic>
 </topic>
 </topic>
-<topic href="help/Model_Implementation.html#Actions_2_Movement_Rule" label="Actions 2 Movement Rule">
+<topic href="help/Model_Implementation.html#Actions_Part_II" label="Actions Part II">
 <topic href="help/Model_Implementation.html#Create_Select_and_Query_Actions" label="">
 <topic href="help/Model_Implementation.html#N11208" label="Create Select and Query Actions"></topic>
-<topic href="help/Model_Implementation.html#Model_Error_Handling" label="Model Error Handling"></topic>
+<topic href="help/Model_Implementation.html#Fixing_Model_Errors" label="Fixing Model Errors"></topic>
+<topic href="help/Model_Implementation.html#Create_Intersection_Action" label="Create Intersection Action"></topic>
+<topic href="help/Model_Implementation.html#Add_Move_Action" label="Add Move Action"></topic>
 </topic>
 <topic href="help/Model_Implementation.html#Run_Final_Model" label="Run Final Model"></topic>
 </topic>
