/// <summary>
/// Event-handler for when a NonlivingThing is picked up from this CellView's Cell.
/// </summary>
/// <param name="nonlivingThing"> the NonlivingThing being picked up from the Cell</param>
public void NonlivingThingPickedUpEvent(NonlivingThing nonlivingThing)
{
NonlivingThingView nonLivingThingView = nonLivingThingViews[nonlivingThing];
nonLivingThingViews.Remove(nonlivingThing);
if (nonLivingThingView.DisplayObjectInGridWithinCell)
{
numOfObjectsInGrid -= 1;
}
Invalidate(); // Cause the OnPaint method to repaint this CellView.
}
/// <summary>
/// Event-handler for when a NonlivingThing is put down on this CellView's Cell.
/// </summary>
/// <param name="nonlivingThing"> the NonlivingThing being put down on the Cell</param>
public void NonlivingThingPutDownEvent(NonlivingThing nonlivingThing)
{
NonlivingThingView nonLivingThingView = (NonlivingThingView)pigWorldView.CreateView(nonlivingThing);
nonLivingThingViews.Add(nonlivingThing, nonLivingThingView);
if (nonLivingThingView.DisplayObjectInGridWithinCell)
{
numOfObjectsInGrid += 1;
}
Invalidate(); // Cause the OnPaint method to repaint this CellView.
}
/// <summary>
/// This method is used to pick up a NonlivingThing off the ground of the cell/square.
/// In general, you will need to cast the object returned from this method, e.g.
/// PigFood food = (PigFood)Cell.PickUp(typeof(PigFood));
///
/// The NonlivingThing will continue to exist, so it may be put down again using
/// the PutDown() method. To stop a NonlivingThing from existing, you need to
/// pick it up, and then destroy it, using its Delete() method.
/// The Eat method (in the Animal class) calls Delete().
///
/// It is an error to attempt to pick up a nonlivingThing that does not exist on
/// this Cell. You should check that it exists, by using the Exists() method of
/// this class first.
/// </summary>
/// <param name="type"> the type of nonlivingThing to pickup. </param>
/// <returns> the NonlivingThing that was picked up. </returns>
public NonlivingThing PickUp(Type type)
{
List <NonlivingThing> list;
bool listExists = nonLivingThings.TryGetValue(type, out list);
if (!listExists || list.Count == 0)
{
throw new Exception(
"There is no " + type.Name + " on this cell. "
+ "You should check with Exists() first before trying to pick one up.");
}
NonlivingThing nonlivingThing = list[0];
return(PickUp(nonlivingThing));
}
/// <summary>
/// Pick up a specific nonlivingThing. The NonlivingThing will continue to exist, so it
/// may be put down again using the PutDown() method. To stop a NonlivingThing
/// from existing, you need to pick it up, and then destroy it, using the
/// Delete() method.
///
/// It is an error to attempt to pick up a nonlivingThing that does not exist on
/// this Cell.
/// </summary>
/// <param name="nonlivingThing"> the type of nonlivingThing to pick up. </param>
/// <returns> the nonlivingThing that was picked up. </returns>
public NonlivingThing PickUp(NonlivingThing nonlivingThing)
{
Type type = nonlivingThing.GetType();
List <NonlivingThing> list;
bool listExists = nonLivingThings.TryGetValue(type, out list);
if (!listExists || list.Count == 0)
{
throw new Exception("Can't pick that nonlivingThing up. It's not there!");
}
if (!list.Remove(nonlivingThing))
{
throw new Exception("Can't pick that nonlivingThing up. It's not there!");
}
nonlivingThing.Cell = null;
nonlivingThingPickedUpEvent(nonlivingThing);
return(nonlivingThing);
}
/// <summary>
/// This method will attempt to put a NonlivingThing down on the ground of a cell.
/// See rules 2-4 (at the top of this file) for restrictions on the number
/// of each type of NonlivingThing in the cell, e.g. there can be no more
/// than one PigFood object in the cell.
///
/// If you attempt to break that rule, then this method will return false.
/// But when the PutDown succeeds, the method will return true.
/// </summary>
/// <param name="nonlivingThing"> the nonlivingThing to put down on the ground. </param>
/// <returns> true if the nonlivingThing was successfully put down, or false
/// otherwise. </returns>
public bool PutDown(NonlivingThing nonlivingThing)
{
// Don't allow when occupant is a Plant (e.g. a tree) -- see rule 4, at top of this file.
if (lifeFormOccupant != null && lifeFormOccupant is Plant)
{
return(false);
}
// Don't allow when the cell already has a NonlivingThing of the same type (e.g. pig-food),
// unless OnlyOneObjectOfThisTypePerCell is false -- see rule 2, at top of this file.
Type type = nonlivingThing.GetType();
if (Exists(type) && nonlivingThing.OnlyOneObjectOfThisTypePerCell)
{
return(false);
}
List <NonlivingThing> list;
bool listExists = nonLivingThings.TryGetValue(type, out list);
if (!listExists)
{
list = new List <NonlivingThing>();
nonLivingThings.Add(type, list);
}
// If the cell already contains the same object that is trying to be added, then complain!
if (list.Contains(nonlivingThing))
{
throw new Exception("You can't put that " + type.Name + " there. It's already there!");
}
list.Add(nonlivingThing);
nonlivingThing.Cell = this;
nonlivingThingPutDownEvent(nonlivingThing);
return(true);
}
/// <summary>
/// Constructs a NonLivingThingView.
///
/// NonlivingThing model the nonlivingThing to view.
/// </summary>
protected NonlivingThingView(NonlivingThing nonlivingThing)
{
this.nonlivingThing = nonlivingThing;
}
