private bool Calculate(CheckCalcArgs args)
{
Piece king = board.Pieces[args.kingIndex];
for (int p = 0; p < board.Pieces.Count; p++)
{
Piece enemy = board.Pieces[p];
if (enemy.OwnerPlayer != king.OwnerPlayer)
{
TurnOptions moveOptions = moveOptionQuery.Send(new TurnOptionCalculatorArgs()
{
pieceIndex = p,
luaState = LuaTranslator.GetMoveCalcState(p, board, db),
});
foreach (var option in moveOptions.options)
{
if (option.components[0].target == args.testPosition)
{
BalugaDebug.Log(string.Format("King {0} in check from {1} at {2}", args.kingIndex, p, enemy.BoardPosition));
return(true);
}
}
}
}
return(false);
}
private void OnReceivedAction(TurnAction action)
{
bool validAction = false;
if (action.components.Count == 1 && action.components[0].type == TurnActionComponentType.Forfeit)
{
validAction = true;
}
else
{
int pieceIndex = board.PieceOnSpace(action.searchPiece);
if (pieceIndex >= 0)
{
TurnOptions currentOptions = turnOptionCalculator.Send(new TurnOptionCalculatorArgs()
{
pieceIndex = pieceIndex,
luaState = LuaTranslator.GetMoveCalcState(pieceIndex, board, db),
});
foreach (var possible in currentOptions.options)
{
if (possible.IsEquivalent(action))
{
validAction = true;
break;
}
}
}
}
if (!validAction)
{
UnityEngine.Debug.LogError("Cheating detected! Or at least a mod mismatch!");
}
choiceMadeEvent.Send(action);
}
private void RefreshMoveOptions()
{
int pieceID = -1;
switch (selEvent.CurrentType)
{
case PlayerSelectionEvent.SelectionType.Piece:
pieceID = selEvent.PieceID;
break;
case PlayerSelectionEvent.SelectionType.Square:
pieceID = board.PieceOnSpace(selEvent.SquarePos);
break;
}
if (pieceID >= 0 && pieceID != chosenPiece.Value)
{
Piece piece = board.Pieces[pieceID];
TurnOptions calculatedOptions = moveOptionCalculator.Send(new TurnOptionCalculatorArgs()
{
pieceIndex = pieceID,
luaState = LuaTranslator.GetMoveCalcState(pieceID, board, db),
});
displayMessage.Send(compiler.Send(new ActionIndicatorPatternCompileArgs()
{
options = calculatedOptions,
highlightedIndex = -1,
mouseOverMode = true,
}));
}
else
{
displayMessage.Send(null);
}
}
private TurnOptions CalculateMoveOptions(TurnOptionCalculatorArgs args)
{
TurnOptions finalOptions = new TurnOptions();
finalOptions.options = new List <TurnAction>();
Piece piece = board.Pieces[args.pieceIndex];
PiecePrototype proto = db.PiecePrototypes[piece.PrototypeID];
scripts.AddGlobal("actionHelper", luaHelper);
DynValue ret = scripts.CallFunction(proto.MovementFunction, args.luaState);
scripts.RemoveGlobal("actionHelper");
try {
Table optionList = SafeGetTable(ret, string.Format("Piece {0} action function error: Expected table to be returned", proto.LuaTag));
int numOptions = optionList.Length;
for (int i = 1; i <= numOptions; i++)
{
Table actionList = SafeGetTable(optionList.Get(i),
string.Format("Piece {0} action function error: Expected table at position {1} in returned list", proto.LuaTag, i));
TurnAction action = TranslateActionTable(args.pieceIndex, actionList, i);
finalOptions.options.Add(action);
}
} catch (BadActionException ex) {
scripts.WriteToAuthorLog(ex.Message);
finalOptions.options.Clear();
}
return(finalOptions);
}
public static void FilterOptionsForPosition(List <int> actionList, TurnOptions allOptions, IntVector2 boardPos)
{
actionList.Clear();
for (int a = 0; a < allOptions.options.Count; a++)
{
TurnAction action = allOptions.options[a];
bool addAction = false;
// Add if final move action ends at boardPos
int lastMoveIndex = -1;
for (int i = action.components.Count - 1; i >= 0; i--)
{
if (action.components[i].type == TurnActionComponentType.MovePiece)
{
lastMoveIndex = i;
break;
}
}
if (lastMoveIndex >= 0 && action.components[lastMoveIndex].target == boardPos)
{
addAction = true;
}
else
{
// Add actions that capture or promote a piece on this position
foreach (var component in action.components)
{
switch (component.type)
{
case TurnActionComponentType.CapturePiece:
if (component.target == boardPos)
{
addAction = true;
}
break;
case TurnActionComponentType.PromotePiece:
if (component.actor == boardPos)
{
addAction = true;
}
break;
}
if (addAction)
{
break;
}
}
}
if (addAction)
{
actionList.Add(a);
}
}
}
private void OnEnterState(int state)
{
if (chooserState.State == (int)TurnChooser.State.ChooseAction)
{
chosenAction.Value = null;
inputOffsets.Clear();
currentOptions = turnOptionCalculator.Send(new TurnOptionCalculatorArgs()
{
pieceIndex = chosenPiece.Value,
luaState = LuaTranslator.GetMoveCalcState(chosenPiece.Value, board, db),
});
RefreshHighlightedValue();
}
else
{
highlightMessage.Send(new TurnChooserHighlight()
{
options = null,
indexesOnSpace = null,
highlightedIndex = -1,
});
currentOptions = null;
}
}
