Пример #1
0
        private void setAvailableTowersOfPlayer()
        {
            Type root = null;

            switch (PlayerMe.self.board.scienceType)
            {
            case ScienceType.PHYS:
                root = typeof(PhysicsTower);
                break;

            case ScienceType.CHEM:
                root = typeof(ChemistryTower);
                break;

            case ScienceType.BIO:
                root = typeof(BiologyTower);
                break;
            }

            PlayerMe.availableTowerTypes = new List <Type>();
            for (int i = 0; i < UserMe.unlockedTowers.Length; i++)
            {
                if (UserMe.unlockedTowers[i])
                {
                    Type      towerType = TypeIdGenerator.getTowerType(i);
                    TowerNode towerNode = TypeIdGenerator.getTowerNodeInsts(towerType);
                    if (UserMe.unlockedTowers[i] && towerNode.parent != null && towerNode.parent.towerType == root)
                    {
                        PlayerMe.availableTowerTypes.Add(towerType);
                    }
                }
            }
        }
Пример #2
0
 public void Deselect()
 {
     selectedNode = null;
     GetComponent <MeshRenderer>().enabled             = false;
     rangeSphere.GetComponent <MeshRenderer>().enabled = false;
     UpdateButtonText();
 }
Пример #3
0
    static TowerNode FindAttachPoint(TowerNode rootNode, string nameToFind)
    {
        if (rootNode == null)
        {
            return(null);
        }

        foreach (var childName in rootNode.subTowerNames)
        {
            if (string.Equals(childName, nameToFind))
            {
                return(rootNode);
            }
        }

        foreach (var tower in rootNode.subTowers)
        {
            var foundNode = FindAttachPoint(tower, nameToFind);
            if (foundNode != null)
            {
                return(foundNode);
            }
        }
        return(null);
    }
Пример #4
0
    static TowerNode FindLastUnbalancedNode(TowerNode rootNode)
    {
        var valCount   = new Dictionary <int, int>();
        var valIndices = new Dictionary <int, int>();

        for (int i = 0; i < rootNode.subTowers.Count; i++)
        {
            var st = rootNode.subTowers[i];
            if (!valCount.ContainsKey(st.totalChildWeight))
            {
                valCount[st.totalChildWeight] = 0;
            }
            valCount[st.totalChildWeight]++;
            valIndices[st.totalChildWeight] = i;
        }
        int unbalancedIndex = -1;

        foreach (var keypair in valCount)
        {
            if (keypair.Value == 1)
            {
                unbalancedIndex = valIndices[keypair.Key];
            }
        }
        if (unbalancedIndex == -1)
        {
            // This is a balanced subtower
            return(rootNode);
        }
        else
        {
            return(FindLastUnbalancedNode(rootNode.subTowers[unbalancedIndex]));
        }
    }
Пример #5
0
    public void SelectNode(TowerNode node)
    {
        selectedNode = node;
        UpdateButtonText();

        //show selection
        GetComponent <MeshRenderer>().enabled = true;
        transform.position  = node.transform.position;
        transform.position += new Vector3(0, 5, 0);

        //Radius circle, maybe add in once towers have models

        /*
         * if (selectedNode.tower != null)
         * {
         *  rangeSphere.GetComponent<MeshRenderer>().enabled = true;
         *  rangeSphere.transform.position = node.tower.transform.position;
         *  rangeSphere.transform.parent = node.tower.transform;
         *
         *  //rangeSphere.transform.localScale = Vector3.one
         *
         *  //rangeSphere.transform.localScale *= node.tower.range;
         * }
         */
    }
Пример #6
0
        private bool checkScienceTypeOfTower(int typeId, ScienceType userScienceType)
        {
            Type root = null;

            switch (userScienceType)
            {
            case ScienceType.PHYS:
                root = typeof(PhysicsTower);
                break;

            case ScienceType.CHEM:
                root = typeof(ChemistryTower);
                break;

            case ScienceType.BIO:
                root = typeof(BiologyTower);
                break;
            }

            Type      type = TypeIdGenerator.getTowerType(typeId);
            TowerNode node = TypeIdGenerator.getTowerNodeInst(type);

            if (node.towerType != root && node.getRoot().towerType == root)
            {
                return(true);
            }

            return(false);
        }
Пример #7
0
    static void CalcTowerWeights(TowerNode rootNode)
    {
        rootNode.totalChildWeight = rootNode.weight;

        foreach (var subtower in rootNode.subTowers)
        {
            CalcTowerWeights(subtower);
            rootNode.totalChildWeight += subtower.totalChildWeight;
        }
    }
Пример #8
0
        private bool checkIfTowerUpgradableTo(int currentTowerTypeId, Type upgradingTowerType)
        {
            TowerNode tn = TypeIdGenerator.getTowerNodeInst(upgradingTowerType);

            if (tn == null)
            {
                return(false);
            }

            return(tn.checkParent(currentTowerTypeId) != null);
        }
Пример #9
0
    public void SetNode(TowerNode node)
    {
        if (currentNode == node)
        {
            DeselectNode();
            return;
        }
        currentNode    = node;
        turretBuilding = null;

        towerUI.SetTarget(node);
    }
Пример #10
0
    private void HandleTowerSelection(GameObject hitObject)
    {
        var node = hitObject.GetComponent <TowerNode>();

        if (node != null)
        {
            if (currentNode != null)
            {
                currentNode.OnCloseRequested();
            }
            currentNode = node;
            node.OnNodeSelected();
        }
    }
Пример #11
0
    public void BuildTurret(TowerNode node)
    {
        if (PlayerStatus.iGold < turretBuilding.iCost)
        {
            Debug.Log("insufficient gold"); //add ui
            return;
        }
        PlayerStatus.iGold -= turretBuilding.iCost;
        GameObject turret = (GameObject)Instantiate(turretBuilding.pObject, node.transform.position + node.vOffset, Quaternion.identity);

        node.turretActive = turret;

        Debug.Log("turret built, gold left: " + PlayerStatus.iGold);
    }
Пример #12
0
    //build turret on the tower node
    public void BuildTurretOn(TowerNode TowerNode)
    {
        if (PlayerStats.Money < turretToBuild.cost)
        {
            Debug.Log("Not Enough Money To Build That Turret");
            return;
        }
        else
        {
            PlayerStats.Money -= turretToBuild.cost;

            GameObject turret = Instantiate(turretToBuild.prefab, TowerNode.GetBuildPosition(), Quaternion.identity);
            TowerNode.turret = turret;
        }
    }
Пример #13
0
    public void BuyNode()
    {
        // do node buying
        PlayerMoneyManager.Instance.UseMoney(GetNextNodePrice());

        TowerNode node = availableNodesToBuy[UnityEngine.Random.Range(0, availableNodesToBuy.Count)];

        OnNodeBought(node);
        availableNodesToBuy.Remove(node);

        UpdateBuyText();
        UpdateNodeBuyButtonState();

        ShowUI(false);
    }
Пример #14
0
    public void BuildTower(TowerNode node, TowerType towerType)
    {
        Tower tower = Instantiate(towerPrefabs[(int)towerType]);

        tower.transform.position = node.transform.position;
        tower.transform.SetParent(towerParent);

        tower.SetStatsGetter(towerStatGetter);
        tower.SetStats(0,
                       towerStatGetter.GetTowerDamage(towerType, 0),
                       towerStatGetter.GetTowerFireRate(towerType, 0),
                       towerStatGetter.GetTowerRange(towerType, 0));

        // hide node mesh
        node.TowerBuiltOnNode();

        PlayerMoneyManager.Instance.UseMoney(PlayerMoneyManager.Instance.GetPrice(towerType, 0));
    }
Пример #15
0
    public void Init()
    {
        availableNodesToBuy = new List <TowerNode>();
        foreach (TowerNode node in nodes)
        {
            if (!node.IsBought)
            {
                availableNodesToBuy.Add(node);
            }
        }

        for (int i = 0; i < startNodeCount; i++)
        {
            TowerNode nodeToActivate = availableNodesToBuy[UnityEngine.Random.Range(0, availableNodesToBuy.Count)];
            OnNodeBought(nodeToActivate);

            availableNodesToBuy.Remove(nodeToActivate);
        }

        UpdateNodeBuyButtonState();
    }
Пример #16
0
    public void SetTarget(TowerNode n)
    {
        Vector3 vOffset = new Vector3(2f, -2f, -1.25f);

        this.targetNode    = n;
        transform.position = targetNode.transform.position + vOffset;
        menu.SetActive(true);

        if (this.targetNode.turretActive.tag == "Mage")
        {
            button1Desc.text = "Speed";
            button2Desc.text = "Burst";
            button3Desc.text = "Range";
            button1Cost.text = "400";
            button2Cost.text = "600";
            button3Cost.text = "350";
            iChoice          = 0;
        }
        if (this.targetNode.turretActive.tag == "Druid")
        {
            button1Desc.text = "Speed";
            button2Desc.text = "Alchemy";
            button3Desc.text = "Range";
            button1Cost.text = "650";
            button2Cost.text = "800";
            button3Cost.text = "400";
            iChoice          = 1;
        }
        if (this.targetNode.turretActive.tag == "Rogue")
        {
            button1Desc.text = "Speed";
            button2Desc.text = "2x Hit";
            button3Desc.text = "Bleed";
            button1Cost.text = "450";
            button2Cost.text = "600";
            button3Cost.text = "550";
            iChoice          = 2;
        }
    }
Пример #17
0
 public void DeselectNode()
 {
     currentNode = null;
     towerUI.HideUI();
 }
Пример #18
0
    static public void Puzzle1()
    {
        string filename = "input/d7p1_b.txt";

        var lines    = File.ReadAllLines(filename);
        var rootNode = new TowerNode("", -1);         // Just used to keep everything organized
        var allNodes = new List <TowerNode>();

        // First create all the nodes and then organize them into a tree after
        foreach (var line in lines)
        {
            // Parse the line - aaaa (32) -> bbbb, cccc, dddd, ...
            var      chunks   = line.Split(' ');
            var      name     = chunks[0];
            var      weight   = int.Parse(chunks[1].Split('(')[1].Split(')')[0]);
            string[] children = new string[0];
            if (chunks.Length > 3)
            {
                children = new string[chunks.Length - 3];
                for (int c = 3; c < chunks.Length; c++)
                {
                    children[c - 3] = chunks[c].Split(',')[0];
                }
            }
            var tower = new TowerNode(name, weight);
            tower.subTowerNames = children;
            allNodes.Add(tower);
        }

        // Now we can build the tree
        foreach (var node in allNodes)
        {
            // Find any nodes in the tree that need this node as a child and connect them
            TowerNode attachPoint = null;
            foreach (var tower in rootNode.subTowers)
            {
                attachPoint = FindAttachPoint(tower, node.name);
                if (attachPoint != null)
                {
                    attachPoint.subTowers.Add(node);
                    node.parentNode = attachPoint;
                    break;
                }
            }
            if (attachPoint == null)
            {
                rootNode.subTowers.Add(node);
            }

            // Find any child nodes that are already in the tree and connect them
            for (int t = rootNode.subTowers.Count - 1; t >= 0; t--)
            {
                var tower = rootNode.subTowers[t];
                foreach (var childName in node.subTowerNames)
                {
                    if (string.Equals(childName, tower.name))
                    {
                        // Remove the found root node and add it as a child to the new node
                        node.subTowers.Add(tower);
                        tower.parentNode = node;
                        rootNode.subTowers.RemoveAt(t);
                    }
                }
            }
        }

        Console.WriteLine("Number of root nodes: " + rootNode.subTowers.Count);
        Console.WriteLine("Root tower name: " + rootNode.subTowers[0].name);

        // Part 2 - Uses all the existing code plus more stuff
        CalcTowerWeights(rootNode.subTowers[0]);
        var unbalancedNode = FindLastUnbalancedNode(rootNode.subTowers[0]);
        var parent         = unbalancedNode.parentNode;

        Console.Write("Tower weights: ");
        var valCount   = new Dictionary <int, int>();
        var valIndices = new Dictionary <int, int>();

        for (int i = 0; i < parent.subTowers.Count; i++)
        {
            var st = parent.subTowers[i];
            Console.Write(st.totalChildWeight + " ");
            if (!valCount.ContainsKey(st.totalChildWeight))
            {
                valCount[st.totalChildWeight] = 0;
            }
            valCount[st.totalChildWeight]++;
            valIndices[st.totalChildWeight] = i;
        }
        Console.WriteLine();
        int unbalancedIndex = -1;
        int balancedValue   = -1;

        foreach (var keypair in valCount)
        {
            if (keypair.Value == 1)
            {
                unbalancedIndex = valIndices[keypair.Key];
            }
            else
            {
                balancedValue = keypair.Key;
            }
        }
        Console.WriteLine("Index of unbalanced tower: " + unbalancedIndex);
        int weightDelta = parent.subTowers[unbalancedIndex].totalChildWeight - balancedValue;
        int newWeight   = parent.subTowers[unbalancedIndex].weight - weightDelta;

        Console.WriteLine("Old weight: " + parent.subTowers[unbalancedIndex].weight + ", new weight: " + newWeight);
    }
Пример #19
0
    private void saveNodes()
    {
        if (nodes.Count > 0)
        {
            // We fill with as many skills as nodes we have
            TowerBlueprint[] blueprints = new TowerBlueprint[nodes.Count];
            int[]            In_dependencies;
            int[]            Out_dependencies;
            List <int>       In_dependenciesList  = new List <int>();
            List <int>       Out_dependenciesList = new List <int>();

            // Iterate over all of the nodes. Populating the skills with the node info
            for (int i = 0; i < nodes.Count; ++i)
            {
                if (connections != null)
                {
                    List <Connection> In_connectionsToRemove  = new List <Connection>();
                    List <Connection> Out_connectionsToRemove = new List <Connection>();

                    for (int j = 0; j < connections.Count; j++)
                    {
                        if (connections[j].inPoint == nodes[i].inPoint)
                        {
                            for (int k = 0; k < nodes.Count; ++k)
                            {
                                if (connections[j].outPoint == nodes[k].outPoint)
                                {
                                    //Debug.Log("node k = " + k);
                                    In_dependenciesList.Add(k);
                                }
                            }
                            In_connectionsToRemove.Add(connections[j]);
                        }
                        if (connections[j].outPoint == nodes[i].outPoint)
                        {
                            for (int k = 0; k < nodes.Count; ++k)
                            {
                                if (connections[j].inPoint == nodes[k].inPoint)
                                {
                                    Out_dependenciesList.Add(k);
                                }
                            }
                            Out_connectionsToRemove.Add(connections[j]);
                        }
                    }
                }
                In_dependencies = In_dependenciesList.ToArray();
                In_dependenciesList.Clear();
                Out_dependencies = Out_dependenciesList.ToArray();
                Out_dependenciesList.Clear();

                TowerNode newTowerNode = (TowerNode)nodes[i].myInfo;

                blueprints[i] = newTowerNode.GetTower();
                //Debug.Log(blueprints[i].name +" In dependecies length = " + In_dependencies.Length.ToString());
                //Debug.Log(blueprints[i].name + "Out dependecies length = " + Out_dependencies.Length.ToString());
                for (int k = 0; k < In_dependencies.Length; k++)
                {
                    TowerNode      towerNode  = (TowerNode)nodes[In_dependencies[k]].myInfo;
                    TowerBlueprint towerToAdd = ScriptableObject.CreateInstance <TowerBlueprint>();
                    towerToAdd = towerNode.GetTower();
                    string         _path       = workingFolders[0] + "/" + towerToAdd.name + ".asset";
                    TowerBlueprint _towerToAdd = AssetDatabase.LoadAssetAtPath(_path, typeof(TowerBlueprint)) as TowerBlueprint;
                    //Debug.LogWarning("Tower to add type: " + towerToAdd.GetType());
                    blueprints[i].upgradesFrom.Add(_towerToAdd);

                    string         tempPath        = workingFolders[0] + "/" + blueprints[i].name + ".asset";
                    TowerBlueprint tempBlueprintsI = AssetDatabase.LoadAssetAtPath(tempPath, typeof(TowerBlueprint)) as TowerBlueprint;
                    TowerBlueprint tempTowerToAdd  = _towerToAdd;
                    //move this functionallity out of bluprints[i] loop
                }

                blueprints[i].setEditorPosition(new Vector2(nodes[i].nodeRect.x, nodes[i].nodeRect.y) + drag);
                //Debug.Log(blueprints[i].name + " Editor Position = " + blueprints[i].getEditorPosition());

                string         path  = workingFolders[0] + "/" + blueprints[i].name + ".asset";
                TowerBlueprint asset = AssetDatabase.LoadAssetAtPath(path, typeof(TowerBlueprint)) as TowerBlueprint;

                if (asset == null)
                {
                    AssetDatabase.CreateAsset(blueprints[i], workingFolders[0] + "/" + blueprints[i].name + ".asset");
                }
                else
                {
                    EditorUtility.CopySerialized(blueprints[i], asset);
                }
            }
            for (int i = 0; i < blueprints.Length; i++)
            {
                for (int j = 0; j < blueprints[i].upgradesFrom.Count; j++)
                {
                    for (int k = 0; k < blueprints.Length; k++)
                    {
                        if (blueprints[i].upgradesFrom[j].name == blueprints[k].name)
                        {
                            //Debug.Log(blueprints[k].name + " || " + blueprints[i].name);
                            string         tempOutPath  = workingFolders[0] + "/" + blueprints[k].name + ".asset";
                            string         tempInPath   = workingFolders[0] + "/" + blueprints[i].name + ".asset";
                            TowerBlueprint tempOutTower = AssetDatabase.LoadAssetAtPath(tempOutPath, typeof(TowerBlueprint)) as TowerBlueprint;
                            TowerBlueprint tempInTower  = AssetDatabase.LoadAssetAtPath(tempInPath, typeof(TowerBlueprint)) as TowerBlueprint;
                            blueprints[k].upgradesTo.Add(tempInTower);

                            //tempTowerToAdd.upgradesTo.Add(tempBlueprintsI);
                            EditorUtility.CopySerialized(blueprints[k], tempOutTower);
                        }
                    }
                }
            }

            Debug.Log("Towers have been saved/updated");
        }
    }
Пример #20
0
    private void LoadTowers()
    {
        Rect    windoPosition   = position;
        Vector2 newNodePosition = new Vector2(windoPosition.x, windoPosition.y);

        string[] result = AssetDatabase.FindAssets("t:TowerBlueprint", workingFolders);

        if (result.Length != 0)
        {
            if (nodes == null)
            {
                nodes = new List <Node>();
            }
            if (result.Length <= nodes.Count)
            {
                //we have already loaded once
                Debug.LogWarning("We have already loaded the Towers once... no need to have duplicate nodes");
                return;
            }
            foreach (String asset in result)
            {
                string path = AssetDatabase.GUIDToAssetPath(asset);
                tower = (TowerBlueprint)AssetDatabase.LoadAssetAtPath(path, typeof(TowerBlueprint));
                Debug.Log("Towers Found = " + tower.name);

                TowerNode towerNode = new TowerNode(tower);

                if (tower.getEditorPosition() == null)
                {
                    //Debug.Log("editor position is null");
                    tower.setEditorPosition(newNodePosition);
                }
                //Debug.Log(tower.name + " Editor position to load in = " + tower.getEditorPosition());
                nodes.Add(new Node(tower.getEditorPosition(), 200, 50, nodeStyle, selectedNodeStyle, inPointStyle,
                                   outPointStyle, OnClickInPoint, OnClickOutPoint, OnClickRemoveNode, towerNode));
            }

            /*for (int i = 0; i < nodes.Count; ++i)
             * {
             *  for (int j = 0; j < nodes[i].skill.skill_Dependencies.Length; ++j)
             *  {
             *      if (skillDictionary.TryGetValue(nodes[i].skill.skill_Dependencies[j], out outSkill))
             *      {
             *          for (int k = 0; k < nodes.Count; ++k)
             *          {
             *              if (nodes[k].skill.id_Skill == outSkill.id_Skill)
             *              {
             *                  outNode = nodes[k];
             *                  OnClickOutPoint(outNode.outPoint);
             *                  break;
             *              }
             *          }
             *          OnClickInPoint(nodes[i].inPoint);
             *      }
             *  }
             * }*/
            for (int i = 0; i < nodes.Count; i++)
            {
                //string curTowerName = nodes[i].myInfo.title;
                string path = AssetDatabase.GUIDToAssetPath(result[i]);
                tower = (TowerBlueprint)AssetDatabase.LoadAssetAtPath(path, typeof(TowerBlueprint));
                for (int j = 0; j < tower.upgradesFrom.Count; j++)
                {
                    string nameToMatch = tower.upgradesFrom[j].name;

                    for (int k = 0; k < nodes.Count; ++k)
                    {
                        Node nodeToMatch;
                        if (nodes[k].myInfo.title == nameToMatch)
                        {
                            nodeToMatch = nodes[k];
                            OnClickOutPoint(nodeToMatch.outPoint);
                            OnClickInPoint(nodes[i].inPoint);
                            break;
                        }
                    }
                }
                for (int j = 0; j < tower.upgradesTo.Count; j++)
                {
                }
            }
        }
        else
        {
            Debug.Log("No TowerBlueprints seems to exist yet");
        }
    }
Пример #21
0
 private void OnNodeBought(TowerNode node)
 {
     node.OnNodeBuy();
 }
Пример #22
0
        private static Dictionary <Type, TowerNode> generateInheritanceTowerTreeHashMap <T>()
        {
            Dictionary <Type, TowerNode> resultDictionary = new Dictionary <Type, TowerNode>();
            Type type = typeof(T);

            var types = AppDomain.CurrentDomain.GetAssemblies()
                        .SelectMany(s => s.GetTypes())
                        .Where(p => type.IsAssignableFrom(p) && p.IsClass && !p.IsAbstract);

            var abstypes = AppDomain.CurrentDomain.GetAssemblies()
                           .SelectMany(s => s.GetTypes())
                           .Where(p => type.IsAssignableFrom(p) && p.IsClass && p.IsAbstract);

            List <Type> abstTypes = new List <Type>();

            foreach (Type t in abstypes)
            {
                abstTypes.Add(t);
            }


            List <Type>      typeList     = new List <Type>();
            List <Type>      typeNodes    = new List <Type>();
            List <Type>      nextTypes    = new List <Type>();
            List <Type>      removeList   = new List <Type>();
            List <TowerNode> currentNodes = new List <TowerNode>();
            List <TowerNode> nextNodes    = new List <TowerNode>();

            foreach (Type t in abstTypes)
            {
                TowerNode newNode = new TowerNode();
                newNode.towerType = t;
                newNode.parent    = null;
                currentNodes.Add(newNode);
                typeNodes.Add(t);
            }


            foreach (Type t in types)
            {
                typeList.Add(t);
            }

            for (int i = 0; i < abstTypes.Count; i++)
            {
                if (abstTypes[i] != type)
                {
                    resultDictionary.Add(abstTypes[i], currentNodes[i]);
                }
            }

            while (typeList.Count > 0)
            {
                for (int j = 0; j < typeNodes.Count; j++)
                {
                    for (int i = 0; i < typeList.Count; i++)
                    {
                        if (typeList[i].BaseType == typeNodes[j])
                        {
                            TowerNode newNode = new TowerNode();
                            newNode.towerType = typeList[i];
                            newNode.parent    = currentNodes[j];
                            currentNodes[j].children.Add(newNode);

                            nextNodes.Add(newNode);
                            nextTypes.Add(typeList[i]);

                            resultDictionary.Add(typeList[i], newNode);

                            removeList.Add(typeList[i]);
                        }
                    }
                }

                foreach (Type t in removeList)
                {
                    typeList.Remove(t);
                }
                removeList.Clear();

                currentNodes.Clear();
                currentNodes.AddRange(nextNodes);
                nextNodes.Clear();


                typeNodes.Clear();
                typeNodes.AddRange(nextTypes);
                nextTypes.Clear();
            }


            return(resultDictionary);
        }