예제 #1
0
        // Instruction **************************************************************

        /// <summary>Creates a shallow copy of an Instruction</summary>
        /// <param name="instr">The instruction to be cloned</param>
        /// <returns>Returns the new Instruction if ILManager.GenInstruction was successful, otherwise null</returns>
        public static Instruction Clone(this Instruction instr)
        {
            if (instr == null)
            {
                throw new ArgumentNullException(nameof(instr));
            }

            return(ILManager.GenInstruction(instr.OpCode, instr.Operand));
        }
예제 #2
0
    void Start()
    {
        textMesh = GetComponent <TextMesh>();

        if (ILManager.IsRtl)
        {
            ILManager.SetText3D(textMesh, textMesh.text);
        }
    }
예제 #3
0
    void Start()
    {
        uiText = GetComponent <Text>();

        if (ILManager.IsRtl)
        {
            ILManager.SetTextUI(uiText, uiText.text);
        }
    }
예제 #4
0
 public override void Load()
 {
     CalamityVersionException.ThrowErrorOnIncorrectVersion(ModLoader.GetMod("CalamityMod"),
                                                           ExpectedCalamityVersion);
     ILManager.Load();
     SummonRotationAdjustmentsGlobalProj.Initialize();
     AbyssalMinesExplosionGlobalProj.Initialize();
     ArmorSetDatabase.Initialize();
     TooltipModificationsItem.Initialize();
 }
예제 #5
0
 private void MakeItemAvailable()
 {
     if (instructionEditor.DragItem == null)
     {
         InstructionInfo nII = new InstructionInfo();
         nII.OldInstructionNum      = -1;
         nII.NewInstructionNum      = -1;
         nII.NewInstruction         = ILManager.GenInstruction(OpCodes.Nop, null);
         instructionEditor.DragItem = nII;
     }
 }
예제 #6
0
    IEnumerator HotfixStart()
    {
        ILManager iL = this.gameObject.AddComponent <ILManager>();

        iL.Init();
        yield return(StartCoroutine(iL.GetServerDllVersion()));

        iL.CheckIsUpdate();
        yield return(StartCoroutine(iL.DownloadTasks()));

        yield return(StartCoroutine(iL.LoadHotfixDll()));
    }
예제 #7
0
        public override void Unload()
        {
            // Unload any data that goes unhandled by tML or contains static data.
            AssetManager.Unload();
            ChangelogData.Unload();
            ILManager.Unload();
            SaveDataManager.Unload();
            LocalizationInitializer.Unload();

            ModLogger = null;
            Instance  = null;
        }
예제 #8
0
        public override void Load()
        {
            Instance  = this;
            ModLogger = Instance.Logger;

            // Initialize all the things!
            AssetManager.Load();
            LocalizationInitializer.Initialize();
            ILManager.Load();
            SaveDataManager.Load();
            SaveDataManager.Save();
            ChangelogData.PopulateChangelogList(this);
        }
예제 #9
0
    private void ChangeListener()
    {
        // remove old listener and create a new one when were done manipulating the text
        // otherwise we will get stackOverflow (recursive change)
        inputField.onValueChanged.RemoveAllListeners();

        bool didSet = ILManager.SetInputText(inputField, lastInput);

        Listen(inputField);

        //if the manager didnt manipulate the text, we dont want to save the last text
        if (didSet)
        {
            lastInput = inputField.text;
        }
    }
        /// <summary>Loads the patch data from an XmlNode</summary>
        /// <param name="input">The XmlNode containing the Instruction nodes</param>
        /// <returns>Returns true if it succeeded, false otherwise</returns>
        public override bool Load(XmlNode input)
        {
            NameCompressor nc  = NameCompressor.Instance;
            Validator      val = new Validator(() => PatchStatus = PatchStatus.Broken);

            if (!val.ValidateTrue(input.ChildNodes.Count > 0, $"Node {input.Name} has no Childnodes"))
            {
                return(val.Ok);
            }

            XmlNode PatchList = input.GetChildNode(SST.PatchList, 0);

            if (!val.ValidateSet(PatchList, "No PatchList Child found"))
            {
                return(val.Ok);
            }

            string metpathunres = PatchList.GetAttribute(SST.MethodPath);

            if (!val.ValidateStringSet(metpathunres, "MethodPath Attribute not found or empty"))
            {
                return(val.Ok);
            }
            methodDefinition = DataStruct.ReferenceTable.Resolve(metpathunres.ToBaseInt()) as MethodDefinition;
            if (!val.ValidateSet(methodDefinition, $"MethodID \"{metpathunres}\" couldn't be resolved"))
            {
                return(val.Ok);
            }

            // TODO: move methodDef related checks to Execute
            OriginalInstructionCount = int.Parse(PatchList.GetAttribute(SST.InstructionCount));
            // if new method body has changed -> patching the new assembly will not work
            if (!val.ValidateTrue(methodDefinition.Body.Instructions.Count == OriginalInstructionCount, $"The PatchAction \" { Name }\" cannot be applied to a changend method"))
            {
                return(val.Ok);
            }

            // TODO: init with given params, instead of static
            AnyArray <InstructionInfo> iibuffer = new AnyArray <InstructionInfo>(OriginalInstructionCount);
            bool checkopcdes     = true;
            bool resolveparams   = false;           // resolves types/methods/...
            bool checkprimitives = true;            // checks if primitive types are identical

            var xmlInstructionLoader = new XMLInstruction <InstructionInfo>(
                DataStruct.ReferenceTable,
                methodDefinition);

            #region Load all InstructionInfo
            foreach (XmlNode xelem in PatchList.ChildNodes)
            {
                if (!val.ValidateTrue(xelem.Name == nc[SST.Instruction], $"PatchList elemtent \"{xelem.Name}\" is not recognized"))
                {
                    continue;
                }

                InstructionInfo nII     = new InstructionInfo();
                XmlAttribute    xdelatt = xelem.Attributes[nc[SST.Delete]];
                OpCode          opcode  = ILManager.OpCodeLookup[xelem.GetAttribute(SST.OpCode)];

                if (xdelatt != null)                 // Old_Instruction
                {
                    nII.Delete = xdelatt.Value == nc[SST.True];

                    //Load old Instruction into InstructionInfo
                    nII.OldInstructionNum = int.Parse(xelem.GetAttribute(SST.InstructionNum));
                    if (nII.OldInstructionNum < OriginalInstructionCount)
                    {
                        nII.OldInstruction = methodDefinition.Body.Instructions[nII.OldInstructionNum];
                        val.ValidateTrue(checkopcdes && opcode == nII.OldInstruction.OpCode, () =>
                        {
                            nII.OpCodeMismatch = true;
                            return($"Opcode of Instruction {nII.OldInstructionNum} has changed");
                        });                          // TODO: set mismatch | from-to log
                    }
                    else
                    {
                        continue;
                    }

                    if (checkprimitives)
                    {
                        if (opcode.OperandType == nII.OldInstruction.OpCode.OperandType)
                        {
                            string oldPrimOperand;
                            if (nII.OldInstruction.Operand == null)
                            {
                                nII.PrimitiveMismatch = xelem.GetAttribute(SST.PrimitiveValue, out oldPrimOperand);
                            }
                            else
                            {
                                nII.PrimitiveMismatch = xelem.GetAttribute(SST.PrimitiveValue) != nII.OldInstruction.Operand.ToString();
                            }
                        }
                        else
                        {
                            nII.PrimitiveMismatch = true;
                        }
                    }

                    if (resolveparams)
                    {
                        Log.Write(Log.Level.Info, "Resolve not implemented yet.");
                        //TODO: PatchStatus = PatchStatus.Broken; of not found ref implement, when DeepTypeCompare works
                    }

                    if (xelem.ChildNodes.Count == 1)                     // check if patchnode exists
                    {
                        XmlNode xpatchelem = xelem.ChildNodes[0];

                        string instnum = xpatchelem.GetAttribute(SST.InstructionNum);
                        if (string.IsNullOrEmpty(instnum))                         // check InstructionNum Patch
                        {
                            nII.NewInstructionNum = nII.OldInstructionNum;
                        }
                        else
                        {
                            nII.NewInstructionNum = int.Parse(instnum);
                        }

                        OpCode patchopc;
                        string patchopcode = xpatchelem.GetAttribute(SST.OpCode);
                        if (string.IsNullOrEmpty(patchopcode))                         // check Opcode patch
                        {
                            patchopc = opcode;
                        }
                        else
                        {
                            patchopc = ILManager.OpCodeLookup[patchopcode];
                        }

                        nII.NewInstruction = xmlInstructionLoader.Node2Instruction(xpatchelem, patchopc, nII.NewInstructionNum);
                        if (nII.NewInstruction == null)
                        {
                            nII.NewInstruction = ILManager.GenInstruction(patchopc, nII.OldInstruction.Operand);
                        }
                    }
                    else                     // no patchnode -> clone old one
                    {
                        nII.NewInstructionNum = nII.OldInstructionNum;
                        nII.NewInstruction    = nII.OldInstruction.Clone();
                    }
                }
                else                 // New_Instruction
                {
                    nII.OldInstructionNum = -1;
                    nII.NewInstructionNum = int.Parse(xelem.GetAttribute(SST.InstructionNum));
                    nII.NewInstruction    = xmlInstructionLoader.Node2Instruction(xelem, opcode, nII.NewInstructionNum);
                    val.ValidateSet(nII.NewInstruction, () =>
                    {
                        nII.NewInstruction         = Instruction.Create(OpCodes.Nop);
                        nII.NewInstruction.OpCode  = opcode;
                        nII.NewInstruction.Operand = "!!!!! Dummy !!!!!";
                        return($"Expected Operand for '{opcode.Name}', but no matching Attribute was found in {xelem.InnerXml}");
                    });
                }

                iibuffer[nII.NewInstructionNum] = nII;
            }
            #endregion

            instructPatchList = new List <InstructionInfo>(iibuffer.ToArray());

            // Check for not loaded Instructions
            if (!val.ValidateTrue(instructPatchList.All(x => x != null), () => "PatchList has holes: " + string.Join(", ", instructPatchList.Select((b, i) => b == null ? i : -1).Where(i => i != -1).ToArray())))
            {
                return(false);
            }

            #region Set all jump operands from PostInitData
            foreach (PostInitData pid in xmlInstructionLoader.GetPostInitalisationList())
            {
                if (pid.isArray)
                {
                    bool success = true;
                    instructPatchList[pid.InstructionNum].NewInstruction.Operand = Array.ConvertAll(pid.targetArray, a =>
                    {
                        InstructionInfo pidinstr = instructPatchList.FirstOrDefault(x => x.NewInstructionNum == a);
                        if (!val.ValidateSet(pidinstr, () => { success = false; return($"PID_At: {a}"); }))
                        {
                            return(null);
                        }
                        else
                        {
                            return(pidinstr.NewInstruction);
                        }
                    });
                    if (!val.ValidateTrue(success, $"PostInitData failed: {pid}"))
                    {
                        continue;
                    }
                }
                else
                {
                    InstructionInfo pidinstr = instructPatchList.First(x => x.NewInstructionNum == pid.targetNum);
                    if (!val.ValidateSet(pidinstr, $"PostInitData failed: {pid}"))
                    {
                        continue;
                    }
                    instructPatchList[pid.InstructionNum].NewInstruction.Operand = pidinstr.NewInstruction;
                }
            }
            #endregion

            if (PatchStatus == PatchStatus.Unset)
            {
                PatchStatus = PatchStatus.WoringPerfectly;
            }

            return(val.Ok);
        }
예제 #11
0
 public override void Unload()
 {
     ILManager.Unload();
     RecipeManager.Unload();
 }
예제 #12
0
 public override void Load()
 {
     ILManager.Load();
     RecipeManager.Load();
 }
예제 #13
0
 public override void Unload()
 {
     ILManager.Unload();
     CataclysmConfig.Instance = null;
     Instance = null;
 }