public TES5Script(TES5GlobalScope globalScope, TES5BlockList blockList, bool isQuestOrTopicInfo)
{
this.ScriptHeader = globalScope.ScriptHeader;
this.GlobalScope = globalScope;
this.BlockList = blockList;
this.isQuestOrTopicInfo = isQuestOrTopicInfo;
}
public static void GenerateINFOAddTopicScripts(ESMAnalyzer esmAnalyzer, BuildTracker buildTracker, IBuildTarget tifBuildTarget)
{
TES5TypeInferencer typeInferencer = new TES5TypeInferencer(esmAnalyzer);
TES5ObjectCallFactory objectCallFactory = new TES5ObjectCallFactory(typeInferencer);
TES4TopicsToTES5GlobalVariableFinder globalVariableFinder = new TES4TopicsToTES5GlobalVariableFinder();
TES5GlobalVariables globalVariables = esmAnalyzer.GlobalVariables;
var builtTIFs = buildTracker.GetBuiltScripts(BuildTargetFactory.TIFName);
foreach (TES4Record infoRecord in esmAnalyzer.GetRecords().Where(r => r.RecordType == TES4RecordType.INFO))
{
TES4SubrecordData[] names = infoRecord.GetSubrecords("NAME").ToArray();
if (names.Any())
{
string fragment0Name = TES5FragmentFactory.GetFragmentName(0);
string nameTES5FormIDHex = (infoRecord.FormID + 0x01000000).ToString("x8");
string scriptName = TES5ReferenceFactory.tif_Prefix + "_" + nameTES5FormIDHex;
TES5Script? infoTIF = builtTIFs.Where(s => s.Key == scriptName).Select(s => s.Value.Script).FirstOrDefault();
TES5FunctionCodeBlock fragment0;
if (infoTIF != null)
{
fragment0 = infoTIF.BlockList.Blocks.OfType <TES5FunctionCodeBlock>().Where(b => b.BlockName == fragment0Name).First();
}
else
{
TES5ScriptHeader scriptHeader = TES5ScriptHeaderFactory.GetFromCacheOrConstructByBasicType(scriptName, TES5BasicType.T_TOPICINFO, TES5TypeFactory.TES4_Prefix, true);
TES5GlobalScope globalScope = new TES5GlobalScope(scriptHeader);
TES5FunctionScope functionScope = new TES5FunctionScope(fragment0Name);
functionScope.AddParameter(new TES5SignatureParameter("akSpeakerRef", TES5BasicType.T_OBJECTREFERENCE, true));
TES5LocalScope localScope = new TES5LocalScope(functionScope);
TES5CodeScope codeScope = TES5CodeScopeFactory.CreateCodeScope(localScope);
fragment0 = new TES5FunctionCodeBlock(functionScope, codeScope, TES5VoidType.Instance, false, true);
TES5BlockList blockList = new TES5BlockList()
{
fragment0
};
infoTIF = new TES5Script(globalScope, blockList, true);
string outputPath = tifBuildTarget.GetTranspileToPath(scriptName);
TES5Target target = new TES5Target(infoTIF, outputPath);
buildTracker.RegisterBuiltScript(tifBuildTarget, target);
}
foreach (TES4SubrecordData name in names)
{
int formID = infoRecord.ExpandBytesIntoFormID(name);
TES4Record addedTopic = esmAnalyzer.GetRecordByFormID(formID);
Tuple <int, string>?globalVariable = globalVariableFinder.GetGlobalVariableNullable(addedTopic.FormID);
string globalVariableEditorID = globalVariable != null ? globalVariable.Item2 : globalVariableFinder.GetGlobalVariableEditorID(addedTopic.GetEditorID());
Nullable <int> globalVariableTES5FormID = globalVariable != null ? globalVariable.Item1 : (Nullable <int>)null;
TES5Property topicAddedProperty = TES5PropertyFactory.ConstructWithTES5FormID(globalVariableEditorID, TES5BasicType.T_GLOBALVARIABLE, globalVariableEditorID, globalVariableTES5FormID);
infoTIF.GlobalScope.AddPropertyIfNotExists(topicAddedProperty);
TES5Reference topicAddedReference = TES5ReferenceFactory.CreateReferenceToVariableOrProperty(topicAddedProperty);
fragment0.AddChunk(objectCallFactory.CreateObjectCall(topicAddedReference, "SetValueInt", new TES5ObjectCallArguments()
{
new TES5Integer(1)
}));
}
}
}
}
public TES5BlockList CreateBlock(TES4CodeBlock block, TES5GlobalScope globalScope, TES5MultipleScriptsScope multipleScriptsScope, ref TES5EventCodeBlock?onUpdateBlockForNonQuestOrAME)
{
TES5BlockList blockList = new TES5BlockList();
string blockType = block.BlockType;
string newBlockType = MapBlockType(blockType);
TES4CodeChunks?chunks = block.Chunks;
if (chunks != null && chunks.Any())
{
TES5FunctionScope blockFunctionScope = TES5FunctionScopeFactory.CreateFromBlockType(newBlockType);
bool onUpdateOfNonQuestOrAME = newBlockType == "OnUpdate" && globalScope.ScriptHeader.ScriptType.NativeType != TES5BasicType.T_QUEST && globalScope.ScriptHeader.ScriptType.NativeType != TES5BasicType.T_ACTIVEMAGICEFFECT;
bool onUpdateBlockOfNonQuestOrAMEAlreadyPresent = onUpdateBlockForNonQuestOrAME != null;
TES5BlockList? onUpdateAdditionalBlocksOfNonQuestOrAME = null;
TES5EventCodeBlock targetEventBlock;
TES5CodeScope targetCodeScope;
if (onUpdateOfNonQuestOrAME)
{
if (!onUpdateBlockOfNonQuestOrAMEAlreadyPresent)
{
CreateActivationStates(globalScope, out onUpdateAdditionalBlocksOfNonQuestOrAME, out targetEventBlock);
onUpdateBlockForNonQuestOrAME = targetEventBlock;
}
else
{
if (onUpdateBlockForNonQuestOrAME == null)
{
throw new NullableException(nameof(onUpdateBlockForNonQuestOrAME));
}
targetEventBlock = onUpdateBlockForNonQuestOrAME;
}
targetCodeScope = targetEventBlock.CodeScope;
}
else
{
targetEventBlock = CreateEventCodeBlock(blockFunctionScope, globalScope);
targetCodeScope = this.initialBlockCodeFactory.AddInitialCode(globalScope, targetEventBlock);
}
TES5CodeScope newScope = TES5CodeScopeFactory.CreateCodeScopeRecursive(targetCodeScope.LocalScope);
TES5CodeScope convertedCodeScope = this.ConvertTES4CodeChunksToTES5CodeScope(chunks, newScope, globalScope, multipleScriptsScope);
TES5CodeScope modifiedCodeScope = this.changesPass.Modify(block, blockList, blockFunctionScope, convertedCodeScope, globalScope, multipleScriptsScope);
targetEventBlock.CodeScope.LocalScope.CopyVariablesFrom(modifiedCodeScope.LocalScope);
targetEventBlock.CodeScope.AddChunks(modifiedCodeScope.CodeChunks);
blockList.Add(targetEventBlock);
if (onUpdateOfNonQuestOrAME)
{
if (!onUpdateBlockOfNonQuestOrAMEAlreadyPresent)
{
if (onUpdateAdditionalBlocksOfNonQuestOrAME == null)
{
throw new NullableException(nameof(onUpdateAdditionalBlocksOfNonQuestOrAME));
}
return(onUpdateAdditionalBlocksOfNonQuestOrAME);
}
return(new TES5BlockList());
}
}
return(blockList);
}
public TES5Target Convert(TES5FragmentType fragmentType, TES4FragmentTarget fragmentTarget, TES5GlobalScope globalScope, TES5MultipleScriptsScope multipleScriptsScope)
{
TES5FunctionCodeBlock fragment = CreateFragment(fragmentType, 0, globalScope, multipleScriptsScope, fragmentTarget.CodeChunks);
TES5BlockList blockList = new TES5BlockList()
{
fragment
};
TES5Script script = new TES5Script(globalScope, blockList, true);
TES5Target target = new TES5Target(script, fragmentTarget.OutputPath);
return(target);
}
private void CreateActivationStates(TES5GlobalScope globalScope, out TES5BlockList blocks, out TES5EventCodeBlock onUpdate)
{
TES5StateCodeBlock activeState;
CreateActiveStateBlock(globalScope, out activeState, out onUpdate);
TES5StateCodeBlock inactiveState = CreateInactiveStateBlock();
TES5EventCodeBlock onCellAttach = CreateEventCodeBlock("OnCellAttach", globalScope);
onCellAttach.CodeScope.AddChunk(objectCallFactory.CreateGotoState("ActiveState", globalScope));
TES5EventCodeBlock onCellDetach = CreateEventCodeBlock("OnCellDetach", globalScope);
onCellDetach.CodeScope.AddChunk(objectCallFactory.CreateGotoState("InactiveState", globalScope));
blocks = new TES5BlockList()
{
activeState, inactiveState, onCellAttach, onCellDetach
};
}
/*
* The script to be converted
* The script"s global scope
* The scope under which we"re converting
*
* @throws ConversionException
*/
public TES5Target Convert(TES4Target target, bool isStandalone, TES5GlobalScope globalScope, TES5MultipleScriptsScope multipleScriptsScope)
{
TES4Script script = target.Script;
TES4BlockList?parsedBlockList = script.BlockList;
Dictionary <string, List <ITES5CodeBlock> > createdBlocks = new Dictionary <string, List <ITES5CodeBlock> >();
if (parsedBlockList != null)
{
TES5EventCodeBlock?onUpdateBlockOfNonQuestOrAME = null;
foreach (TES4CodeBlock block in parsedBlockList.Blocks)
{
TES5BlockList newBlockList = this.blockFactory.CreateBlock(block, globalScope, multipleScriptsScope, ref onUpdateBlockOfNonQuestOrAME);
foreach (ITES5CodeBlock newBlock in newBlockList.Blocks)
{
createdBlocks.AddNewListIfNotContainsKeyAndAddValueToList(newBlock.BlockName, newBlock);
}
}
}
TES5BlockList blockList = new TES5BlockList();
foreach (var createdBlock in createdBlocks)
{
var blockType = createdBlock.Key;
var blocks = createdBlock.Value;
if (blocks.Count > 1)
{
foreach (TES5CodeBlock block in CombineRepeatedEventCodeBlockNames(blocks, blockType, isStandalone, globalScope))
{
blockList.Add(block);
}
}
else
{
ITES5CodeBlock block = blocks[0];
blockList.Add(block);
}
}
TES5Target result = new TES5Target(new TES5Script(globalScope, blockList, false), target.OutputPath);
return(result);
}
public TES5BlockList CreateBlock(TES4CodeBlock block, TES5GlobalScope globalScope, TES5MultipleScriptsScope multipleScriptsScope)
{
TES5BlockList blockList = new TES5BlockList();
string blockType = block.BlockType;
if (blockType.Equals("menumode", StringComparison.OrdinalIgnoreCase))
{
return(blockList);
}
string newBlockType = MapBlockType(blockType);
TES4CodeChunks chunks = block.Chunks;
if (chunks != null && chunks.Any())
{
TES5EventCodeBlock newBlock;
bool onUpdateOfNonQuest = newBlockType == "OnUpdate" && globalScope.ScriptHeader.BasicScriptType != TES5BasicType.T_QUEST;
TES5BlockList onUpdateOfNonQuestAdditionalBlocks = null;
if (onUpdateOfNonQuest)
{
CreateActivationStates(globalScope, multipleScriptsScope, out onUpdateOfNonQuestAdditionalBlocks, out newBlock);
}
else
{
TES5FunctionScope blockFunctionScope = TES5FunctionScopeFactory.CreateFromBlockType(newBlockType);
newBlock = CreateEventCodeBlock(newBlockType, blockFunctionScope);
}
this.ConvertTES4CodeChunksToTES5EventCodeBlock(chunks, newBlock, globalScope, multipleScriptsScope);
this.changesPass.Modify(block, blockList, newBlock, globalScope, multipleScriptsScope);
blockList.Add(newBlock);
if (onUpdateOfNonQuest)
{
return(onUpdateOfNonQuestAdditionalBlocks);
}
}
return(blockList);
}
public void Modify(TES4CodeBlock block, TES5BlockList blockList, TES5EventCodeBlock newBlock, TES5GlobalScope globalScope, TES5MultipleScriptsScope multipleScriptsScope)
{
TES5FunctionScope blockFunctionScope = newBlock.FunctionScope;
switch (block.BlockType.ToLower())
{
case "gamemode":
case "scripteffectupdate":
{
TES5ObjectCall function = this.objectCallFactory.CreateRegisterForSingleUpdate(globalScope, multipleScriptsScope);
newBlock.AddChunk(function);
if (globalScope.ScriptHeader.BasicScriptType == TES5BasicType.T_QUEST)
{
TES5EventCodeBlock onInitBlock = TES5BlockFactory.CreateOnInit();
onInitBlock.AddChunk(function);
blockList.Add(onInitBlock);
}
break;
}
case "onactivate":
{
TES5EventCodeBlock onInitBlock = TES5BlockFactory.CreateOnInit();
TES5ObjectCall function = this.objectCallFactory.CreateObjectCall(TES5ReferenceFactory.CreateReferenceToSelf(globalScope), "BlockActivation", multipleScriptsScope);
onInitBlock.AddChunk(function);
blockList.Add(onInitBlock);
break;
}
case "onactorequip":
{
SetUpBranch(block, newBlock, blockFunctionScope, TES5LocalVariableParameterMeaning.CONTAINER, globalScope, multipleScriptsScope);
break;
}
case "ontriggeractor":
{
TES4BlockParameterList parameterList = block.BlockParameterList;
TES5LocalScope localScope = newBlock.CodeScope.LocalScope;
TES5LocalVariable activator = localScope.GetVariableWithMeaning(TES5LocalVariableParameterMeaning.ACTIVATOR);
TES5LocalVariable castedToActor = new TES5LocalVariable("akAsActor", TES5BasicType.T_ACTOR);
TES5Reference referenceToCastedVariable = TES5ReferenceFactory.CreateReferenceToVariable(castedToActor);
TES5Reference referenceToNonCastedVariable = TES5ReferenceFactory.CreateReferenceToVariable(activator);
TES5ComparisonExpression expression = TES5ExpressionFactory.CreateComparisonExpression(referenceToCastedVariable, TES5ComparisonExpressionOperator.OPERATOR_NOT_EQUAL, new TES5None());
TES5CodeScope newCodeScope = TES5CodeScopeFactory.CreateCodeScopeRoot(blockFunctionScope);
newCodeScope.LocalScope.AddVariable(castedToActor);
newCodeScope.AddChunk(TES5VariableAssignationFactory.CreateAssignation(referenceToCastedVariable, referenceToNonCastedVariable));
TES5CodeScope outerBranchCode;
if (parameterList != null)
{
//NOT TESTED
List <TES4BlockParameter> parameterListVariableList = parameterList.Parameters;
ITES5Referencer targetActor = this.referenceFactory.CreateReadReference(parameterListVariableList[0].BlockParameter, globalScope, multipleScriptsScope, localScope);
TES5ComparisonExpression interExpression = TES5ExpressionFactory.CreateComparisonExpression(TES5ReferenceFactory.CreateReferenceToVariable(activator), TES5ComparisonExpressionOperator.OPERATOR_EQUAL, targetActor);
//TES5CodeScope interBranchCode = PHPFunction.Deserialize<TES5CodeScope>(PHPFunction.Serialize(newBlock.CodeScope));//WTM: Change: Why serialize and then deserialize?
TES5CodeScope interBranchCode = newBlock.CodeScope;
outerBranchCode = TES5CodeScopeFactory.CreateCodeScopeRoot(blockFunctionScope);
interBranchCode.LocalScope.ParentScope = outerBranchCode.LocalScope;
outerBranchCode.AddChunk(new TES5Branch(new TES5SubBranch(interExpression, interBranchCode)));
}
else
{
//outerBranchCode = PHPFunction.Deserialize<TES5CodeScope>(PHPFunction.Serialize(newBlock.CodeScope));//WTM: Change: Why serialize and then deserialize?
outerBranchCode = newBlock.CodeScope;
outerBranchCode.LocalScope.ParentScope = newCodeScope.LocalScope;
}
newCodeScope.AddChunk(new TES5Branch(new TES5SubBranch(expression, outerBranchCode)));
newBlock.CodeScope = newCodeScope;
break;
}
case "onadd":
{
SetUpBranch(block, newBlock, blockFunctionScope, "akNewContainer", globalScope, multipleScriptsScope);
break;
}
case "ondrop":
{
SetUpBranch(block, newBlock, blockFunctionScope, "akOldContainer", globalScope, multipleScriptsScope);
break;
}
case "onpackagestart":
{
SetUpBranch(block, newBlock, blockFunctionScope, "akNewPackage", globalScope, multipleScriptsScope);
break;
}
case "onpackagedone":
case "onpackagechange":
case "onpackageend":
{
SetUpBranch(block, newBlock, blockFunctionScope, "akOldPackage", globalScope, multipleScriptsScope);
break;
}
case "onalarm":
{
//@INCONSISTENCE - We don"t account for alarm type.
TES5ComparisonExpression expression = TES5ExpressionFactory.CreateComparisonExpression(this.objectCallFactory.CreateObjectCall(TES5ReferenceFactory.CreateReferenceToSelf(globalScope), "IsAlarmed", multipleScriptsScope), TES5ComparisonExpressionOperator.OPERATOR_EQUAL, new TES5Bool(true));
SetUpBranch(blockFunctionScope, newBlock, expression);
break;
}
/*
*
* case "onalarm":
* {
*
* this.skyrimGroupEventName = "onhit";
*
* if (this.eventArgs[1] != 3) {
* //Nothing eelse is supported really..
* this.omit = true;
* break;
* }
*
* branch = new TES4ConditionalBranch();
* expression = new TES4Expression();
* leftConstant = new TES4Constant("akAggressor", "ObjectReference");
* //actionConstant = new TES4Constant(this.eventArgs[1],"Package");
* actionConstant = TES4Factories.createReference(this.eventArgs[2], this);
*
* expression.left_side = leftConstant;
* expression.right_side = actionConstant;
* expression.comparision_operator = TES4Expression.COMPARISION_OPERATOR_EQUAL;
*
* codeBlock = new TES4CodeBlock();
* codeBlock.chunks = this.chunks;
*
* branch.ifs[] = array(
* "rawExpression" => "SCRIPT_GENERATED",
* "expression" => expression,
* "codeBlock" => codeBlock
* );
* this.chunks = new TES4ChunkContainer();
* this.chunks.parent = this;
* this.chunks.addChunk(branch);
*
* break;
* }
*/
case "onequip":
case "onunequip":
{
SetUpBranch(block, newBlock, blockFunctionScope, "akActor", globalScope, multipleScriptsScope);
break;
}
}
}
/*
* The script to be converted
* The script"s global scope
* The scope under which we"re converting
*
* @throws ConversionException
*/
public TES5Target Convert(TES4Target target, TES5GlobalScope globalScope, TES5MultipleScriptsScope multipleScriptsScope)
{
TES4Script script = target.Script;
TES5BlockList blockList = new TES5BlockList();
TES4BlockList parsedBlockList = script.BlockList;
Dictionary <string, List <ITES5CodeBlock> > createdBlocks = new Dictionary <string, List <ITES5CodeBlock> >();
if (parsedBlockList != null)
{
foreach (TES4CodeBlock block in parsedBlockList.Blocks)
{
TES5BlockList newBlockList = this.blockFactory.CreateBlock(block, globalScope, multipleScriptsScope);
foreach (ITES5CodeBlock newBlock in newBlockList.Blocks)
{
createdBlocks.AddNewListIfNotContainsKeyAndAddValueToList(newBlock.BlockName, newBlock);
}
}
}
//todo encapsulate it to a different class.
bool isStandalone = target.OutputPath.Contains(Path.DirectorySeparatorChar + "Standalone" + Path.DirectorySeparatorChar);
foreach (var createdBlock in createdBlocks)
{
var blockType = createdBlock.Key;
var blocks = createdBlock.Value;
if (blocks.Count > 1)
{
List <TES5FunctionCodeBlock> functions = new List <TES5FunctionCodeBlock>();
int i = 1;
TES5ObjectCallArguments localScopeArguments = null;
foreach (TES5CodeBlock block in blocks)
{
TES5FunctionScope newFunctionScope = new TES5FunctionScope(blockType + "_" + i.ToString());
foreach (var variable in block.FunctionScope.Variables.Values)
{
newFunctionScope.AddVariable(variable);
}
TES5FunctionCodeBlock function = new TES5FunctionCodeBlock(newFunctionScope, block.CodeScope, new TES5VoidType(), isStandalone);
functions.Add(function);
if (localScopeArguments == null)
{
localScopeArguments = new TES5ObjectCallArguments();
foreach (var variable in block.FunctionScope.Variables.Values)
{
localScopeArguments.Add(TES5ReferenceFactory.CreateReferenceToVariable(variable));
}
}
++i;
}
//Create the proxy block.
ITES5CodeBlock lastBlock = blocks.Last();
TES5EventCodeBlock proxyBlock = TES5BlockFactory.CreateEventCodeBlock(blockType,
/*
* //WTM: Change: block was used below, but block is out of scope. The PHP must have been using the last defined block from above.
* //WTM: Change: PHP called "clone" below, but I'm not sure if this is necessary or would even operate the same in C#.
*/
lastBlock.FunctionScope);
foreach (var function in functions)
{
blockList.Add(function);
TES5ObjectCall functionCall = this.objectCallFactory.CreateObjectCall(TES5ReferenceFactory.CreateReferenceToSelf(globalScope), function.BlockName, multipleScriptsScope, localScopeArguments, false // hacky.
);
proxyBlock.AddChunk(functionCall);
}
blockList.Add(proxyBlock);
}
else
{
ITES5CodeBlock block = blocks[0];
blockList.Add(block);
}
}
TES5Target result = new TES5Target(new TES5Script(globalScope, blockList), target.OutputPath);
return(result);
}
public TES5CodeScope Modify(TES4CodeBlock block, TES5BlockList blockList, TES5FunctionScope blockFunctionScope, TES5CodeScope codeScope, TES5GlobalScope globalScope, TES5MultipleScriptsScope multipleScriptsScope)
{
//https://cs.elderscrolls.com/index.php?title=Begin
//WTM: Change: Added: I reorganized this method and forced each event to account for the first Oblivion parameter.
bool accountedForParameter = false;
switch (block.BlockType.ToLower())
{
case "gamemode":
case "scripteffectupdate":
{
TES5ObjectCall function = this.objectCallFactory.CreateRegisterForSingleUpdate(globalScope);
codeScope.AddChunk(function);
if (globalScope.ScriptHeader.ScriptType.NativeType == TES5BasicType.T_QUEST)
{
TES5EventCodeBlock onInitBlock = TES5BlockFactory.CreateOnInit();
onInitBlock.AddChunk(function);
blockList.Add(onInitBlock);
}
break;
}
case "menumode":
{
TES5ComparisonExpression isInMenuModeComparisonExpression = GetIsInMenuModeComparisonExpression();
codeScope = SetUpBranch(blockFunctionScope, codeScope, isInMenuModeComparisonExpression);
accountedForParameter = true; //Skyrim handles menus differently than Oblivion's MenuType.
break;
}
case "onactivate":
{
TES5EventCodeBlock onInitBlock = TES5BlockFactory.CreateOnInit();
TES5ObjectCall function = this.objectCallFactory.CreateObjectCall(TES5ReferenceFactory.CreateReferenceToSelf(globalScope), "BlockActivation");
onInitBlock.AddChunk(function);
blockList.Add(onInitBlock);
//WTM: Change: Added: The following scripts erroneously add a parameter to their OnActivate block:
//MS11BradonCorpse, SE01WaitingRoomScript, SE02LoveLetterScript, SE08Xeddefen03DoorSCRIPT, SE08Xeddefen05DoorSCRIPT, SE32TombEpitaph01SCRIPT, SEHillofSuicidesSCRIPT, SEXidPuzButton1, SEXidPuzButton2, SEXidPuzButton3, SEXidPuzButton4, SEXidPuzButtonSCRIPT, SEXidPuzHungerSCRIPT, XPEbroccaCrematorySCRIPT
//But OnActivate does not take a parameter. I'm trying to use the author's intended parameter instead of just ignoring it.
codeScope = SetUpBranch(block, codeScope, blockFunctionScope, "akActivateRef", globalScope, multipleScriptsScope);
accountedForParameter = true;
break;
}
case "onactorequip":
{
codeScope = SetUpBranch(block, codeScope, blockFunctionScope, TES5LocalVariableParameterMeaning.CONTAINER, globalScope, multipleScriptsScope);
accountedForParameter = true;
break;
}
case "onadd":
{
codeScope = SetUpBranch(block, codeScope, blockFunctionScope, "akNewContainer", globalScope, multipleScriptsScope);
accountedForParameter = true;
break;
}
case "onalarm":
{
//@INCONSISTENCE - We don"t account for CrimeType or Criminal.
codeScope.AddChunk(this.objectCallFactory.CreateObjectCall(TES5StaticReferenceFactory.Debug, "Trace", new TES5ObjectCallArguments()
{
new TES5String("This function does not account for OnAlarm's CrimeType or Criminal.")
}));
ITES5Value isAlarmed = TES5ExpressionFactory.CreateComparisonExpression(this.objectCallFactory.CreateObjectCall(TES5ReferenceFactory.CreateReferenceToSelf(globalScope), "IsAlarmed"), TES5ComparisonExpressionOperator.OPERATOR_EQUAL, new TES5Bool(true));
codeScope = SetUpBranch(blockFunctionScope, codeScope, isAlarmed);
accountedForParameter = true;
break;
}
/*
* case "onalarm":
* {
*
* this.skyrimGroupEventName = "onhit";
*
* if (this.eventArgs[1] != 3) {
* //Nothing eelse is supported really..
* this.omit = true;
* break;
* }
*
* branch = new TES4ConditionalBranch();
* expression = new TES4Expression();
* leftConstant = new TES4Constant("akAggressor", "ObjectReference");
* //actionConstant = new TES4Constant(this.eventArgs[1],"Package");
* actionConstant = TES4Factories.createReference(this.eventArgs[2], this);
*
* expression.left_side = leftConstant;
* expression.right_side = actionConstant;
* expression.comparision_operator = TES4Expression.COMPARISION_OPERATOR_EQUAL;
*
* codeBlock = new TES4CodeBlock();
* codeBlock.chunks = this.chunks;
*
* branch.ifs[] = array(
* "rawExpression" => "SCRIPT_GENERATED",
* "expression" => expression,
* "codeBlock" => codeBlock
* );
* this.chunks = new TES4ChunkContainer();
* this.chunks.parent = this;
* this.chunks.addChunk(branch);
*
* break;
* }
*/
case "ondeath":
{
codeScope = SetUpBranch(block, codeScope, blockFunctionScope, "akKiller", globalScope, multipleScriptsScope);
accountedForParameter = true;
break;
}
case "ondrop":
{
codeScope = SetUpBranch(block, codeScope, blockFunctionScope, "akOldContainer", globalScope, multipleScriptsScope);
accountedForParameter = true;
break;
}
case "onequip":
case "onunequip":
{
codeScope = SetUpBranch(block, codeScope, blockFunctionScope, "akActor", globalScope, multipleScriptsScope);
accountedForParameter = true;
break;
}
case "onhit":
{
codeScope = SetUpBranch(block, codeScope, blockFunctionScope, "akAggressor", globalScope, multipleScriptsScope);
accountedForParameter = true;
break;
}
case "onhitwith":
{
TES4BlockParameterList?parameterList = block.BlockParameterList;
if (parameterList != null)
{
TES5LocalScope localScope = codeScope.LocalScope;
ITES5Referencer hitWithCriteria = this.referenceFactory.CreateReadReference(parameterList.Parameters[0].BlockParameter, globalScope, multipleScriptsScope, localScope);
TES5SignatureParameter akSource = localScope.FunctionScope.GetParameter("akSource");
TES5ComparisonExpression hitWithEqualsSource = TES5ExpressionFactory.CreateComparisonExpression(TES5ReferenceFactory.CreateReferenceToVariableOrProperty(akSource), TES5ComparisonExpressionOperator.OPERATOR_EQUAL, hitWithCriteria);
TES5CodeScope newCodeScope = TES5CodeScopeFactory.CreateCodeScopeRoot(blockFunctionScope);
if (TES5InheritanceGraphAnalyzer.IsTypeOrExtendsType(TES5BasicType.T_AMMO, hitWithCriteria.TES5Type))
{
newCodeScope.AddChunk(this.objectCallFactory.CreateObjectCall(TES5StaticReferenceFactory.Debug, "Trace", new TES5ObjectCallArguments()
{
new TES5String("OBScript called OnHitWith using Ammo, but it's unlikely Papyrus will handle it properly. When arrows are used, " + akSource.Name + " will be a bow.")
}));
}
newCodeScope.AddChunk(new TES5Branch(new TES5SubBranch(hitWithEqualsSource, codeScope)));
codeScope = newCodeScope;
}
accountedForParameter = true;
break;
}
case "onmagiceffecthit":
{
codeScope = SetUpBranch(block, codeScope, blockFunctionScope, "akEffect", globalScope, multipleScriptsScope);
accountedForParameter = true;
break;
}
case "onpackagestart":
{
codeScope = SetUpBranch(block, codeScope, blockFunctionScope, "akNewPackage", globalScope, multipleScriptsScope);
accountedForParameter = true;
break;
}
case "onpackagechange":
case "onpackagedone":
case "onpackageend":
{
codeScope = SetUpBranch(block, codeScope, blockFunctionScope, "akOldPackage", globalScope, multipleScriptsScope);
accountedForParameter = true;
break;
}
case "onsell":
{
codeScope = SetUpBranch(block, codeScope, blockFunctionScope, "akSeller", globalScope, multipleScriptsScope);
accountedForParameter = true;
break;
}
case "onstartcombat":
{
codeScope = SetUpBranch(block, codeScope, blockFunctionScope, "akTarget", globalScope, multipleScriptsScope);
accountedForParameter = true;
break;
}
case "ontrigger":
{
codeScope = SetUpBranch(block, codeScope, blockFunctionScope, "akActivateRef", globalScope, multipleScriptsScope);
accountedForParameter = true;
break;
}
case "ontriggeractor":
{
TES4BlockParameterList? parameterList = block.BlockParameterList;
TES5LocalScope localScope = codeScope.LocalScope;
ITES5VariableOrProperty activator = localScope.GetVariableWithMeaning(TES5LocalVariableParameterMeaning.ACTIVATOR);
TES5LocalVariable castedToActor = new TES5LocalVariable("akAsActor", TES5BasicType.T_ACTOR);
TES5Reference referenceToCastedVariable = TES5ReferenceFactory.CreateReferenceToVariableOrProperty(castedToActor);
TES5Reference referenceToNonCastedVariable = TES5ReferenceFactory.CreateReferenceToVariableOrProperty(activator);
TES5ComparisonExpression expression = TES5ExpressionFactory.CreateComparisonExpression(referenceToCastedVariable, TES5ComparisonExpressionOperator.OPERATOR_NOT_EQUAL, new TES5None());
TES5CodeScope newCodeScope = TES5CodeScopeFactory.CreateCodeScopeRoot(blockFunctionScope);
newCodeScope.AddVariable(castedToActor);
newCodeScope.AddChunk(TES5VariableAssignationFactory.CreateAssignation(referenceToCastedVariable, referenceToNonCastedVariable));
TES5CodeScope outerBranchCode = TES5CodeScopeFactory.CreateCodeScopeRoot(blockFunctionScope);
outerBranchCode.LocalScope.CopyVariablesFrom(codeScope.LocalScope);
if (parameterList != null)
{
ITES5Referencer targetActor = this.referenceFactory.CreateReadReference(parameterList.Parameters[0].BlockParameter, globalScope, multipleScriptsScope, localScope);
TES5ComparisonExpression interExpression = TES5ExpressionFactory.CreateComparisonExpression(TES5ReferenceFactory.CreateReferenceToVariableOrProperty(activator), TES5ComparisonExpressionOperator.OPERATOR_EQUAL, targetActor);
outerBranchCode.AddChunk(new TES5Branch(new TES5SubBranch(interExpression, codeScope)));
}
else
{
outerBranchCode.AddChunks(codeScope.CodeChunks);
}
newCodeScope.AddChunk(new TES5Branch(new TES5SubBranch(expression, outerBranchCode)));
codeScope = newCodeScope;
accountedForParameter = true;
break;
}
case "onload":
case "onreset":
case "ontriggermob":
case "scripteffectstart":
case "scripteffectfinish":
{
break;
}
default:
{
throw new InvalidOperationException(block.BlockType + " not found.");
}
}
if (!accountedForParameter)
{
TES4BlockParameterList?parameterList = block.BlockParameterList;
if (parameterList != null && parameterList.Parameters.Any())
{
throw new ConversionException("Parameter not accounted for in " + block.BlockType + ": " + parameterList.Parameters[0].BlockParameter);
}
}
return(codeScope);
}
/*
* Joins N QF subfragments into one QF fragment that can be properly binded into Skyrim VM
* @throws ConversionException
*/
public TES5Target JoinQFFragments(IBuildTarget target, string resultingFragmentName, List <QuestStageScript> subfragmentsTrees)
{
int tes4FormID = GetTES4FormID(resultingFragmentName);
StageMap stageMap = StageMapBuilder.Build(target, resultingFragmentName, esmAnalyzer, tes4FormID);
/*
* We need script fragment for objective handling for each stage, so when parsing the script fragments,
* we"ll be marking them there, and intersecting this with stage.
* This will give us an array of stages which don"t have script fragment, but will need it anyways
* for objective handling.
*/
TES5ScriptHeader resultingScriptHeader = TES5ScriptHeaderFactory.GetFromCacheOrConstructByBasicType(resultingFragmentName, TES5BasicType.T_QUEST, TES5TypeFactory.TES4_Prefix, true);
TES5GlobalScope resultingGlobalScope = new TES5GlobalScope(resultingScriptHeader);
string[] referenceAliases = ReferenceAliasBuilder.Build(target, resultingFragmentName, esmAnalyzer, tes4FormID).ToArray();
foreach (string propertyName in referenceAliases)
{
resultingGlobalScope.AddProperty(TES5PropertyFactory.ConstructWithoutFormID(propertyName, TES5BasicType.T_REFERENCEALIAS, propertyName));
}
List <QuestStageBlock> questStageBlocks = new List <QuestStageBlock>();
HashSet <int> implementedStages = new HashSet <int>();
HashSet <string> propertiesNamesDeclared = new HashSet <string>();
foreach (var subfragment in subfragmentsTrees)
{
TES5Target subfragmentsTree = subfragment.Script;
TES5Script subfragmentScript = subfragmentsTree.Script;
TES5GlobalScope subfragmentGlobalScope = subfragmentScript.GlobalScope;
foreach (TES5Property subfragmentProperty in subfragmentGlobalScope.Properties)
{
/*
* Move over the properties to the new global scope
*/
if (propertiesNamesDeclared.Add(subfragmentProperty.Name))
{
resultingGlobalScope.AddProperty(subfragmentProperty);
}
else
{
if (subfragmentProperty.IsPlayerRef)
{
continue;
}
//WTM: Change: I don't think renaming these properties actually helps anything.
/*
* string propertyName = GeneratePropertyName(subfragmentScript.ScriptHeader, subfragmentProperty);
* subfragmentProperty.Rename(propertyName);
* if (!propertiesNamesDeclared.Add(subfragmentProperty.Name))
* {
* throw new ConversionException(nameof(propertiesNamesDeclared) + " already contained property " + subfragmentProperty.Name + ".");
* }
*/
//WTM: Change: I'm trying to unify properties and include extended type declarations.
TES5Property existingProperty = resultingGlobalScope.GetPropertyByName(subfragmentProperty.Name);
if (TES5InheritanceGraphAnalyzer.IsTypeOrExtendsType(existingProperty.TES5Type, subfragmentProperty.TES5Type))
{
continue;
}
if (TES5InheritanceGraphAnalyzer.IsExtending(subfragmentProperty.TES5Type, existingProperty.TES5Type))
{
existingProperty.TES5Type = subfragmentProperty.TES5Type;
continue;
}
if (TES5InheritanceGraphAnalyzer.IsExtending(existingProperty.TES5Type, subfragmentProperty.TES5Type.NativeType))
{
subfragmentProperty.TES5Type.NativeType = existingProperty.TES5Type.NativeType;
existingProperty.TES5Type = subfragmentProperty.TES5Type;
continue;
}
throw new ConversionException("Types were not compatible for property " + subfragmentProperty.Name + ": " + subfragmentProperty.TES5Type.Value + " should extend " + existingProperty.TES5Type.Value + " (" + existingProperty.TES5Type.NativeType.Value + ").");
}
}
List <ITES5CodeBlock> subfragmentBlocks = subfragmentScript.BlockList.Blocks;
if (subfragmentBlocks.Count != 1)
{
throw new ConversionException("Wrong QF fragment, actual function count: " + subfragmentBlocks.Count + "..");
}
ITES5CodeBlock subfragmentBlock = subfragmentBlocks[0];
if (subfragmentBlock.FunctionScope.BlockName != TES5FragmentFactory.GetFragmentName(0))
{
throw new ConversionException("Wrong QF fragment funcname, actual function name: " + subfragmentBlock.FunctionScope.BlockName + ".");
}
string newFragmentFunctionName = TES5FragmentFactory.GetFragmentName(subfragment.Stage, subfragment.LogIndex);
subfragmentBlock.FunctionScope.Rename(newFragmentFunctionName);
List <int>?stageMapOfStage = stageMap.TryGetStageTargetsMap(subfragment.Stage);
if (stageMapOfStage != null)
{
var objectiveCodeChunks = objectiveHandlingFactory.GenerateObjectiveHandling(subfragmentBlock, resultingGlobalScope, stageMapOfStage);
foreach (var newCodeChunk in objectiveCodeChunks)
{
subfragmentBlock.AddChunk(newCodeChunk);
}
}
questStageBlocks.Add(new QuestStageBlock(subfragment.Stage, subfragment.LogIndex, subfragmentBlock));
implementedStages.Add(subfragment.Stage);
}
/*
* Diff to find stages which we still need to mark
*/
int[] nonDoneStages = stageMap.StageIDs.Where(stageID => !implementedStages.Contains(stageID)).ToArray();
foreach (int nonDoneStage in nonDoneStages)
{
TES5FunctionCodeBlock fragment = objectiveHandlingFactory.CreateEnclosedFragment(resultingGlobalScope, nonDoneStage, stageMap.GetStageTargetsMap(nonDoneStage));
questStageBlocks.Add(new QuestStageBlock(nonDoneStage, 0, fragment));
}
this.mappedTargetsLogService.WriteScriptName(resultingFragmentName);
foreach (var kvp in stageMap.MappedTargetsIndex)
{
var originalTargetIndex = kvp.Key;
var mappedTargetIndexes = kvp.Value;
this.mappedTargetsLogService.WriteLine(originalTargetIndex, mappedTargetIndexes);
}
TES5BlockList resultingBlockList = new TES5BlockList(questStageBlocks.OrderBy(b => b.StageID).ThenBy(b => b.LogIndex).Select(b => b.CodeBlock));
TES5Script resultingTree = new TES5Script(resultingGlobalScope, resultingBlockList, true);
string outputPath = target.GetTranspileToPath(resultingFragmentName);
return(new TES5Target(resultingTree, outputPath));
}
public TES5Script(TES5GlobalScope globalScope, TES5BlockList blockList = null)
{
this.ScriptHeader = globalScope.ScriptHeader;
this.GlobalScope = globalScope;
this.BlockList = blockList;
}
/*
* Joins N QF subfragments into one QF fragment that can be properly binded into Skyrim VM
* @throws ConversionException
*/
public TES5Target JoinQFFragments(BuildTarget target, string resultingFragmentName, List <QuestStageScript> subfragmentsTrees)
{
StageMap stageMap = BuildStageMap(target, resultingFragmentName);
/*
* We need script fragment for objective handling for each stage, so when parsing the script fragments,
* we"ll be marking them there, and intersecting this with stage.
* This will give us an array of stages which don"t have script fragment, but will need it anyways
* for objective handling.
*/
TES5ScriptHeader resultingScriptHeader = new TES5ScriptHeader(resultingFragmentName, TES5BasicType.T_QUEST, "", true);
TES5BlockList resultingBlockList = new TES5BlockList();
TES5GlobalScope resultingGlobalScope = new TES5GlobalScope(resultingScriptHeader);
/*
* Add ReferenceAlias"es
* At some point, we might port the conversion so it doesn"t use the directly injected property,
* but instead has a map to aliases and we"ll map accordingly and have references point to aliases instead
*/
string sourcePath = target.GetSourceFromPath(resultingFragmentName);
string scriptName = Path.GetFileNameWithoutExtension(sourcePath);
string aliasesFile = Path.Combine(Path.GetDirectoryName(sourcePath), scriptName + ".aliases");
string[] aliasesLines = File.ReadAllLines(aliasesFile);
Dictionary <string, bool> aliasesDeclared = new Dictionary <string, bool>();
foreach (var alias in aliasesLines)
{
string trimmedAlias = alias.Trim();
if (trimmedAlias == "")
{
continue;
}
try
{
aliasesDeclared.Add(trimmedAlias, true);
}
catch (ArgumentException) { continue; }
resultingGlobalScope.AddProperty(new TES5Property(trimmedAlias, TES5BasicType.T_REFERENCEALIAS, trimmedAlias));
}
Dictionary <int, bool> implementedStages = new Dictionary <int, bool>();
Dictionary <string, bool> propertiesNamesDeclared = new Dictionary <string, bool>();
foreach (var subfragment in subfragmentsTrees)
{
TES5Target subfragmentsTree = subfragment.Script;
TES5Script subfragmentScript = subfragmentsTree.Script;
TES5GlobalScope subfragmentGlobalScope = subfragmentScript.GlobalScope;
foreach (TES5Property subfragmentProperty in subfragmentGlobalScope.Properties)
{
/*
* Move over the properties to the new global scope
*/
string propertyName;
if (propertiesNamesDeclared.ContainsKey(subfragmentProperty.Name))
{
propertyName = GeneratePropertyName(subfragmentScript.ScriptHeader, subfragmentProperty);
subfragmentProperty.Rename(propertyName);
}
else
{
propertyName = subfragmentProperty.Name;
}
propertiesNamesDeclared.Add(propertyName, true);
resultingGlobalScope.AddProperty(subfragmentProperty);
//WTM: Note: See QF_FGD03Viranus_0102d154. Since ViranusDontonREF is present in multiple of the original fragments,
//ViranusDontonREF gets renamed by the above. So multiple ViranusDontonREF variables are output.
//Below I tried not renaming, assuming instead that variables with matching names and types within a set of fragments were intended to be the same variable.
//It had OK results, but I'm leaving it commented for now.
/*string propertyNameWithSuffix = subfragmentProperty.PropertyNameWithSuffix;
* TES5Property existingProperty = resultingGlobalScope.Properties.Where(p => p.PropertyNameWithSuffix == propertyNameWithSuffix).FirstOrDefault();
* if (existingProperty != null && TES5InheritanceGraphAnalyzer.isExtending(subfragmentProperty.PropertyType, existingProperty.PropertyType))
* {
* existingProperty.PropertyType = subfragmentProperty.PropertyType;
* }
* else
* {
* bool add = true;
* if (existingProperty != null)
* {
* if (TES5InheritanceGraphAnalyzer.isExtending(existingProperty.PropertyType, subfragmentProperty.PropertyType))
* {
* add = false;
* }
* else
* {
* string generatedPropertyName = generatePropertyName(subfragmentScript.ScriptHeader, subfragmentProperty, i);
* subfragmentProperty.Rename(generatedPropertyName);
* }
* }
* if (add)
* {
* resultingGlobalScope.Add(subfragmentProperty);
* }
* }*/
}
List <ITES5CodeBlock> subfragmentBlocks = subfragmentScript.BlockList.Blocks;
if (subfragmentBlocks.Count != 1)
{
throw new ConversionException("Wrong QF fragment, actual function count: " + subfragmentBlocks.Count + "..");
}
ITES5CodeBlock subfragmentBlock = subfragmentBlocks[0];
if (subfragmentBlock.FunctionScope.BlockName != "Fragment_0")
{
throw new ConversionException("Wrong QF fragment funcname, actual function name: " + subfragmentBlock.FunctionScope.BlockName + "..");
}
string newFragmentFunctionName = "Fragment_" + subfragment.Stage.ToString();
if (subfragment.LogIndex != 0)
{
newFragmentFunctionName += "_" + subfragment.LogIndex;
}
subfragmentBlock.FunctionScope.Rename(newFragmentFunctionName);
var objectiveCodeChunks = this.objectiveHandlingFactory.GenerateObjectiveHandling(subfragmentBlock, resultingGlobalScope, stageMap.GetStageTargetsMap(subfragment.Stage));
foreach (var newCodeChunk in objectiveCodeChunks)
{
subfragmentBlock.AddChunk(newCodeChunk);
}
resultingBlockList.Add(subfragmentBlock);
implementedStages[subfragment.Stage] = true;
}
/*
* Diff to find stages which we still need to mark
*/
int[] nonDoneStages = stageMap.StageIDs.Where(stageID => !implementedStages.ContainsKey(stageID)).ToArray();
foreach (int nonDoneStage in nonDoneStages)
{
TES5FunctionCodeBlock fragment = this.objectiveHandlingFactory.CreateEnclosedFragment(resultingGlobalScope, nonDoneStage, stageMap.GetStageTargetsMap(nonDoneStage));
resultingBlockList.Add(fragment);
}
this.mappedTargetsLogService.WriteScriptName(resultingFragmentName);
foreach (var kvp in stageMap.MappedTargetsIndex)
{
var originalTargetIndex = kvp.Key;
var mappedTargetIndexes = kvp.Value;
this.mappedTargetsLogService.WriteLine(originalTargetIndex, mappedTargetIndexes);
}
TES5Script resultingTree = new TES5Script(resultingGlobalScope, resultingBlockList);
string outputPath = target.GetTranspileToPath(resultingFragmentName);
return(new TES5Target(resultingTree, outputPath));
}
