Inheritance: MonoBehaviour
Example #1
0
    public void RemoveGem(GameObject gem)
    {
        UpgradeScript gemScript = gem.GetComponent <UpgradeScript>();

        gems.Remove(gemScript);
        gemScript.RemoveEffectFromWeapon(this);
    }
Example #2
0
    public void AddGem(GameObject gem)
    {
        UpgradeScript gemScript = gem.GetComponent <UpgradeScript>();

        gems.Add(gemScript);
        gemScript.ApplyEffectToWeapon(this);
    }
Example #3
0
        private void RunScriptChecked(UpgradeScript script)
        {
            try
            {
                script.Method.Invoke();
            }
            catch (Exception e)
            {
                int line = 0;

                StackTrace stack = new StackTrace(e, true);
                for (int frameIndex = 0; frameIndex < stack.FrameCount; frameIndex++)
                {
                    StackFrame?frame  = stack.GetFrame(frameIndex);
                    MethodBase?method = frame?.GetMethod();
                    if (method == null)
                    {
                        continue;
                    }

                    VersionAttribute?attr = method.GetCustomAttribute <VersionAttribute>();
                    if (attr != null)
                    {
                        line = frame?.GetFileLineNumber() ?? 0;
                        break;
                    }
                }

                throw new InvalidOperationException($"Error in script version {script.Major}.{script.Minor}.{script.Patch}, line {line} -> {e.Message}", e);
            }
        }
Example #4
0
    private void AddListenersToGemRowButtonsForSell(Button infoButton, Button equipButton, string infoText, GameObject gem)
    {
        UpgradeScript gemScript = gem.GetComponent <UpgradeScript>();

        infoButton.onClick.AddListener(() => ShowTextDialog(infoText, gemScript.upgradeSprite));
        equipButton.onClick.AddListener(() => OpenBuyMenuForGem(gem, "Sell " + gemScript.upgradeName + " for " + gemScript.upgradePrice / 2 + " coins?", () => SellGem(gem), 0));
        equipButton.GetComponentInChildren <Text>().text = "Sell";
    }
Example #5
0
        public v180_ModuleAeroSurfaceFixed(UpgradeScript parent)
        {
            var nodeUrlCraft = typeof(UpgradeScript).GetField("nodeUrlCraft", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(parent);
            var nodeUrlSFS   = typeof(UpgradeScript).GetField("nodeUrlSFS", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(parent);

            this.nodeUrlCraft = (string)nodeUrlCraft;
            this.nodeUrlSFS   = (string)nodeUrlSFS;
            this.ContextMask  = parent.ContextMask;
        }
Example #6
0
    private void Start()
    {
        instance = this;
        audioS   = GetComponent <AudioSource>();
        upgrades = new List <UpgradeImage>();

        for (int i = 0; i < images.Length; i++)
        {
            upgrades.Add(new UpgradeImage(images[i], i));
        }
    }
Example #7
0
        /// <summary>
        /// Called when this character collides with a gameobject that represents item (= picking up an item)
        /// </summary>
        public void HitItem(UpgradeScript upg)
        {
            if (upg.item.CollectableByPlayer && !(this is Player))
            {
                return;
            }

            if (upg.item == null)
            {
                Debug.LogError("null item for " + upg.gameObject.name);
                return;
            }

            if (upg.item.OnPickup(this))
            {
                upg.DeleteMe(true);
                Data.UpdateInventory(Inventory);
                UpdateStats();
                return;
            }

            EquippableItem upgrade = upg.item as EquippableItem;

            if (upgrade != null)
            {
                if (upgrade.GoesIntoBasestatSlot)
                {
                    Message("You have absorbed " + upg.item.VisibleName + "");
                    Inventory.AddBasestatUpgrade(upgrade);
                    upg.DeleteMe(true);
                    Data.UpdateInventory(Inventory);
                    UpdateStats();
                }
                else if (AddItem(upgrade))
                {
                    upg.DeleteMe(true);
                    //EquipUpgrade(upg.upgrade);
                }
            }
            else
            {
                if (AddItem(upg.item))
                {
                    upg.DeleteMe(true);
                    //EquipUpgrade(upg.upgrade);
                }
            }
        }
    //Funçao para a compra de mais velocidade no tiro
    public void buyVelocity(UpgradeScript upScript)
    {
        int price = upScript.GetPrice();

        if (checkPrice(price) && upScript.canBuy())
        {
            audioSource.PlayOneShot(upgradeBuySound, 0.3f);
            player.bulletVelocity += upScript.GetUpgradeAmount();
            managerScript.score   -= price;
            upScript.BuyUpgrade();
        }
        else
        {
            audioSource.PlayOneShot(errorSound, 0.1f);
        }
    }
    //Funçao para a compra do upgrade de tiro automatico da arma
    public void buyAutomatic(UpgradeScript upScript)
    {
        int price = upScript.GetPrice();

        if (checkPrice(price) && upScript.canBuy())
        {
            audioSource.PlayOneShot(upgradeBuySound, 0.3f);
            player.automatic     = true;
            managerScript.score -= price;
            upScript.BuyUpgrade();
        }
        else
        {
            audioSource.PlayOneShot(errorSound, 0.1f);
        }
    }
Example #10
0
            public int Compare(object o1, object o2)
            {
                UpgradeScript us1 = (UpgradeScript)o1;
                UpgradeScript us2 = (UpgradeScript)o2;

                if (us1.Version < us2.Version)
                {
                    return(-1);
                }
                else if (us1.Version == us2.Version)
                {
                    return(0);
                }
                else
                {
                    return(+1);
                }
            }
        private void ExecuteUpgradeScript(UpgradeScript upgradeScript)
        {
            var connection = new SqlConnection(Settings.ConnectionString);

            string sql = System.IO.File.ReadAllText(upgradeScript.FullPath);

            string[] cmds = sql.Split(new string[] { "GO" }, StringSplitOptions.RemoveEmptyEntries);

            SqlCommand command = new SqlCommand();
            command.Connection = connection;
            connection.Open();
            foreach (string cmd in cmds)
            {
                command.CommandText = cmd;
                command.ExecuteNonQuery();
            }
            connection.Close();
            connection.Dispose();
        }
Example #12
0
        internal List <UpgradeScript> GetUpgradeScripts(MethodInfo?unitTestScript)
        {
            List <UpgradeScript> scripts = new List <UpgradeScript>();

            foreach (MethodInfo info in GetType().GetMethods(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance))
            {
                VersionAttribute?attr = info.GetCustomAttribute <VersionAttribute>();
                if (attr != null)
                {
                    Action method = (Action)Delegate.CreateDelegate(typeof(Action), this, info);
                    scripts.Add(new UpgradeScript(method, attr.Major, attr.Minor, attr.Patch, info.Name));
                }
            }
            scripts.Sort();

            UpgradeScript?prev = null;

            foreach (UpgradeScript item in scripts)
            {
                if (!(prev is null) && prev.Equals(item)) // don't use prev == item !!!!
                {
                    throw new NotSupportedException($"There are two methods ({prev.Name} & {item.Name}) with the same script version ({item.Major}.{item.Minor}.{item.Patch}).");
                }

                prev = item;
            }


            if (!(unitTestScript is null))
            {
                UpgradeScript prevScript = scripts.LastOrDefault();
                long          major      = prevScript?.Major ?? 0;
                long          minor      = prevScript?.Minor ?? 0;
                long          patch      = prevScript?.Patch ?? 0;

                Action <DatastoreModel> method         = (Action <DatastoreModel>)Delegate.CreateDelegate(typeof(Action <DatastoreModel>), null, unitTestScript);
                UpgradeScript           injectedScript = new UpgradeScript(new Action(() => method(this)), major, minor, patch + 1, "InjectedUnitTestMethod");
                scripts.Add(injectedScript);
            }

            return(scripts);
        }
        private void ExecuteUpgradeScript(UpgradeScript upgradeScript)
        {
            var connection = new SqlConnection(Settings.ConnectionString);

            string sql = System.IO.File.ReadAllText(upgradeScript.FullPath);

            string[] cmds = sql.Split(new string[] { "GO" }, StringSplitOptions.RemoveEmptyEntries);

            SqlCommand command = new SqlCommand();

            command.Connection = connection;
            connection.Open();
            foreach (string cmd in cmds)
            {
                command.CommandText = cmd;
                command.ExecuteNonQuery();
            }
            connection.Close();
            connection.Dispose();
        }
    void CheckBitLists(UpgradeScript ug)
    {
        if (ug.mattock && !ug.commons.Contains (bitTypes.mattock)) {
            ug.commons.Add (bitTypes.mattock);
        }
        else{
            if (!ug.mattock && ug.commons.Contains (bitTypes.mattock)) {
                ug.commons.Remove (bitTypes.mattock);
            }
        }
        if (ug.compression && !ug.commons.Contains (bitTypes.compress)) {
            ug.commons.Add (bitTypes.compress);
        }
        else{
            if (!ug.compression && ug.commons.Contains (bitTypes.compress)) {
                ug.commons.Remove (bitTypes.compress);
            }
        }
        if (ug.oscillation && !ug.commons.Contains (bitTypes.oscillate)) {
            ug.commons.Add (bitTypes.oscillate);
        }
        else{
            if (!ug.oscillation && ug.commons.Contains (bitTypes.oscillate)) {
                ug.commons.Remove (bitTypes.oscillate);
            }
        }

        if (ug.commons.Count > 2) {
            switch(ug.commons[0])
            {
            case(bitTypes.mattock):
                ug.mattock = false;
                break;
            case(bitTypes.compress):
                ug.compression = false;
                break;
            case(bitTypes.oscillate):
                ug.oscillation = false;
                break;
            }
            ug.commons.RemoveAt (0);
        }

        if (ug.engine && !ug.rares.Contains (bitTypes.engine)) {
            ug.rares.Add (bitTypes.engine);
        }
        else{
            if (!ug.engine && ug.rares.Contains (bitTypes.engine)) {
                ug.rares.Remove (bitTypes.engine);
            }
        }
        if (ug.alembic && !ug.rares.Contains (bitTypes.alembic)) {
            ug.rares.Add (bitTypes.alembic);
        }
        else{
            if (!ug.alembic && ug.rares.Contains (bitTypes.alembic)) {
                ug.rares.Remove (bitTypes.alembic);
            }
        }
        if (ug.silvered && !ug.rares.Contains (bitTypes.silvered)) {
            ug.rares.Add (bitTypes.silvered);
        }
        else{
            if (!ug.silvered && ug.rares.Contains (bitTypes.silvered)) {
                ug.rares.Remove (bitTypes.silvered);
            }
        }

        if (ug.rares.Count > 2) {
            switch(ug.rares[0])
            {
            case(bitTypes.alembic):
                ug.alembic = false;
                break;
            case(bitTypes.engine):
                ug.engine = false;
                break;
            case(bitTypes.silvered):
                ug.silvered = false;
                break;
            }
            ug.rares.RemoveAt (0);
        }
    }
Example #15
0
        /// <summary>
        /// Upgrades the database returning true on success.
        /// </summary>
        private bool Upgrade()
        {
            Package      package       = wizard.Package;
            PackageEntry schemaFile    = package["/Schema/Schema.sql"];
            PackageEntry delProcFile   = package["/Schema/DeleteProcs.sql"];
            PackageEntry grantFile     = package["/Schema/GrantAccess.sql"];
            PackageEntry funcFolder    = package["/Funcs"];
            PackageEntry procFolder    = package["/Procs"];
            PackageEntry upgradeFolder = package["/Upgrade"];
            Version      curVersion    = new Version(wizard.SetupState["CurSchemaVersion"]);

            UpgradeScript[] upgradeScripts;
            int             opCount;
            string          script;
            SqlConnection   sqlCon;

            QueryDisposition[] qd;
            int pos;

            if (schemaFile == null || !schemaFile.IsFile)
            {
                MessageBox.Show("Invalid Database Package: /Schema/Schema.sql missing.",
                                wizard.SetupTitle, MessageBoxButtons.OK, MessageBoxIcon.Error);
                return(false);
            }

            if (delProcFile == null || !delProcFile.IsFile)
            {
                MessageBox.Show("Invalid Database Package: /Schema/DeleteProcs.sql missing.",
                                wizard.SetupTitle, MessageBoxButtons.OK, MessageBoxIcon.Error);
                return(false);
            }

            if (grantFile == null || !grantFile.IsFile)
            {
                MessageBox.Show("Invalid Database Package: /Schema/GrantAccess.sql missing.",
                                wizard.SetupTitle, MessageBoxButtons.OK, MessageBoxIcon.Error);
                return(false);
            }

            if (upgradeFolder == null || !upgradeFolder.IsFolder || upgradeFolder.Children.Length == 0)
            {
                MessageBox.Show("Invalid Database Package: There are no upgrade scripts.",
                                wizard.SetupTitle, MessageBoxButtons.OK, MessageBoxIcon.Error);
                return(false);
            }

            // Build the set of upgrade scripts to be run.

            ArrayList list = new ArrayList();

            foreach (PackageEntry file in upgradeFolder.Children)
            {
                Version ver;

                if (!file.IsFile)
                {
                    continue;
                }

                try
                {
                    ver = new Version(file.Name.Substring(0, file.Name.Length - 4));
                }
                catch
                {
                    continue;
                }

                list.Add(new UpgradeScript(ver, Helper.FromAnsi(file.GetContents())));
            }

            if (list.Count == 0)
            {
                MessageBox.Show("Invalid Database Package: There are no upgrade scripts.",
                                wizard.SetupTitle, MessageBoxButtons.OK, MessageBoxIcon.Error);
                return(false);
            }

            list.Sort(new UpgradeComparer());

            for (pos = 0; pos < list.Count; pos++)
            {
                if (((UpgradeScript)list[pos]).Version > curVersion)
                {
                    break;
                }
            }

            if (pos >= list.Count)
            {
                MessageBox.Show("Invalid Database Package: There are no upgrade scripts.",
                                wizard.SetupTitle, MessageBoxButtons.OK, MessageBoxIcon.Error);
                return(false);
            }

            upgradeScripts = new UpgradeScript[list.Count - pos];
            list.CopyTo(pos, upgradeScripts, 0, upgradeScripts.Length);

            // Count the number of operations we're going to perform and
            // initialize the progress bar.

            opCount = 0;
            opCount++;      // Delete functions and stored procedures
            opCount++;      // Run the schema script
            opCount++;      // Grant access

            opCount += upgradeScripts.Length;

            if (funcFolder != null)
            {
                opCount += funcFolder.Children.Length;
            }

            if (procFolder != null)
            {
                opCount += procFolder.Children.Length;
            }

            progressBar.Minimum = 0;
            progressBar.Maximum = opCount;
            progressBar.Step    = 1;

            sqlCon = new SqlConnection(conString);

            try
            {
                sqlCon.Open();
            }
            catch (Exception e)
            {
                Append("Error: " + e.Message);
                return(false);
            }

            try
            {
                // Remove the functions and procedures

                Append("Removing functions and procedures");
                script = Helper.FromAnsi(delProcFile.GetContents());
                qd     = new SqlScriptRunner(script).Run(sqlCon, true);

                for (int i = 0; i < qd.Length; i++)
                {
                    if (qd[i].Message != null)
                    {
                        Append(qd[i].Message);
                        return(false);
                    }
                }

                progressBar.Value++;

                // Run the update scripts

                foreach (UpgradeScript us in upgradeScripts)
                {
                    script = us.Script;
                    Append("Upgrading schema to version {0}", us.Version);

                    qd = new SqlScriptRunner(script).Run(sqlCon, true);

                    for (int i = 0; i < qd.Length; i++)
                    {
                        if (qd[i].Message != null)
                        {
                            Append(qd[i].Message);
                            return(false);
                        }
                    }

                    progressBar.Value++;
                }

                // Add the functions

                if (funcFolder != null)
                {
                    foreach (PackageEntry file in funcFolder.Children)
                    {
                        if (!file.IsFile)
                        {
                            continue;
                        }

                        Append("Adding: {0}", file.Name);

                        script = Helper.FromAnsi(file.GetContents());
                        qd     = new SqlScriptRunner(script).Run(sqlCon, true);

                        for (int i = 0; i < qd.Length; i++)
                        {
                            if (qd[i].Message != null)
                            {
                                Append(qd[i].Message);
                                return(false);
                            }
                        }

                        progressBar.Value++;
                    }
                }

                // Add the procedures

                if (procFolder != null)
                {
                    foreach (var file in procFolder.Children)
                    {
                        if (!file.IsFile)
                        {
                            continue;
                        }

                        Append("Adding: {0}", file.Name);

                        script = Helper.FromAnsi(file.GetContents());
                        qd     = new SqlScriptRunner(script).Run(sqlCon, true);

                        for (int i = 0; i < qd.Length; i++)
                        {
                            if (qd[i].Message != null)
                            {
                                Append(qd[i].Message);
                                return(false);
                            }
                        }

                        progressBar.Value++;
                    }
                }

                // Grant access to the application account

                Append("Granting access to: {0}", wizard.SetupState["account"]);

                script = Helper.FromAnsi(grantFile.GetContents());
                script = script.Replace("%account%", wizard.SetupState["account"]);

                qd = new SqlScriptRunner(script).Run(sqlCon, true);

                for (int i = 0; i < qd.Length; i++)
                {
                    if (qd[i].Message != null)
                    {
                        Append(qd[i].Message);
                        return(false);
                    }
                }

                progressBar.Value++;
            }
            catch (Exception e)
            {
                Append("Error: " + e.Message);
                return(false);
            }
            finally
            {
                sqlCon.Close();
            }

            return(true);
        }
Example #16
0
 public void AddUpgrade(UpgradeScript upgrade)
 {
     upgrades.Add(upgrade);
 }
Example #17
0
 public void RegisterUpgrade(UpgradeScript uScript)
 {
     upgrades.Add(uScript);
 }
Example #18
0
        /// <summary>
        /// Touch-free database upgrade.
        /// </summary>
        private DBInstallResult Upgrade()
        {
            PackageEntry schemaFile    = package["/Schema/Schema.sql"];
            PackageEntry delProcFile   = package["/Schema/DeleteProcs.sql"];
            PackageEntry grantFile     = package["/Schema/GrantAccess.sql"];
            PackageEntry funcFolder    = package["/Funcs"];
            PackageEntry procFolder    = package["/Procs"];
            PackageEntry upgradeFolder = package["/Upgrade"];

            UpgradeScript[] upgradeScripts;
            string          script;
            string          cs;
            SqlConnection   sqlCon;

            QueryDisposition[] qd;
            int pos;

            if (schemaFile == null || !schemaFile.IsFile)
            {
                throw new InvalidOperationException("Invalid Database Package: /Schema/Schema.sql missing.");
            }

            if (delProcFile == null || !delProcFile.IsFile)
            {
                throw new InvalidOperationException("Invalid Database Package: /Schema/DeleteProcs.sql missing.");
            }

            if (grantFile == null || !grantFile.IsFile)
            {
                throw new InvalidOperationException("Invalid Database Package: /Schema/GrantAccess.sql missing.");
            }

            if (curVersion >= schemaVersion)
            {
                return(DBInstallResult.UpToDate);
            }

            // Build the set of upgrade scripts to be run.

            ArrayList list = new ArrayList();

            foreach (PackageEntry file in upgradeFolder.Children)
            {
                Version ver;

                if (!file.IsFile)
                {
                    continue;
                }

                try
                {
                    ver = new Version(file.Name.Substring(0, file.Name.Length - 4));
                }
                catch
                {
                    continue;
                }

                if (ver > curVersion)
                {
                    list.Add(new UpgradeScript(ver, Helper.FromAnsi(file.GetContents())));
                }
            }

            if (list.Count == 0)
            {
                throw new InvalidOperationException("Invalid Database Package: There are no upgrade scripts.");
            }

            list.Sort(new UpgradeComparer());

            for (pos = 0; pos < list.Count; pos++)
            {
                if (((UpgradeScript)list[pos]).Version > curVersion)
                {
                    break;
                }
            }

            if (pos >= list.Count)
            {
                return(DBInstallResult.UpToDate);
            }

            upgradeScripts = new UpgradeScript[list.Count - pos];
            list.CopyTo(pos, upgradeScripts, 0, upgradeScripts.Length);

            cs     = string.Format("server={0};database={1};{2}", server, database, dbParams.AdminSecurity);
            sqlCon = new SqlConnection(cs);
            sqlCon.Open();

            try
            {
                // Remove the functions and procedures

                script = Helper.FromAnsi(delProcFile.GetContents());
                qd     = new SqlScriptRunner(script).Run(sqlCon, true);

                for (int i = 0; i < qd.Length; i++)
                {
                    if (qd[i].Message != null)
                    {
                        throw new InvalidOperationException(qd[i].Message);
                    }
                }

                // Run the update scripts

                foreach (UpgradeScript us in upgradeScripts)
                {
                    script = us.Script;
                    qd     = new SqlScriptRunner(script).Run(sqlCon, true);

                    for (int i = 0; i < qd.Length; i++)
                    {
                        if (qd[i].Message != null)
                        {
                            throw new InvalidOperationException(qd[i].Message);
                        }
                    }
                }

                // Add the functions

                if (funcFolder != null)
                {
                    foreach (var file in funcFolder.Children)
                    {
                        if (!file.IsFile)
                        {
                            continue;
                        }

                        script = Helper.FromAnsi(file.GetContents());
                        qd     = new SqlScriptRunner(script).Run(sqlCon, true);

                        for (int i = 0; i < qd.Length; i++)
                        {
                            if (qd[i].Message != null)
                            {
                                throw new InvalidOperationException(qd[i].Message);
                            }
                        }
                    }
                }

                // Add the procedures

                if (procFolder != null)
                {
                    foreach (var file in procFolder.Children)
                    {
                        if (!file.IsFile)
                        {
                            continue;
                        }

                        script = Helper.FromAnsi(file.GetContents());
                        qd     = new SqlScriptRunner(script).Run(sqlCon, true);

                        for (int i = 0; i < qd.Length; i++)
                        {
                            if (qd[i].Message != null)
                            {
                                throw new InvalidOperationException(qd[i].Message);
                            }
                        }
                    }
                }

                // Grant access to the application account

                if (account != null)
                {
                    script = Helper.FromAnsi(grantFile.GetContents());
                    script = script.Replace("%account%", account);
                    qd     = new SqlScriptRunner(script).Run(sqlCon, true);

                    for (int i = 0; i < qd.Length; i++)
                    {
                        if (qd[i].Message != null)
                        {
                            throw new InvalidOperationException(qd[i].Message);
                        }
                    }
                }
            }
            finally
            {
                sqlCon.Close();
            }

            return(DBInstallResult.Upgraded);
        }
    void addBits(UpgradeScript ug)
    {
        while (ug.upgradeDict.Count < 7){
            Debug.Log ("Bits Counts: "+ug.upgradeDict.Count);
            ug.upgradeDict.Add (new UpgradeBit());
        }

        List<bitTypes> trueBits = new List<bitTypes> ();
        if (ug.mattock) {
            trueBits.Add (bitTypes.mattock);
        }
        if(ug.oscillation){
            trueBits.Add (bitTypes.oscillate);
        }
        if(ug.compression){
            trueBits.Add (bitTypes.compress);
        }
        if(ug.alembic){
            trueBits.Add (bitTypes.alembic);
        }
        if (ug.engine) {
            trueBits.Add (bitTypes.engine);
        }
        if(ug.silvered){
            trueBits.Add (bitTypes.silvered);
        }
        trueBits.Add (bitTypes.commonAdd);
        trueBits.Add (bitTypes.rare1Add);
        trueBits.Add (bitTypes.rare2Add);

        for (int i = 0; i < trueBits.Count; i++) {
            ug.upgradeDict[i].bit = trueBits[i];

        }
    }
 void OnEnable()
 {
     script = (UpgradeScript)target;
     GetTarget = new SerializedObject(script);
     ThisList = GetTarget.FindProperty("myVariables");
 }
Example #21
0
 // Start is called before the first frame update
 void Start()
 {
     Upgrader = GetComponent <UpgradeScript>();
 }
 // Use this for initialization
 void Start()
 {
     upgrade = GetComponent<UpgradeScript>();
 }