Beispiel #1
0
    //only for use by the above 2
    void setUnitStatsSaver(ref unitStats current_toy, unitStatsSaver toy, bool set_max_lvl)
    {
        int old_max_lvl = current_toy.getMaxLvl();

        if (set_max_lvl)
        {// I HATE THIS SHIT
            if (toy.toy_id.toy_type == ToyType.Hero)
            {
                int new_max_lvl = Mathf.Max(toy.getMaxLvl(), old_max_lvl);

                foreach (Rune h in hero_toy_stats)
                {
                    //if (h.toy_name.Equals(toy.name))
                    if (h.runetype == toy.toy_id.rune_type && h.toy_type == toy.toy_id.toy_type)
                    {
                        new_max_lvl = Mathf.Max(toy.getMaxLvl(), (int)h.getMaxLevel());
                        h.setMaxLevel(new_max_lvl);
                    }
                }
                current_toy.setMaxLvl(new_max_lvl);
            }
            else
            {
                current_toy.setMaxLvl(toy.getMaxLvl());
            }
        }
        else
        {
            current_toy.setMaxLvl(old_max_lvl);
        }
    }
Beispiel #2
0
    public float _getSignalSize(unitStats s)
    {
        float size = 0.5f;


        float distance_bonus = 0f;

        if (s.toy_id.toy_type == ToyType.Temporary)
        {
            distance_bonus = StaticRune.GetDistanceBonus(s.name, islands[island_selected].transform.position, null);
        }
        if (s.toy_id.rune_type == RuneType.SensibleCity)
        {
            return(0.5f);
        }
        if (s != null)
        {
            size = StaticRune.time_bonus_aff(StaticStat.getBaseFactor(s.toy_id.rune_type, EffectType.Range, s.toy_id.toy_type == ToyType.Hero),
                                             EffectType.Range, s.toy_id.rune_type, s.toy_id.toy_type, distance_bonus) / 2f;
        }

        //   Debug.Log("Getting signal size for " + selected + " got " + size + "\n");

        return(size);
    }
Beispiel #3
0
    public StateType canBuildToy(string name, Cost toy_cost, unitStats toy)
    {
        bool vocal = false;

        if (Central.Instance.getToy(name) == null)
        {
            if (vocal)
            {
                Debug.Log("Central does not know anything about " + name + "\n");
            }
            return(StateType.No);
        }
        if (!Central.Instance.getToy(name).isUnlocked)
        {
            if (vocal)
            {
                Debug.Log("Peripeheral does not have toy " + name + "\n");
            }
            return(StateType.No);
        }
        else if (!Peripheral.Instance.canBuildToy(toy))
        {
            if (vocal)
            {
                Debug.Log(name + "toy needs a city or is a city and we have a city already\n");
            }
            return(StateType.No);
        }
        else if (!peripheral.HaveResource(toy_cost))
        {
            //      if (vocal) Debug.Log("Can't afford " + name + "\n");
            return(StateType.NoResources);
        }
        return(StateType.Yes);
    }
Beispiel #4
0
    bool AttemptBuilt(BuildTower tower)
    {
        if (tower.done)
        {
            return(false);
        }
        unitStats stats    = Central.Instance.getToy(tower.toy_id.rune_type, tower.toy_id.toy_type);
        string    toy_name = stats.name;
        bool      force    = (force_all_towers || tower.force);

        if (canBuildTower(stats, force))
        {
            Toy        f = null;
            GameObject o = Peripheral.Instance.makeToy(toy_name, tower.island, !force, ref f, false);
            o.GetComponent <Toy>().my_tower_stats.name = tower.label;

            if (tower.toy_id.toy_type == ToyType.Temporary)
            {
                ghosts.Add(o.GetComponent <Toy>());
            }
            if (tower.disable_tower)
            {
                StartCoroutine(DisableTower(o));
            }

            tower.done = true;
            return(true);
        }

        return(false);
    }
Beispiel #5
0
 //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                    LOAD ACTORS
 public void LoadAllToys(InitLevel level)
 {
     for (int i = 0; i < level.toys.Length; i++)
     {
         unitStats actor = LoadToy(level.toys[i]);
         Central.Instance.setUnitStats(actor, true);
     }
 }
Beispiel #6
0
    public wavelet(float mi, float ll, List <string> c, List <int> p)
    {
        monster_interval = mi;
        lull_length      = ll;

        string monster      = "";
        int    count        = 0;
        int    path         = -1;
        int    paths_length = p.Count;
        int    path_count   = 0;

        //    Debug.Log("Paths length " + paths_length + "\n");
        for (int i = 0; i < c.Count; i++)
        {
            string m = c[i];
            //   Debug.Log("m " + m + "\n");
            if (int.TryParse(m, out count) || (!int.TryParse(m, out count) && monster != ""))
            {
                count = -1;
                int.TryParse(m, out count);
                if (count == -1)
                {
                    Debug.LogError("Failed to parse line: " + c + "\n");
                }
                if (!monster.Equals(""))
                {
                    unitStats stats = Central.Instance.getToy(monster);
                    if (stats != null)
                    {
                        while (count > 0)
                        {
                            monsters.Add(monster);
                            monster_count++;

                            paths.Add(path);
                            count--;
                        }
                        monster = "";
                    }
                    //       else { Debug.Log("Trying to add invalid monster to wavelet " + monster + "\n"); }
                }
            }
            else
            {
                //   Debug.Log("Got monster " + m + "\n");
                monster = m;
                count   = 1;
                if (path_count < paths_length)
                {
                    path = p[path_count]; path_count++;
                }
                else
                {
                    path = -1;
                }
            }
        }
    }
Beispiel #7
0
    public int CompareTo(object obj)
    {
        if (obj == null)
        {
            return(1);
        }
        unitStats d = obj as unitStats;

        return(toy_id.CompareTo(d.toy_id));
    }
Beispiel #8
0
 public unitStats getToy(unitStats toy)
 {
     foreach (unitStats actor in actors)
     {
         if (actor.CompareTo(toy) == 0)
         {
             return(actor);
         }
     }
     return(null);
 }
Beispiel #9
0
 public bool canBuildToy(unitStats toy)
 {
     if (toy.toy_id.rune_type == RuneType.SensibleCity && (have_cities || building_a_city))
     {
         return(false);
     }
     if (toy.required_building.Equals(""))
     {
         return(true);
     }
     return(have_cities);
 }
Beispiel #10
0
    public bool TowerBuild(MyPlayerEvent e)
    {
        if (e.event_complete)
        {
            return(true);
        }


        //unitStats stats = Central.Instance.getToy(tower.toy_id.rune_type, tower.toy_id.toy_type);
        unitStats stats    = Central.Instance.getToy(e.attribute_1);
        string    toy_name = stats.name;
        bool      force    = true;

        if (force || canBuildTower(stats, force))
        {
            Toy           f      = null;
            Island_Button island = Monitor.Instance.getIslandByID(e.attribute_2);
            if (island == null)
            {
                Debug.LogError("Could not locate island " + e.attribute_2 + " for tower " + e.attribute_1 + "\n");
                return(false);
            }

            GameObject o   = Peripheral.Instance.makeToy(toy_name, island, true, ref f, true);
            Toy        toy = o.GetComponent <Toy>();
            toy.my_tower_stats.name = e.metric_1.ToString();

            if (toy.toy_type == ToyType.Temporary)
            {
                ghosts.Add(toy);
            }
            else
            {
                toys.Add(toy);
            }

            if (toy.toy_type == ToyType.Hero)
            {
                loadHeroSkills(skills_and_inventory, toy.runetype);
            }

            e.event_complete = true;
            return(true);
        }
        else
        {
            Debug.LogError("Could not build tower " + e.attribute_2 + " for tower " + e.attribute_1 + "\n");
            return(false);
        }

        return(false);
    }
Beispiel #11
0
    public void setUnitStats(unitStats toy, bool set_max_lvl)
    {
        unitStats current_toy = getToy(toy);

        //   toy.setActive(toy.toy_type != ToyType.Temporary);

        if (current_toy != null)
        {
            current_toy = toy;
            setUnitStatsSaver(ref current_toy, toy.getSnapshot(), set_max_lvl);
            return;
        }
        actors.Add(toy);
    }
Beispiel #12
0
    public void setUnitStats(unitStatsSaver toy, bool set_max_lvl)
    {
        unitStats current_toy = getToy(toy.toy_id.rune_type, toy.toy_id.toy_type);


        if (current_toy != null)
        {
            setUnitStatsSaver(ref current_toy, toy, set_max_lvl);
            return;
        }
        else
        {
            Debug.LogError("Could not set actor stats from actorStatsSaver for toy " + toy.name + "\n");
        }
    }
Beispiel #13
0
    public bool SelectToy(string toy, RuneType rune, bool quietly)
    {
        //   Debug.Log("Select toy " + toy + "\n") ;
        if (toy == null)
        {
            toy = "";
        }

        if (toy.Equals(toy_selected))
        {
            return(toy_selected.Equals(""));
        }

        if (toy.Equals(""))
        {
            toy_selected = null;
            SetAllowedRange("");

            if (!quietly && onSelected != null)
            {
                onSelected(SelectedType.Toy, "");
            }

            return(false);
        }
        else
        {
            rune_selected = rune;
            unitStats stats = Central.Instance.getToy(toy);
            if (stats == null)
            {
                return(false);
            }

            toy_selected = new SelectedToy(toy, stats.island_type);

            SetAllowedRange(toy_selected.name);

            if (!quietly && onSelected != null)
            {
                onSelected(SelectedType.Toy, toy_selected.name);
            }

            return(true);
        }
    }
Beispiel #14
0
    public unitStats LoadToy(InitToy toy)
    {
        unitStats test = Central.Instance.getToy(toy.name);

        if (test != null)
        {
            if (toy.hasMaxLvl())
            {
                test.setMaxLvl(toy.max_lvl);
            }
            return(test);
        }
        else
        {
            Debug.LogError("THIS IS NOT SUPPORTED YET WHY ARE YOU DOING THIS STOP\n");
            return(null);
        }
    }
Beispiel #15
0
    bool canBuildTower(unitStats toy, bool force)
    {
        Cost  toy_cost = null;
        float cost     = 9999;

        if (toy != null)
        {
            toy_cost = toy.cost_type;
        }

        if (toy_cost != null)
        {
            cost = toy_cost.Amount;
        }

        StateType answer = EagleEyes.Instance.canBuildToy(toy.name, toy_cost, toy);

        return((!force && answer == StateType.Yes) || (force && answer != StateType.No));
    }
Beispiel #16
0
    //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                    LOAD ACTORS
    public string oldLoadActors(string what)
    {
        string line = file.Dequeue();

        while (line != null && !line[0].Equals(':'))
        {
            if (what.Equals("Toys"))
            {
                unitStats actor = LoadActor(line);
                line = file.Dequeue();
                Central.Instance.setUnitStats(actor, true);
            }
            else
            {
                enemyStats enemy = LoadEnemy(line);
                line = file.Dequeue();
                Central.Instance.enemies.Add(enemy);
                Peripheral.Instance.haveMonsters.Add(enemy.name, true);
            }
        }

        return(line);
    }
Beispiel #17
0
    public unitStats LoadActor(string line)
    {
        //  Debug.Log("Loading actor\n");
        JSONObject pname    = new JSONObject();
        JSONObject pcost    = new JSONObject();
        JSONObject ptoytype = new JSONObject();
        //JSONObject pcost_runetype = new JSONObject ();
        JSONObject prune_type     = new JSONObject();
        JSONObject pcost_wishtype = new JSONObject();
        JSONParser p = new JSONParser(line);

        JSONObject ppermanent = new JSONObject();
        JSONObject pammo      = new JSONObject();
        JSONObject inv        = new JSONObject();



        JSONObject pmax_lvl          = new JSONObject();
        JSONObject exclude_skills    = new JSONObject();
        JSONObject required_building = new JSONObject();

        p.parse();
        p.root.TryGetValue("name", out pname);

        p.root.TryGetValue("cost", out pcost);

        p.root.TryGetValue("toy_type", out ptoytype);
        p.root.TryGetValue("rune_type", out prune_type);
        p.root.TryGetValue("cost_wishtype", out pcost_wishtype);
        p.root.TryGetValue("max_lvl", out pmax_lvl);


        p.root.TryGetValue("ammo", out pammo);
        p.root.TryGetValue("inventory", out inv);



        p.root.TryGetValue("islandtype", out ppermanent);
        p.root.TryGetValue("exclude_skills", out exclude_skills);
        p.root.TryGetValue("required_building", out required_building);
        unitStats test = Central.Instance.getToy(pname.value);


        if (test != null)
        {
            if (pmax_lvl != null)
            {
                test.setMaxLvl(int.Parse(pmax_lvl.value));
            }

            //    Debug.Log("Loading actor again\n");
            //thing has already been defined in a previous level. do not load most stats again

            return(test);
        }
        else
        {
            int cost = int.Parse(pcost.value);



            unitStats stats = new unitStats(pname.value);

            if (pmax_lvl != null)
            {
                stats.setMaxLvl(int.Parse(pmax_lvl.value));
            }
            stats.isUnlocked = false;
            RuneType rune_type = (prune_type != null) ? EnumUtil.EnumFromString(prune_type.value, RuneType.Null) : RuneType.Null;
            ToyType  toy_type  = (ptoytype != null) ? EnumUtil.EnumFromString(ptoytype.value, ToyType.Null) : ToyType.Null;
            //WishType wish_type = WishType.Null;
            CostType cost_type = CostType.Dreams;

            stats.toy_id.toy_type  = toy_type;
            stats.toy_id.rune_type = rune_type;



            cost_type = TowerStore.costType(rune_type, toy_type);

            //if (pcost_wishtype != null) wish_type = Get.WishTypeFromString(pcost_wishtype.value);
            if (required_building != null)
            {
                stats.required_building = (required_building.value);
            }
            stats.setCost(cost_type, cost);


            stats.island_type = ppermanent != null?EnumUtil.EnumFromString(ppermanent.value, IslandType.Permanent) : IslandType.Permanent;


            if (pammo != null)
            {
                stats.ammo = int.Parse(pammo.value);
            }
            Central.Instance.setUnitStats(stats, false);
            return(stats);
        }
    }
Beispiel #18
0
    public void UpdateToyButtons(string mytoy, ToyType kind, bool reset)
    {
        bool   vocal        = false;
        string selected_toy = peripheral.getSelectedToy();

        if (current_GUIState.state != GameState.InGame)
        {
            //Debug.Log("UpdateToyButtons is in " + current_GUIState.state + ", not in game state!\n");
            return;
        }
        if (vocal)
        {
            Debug.Log("UpdateToyButtons running " + kind + "\n");
        }

        // Debug.Log("Beep\n");
        foreach (MyLabel l in current_GUIState.labels)
        {
            if (l == null || l.toytype == ToyType.Null)
            {
                continue;
            }
            if (l.toytype != kind && kind != ToyType.Null)
            {
                continue;
            }
            if (reset)
            {
                l.ResetButton();
            }
            string name = l.content;

            float     cost = 9999;
            unitStats toy  = central.getToy(name);

            Cost toy_cost = null;
            if (toy != null)
            {
                toy_cost = toy.cost_type;
            }

            if (toy_cost != null)
            {
                cost = toy_cost.Amount;
            }
            if (cost == 9999)
            {
                Debug.Log("Getting name " + name + " " + l.gameObject.name + "\n");
                return;
            }
            switch (canBuildToy(name, toy_cost, toy))
            {
            case StateType.No:
                if (vocal)
                {
                    Debug.Log("Turning off toy No " + l.content + "\n");
                }
                l.SetActive(false);
                break;

            case StateType.NoResources:
                if (vocal)
                {
                    Debug.Log("Turning off toy NoResources " + l.content + "\n");
                }
                l.SetActive(true);
                ClearInfo();
                SetRowButton(l, false, false);
                if (mytoy.Equals(name))
                {
                    Central.Instance.button_selected = null;                        // is this used??!!
                }
                break;

            case StateType.Yes:
                if (vocal)
                {
                    Debug.Log("Turning on toy " + l.content + "\n");
                }
                l.SetActive(true);
                if (vocal)
                {
                    Debug.Log("Turning on thing " + selected_toy + " == " + name + "\n");
                }
                if (selected_toy == name)
                {
                    if (l != null)
                    {
                        l.SetSelected(true, true);
                    }
                    if (l != null)
                    {
                        l.SetInteractable(true);
                    }
                }
                else
                {
                    //if (l != null) l.SetSelected(true, false);
                    if (l != null)
                    {
                        l.SetInteractable(true);
                    }
                }
                break;
            }
            string[] vars = new string[2];
            vars[0] = name;
            vars[1] = cost.ToString();
            StartCoroutine("DoOnPriceUpdate", vars);
        }
    }
Beispiel #19
0
    void OnInput(bool is_click)
    {
        if (Central.Instance.getState() != GameState.InGame)
        {
            return;
        }

        //bool drag_mode = EagleEyes.Instance.floating_tower_scroll_driver.DragMode();
        bool drag_mode = Monitor.Instance.my_spyglass.isDisabledByDragButton();

        if (!drag_mode)
        {
            Monitor.Instance.my_spyglass.InitiateSpyglass();
        }

        if (block != null && block.gameObject.activeSelf == false)
        {
            block = null;
        }
        if (blocked && block == null && my_toy == null)
        {
            blocked = false;
        }

        if (drag_mode && blocked)
        {
            return;
        }

        if (my_toy != null)
        {
            if (onSelected != null)
            {
                onSelected(SelectedType.Island, parent.name);
            }
            return;
        }

        if (!drag_mode && blocked)
        {
            if (onSelected != null)
            {
                onSelected(SelectedType.Island, parent.name);
            }
            return;
        }



        Selected_toy = "";

        string selected = peripheral.getSelectedToy();

        if (is_click && onSelected != null)
        {
            onSelected(SelectedType.DirectIsland, parent.name);//when tapping an empty island, deselect everything else, only need bool is_click for mouse, not an issue for phone?
        }
        //  if (is_click && !blocked && selected != null) Noisemaker.Instance.Click(ClickType.Success);

        unitStats stats = Central.Instance.getToy(selected);

        if (stats == null)
        {
            //I DON'T KNOW
            //  if (is_click && onSelected != null) onSelected(SelectedType.DirectIsland, parent.name);//when tapping an empty island, deselect everything else, only need bool is_click for mouse, not an issue for phone?
            return;
        }



        if (stats.island_type != IslandType.Either && stats.island_type != island_type)
        {
            return;
        }

        if (selected != "")
        {
            Selected_toy = verify_toy_for_distance(selected);
        }

        if (drag_mode && onSelected != null)
        {
            onSelected(SelectedType.Island, parent.name);
        }
    }
Beispiel #20
0
    /*
     *  public void StopTween(GameObject obj){
     *          Tweener[] stopme = obj.GetComponentsInChildren<Tweener> ();
     *          for (int i = 0; i < stopme.Length; i++)
     *                  {
     *                          stopme[i].StopMe();
     *                  }
     *  }
     */
    public void Do()
    {
        //    Debug.Log("Doing gameaction " + this._type + " " + this.name + " " + _text + "\n");
        switch (_type)
        {
        case ActionType.UIFilter:
            if (_name.Equals(""))
            {
                EagleEyes.Instance.ResetUIFilter();
            }
            else
            {
                EagleEyes.Instance.SetUIFilter(_name, _text);
            }
            break;

        case ActionType.SetSensibleWishUplift:
            Peripheral.Instance.getLevelMod().sensible_wish_uplift = _number;
            break;

        case ActionType.Panel:
            if (Peripheral.Instance == null)
            {
                Debug.Log("NO PERIPHERAL\n");
                return;
            }
            if (Peripheral.Instance.zoo == null)
            {
                Debug.Log("NO ZOO\n");
                return;
            }

            GameObject panel = Peripheral.Instance.zoo.getObject(_name, true);
            if (panel == null)
            {
                Debug.LogError("GameAction could not find object " + _name + "\n");
            }
            if (!_bool)
            {
                panel.transform.SetParent(EagleEyes.Instance.events.transform);
            }
            else
            {
                panel.transform.SetParent(EagleEyes.Instance.world_space_events.transform);
            }
            panel.gameObject.transform.GetChild(0).gameObject.SetActive(true);
            panel.transform.localPosition = Vector3.zero;
            panel.transform.localScale    = Vector3.one;
            panel.transform.localRotation = Quaternion.identity;
            break;

        case ActionType.ShowIslands:
            Debug.Log("Show islands " + _name + " " + _bool);
            IslandType type = EnumUtil.EnumFromString <IslandType>(_name, IslandType.Null);
            if (type == IslandType.Null)
            {
                Debug.LogError("Event trying to show (" + _bool + ")islands of invalid type: " + _name + "\n");
                return;
            }
            Monitor.Instance.ShowIslandSprites(_bool, type);
            break;

        case ActionType.EnemyDescription:

            GameObject enemy_desc = Peripheral.Instance.zoo.getObject("Tutorial/Descriptions/generic_enemy_description", true);
            if (enemy_desc == null)
            {
                Debug.LogError("GameAction could not find object " + _name + "\n");
            }
            enemy_desc.transform.SetParent(EagleEyes.Instance.events.transform);


            enemy_desc.gameObject.transform.GetChild(0).gameObject.SetActive(true);
            enemy_desc.transform.localPosition = Vector3.zero;
            enemy_desc.transform.localScale    = Vector3.one;
            enemy_desc.transform.localRotation = Quaternion.identity;
            enemy_desc.GetComponent <EnemyDescriptionLabel>().setType(_text);
            RectTransform b   = enemy_desc.GetComponent <EnemyDescriptionButton>().button;
            Vector3       pos = b.localPosition;
            pos.y += _number * -6.5f;
            //Debug.Log(_number + "\n");
            b.localPosition = pos;
            break;

        case ActionType.MakeFloaty:
            //GameObject floaty = Peripheral.Instance.zoo.getObject(_name, true);
            //if (floaty == null) { Debug.Log("GameAction could not find object " + _name + "\n"); }
            //  floaty.GetComponent<Floaty>().Init(_vector);
            break;

        case ActionType.AddWish:

            WishType w = Get.WishTypeFromString(_text);
            // Debug.Log("We should add a wish " + _text + " " + w + "\n");
            Peripheral.Instance.my_inventory.AddWish(w, _number, 1);
            break;

        case ActionType.AddDream:
            if (_number <= 0)
            {
                return;
            }
            Peripheral.Instance.addDreams(_number, Vector3.zero, false);
            break;

        case ActionType.GiveSpecialSkill:
            EffectType effect_type = EnumUtil.EnumFromString <EffectType>(_name, EffectType.Null);
            RuneType   rune_type   = EnumUtil.EnumFromString <RuneType>(_text, RuneType.Null);
            Rune       r           = Central.Instance.getHeroRune(rune_type);

            if (r == null)
            {
                Debug.LogError("Cannot find a rune for hero of type " + rune_type + ", cannot give skill " + effect_type + "\n");
            }
            r.GiveSpecialSkill(effect_type);
            break;

        case ActionType.MakeWish:
            List <Wish> inv = new List <Wish>();
            inv.Add(new Wish(WishType.Sensible, 0.2f * _number));
            inv.Add(new Wish(WishType.MoreDamage, 0.1f * _number));
            inv.Add(new Wish(WishType.MoreXP, 015f * _number));
            inv.Add(new Wish(WishType.MoreDreams, 0.1f * _number));
            inv.Add(new Wish(WishType.MoreHealth, 0.1f * _number));
            if (onMakeWish != null)
            {
                onMakeWish(inv, _vector);
            }

            Debug.Log("We should make a wish\n");
            break;

        case ActionType.Pause:
            Peripheral.Instance.Pause(true);
            break;

        case ActionType.Resume:
            //       Debug.Log("Resuming\n");
            Peripheral.Instance.Pause(false);
            break;

        case ActionType.DisableMonitor:
            Monitor.Instance.is_active = _bool;
            break;

        case ActionType.HideUIElement:
            //name is include, //text is exclude
            //	Debug.Log("Setting " + _name + " to " + _bool + "\n");
            EagleEyes.Instance.PlaceElement(_name, _bool);
            break;

        case ActionType.DisableUIElement:
            //name is include, //text is exclude
            //BUTTON HAS TO BE in GUI STATES WITH A MYLABEL

            EagleEyes.Instance.DisableElement(_name, _bool);
            //EagleEyes.Instance.SetEnableButtons(_name, _text, _bool);
            break;

        case ActionType.RemoveEventObjects:
            RemoveEventObjects();
            break;

        case ActionType.UnlockToy:
            Debug.Log("Unlocking toy " + _text + "\n");
            //Peripheral.Instance.ActivateToy(_text);
            unitStats toy = Central.Instance.getToy(_text);
            toy.isUnlocked = true;
            EagleEyes.Instance.UpdateToyButtons("blah", ToyType.Null, false);
            break;

        case ActionType.PointSpyGlass:
            if (Monitor.Instance != null)
            {
                Monitor.Instance.my_spyglass.PointSpyglass(_vector, true);
            }
            break;

        case ActionType.EnableSpyGlass:
            if (Monitor.Instance != null)
            {
                Monitor.Instance.my_spyglass.DisableByEvent(!_bool);
            }
            break;

        case ActionType.RemoveObject:
            if (_target != null)
            {
                foreach (GameObject t in _target)
                {
                    Peripheral.Instance.zoo.returnObject(t);
                }
            }
            if (_name != null)
            {
                Debug.Log("GameAction removing object with name, TERRIBLE\n");
            }
            Peripheral.Instance.zoo.returnObject(GameObject.Find(_name));
            break;

        case ActionType.EnableReward:
            RewardType rt = EnumUtil.EnumFromString <RewardType>(_text, RewardType.Null);
            if (rt != RewardType.Null)
            {
                RewardOverseer.RewardInstance.EnableReward(rt);
            }
            else
            {
                Debug.LogError(this.gameObject.name + " RewardType gameAction has an invalid rewardType( " + _text + ")\n");
            }
            break;

        default:
            Debug.LogError(this.gameObject.name + " " + _type + " gameAction has an unsupported ActionType\n");
            break;
        }
    }
    public void UpdatePanel(Island_Button button)
    {
        if (button == null && selected_island == null)
        {
            return;
        }
        if (button != null && selected_island != null && button.gameObject.GetInstanceID() == selected_island.gameObject.GetInstanceID())
        {
            return;
        }

        if (button == null)
        {
            selected_island = null;
            selected_island_image.gameObject.SetActive(false);
            my_panel.gameObject.SetActive(false);
            return;
        }


        //if (selected_island != null && button.gameObject.GetInstanceID() != selected_island.gameObject.GetInstanceID()) ResetSelected();

        selected_island = button;

        bool temp_ok = false;

        temp_ok = (selected_island.island_type == IslandType.Permanent || (selected_island.island_type == IslandType.Temporary && Monitor.Instance.SetAllowedRange("sensible_city")));


        int ok_buttons = 0;

        EagleEyes.Instance.UpdateToyButtons("blah", ToyType.Normal, true);

        foreach (MyLabel label in my_panel.list)
        {
            if (!label.AmIActive())
            {
                label.SetHidden(true);
                continue;
            }


            unitStats stats = Central.Instance.getToy(label.runetype, label.toytype);
            if (stats != null)
            {
                if (stats.island_type != IslandType.Either && stats.island_type != selected_island.island_type)
                {
                    label.SetHidden(true);
                    label.ShowButtons(false);
                    continue;
                }
                if (stats.island_type == IslandType.Temporary)
                {
                    if (!temp_ok)
                    {
                        label.SetHidden(true);
                        label.ShowButtons(false);
                        continue;
                    }
                    string ok = selected_island.verify_toy_for_distance(label.content);
                    if (ok.Equals("TOOFAR"))
                    {
                        label.SetHidden(true);
                        label.ShowButtons(false);
                        continue;
                    }
                }

                //if (label.button.IsInteractable()){
                label.SetHidden(false);
                label.ShowButtons(true);
                ok_buttons++;

                /*
                 * }else{
                 * label.SetHidden(true);
                 * label.ShowButtons(false);
                 * }*/
            }
        }
        Vector3 set_to = button.transform.position;

        if (ok_buttons > 0)
        {
            my_panel.transform.position = set_to;
            my_panel.gameObject.SetActive(true);

            my_panel.radius = (ok_buttons <= 6) ? 1.2f :
                              (ok_buttons == 7) ? 1.35f :
                              (ok_buttons == 8) ? 1.5f : 1.6f;
            my_panel.spacing = 2f * Mathf.PI * my_panel.radius / ok_buttons;
            my_panel.UpdatePanel();
            // if (Monitor.Instance != null) Monitor.Instance.my_spyglass.PointSpyglass(button.transform.position,.20f);

            selected_island_image.gameObject.SetActive(true);
            selected_island_image.transform.position = set_to;
        }
        else
        {
            selected_island_image.gameObject.SetActive(false);
            Noisemaker.Instance.Play("island_too_far");
            ShowNoResourcesPopup(set_to);
        }
    }
Beispiel #22
0
    public float getSignalSize(string selected)
    {
        unitStats s = Central.Instance.getToy(selected);

        return(_getSignalSize(s));
    }
Beispiel #23
0
    public float getSignalSize(RuneType runeType, ToyType toyType)
    {
        unitStats s = Central.Instance.getToy(runeType, toyType);

        return(_getSignalSize(s));
    }
Beispiel #24
0
    public void initStats(unitStats s, Vector3 scaleV, Island_Button i, string _name, Rune _rune)
    {
        tilesize = i.getPeripheral().tileSize;
        stats    = s;
        float dmg_base = 0;

        my_name                    = _name;
        my_tower_stats             = new tower_stats();
        my_tower_stats.island_name = string.Copy(i.ID);
        my_tower_stats.wave_time   = Moon.Instance.TIME;
        my_tower_stats.initSkillStats(runetype);
        if (building.tower_visual)
        {
            building.tower_visual.updateVisuals();
            building.tower_visual.setSprite(true);
        }

        Rune.onUpgrade += onUpgrade;

        float bonus = 0f;

        //  float bonus = StaticRune.GetDistanceBonus(my_name, this.transform.position, this);
        Debug.Log($"TOY Initializing {toy_type} {runetype}\n");
        if (_rune == null || toy_type != ToyType.Hero)
        {
            rune = new Rune();
            SetBonus(bonus);
            int max_lvl = LevelStore.getMaxLevel(Central.Instance.current_lvl, Peripheral.Instance.difficulty, runetype, toy_type);

            rune.initStats(runetype, max_lvl, toy_type);
            Debug.Log($"TOY Initializing {toy_type} {runetype} new rune lvl {max_lvl}\n");
        }
        else
        {
            SetBonus(bonus);
            rune = _rune;
            rune.UpdateStats();
            Debug.Log($"TOY Initializing {toy_type} {runetype} EXISTING rune lvl {rune.getMaxLevel()}\n");
        }
        Active  = true;
        island  = i;
        rune.ID = this.gameObject.GetInstanceID();
        center.localPosition = Vector3.Scale(center.localPosition, scaleV);
        //        my_toy.center.localPosition = Vector3.Scale(my_toy.center.localPosition, scaleV);
        transform.transform.localRotation = Quaternion.identity;

        building.initStats(this);
        //


        // if (rune.level > 0 && rune_buttons != null) rune_buttons.UpdateMe();

        if (parent_toy != null)
        {
            parent_toy.AddTargetToy(this);
        }


        if (toy_type == ToyType.Hero)
        {
            //rune.InitHero(Central.Instance.current_lvl);//for testing, gives hero some xp based on current level, if xp is 0
            // also sensible hero comes with airattack for free, done by an event in 02level_scene
            rune.setMaxLevel((int)Mathf.Max(Central.Instance.getToy(my_name).getMaxLvl(), rune.getMaxLevel()));
        }

        if (firearm != null)
        {
            firearm.initStats(this);
        }
        //if (rune_buttons != null) rune_buttons.UpdateMe(); // ghost towers don't get their own rune buttons
        TIME_AT_START = Time.time;
    }
Beispiel #25
0
    public GameObject makeToy(string toy_name, Island_Button island_b, bool check_cost, ref Toy _toy, bool force)
    {
        unitStats my_stats     = Central.Instance.getToy(toy_name);
        Cost      my_cost_type = my_stats.cost_type;

        if (!force && check_cost && my_cost_type.type != CostType.Dreams)
        {
            if (!HaveResource(my_stats.cost_type))
            {
                Debug.Log("Cannot afford toy " + toy_name + " of type " + my_cost_type + " for " + my_cost_type.Amount + " cost\n");
                return(null);
            }
        }



        _toy = InitToyObj(island_b, toy_name, false);
        GameObject toy_obj = _toy.gameObject;

        if (_toy.target_toys.Length > 0)
        {
            toy_parents.Add(_toy);
        }

        if (_toy.firearm != null)
        {
            firearms.Add(_toy.firearm);
        }

        island_b.my_toy = _toy;
        _toy.my_name    = toy_name;

        Rune rune = null;

        bool new_hero = false;

        if (_toy.toy_type == ToyType.Hero)
        {
            Rune have = Central.Instance.getHeroStats(_toy.runetype);
            if (have != null)
            {
                rune = have;
            }
            else
            {
                new_hero = true;
            }
        }

        if (_toy != null)
        {
            _toy.initStats(my_stats, Vector3.one, island_b, toy_name, rune);
        }


        if (_toy.building)
        {
            _toy.building.StartConstruction();
        }

        //   Debug.Log("NEW TOY cost toytype " + my_cost_type.toytype + "\n");


        _toy.name       = toy_name + "|" + all_toys;
        _toy.rune.order = all_toys;



        all_toys++;
        if (check_cost || my_cost_type.isHero())
        {
            if (my_cost_type.type == CostType.Dreams)
            {
                if (_toy.runetype != RuneType.Modulator)
                {
                    incrementToys();
                }
                addDreams(-my_cost_type.Amount, toy_obj.transform.position, false);
                Central.Instance.updateCost(toys);
                // if (Central.Instance.getToy(toy_name).cost_type.cost > dreams) { SelectToy(""); }
            }
            else if (my_cost_type.type == CostType.Wishes)
            {
                my_inventory.AddWish(WishType.Sensible, -my_cost_type.Amount, 1);
            }
            else if (my_cost_type.isHero())
            {
                SetHeroPoint(my_cost_type.getHeroRuneType(), 0, true);
                SelectToy(null, RuneType.Null);
            }
        }


        if (onPlacedToy != null)
        {
            onPlacedToy(_toy.my_name, _toy.runetype, _toy.toy_type);
        }


        if (new_hero)
        {
            Central.Instance.hero_toy_stats.Add(_toy.rune);
        }
        if (check_cost)
        {
            Noisemaker.Instance.Play("make_tower");
        }

        if (check_cost)
        {
            Tracker.Log(PlayerEvent.TowerBuilt, true,
                        customAttributes: new Dictionary <string, string>()
            {
                { "attribute_1", _toy.my_name }, { "attribute_2", island_b.ID }
            },
                        customMetrics: new Dictionary <string, double>()
            {
                { "metric_1", _toy.rune.order }
            });
        }


        return(toy_obj);
    }
Beispiel #26
0
    public static unitStats getBasicStats(RuneType runetype, ToyType toytype)

    {
        unitStats stats = null;

        switch (runetype)
        {
        case RuneType.Sensible:
            if (toytype != ToyType.Hero)
            {
                stats = new unitStats("sensible_tower", runetype, toytype);
                stats.setCost(costType(runetype, toytype), 40);
            }
            else
            {
                stats = new unitStats("sensible_tower_hero", runetype, toytype);
                stats.setCost(costType(runetype, toytype), 1);
            }
            stats.island_type = IslandType.Permanent;

            break;


        case RuneType.Airy:
            if (toytype != ToyType.Hero)
            {
                stats = new unitStats("airy_tower", runetype, toytype);
                stats.setCost(costType(runetype, toytype), 30);
            }
            else
            {
                stats = new unitStats("airy_tower_hero", runetype, toytype);
                stats.setCost(costType(runetype, toytype), 1);
            }
            stats.island_type = IslandType.Permanent;
            break;

        case RuneType.Vexing:
            if (toytype != ToyType.Hero)
            {
                stats = new unitStats("vexing_tower", runetype, toytype);
                stats.setCost(costType(runetype, toytype), 50);
            }
            else
            {
                stats = new unitStats("vexing_tower_hero", runetype, toytype);
                stats.setCost(costType(runetype, toytype), 1);
            }
            stats.island_type = IslandType.Permanent;
            break;

        case RuneType.Castle:
            stats = new unitStats("castle", runetype, toytype);
            stats.setCost(costType(runetype, toytype), 9999);
            stats.island_type = IslandType.Permanent;
            break;

        case RuneType.SensibleCity:
            stats = new unitStats("sensible_city", runetype, toytype);
            stats.setCost(costType(runetype, toytype), 20);
            stats.island_type = IslandType.Permanent;
            break;

        case RuneType.Modulator:
            stats = new unitStats("modulator", runetype, toytype);
            stats.setCost(costType(runetype, toytype), 5);
            stats.island_type = IslandType.Either;
            break;

        case RuneType.Fast:
            stats = new unitStats("sensible_tower_ghost", runetype, toytype);
            stats.setCost(costType(runetype, toytype), 2);
            stats.island_type       = IslandType.Temporary;
            stats.required_building = "sensible_city";
            stats.ammo = 5;
            break;

        case RuneType.Slow:
            stats = new unitStats("slow_ghost", runetype, toytype);
            stats.setCost(costType(runetype, toytype), 2);
            stats.island_type       = IslandType.Temporary;
            stats.required_building = "sensible_city";
            stats.ammo = 5;
            break;

        case RuneType.Time:
            stats = new unitStats("time_ghost", runetype, toytype);
            stats.setCost(costType(runetype, toytype), 2);
            stats.island_type       = IslandType.Temporary;
            stats.required_building = "sensible_city";
            stats.ammo = 5;
            break;
        }
        stats.isUnlocked = false;

        /*
         *
         * { "name":"castle", "toy_type": "hero", "cost":"9999", "scale":{ "x":"2","z":"2"},"rune_type":"Castle"}
         * { "name":"sensible_city", "toy_type": "normal", "cost":"20", "scale":{ "x":"2","z":"2"},"rune_type":"SensibleCity"}
         * { "name":"sensible_tower",      "toy_type": "normal",   "cost":"40", "rune_type":"Sensible"}
         * { "name":"airy_tower",          "toy_type": "normal",   "cost":"30", "rune_type":"Airy"}
         * { "name":"vexing_tower",        "toy_type": "normal",   "cost":"50", "rune_type":"Vexing"}
         * { "name":"sensible_tower_hero", "toy_type": "hero",     "cost":"1", "rune_type":"Sensible"}
         * { "name":"airy_tower_hero",     "toy_type": "hero",     "cost":"1","rune_type":"Airy"}
         * { "name":"vexing_tower_hero",   "toy_type": "hero",     "cost":"1","rune_type":"Vexing"}
         * { "name":"sensible_tower_ghost","toy_type": "temporary","cost":"2","ammo":"5", "required_building":"sensible_city","islandtype":"temporary","rune_type":"Fast"}
         * { "name":"slow_ghost",          "toy_type": "temporary","cost":"2","ammo":"5", "required_building":"sensible_city","islandtype":"temporary","rune_type":"Slow"}
         * { "name":"time_ghost",          "toy_type": "temporary","cost":"2","ammo":"5","required_building":"sensible_city","islandtype":"temporary","rune_type":"Duration"}
         * { "name":"modulator",           "toy_type": "normal"   ,"cost":"5","islandtype":"either","rune_type":"Modulator"}
         */

        return(stats);
    }