public void AddCharacter(ICharacter character, PartySlot slot)
{
var relevantList = slot == PartySlot.FrontRow
? FrontRow
: slot == PartySlot.BackSeat ? BackSeat : Reserve;
var limit = slot == PartySlot.FrontRow ? FrontRowLimit : slot == PartySlot.BackSeat ? BackSeatLimit : -1;
if (relevantList.Count == limit)
{
ExitHelper.Exit(
slot == PartySlot.FrontRow
? ErrorCodes.ErrorCharLimitReachedFrontrow
: slot == PartySlot.BackSeat
? ErrorCodes.ErrorCharLimitReachedBackseat
: ErrorCodes.ErrorCharLimitReachedReserve,
"Attempted to add Character to party depsite being full");
}
relevantList.Add(character);
_charMap[character] = relevantList;
var currentHighestPartyCount = _model.Statistics[Statistic.HighestPartyCount];
var currentPartyCount = (ulong)_charMap.Count;
if (currentPartyCount > currentHighestPartyCount)
{
_model.Statistics.AddToStatistic(Statistic.HighestPartyCount,
(uint)(currentPartyCount - currentHighestPartyCount));
}
character.LvlUp(Experience);
ResetCache();
}
public void Notify()
{
if (RConsole.ConsoleWindowClosed)
{
ExitHelper.Exit(0, "Window was closed");
}
Show();
}
public ISpell GetSpell(string name)
{
name = name.ToLower();
if (!_nameMap.ContainsKey(name))
{
ExitHelper.Exit(ErrorCodes.ErrorSpellNotFound, "Spell not found " + name);
}
return(_nameMap[name]);
}
public IAffliction GetAffliction(string name)
{
name = name.ToLower();
if (!_afflictions.ContainsKey(name))
{
ExitHelper.Exit(ErrorCodes.ErrorAfflictionNotFound, "Affliction not found " + name);
}
return(_afflictions[name]);
}
private void CancelAction()
{
if (FirstStateActive())
{
ExitHelper.Exit();
}
else
{
Previous();
}
}
public override void Run()
{
Model.CommitChanges();
Input.Update();
if (Input.Action(Actions.Cancel))
{
ExitHelper.Exit();
}
else if (Input.Action(Actions.Confirm))
{
Master.Next();
}
Model.CommitChanges();
}
public void WhenThePlayerMoves(string exit, int numberOfRooms)
{
PlayerHelper.MovePlayer(ExitHelper.GetExitByName(exit), numberOfRooms);
}
/// <exception cref="System.IO.IOException"/>
public static RootStatement CodeToJava(StructMethod mt, MethodDescriptor md, VarProcessor
varProc)
{
StructClass cl = mt.GetClassStruct();
bool isInitializer = ICodeConstants.Clinit_Name.Equals(mt.GetName());
// for now static initializer only
mt.ExpandData();
InstructionSequence seq = mt.GetInstructionSequence();
ControlFlowGraph graph = new ControlFlowGraph(seq);
DeadCodeHelper.RemoveDeadBlocks(graph);
graph.InlineJsr(mt);
// TODO: move to the start, before jsr inlining
DeadCodeHelper.ConnectDummyExitBlock(graph);
DeadCodeHelper.RemoveGotos(graph);
ExceptionDeobfuscator.RemoveCircularRanges(graph);
ExceptionDeobfuscator.RestorePopRanges(graph);
if (DecompilerContext.GetOption(IFernflowerPreferences.Remove_Empty_Ranges))
{
ExceptionDeobfuscator.RemoveEmptyRanges(graph);
}
if (DecompilerContext.GetOption(IFernflowerPreferences.Ensure_Synchronized_Monitor
))
{
// special case: search for 'synchronized' ranges w/o monitorexit instruction (as generated by Kotlin and Scala)
DeadCodeHelper.ExtendSynchronizedRangeToMonitorexit(graph);
}
if (DecompilerContext.GetOption(IFernflowerPreferences.No_Exceptions_Return))
{
// special case: single return instruction outside of a protected range
DeadCodeHelper.IncorporateValueReturns(graph);
}
// ExceptionDeobfuscator.restorePopRanges(graph);
ExceptionDeobfuscator.InsertEmptyExceptionHandlerBlocks(graph);
DeadCodeHelper.MergeBasicBlocks(graph);
DecompilerContext.GetCounterContainer().SetCounter(CounterContainer.Var_Counter,
mt.GetLocalVariables());
if (ExceptionDeobfuscator.HasObfuscatedExceptions(graph))
{
DecompilerContext.GetLogger().WriteMessage("Heavily obfuscated exception ranges found!"
, IFernflowerLogger.Severity.Warn);
if (!ExceptionDeobfuscator.HandleMultipleEntryExceptionRanges(graph))
{
DecompilerContext.GetLogger().WriteMessage("Found multiple entry exception ranges which could not be splitted"
, IFernflowerLogger.Severity.Warn);
}
ExceptionDeobfuscator.InsertDummyExceptionHandlerBlocks(graph, cl.GetBytecodeVersion
());
}
RootStatement root = DomHelper.ParseGraph(graph);
FinallyProcessor fProc = new FinallyProcessor(md, varProc);
while (fProc.IterateGraph(mt, root, graph))
{
root = DomHelper.ParseGraph(graph);
}
// remove synchronized exception handler
// not until now because of comparison between synchronized statements in the finally cycle
DomHelper.RemoveSynchronizedHandler(root);
// LabelHelper.lowContinueLabels(root, new HashSet<StatEdge>());
SequenceHelper.CondenseSequences(root);
ClearStructHelper.ClearStatements(root);
ExprProcessor proc = new ExprProcessor(md, varProc);
proc.ProcessStatement(root, cl);
SequenceHelper.CondenseSequences(root);
StackVarsProcessor stackProc = new StackVarsProcessor();
do
{
stackProc.SimplifyStackVars(root, mt, cl);
varProc.SetVarVersions(root);
}while (new PPandMMHelper().FindPPandMM(root));
while (true)
{
LabelHelper.CleanUpEdges(root);
do
{
MergeHelper.EnhanceLoops(root);
}while (LoopExtractHelper.ExtractLoops(root) || IfHelper.MergeAllIfs(root));
if (DecompilerContext.GetOption(IFernflowerPreferences.Idea_Not_Null_Annotation))
{
if (IdeaNotNullHelper.RemoveHardcodedChecks(root, mt))
{
SequenceHelper.CondenseSequences(root);
stackProc.SimplifyStackVars(root, mt, cl);
varProc.SetVarVersions(root);
}
}
LabelHelper.IdentifyLabels(root);
if (InlineSingleBlockHelper.InlineSingleBlocks(root))
{
continue;
}
// initializer may have at most one return point, so no transformation of method exits permitted
if (isInitializer || !ExitHelper.CondenseExits(root))
{
break;
}
}
// FIXME: !!
//if(!EliminateLoopsHelper.eliminateLoops(root)) {
// break;
//}
ExitHelper.RemoveRedundantReturns(root);
SecondaryFunctionsHelper.IdentifySecondaryFunctions(root, varProc);
varProc.SetVarDefinitions(root);
// must be the last invocation, because it makes the statement structure inconsistent
// FIXME: new edge type needed
LabelHelper.ReplaceContinueWithBreak(root);
mt.ReleaseResources();
return(root);
}