public bool CanPlayerPerformAction(string playerId, Action action)
{
try
{
var player = _characterInfoDictionary[playerId];
if (action == Action.Stay)
{
return(true);
}
if (action == Action.Explode)
{
return(player.CarryingPowerUp);
}
var currentPosition = player.Position;
var coordinate = GetCoordinateFrom(currentPosition);
var newCoordinate = coordinate.MoveIn(action);
return(IsMovementPossibleTo(newCoordinate));
}
catch (Exception e)
{
Logger.Error(e, e.Message);
return(false);
}
}
private void btnSave_Click(object sender, EventArgs e)
{
Action.Action action = new Action.Action();
action.Name = tbActionName.Text;
action.Script = rtbCommand.Text;
action.Save();
}
public MapCoordinate MoveIn(Action action)
{
return(action switch
{
Action.Down => Move(0, 1),
Action.Up => Move(0, -1),
Action.Left => Move(-1, 0),
Action.Right => Move(1, 0),
_ => Move(0, 0)
});
/// <summary>
/// When coniditons are met we prune the character's decision tree
/// </summary>
/// <param name="learningCharacter">Character not caring anymore</param>
/// <param name="overusedAction">Action that led to a devolution</param>
/// <returns>false = a problem occured</returns>
private bool DevolveDecisionTree(Character learningCharacter, Action.Action overusedAction)
{
//If an exception occurs it's because an Action was set in the list
//This should never happen. The conception of the framework is such
//that it should ALWAYS be a Reaction.
string treeName = ((Reaction)overusedAction).InitialEvent.EventName;
DecisionTreeEvolved = _controller.PruneDecisionTree(_builder, learningCharacter.MyName, overusedAction, treeName);
return(DecisionTreeEvolved);
}
/// <summary>
/// It was really, really bad
/// used by archiving process
/// </summary>
/// <param name="unforgetableAction">a very good actionI won't forget</param>
// ReSharper disable once InconsistentNaming
internal void ICanNeverForgetThis(Action.Action unforgetableAction)
{
_myUnforgettableActions.Add(unforgetableAction);
}
/// <summary>
/// It was really, really bad
/// used by archiving process
/// </summary>
/// <param name="unforgivableAction">a very bad actionI won't forget</param>
// ReSharper disable once InconsistentNaming
internal void ICanNeverForgiveMyselfForThis(Action.Action unforgivableAction)
{
_myUnforgivableActions.Add(unforgivableAction);
}
internal void AddActionToLongTermMemory(Action.Action recentAction)
{
//transfers rememberance of recent actions to long term memory
_myPastActions.Add(recentAction);
}
public override List <ImportExport.Result> XmlImport(System.Xml.XmlNode objectNode)
{
List <ImportExport.Result> response = base.XmlImport(objectNode);
try {
foreach (System.Xml.XmlNode currentNode in objectNode.ChildNodes)
{
switch (currentNode.Name)
{
case "Dependencies":
#region Dependencies
foreach (System.Xml.XmlNode currentDependencyNode in currentNode.ChildNodes)
{
switch (currentDependencyNode.Name)
{
case "ConditionClass":
ConditionClass conditionClass = application.ConditionClassGet(currentDependencyNode.Attributes[Name].Value);
if (conditionClass == null)
{
conditionClass = new Core.Condition.ConditionClass(application);
response.AddRange(conditionClass.XmlImport(currentDependencyNode));
}
break;
}
}
#endregion
break;
case "Properties":
#region Properties
foreach (System.Xml.XmlNode currentPropertyNode in currentNode.ChildNodes)
{
switch (currentPropertyNode.Attributes["Name"].Value)
{
case "ConditionClassName":
conditionClassId = application.ConditionClassGetIdByName(currentPropertyNode.InnerText);
if (conditionClassId == 0)
{
throw new ApplicationException("Unable to retreive Condition Type: " + currentPropertyNode.InnerText);
}
break;
}
}
#endregion
break;
case "ConditionCriteria":
#region Condition Criteria
foreach (System.Xml.XmlNode currentCriteriaNode in currentNode.ChildNodes)
{
switch (currentCriteriaNode.Name)
{
case "ConditionCriteriaDemographic":
ConditionCriteria.ConditionCriteriaDemographic conditionCriteriaDemographic = new ConditionCriteria.ConditionCriteriaDemographic(application);
response.AddRange(conditionCriteriaDemographic.XmlImport(currentCriteriaNode));
demographicCriteria.Add(conditionCriteriaDemographic);
break;
case "ConditionCriteriaEvent":
ConditionCriteria.ConditionCriteriaEvent conditionCriteriaEvent = new ConditionCriteria.ConditionCriteriaEvent(application);
response.AddRange(conditionCriteriaEvent.XmlImport(currentCriteriaNode));
eventCriteria.Add(conditionCriteriaEvent);
break;
}
}
#endregion
break;
case "ConditionEvents":
#region Condition Events
foreach (System.Xml.XmlNode currentEventNode in currentNode.ChildNodes)
{
String eventName = currentEventNode.Name;
Core.Action.Action eventAction = new Action.Action(application);
response.AddRange(eventAction.XmlImport(currentEventNode.FirstChild));
if (events.ContainsKey(eventName))
{
events.Remove(eventName);
}
events.Add(eventName, eventAction);
}
#endregion
break;
} // switch (currentNode.Name) {
} // foreach (System.Xml.XmlNode currentNode in objectNode.ChildNodes) {
// SAVE IMPORTED OBJECT
if (!Save())
{
throw new ApplicationException("Unable to save " + ObjectType + ": " + Name + ".");
}
}
catch (Exception importException) {
response.Add(new ImportExport.Result(ObjectType, Name, importException));
}
return(response);
}
