public override void NowPrimaried(object request)
{
TargettingKeystrokeRequest targettingRequest = (TargettingKeystrokeRequest)request;
m_targetablePoints = targettingRequest.TargetablePoints;
m_selectionDelegate = targettingRequest.SelectionDelegate;
if (m_selectionDelegate == null)
throw new ArgumentNullException("Selection delegate for targetting must not be null");
m_alternateSelectionKey = targettingRequest.AlternateSelectionKey;
m_targettingType = targettingRequest.TargettingType;
SelectionPoint = SetTargettingInitialSpot(m_engine);
EnablePlayerTargeting enableRequest = new EnablePlayerTargeting(true, m_targetablePoints);
if (targettingRequest.HaloDelegate != null)
enableRequest.HaloDelegate = x => targettingRequest.HaloDelegate(x);
m_gameInstance.SendPaintersRequest(enableRequest);
m_gameInstance.SendPaintersRequest(new EnableMapCursor(true, SelectionPoint));
// If we have no targetable points, just exit now
if (m_targetablePoints.Count == 0)
Escape();
m_gameInstance.UpdatePainters();
}
internal void HandleInvoke(object invokingObject, TargetingInfo targetInfo, OnKeyboardInvoke onInvoke, NamedKey invokeKey)
{
if (targetInfo == null)
{
onInvoke(m_engine.Player.Position);
m_gameInstance.ResetHandlerName();
m_gameInstance.UpdatePainters();
return;
}
else
{
switch (targetInfo.Type)
{
case TargetingInfo.TargettingType.Stream:
{
List<EffectivePoint> targetablePoints = PointListUtils.EffectivePointListOneStepAllDirections(m_engine.Player.Position);
HandleRangedSinglePointInvoke(invokingObject, targetablePoints, onInvoke, invokeKey);
return;
}
case TargetingInfo.TargettingType.RangedSingle:
case TargetingInfo.TargettingType.RangedBlast:
case TargetingInfo.TargettingType.RangedExplodingPoint:
{
List<EffectivePoint> targetablePoints = PointListUtils.EffectivePointListFromBurstPosition(m_engine.Player.Position, targetInfo.Range);
HandleRangedSinglePointInvoke(invokingObject, targetablePoints, onInvoke, invokeKey);
return;
}
case TargetingInfo.TargettingType.Cone:
{
Point playerPosition = m_engine.Player.Position;
List<EffectivePoint> targetablePoints = GetConeTargetablePoints(playerPosition);
OnTargetSelection selectionDelegate = new OnTargetSelection(s =>
{
if (s != m_engine.Player.Position)
onInvoke(s);
return false;
});
m_gameInstance.SetHandlerName("Target", new TargettingKeystrokeRequest(targetablePoints, selectionDelegate,
NamedKey.Invalid, TargettingKeystrokeHandler.TargettingType.Monster,
p => m_engine.Targetting.TargettedDrawablePoints(invokingObject, p)));
return;
}
case TargetingInfo.TargettingType.Self:
{
onInvoke(m_engine.Player.Position);
m_gameInstance.ResetHandlerName();
m_gameInstance.UpdatePainters();
return;
}
default:
throw new System.InvalidOperationException("InvokingKeystrokeHandler - HandleInvoke, don't know how to handle: " + targetInfo.Type.ToString());
}
}
}
private void HandleRangedSinglePointInvoke(object invokingObject, List<EffectivePoint> targetablePoints, OnKeyboardInvoke onInvoke, NamedKey invokeKey)
{
m_engine.Targetting.FilterNotTargetableToPlayerPointsFromList(targetablePoints, true);
m_engine.Targetting.FilterNotVisibleToPlayerBothWaysFromList(targetablePoints, true);
OnTargetSelection selectionDelegate = new OnTargetSelection(s =>
{
if (s != m_engine.Player.Position)
onInvoke(s);
return false;
});
m_gameInstance.SetHandlerName("Target", new TargettingKeystrokeRequest(targetablePoints, selectionDelegate, invokeKey,
TargettingKeystrokeHandler.TargettingType.Monster, p => m_engine.Targetting.TargettedDrawablePoints(invokingObject, p)));
}
public override void HandleKeystroke(NamedKey keystroke)
{
// If we match the alternate key, call Select()
if (m_alternateSelectionKey != NamedKey.Invalid && m_alternateSelectionKey == keystroke)
{
Select();
return;
}
MethodInfo action;
m_keyMappings.TryGetValue(keystroke, out action);
if (action != null)
{
try
{
action.Invoke(this, null);
}
catch (Exception e)
{
throw e.InnerException;
}
}
}
public void HandleKeyStroke()
{
TCODKey key = TCODConsole.checkForKeypress((int)TCODKeyStatus.KeyPressed);
NamedKey namedKey;
// Some keys, like backspace, space, and tab have both a character and a code. We only stick one in the dictionary
// Strip the other one out.
if (key.KeyCode == TCODKeyCode.Char)
namedKey = new NamedKey() { Character = (char)key.Character,
Code = TCODKeyCode.Char,
ControlPressed = (key.LeftControl | key.RightControl),
ShiftPressed = key.Shift,
AltPressed = (key.LeftAlt | key.RightAlt) };
else
namedKey = new NamedKey() { Character = (char)0,
Code = key.KeyCode,
ControlPressed = (key.LeftControl | key.RightControl),
ShiftPressed = key.Shift,
AltPressed = (key.LeftAlt | key.RightAlt) };
m_currentHandler.HandleKeystroke(namedKey);
}
public void MoveToLocation(NamedKey movementKey)
{
List<EffectivePoint> targetPoints = GeneratePointsOneCanMoveTo();
m_gameInstance.SetHandlerName("Target", new TargettingKeystrokeRequest(targetPoints, OnMovementLocationSelected, movementKey, TargettingKeystrokeHandler.TargettingType.OpenFloor));
}
public void Operate(NamedKey operateKey)
{
List<EffectivePoint> targetPoints = CalculateOperatePoints();
if ((bool)Preferences.Instance["SinglePressOperate"] && targetPoints.Count == 1)
{
m_engine.Actions.Operate(targetPoints[0].Position);
m_gameInstance.UpdatePainters();
}
else
{
OnTargetSelection operateDelegate = new OnTargetSelection(OnOperate);
m_gameInstance.SetHandlerName("Target", new TargettingKeystrokeRequest(targetPoints, operateDelegate, operateKey, TargettingKeystrokeHandler.TargettingType.Operatable));
}
}
public void MoveToLocation(NamedKey movementKey)
{
m_autoTraveler.MoveToLocation(movementKey);
}
public void Attack(NamedKey attackKey)
{
if (m_engine.Player.CurrentWeapon.IsRanged && !m_engine.Player.CurrentWeapon.IsLoaded)
{
m_engine.Actions.ReloadWeapon();
m_gameInstance.TextBox.AddText(string.Format("{0} reloads the {1}.", m_engine.Player.Name, m_engine.Player.CurrentWeapon.DisplayName));
}
else
{
List<EffectivePoint> targetPoints = m_engine.GameState.CalculateTargetablePointsForEquippedWeapon();
m_gameInstance.SetHandlerName("Target", new TargettingKeystrokeRequest(targetPoints, OnRangedAttack, attackKey, TargettingKeystrokeHandler.TargettingType.Monster));
}
}
private void ReadFileCallback(XmlReader reader, object data)
{
bool requireAllActions = (bool)data;
if (reader.LocalName != "KeyMappings")
throw new System.InvalidOperationException("Bad key mappings file");
while (true)
{
reader.Read();
if (reader.NodeType == XmlNodeType.EndElement && reader.LocalName == "KeyMappings")
{
break;
}
if (reader.LocalName == "KeyMapping")
{
string keyString = reader.GetAttribute("Key");
string actionName = reader.GetAttribute("Action");
if (isDirectionAction(actionName))
{
string runSuffix = (bool)Preferences.Instance["UseAltInsteadOfCtrlForRunning"] ? "Alt" : "Control";
FindAndAddKeyHandler(requireAllActions, keyString + runSuffix, "Run" + actionName);
m_actionKeyMapping["Run" + actionName] = new NamedKey(keyString + runSuffix);
}
if (actionName == "ChangeTabs")
{
FindAndAddKeyHandler(requireAllActions, keyString + "Shift", "Shift" + actionName);
m_actionKeyMapping["Shift" + actionName] = new NamedKey(keyString + "Shift");
}
m_actionKeyMapping[actionName] = new NamedKey(keyString);
FindAndAddKeyHandler(requireAllActions, keyString, actionName);
}
}
}
public virtual void HandleKeystroke(NamedKey keystroke)
{
MethodInfo action;
m_keyMappings.TryGetValue(keystroke, out action);
if (action != null)
{
action.Invoke(this, null);
}
}
private void FindAndAddKeyHandler(bool requireAllActions, string keyString, string actionName)
{
MethodInfo action = this.GetType().GetMethod(actionName, BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy);
if (action != null)
{
NamedKey namedKey = new NamedKey(keyString);
if (m_keyMappings.ContainsKey(namedKey))
{
AddErrorIfNotReported("Error in keymapping - Trying to assign multiple keys to '" + namedKey.ToString() + "'.\n");
m_keyMappings.Remove(namedKey);
}
m_keyMappings.Add(namedKey, action);
}
else if (requireAllActions)
{
throw new InvalidOperationException(string.Format("Could not find a mappable operation named {0}.", actionName));
}
}
