// Use this for initialization
void Start()
{
app = AppManager.appManager;
gManager = GameManager.gManager;
if (!app.gameToLaunch.isTutorial)
{
this.enabled = false;
}
else
{
currentInfoIndex = 0;
textInfo = infoUI.transform.Find("Text").GetComponent <Text>();
tutorialInstructionsData = app.GetComponent <LanguageManager>().tutorialsTexts.GetField(app.gameToLaunch.tutorialName).GetField("ContextualInfo").GetField(app.gameLanguage.ToString());
nbInfos = tutorialInstructionsData.Count;
if (nbInfos > 0)
{
textInfo.text = tutorialInstructionsData[currentInfoIndex].str;
}
else
{
this.enabled = false;
}
checkForkNextStep = tuto01checks;
doNextStep = tuto01actions;
}
}
private void runRunTo()
{
if (m_Cart == null)
{
return;
}
while (m_Clocks < freqOverSixty)
{
if (m_PC != m_BreakAddress)
{
execute = new ExecuteStep(runStopped);
}
step();
}
if (m_Clocks >= freqOverSixty)
{
m_Clocks -= freqOverSixty;
}
}
public void runTo(ushort address)
{
m_BreakAddress = address;
execute = new ExecuteStep(runRunTo);
}
public void run()
{
execute = new ExecuteStep(runFrame);
}
public void stop()
{
execute = new ExecuteStep(runStopped);
}
private async Task <StepResult> DoExecuteAsync(ExecuteStep step)
{
var command = new Execute
{
Executable = step.Executable,
Arguments = step.Arguments,
WorkingDirectory = step.WorkingDirectory,
RunAsAdministrator = step.RunAsAdmin,
WaitForCompletion = step.WaitForCompletion,
ExecutionTimeoutSecs = step.TimeoutSecs
};
IResponse response;
if (step.Environment == StepEnvironment.Local)
{
response = await new ObservableProcess(command).StartAndObserveAsync(tree =>
step.ConfirmTerminationOnTimeout ? _controller.ShouldTerminateProcessOnTimeoutAsync(tree) : Task.FromResult(true), _controller.CancellationToken);
}
else
{
response = await _channel.SendWithReplyAsync <IResponse>(command, _controller.CancellationToken);
if (response is ExecutionTimedOutResponse timeoutResponse)
{
var shouldTerminate = !step.ConfirmTerminationOnTimeout || await _controller.ShouldTerminateProcessOnTimeoutAsync(timeoutResponse.ProcessTree);
response = await _channel.SendWithReplyAsync <IResponse>(
new ExecutionTimedOutActionCommand { TerminateProcesses = shouldTerminate }, _controller.CancellationToken);
}
}
var machine = step.Environment == StepEnvironment.Local ? "local" : "remote";
if (response is ExecutionTerminatedResponse terminatedResponse)
{
var log = new StringBuilder("The following processes were terminated:\r\n");
ProcessUtils.PrintProcessTree(log, terminatedResponse.TerminatedProcessTree);
return(new StepResult(false, $"Execution timeout is exceeded. {step.Executable} process on the {machine} machine is terminated.", log.ToString()));
}
else
{
var result = (ExecutionCompleted)response;
if (result.Status == ExecutionStatus.Completed)
{
var log = new StringBuilder();
var stdout = result.Stdout.TrimEnd('\r', '\n');
var stderr = result.Stderr.TrimEnd('\r', '\n');
if (stdout.Length == 0 && stderr.Length == 0)
{
log.AppendFormat("No stdout/stderr captured (exit code {0})\r\n", result.ExitCode);
}
if (stdout.Length != 0)
{
log.AppendFormat("Captured stdout (exit code {0}):\r\n{1}\r\n", result.ExitCode, stdout);
}
if (stderr.Length != 0)
{
log.AppendFormat("Captured stderr (exit code {0}):\r\n{1}\r\n", result.ExitCode, stderr);
}
if (result.ExitCode == 0)
{
return(new StepResult(true, "", log.ToString(), errorListOutput: new string[] { stdout, stderr }));
}
else
{
return(new StepResult(false, $"{step.Executable} process exited with a non-zero code ({result.ExitCode}). Check your application or debug script output in Output -> RAD Debug.", log.ToString(), errorListOutput: new string[] { stdout, stderr }));
}
}
else
{
// result.Stderr contains the error reason
return(new StepResult(false, $"{step.Executable} process could not be started on the {machine} machine. {result.Stderr}", result.Stderr + "\r\n"));
}
}
}
public bool EndOfFrame()
{
nowStep = ExecuteStep.EndOfFrame;
return(MoveNext());
}
public bool FixedUpdate()
{
nowStep = ExecuteStep.FixedUpdate;
return(MoveNext());
}
public bool Update()
{
nowStep = ExecuteStep.Update;
return MoveNext();
}
public bool EndOfFrame()
{
nowStep = ExecuteStep.EndOfFrame;
return MoveNext();
}
static void Main()
{
Random random = new Random();
bool endSteps = false;
Step[] stepOrder = new Step[]
{
Step.NPCorMonster,
Step.Level,
Step.Traits,
Step.Size,
Step.Hit_Points,
Step.Resistances_Weaknesses,
Step.Skills,
Step.Armor_Class,
Step.Strike_Attack_Bonus,
Step.Strike_Damage,
Step.Ability_Scores,
Step.Perception,
Step.Saves,
Step.Spells,
Step.Spell_DC_And_Attack_Bonus,
Step.Area_Damage,
Step.Gear,
Step.End,
Step.SaveToFile
};
int partyLevel = Program.GetMinMaxInt("Please enter the party's current level: ", MinMax.hasBoth, 1, 20);
for (int step = 0; endSteps == false; step++)
{
if (step >= 0 && step < stepOrder.Length)
{
Console.WriteLine("Step: " + stepOrder[step]);
}
if (step > 0)
{
step = ContinueOrBack(stepOrder, step);
}
if (_creatureSaves.ContainsKey(stepOrder[step]))
{
_creatureSaves.Remove(stepOrder[step]);
}
_creatureSaves.Add(stepOrder[step], CopyCreature(_creature));
switch (stepOrder[step])
{
case Step.NPCorMonster:
{
Console.WriteLine("Enter NPC or Monster to select a creature type, or press Enter to randomly select");
string userInput = GetValidString("NPC", "Monster", "");
switch (userInput.ToUpper())
{
case "NPC":
_creature.Type = CreatureType.NPC;
break;
case "Monster":
_creature.Type = CreatureType.Monster;
break;
case "":
_creature.Type = CreatureType.Any;
break;
}
break;
}
case Step.Level:
{
ExecuteStep.LevelStep(random, _creature, partyLevel);
break;
}
case Step.Traits:
{
string userInput = "";
do
{
ExecuteStep.TraitsStep(_creature, random);
Console.WriteLine("Press enter to continue or ADD to add another trait");
userInput = GetValidString("", "ADD");
} while (userInput.ToUpper() == "ADD");
break;
}
case Step.Size:
{
ExecuteStep.SizeStep(_creature, random);
break;
}
case Step.Hit_Points:
{
ExecuteStep.HitPointStep(_creature, random);
break;
}
case Step.Resistances_Weaknesses:
{
Console.WriteLine("Press Enter to continue or NO to skip this step");
string userInput = GetValidString("", "NO");
if (userInput.ToUpper() != "NO")
{
ExecuteStep.ResistanceWeaknessStep(_creature, random);
}
break;
}
case Step.Skills:
{
do
{
List <Degree> savedDegrees = CopyDegreeList(_creature.DegreeList);
ExecuteStep.SkillStep(_creature, random);
Console.WriteLine("Press ENTER to continue or BACK to erase previous skill");
string userInput = GetValidString("", "BACK");
if (userInput.ToUpper() == "BACK")
{
int latestSkillIndex = _creature.SkillPool.SelectedSkills.Count() - 1;
_creature.SkillPool.PossibleSkills.Add(_creature.SkillPool.SelectedSkills[latestSkillIndex].skillName);
_creature.SkillPool.PossibleSkills.Sort();
_creature.SkillPool.SelectedSkills.RemoveAt(latestSkillIndex);
_creature.DegreeList = CopyDegreeList(savedDegrees);
}
} while (_creature.SkillPool.SelectedSkills.Count < 6);
break;
}
case Step.Armor_Class:
{
ExecuteStep.ArmorClassStep(_creature, random);
break;
}
case Step.Strike_Attack_Bonus:
{
ExecuteStep.StrikeAttackStep(_creature, random);
break;
}
case Step.Strike_Damage:
{
ExecuteStep.StrikeDamageStep(_creature, random);
break;
}
case Step.Ability_Scores:
{
AbilityScoreEnum[] abilities = new AbilityScoreEnum[] { AbilityScoreEnum.Strength, AbilityScoreEnum.Dexterity, AbilityScoreEnum.Intelligence, AbilityScoreEnum.Wisdom, AbilityScoreEnum.Charisma };
foreach (AbilityScoreEnum ability in abilities)
{
string userInput = "";
do
{
List <Degree> saveDegrees = CopyDegreeList(_creature.DegreeList);
ExecuteStep.AbilityScoreStep(_creature, random, ability);
Console.WriteLine("Press ENTER to continue or BACK to redo the {0} score", ability);
userInput = GetValidString("", "BACK");
if (userInput.ToUpper() == "BACK")
{
_creature.DegreeList = CopyDegreeList(saveDegrees);
}
} while (userInput.ToUpper() == "BACK");
}
break;
}
case Step.Perception:
{
ExecuteStep.PerceptionStep(_creature, random);
break;
}
case Step.Saves:
{
SaveName[] saves = new SaveName[] { SaveName.Fortitude, SaveName.Reflex, SaveName.Will };
foreach (SaveName save in saves)
{
ExecuteStep.SavesStep(_creature, random, save);
}
break;
}
case Step.Spells:
{
string[] spellTypes = new string[] { "Arcane", "Occult", "Primal", "Divine", "Focus", "NONE" };
Console.WriteLine("Press Enter to randomly select this creature's magic type or one of the following types:");
foreach (string type in spellTypes)
{
Console.WriteLine(type);
}
string[] validInputs = new string[spellTypes.Length + 1];
for (int i = 0; i < validInputs.Length; i++)
{
if (i == 0)
{
validInputs[i] = "";
}
else
{
validInputs[i] = spellTypes[i - 1];
}
}
string typeInput = GetValidString(validInputs);
if (typeInput == "")
{
if (random.Next(2) == 1)
{
typeInput = spellTypes[random.Next(spellTypes.Length)];
}
else
{
_creature.HasSpells = false;
}
}
if (typeInput.ToUpper() == "NONE")
{
_creature.HasSpells = false;
}
if (_creature.HasSpells)
{
ExecuteStep.SpellsStep(_creature, random, CapitalizeString(typeInput));
}
break;
}
case Step.Spell_DC_And_Attack_Bonus:
{
if (!_creature.Spells.Any())
{
Console.WriteLine("No spells detected. Skipping step");
}
else
{
ExecuteStep.SpellStatsStep(_creature, random);
}
break;
}
case Step.Area_Damage:
{
ExecuteStep.AreaDamageStep(_creature);
break;
}
case Step.Gear:
{
Console.WriteLine("Press Enter to randomly determine if creature has gear or Y\\N:");
string userInput = GetValidString("", "Y", "N");
if (userInput == "" && random.Next(2) == 1)
{
userInput = "Y";
}
if (userInput.ToUpper() == "Y")
{
ExecuteStep.GearStep(_creature, random);
}
break;
}
case Step.End:
{
ExecuteStep.EndStep(_creature);
break;
}
case Step.SaveToFile:
{
Console.WriteLine("Would you like to save this creature? Y/N");
string saveOrNot = GetValidString("Y", "N");
if (saveOrNot.ToUpper() == "Y")
{
ExecuteStep.SaveToFileStep(_creature);
}
endSteps = true;
break;
}
default:
{
Console.WriteLine("Step incomplete");
//endSteps = true;
break;
}
}
}
}
