public Minion( long id, double x, double y, double speedX, double speedY, double angle, Faction faction, double radius, int life, int maxLife, Status[] statuses, MinionType type, double visionRange, int damage, int cooldownTicks, int remainingActionCooldownTicks) : base(id, x, y, speedX, speedY, angle, faction, radius, life, maxLife, statuses) { Type = type; VisionRange = visionRange; Damage = damage; CooldownTicks = cooldownTicks; RemainingActionCooldownTicks = remainingActionCooldownTicks; }
private static void CalculateStatsByType(Minion m) { using (var db = new MinionWarsEntities()) { int strMod = 0; int dexMod = 0; int vitMod = 0; int powMod = 0; int cdMod = 0; int durMod = 0; //get from db MinionType mtype = db.MinionType.Find(m.mtype_id); strMod += mtype.str_modifier; dexMod += mtype.dex_modifier; vitMod += mtype.vit_modifier; powMod += mtype.pow_modifier; cdMod += mtype.cd_modifier; durMod += mtype.dur_modifier; m.strength += strMod; m.dexterity += dexMod; m.vitality += vitMod; m.power += powMod; m.cooldown += cdMod; m.duration += durMod; } }
void OnScrollButtonClicked(string desc, bool isBlocked, bool isBought, MinionType type) { if (isBlocked) { return; } if (!isBought) { shopPopup.DisplayPopup(); shopPopup.SelectMinionByCode(type); return; } var orderList = _user.GetSquadMinionsOrder(); if (orderList.Any(i => i == type.ToString()) || orderList.Count == selectedButtons.Count) { return; } _user.SetSquadMinionItem(type); var selectedItem = selectedButtons.FirstOrDefault(i => i.IsEmpty); selectedItem.SetMinion(type, _gm); selectedItem.onMinionClick += OnSelectedMinionClickCallback; var selectedItemScroll = _totalMinionsList.FirstOrDefault(i => i.minionType == type); if (selectedItemScroll != null) { selectedItemScroll.ChangeToColor(true); } }
/// <summary> /// This will add to the inventory a new minion of type 'type'. /// And then save it locally /// </summary> public void AddNewMinionToInventory(MinionType type) { var minion = CreateMinionDefInstance(type); _minionsBoughts.list.Add(minion); SaveSystem.Save(_minionsBoughts, _pathToMinionsSaved); }
public Troop(string name, MinionType minion, int number) { //constructor of three parameters-called when the program adds an object of this type TroopName = name; DefineType = minion; NumberOfMinions = number; }
public void SelectMinionByCode(MinionType type = MinionType.Runner) { MinionInShop m = null; float i = 0; foreach (var item in _scrollContentList) { if (item.minionType == type) { m = item; break; } i += 1; } if (m == null) { return; } m.button.onClick.Invoke(); ShowItemInScroller(i); }
/// <summary> /// Function that handles the searchbutton enabling the user to search for minions based on different /// criterias and displays different items dependent on the conditions selected. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void Search_Click(object sender, RoutedEventArgs e) { string search = SearchCondition(); if (rbtnSearchName.IsChecked == true) { //List<Minion> name = new List<Minion>(); //name.Add(minions.SearchByName(search)); lstMinions.ItemsSource = minions.MyMinions(minions.SearchNameByStartLetter(search)); } else if (rbtn_SearchStrenght.IsChecked == true) { int SearchForStrenght = ParseSearch(); lstMinions.ItemsSource = minions.MyMinions(minions.SearchByStrength(SearchForStrenght)); } else if (rbtn_SearchType.IsChecked == true) { MinionType miniType = SearchType(search); lstMinions.ItemsSource = minions.MyMinions(minions.SearchByType(miniType)); } else if (rbtn_SearchTrait.IsChecked == true) { if (!string.IsNullOrEmpty(txt_SearchField.Text.Trim())) { lstMinions.ItemsSource = minions.MyMinions(minions.SearchByTrait(txt_SearchField.Text.Trim())); } } txt_SearchField.Text = string.Empty; }
public void ResetMinion() { minionPic.enabled = false; _isEmpty = true; text.text = ""; minionType = MinionType.Runner; }
/// <summary> /// This will add to the inventory a new minion of type 'type'. /// And then save it locally /// </summary> public void AddNewMinionToInventory(MinionType type) { var minion = CreateMinionDefInstance(type); _minionsBoughts.list.Add(minion); SaveSystem.Save(_minionsBoughts, SaveSystem.MINIONS_SAVE_NAME); }
public Minion() { Health = 1; Attack = 1; Name = "Unnamed thing"; Type = MinionType.None; }
public void Spawn(MinionType _type) { //Initialize variables m_Type = _type; m_Animator.SetBool ("NoFaith", false); m_Animator.SetInteger ("Type", (int)_type); m_Penalty = AudienceManager.Instance.GetRandomPenalty (); //Get cur limits AudienceManager.Instance.GetMoneyLimits (m_Type, out m_MinMoney, out m_MaxMoney); AudienceManager.Instance.GetFaithLimits (m_Type, out m_MinFaith, out m_MaxFaith); AudienceManager.Instance.GetWillLimits (m_Type, out m_MinWill, out m_MaxWill); //Round values to integers m_Money = Mathf.Floor (Random.Range (m_MinMoney, m_MaxMoney)+GameManager.Instance.GetMoneyBonus(m_Type)); m_Faith = Mathf.Floor (Random.Range (m_MinFaith, m_MaxFaith)+GameManager.Instance.GetFaithBonus(m_Type)); m_Will = Mathf.Floor (Random.Range (m_MinWill, m_MaxWill)+GameManager.Instance.GetWillBonus(m_Type)); //Assign values to the text TODO: add icons? m_MoneyText.text = m_Money.ToString(); m_FaithText.text = m_Faith.ToString(); m_WillText.text = m_Will.ToString (); m_PenaltyIcon.sprite = GameManager.Instance.GetPenaltyICon (m_Penalty); MoveToFront (); }
public void TransformToNewCardWithEffectsForBoss(Card card) { id = card.id; name = card.name; image = card.image; cost = card.cost; isToken = card.isToken; isGold = card.isGold; skillDescription = card.skillDescription; goldVersion = card.goldVersion; star = card.star; attack = card.attack; health = card.health; tag = card.tag; keyWords = card.keyWords; proxys = card.proxys; effectsOri = new List <Effect>(); effectsOri.AddRange(card.effectsOri); if (IsMinionType(card.type) && effectsStay.Count > 0) { for (int i = effectsStay.Count - 1; i >= 0; i--) { if (!(effectsStay[i] is BodyPlusEffect)) { effectsStay.Remove(effectsStay[i]); } } } type = card.type; }
public void SetButton(MinionType t, string desc, GameManager gm) { buttonText.text = t.ToString(); minionPic.sprite = gm.LoadedAssets.GetSpriteByName(buttonText.text); minionType = t; _description = desc; }
public static TargetType GetTargetTypeByMinionType(MinionType type) { switch (type) { case MinionType.Runner: return(TargetType.Ground); case MinionType.Tank: return(TargetType.Ground); case MinionType.Dove: return(TargetType.Air); case MinionType.Healer: return(TargetType.Ground); case MinionType.Zeppelin: return(TargetType.Air); case MinionType.MiniZeppelin: return(TargetType.Air); case MinionType.WarScreamer: return(TargetType.Ground); } return(TargetType.Both); }
public void SpawnMinion(MinionType type, Vector3 spawnPos, Minion available) { Minion minion = null; minion = Instantiate(available, spawnPos, Quaternion.identity); if (type == MinionType.Healer) { (minion as Healer).manager = this; } else if (type == MinionType.Zeppelin) { (minion as Zeppelin).manager = this; } else if (type == MinionType.WarScreamer) { (minion as WarScreamer).manager = this; } if (minion == null) { Debug.LogError("Error creating a Minion"); return; } ModifyMinionStatByLevelID(ref minion, level.levelID); minion.transform.SetParent(_allMinions.transform); minion.OnWalkFinished += MinionWalkFinishedHandler; minion.OnDeath += MinionDeathHandler; minion.OnMinionSkill += MinionSkillActivatedHandler; _minions.Add(minion); OnNewMinionSpawned(type); }
void MinionSkillSelectedHandler(MinionType t) { if (_runnerCount == 3 && _doveCount == 0) { LevelCanvasManager.StopHoldDownMoveAnim(); var m = _minionManager.GetMinion(MinionType.Runner); m.SetWalk(true); } if (_doveCount == 1) { LevelCanvasManager.StopHoldDownMoveAnim(); var m = _minionManager.GetMinion(MinionType.Dove); m.SetWalk(true); LevelCanvasManager.SetMinionSkillButton(LevelCanvasManager.GetSpecificMinionSaleBtn(m.minionType).GetComponent <Button>() , m.skillType, false, MinionSkillManager); } if (_tankCount == 1) { LevelCanvasManager.StopHoldDownMoveAnim(); var m = _minionManager.GetMinion(MinionType.Tank); var minions = MinionManager.GetMinions(GetAllMinions); foreach (var item in minions) { item.SetWalk(true); } LevelCanvasManager.SetMinionSkillButton(LevelCanvasManager.GetSpecificMinionSaleBtn(m.minionType).GetComponent <Button>() , m.skillType, false, MinionSkillManager); } }
/// <summary> /// 미니언의 종류 구분, 레이어에 따른 팀 설정 /// </summary> protected void SetMinion() { //미니언 타입 설정 if (transform.name.Contains("Super")) { minionType = MinionType.Super; SetStat("Minion_Super"); } else if (transform.name.Contains("Melee")) { minionType = MinionType.Melee; SetStat("Minion_Warrior"); } else if (transform.name.Contains("Magician")) { minionType = MinionType.Magic; SetStat("Minion_Magician"); } else if (transform.name.Contains("Siege")) { minionType = MinionType.Siege; SetStat("Minion_Siege"); } //미니언 경로 설정 }
public Tuple <int, int> GetCurrencies(MinionType t) { var needToUnlockBuy = _storeInfoData[t].starsNeedToUnlock - GetUserTotalStars(); var price = _storeInfoData[t].currencyValue; return(Tuple.Create(needToUnlockBuy, price)); }
public static IEnumerable <Obj_AI_Base> GetMobGroup(this LeagueSharp.Common.Spell spell, FarmMode farmMode, GameObjectTeam minionTeam, MinionType minionType = MinionType.All, MinionGroup minionGroup = MinionGroup.Alone, int minionCount = 1) { IEnumerable <Obj_AI_Base> list = ObjectManager.Get <Obj_AI_Minion>() .Where(m => m.LSIsValidTarget(spell.Range) && m.Team == GameObjectTeam.Neutral); if (minionType == MinionType.BigMobs) { IEnumerable <Obj_AI_Base> oMob = (from fMobs in list from fBigBoys in new[] { "SRU_Blue", "SRU_Gromp", "SRU_Murkwolf", "SRU_Razorbeak", "SRU_Red", "SRU_Krug", "SRU_Dragon", "SRU_Baron", "Sru_Crab" } where fBigBoys == fMobs.BaseSkinName select fMobs).AsEnumerable(); list = oMob; } return(list); }
public void SpawnMinion(MinionType minionType) { var currentId = _entityService.GetNewEntityId(); var messageRouter = ServiceFactory.Instance.GetService <MessageRouter>(); messageRouter.RaiseMessage(new SpawnMinionMessage(currentId, minionType)); RegisterMinion(currentId, minionType); }
public void AddMinionToShop(MinionType type, string description) { var m = Instantiate <MinionInShop>(minionInShopPrefab, _gridGroup.transform); m.SetButton(type, description); m.onMinionClick += OnClickMinionButton; _scrollContentList.Add(m); }
void NewMinionBuiltHandler(MinionType t) { _minionCount++; if (_minionCount == _overchargeManager.minionsAmount) { OnExecuteStep(null); } }
public float GetStatByStatId(MinionBoughtDef.StatNames id, MinionType minionType) { var result = -1f; switch (id) { case MinionBoughtDef.StatNames.HP: result = hp; break; case MinionBoughtDef.StatNames.SPD: result = speed; break; case MinionBoughtDef.StatNames.PASSIVE: if (minionType == MinionType.Healer) { result = healPerSecond; } /*else if (minionType == MinionType.WarScreamer) * result = passiveSpeedDelta;*/ break; case MinionBoughtDef.StatNames.SKILL: switch (minionType) { case MinionType.Runner: result = skillDeltaSpeed; break; case MinionType.Tank: result = shieldHits; break; case MinionType.Healer: result = skillHealAmount; break; case MinionType.Zeppelin: result = miniZeppelinStat.hitsToDie; break; case MinionType.WarScreamer: result = activeSpeedDelta; break; case MinionType.Dove: result = skillCooldown; break; } break; } return(result); }
private void OnEnable() { selectedType = (SelectedType)PlayerPrefs.GetInt("selectedType", 0); minionType = (MinionType)PlayerPrefs.GetInt("minionType", 0); keywordValue = (Keyword)PlayerPrefs.GetInt("keywordValue", 0); scrollPosition = Vector2.zero; isToken = false; tagValue = ""; }
public void StartSkillTapAnimation(MinionType t, Vector3 toPosition) { holdMoveImage.gameObject.SetActive(true); var btn = GetSpecificMinionSaleBtn(t).GetComponentInChildren <MinionSkillMouseDown>(); //skill btn time = 0; StartCoroutine(WaitForEndOfFrame(btn.GetComponent <Image>().rectTransform, holdMoveImage, null, true)); _holdImageTargetPosition = toPosition; }
void MinionSkillActivatedHandler(MinionType t) { if (level.levelMode != LevelMode.Tutorial) { return; } OnMinionSkillSelected(t); }
public void SummonFromGraveyard(MinionType type, int index, Direction direction = Direction.InPlace, int amount = 1) { var revive = Graveyard.Where(m => m.MinionType == type).Take(amount); foreach (var minion in revive) { Summon(minion.Name, index, direction); } }
MinionBoughtDef CreateMinionDefInstance(MinionType t) { var minion = new MinionBoughtDef(); minion.hp = minion.passiveSkill = minion.skill = minion.speed = 1; minion.type = t.ToString(); return(minion); }
public override bool BuildMinion(MinionType t) { var result = base.BuildMinion(t); if (t == MinionType.Runner) { _runnerCount++; if (!tankTutoStarted) { ExecuteTutorialStep(gameObject); } else { ExecuteTutorialStep(null); } } else if (t == MinionType.Dove) { _doveCount++; if (_doveCount == 1) { _lvlCanvasManager.StopTapAnimation(); } } else if (t == MinionType.Tank) { _tankCount++; _livesRemoved = 0; if (_tankCount == 1) { LevelCanvasManager.StopTapAnimation(); } } if (tankTutoStarted && t != MinionType.Tank) { //ExecuteTutorialStep (MinionManager.GetMinion(t).gameObject); if (t == MinionType.Dove) { _spawnedAfterTank++; } else if (t == MinionType.Runner) { _spawnedAfterTank++; } if (_spawnedAfterTank == 2) { Time.timeScale = 1; _stopTutorial = true; } } return(result); }
public DeadUnitInfo(World world, Minion unit, Wizard me) { Faction = unit.Faction; Angle = unit.Angle; IsUnion = unit.IsUnion(me); TickIndex = world.TickIndex; X = unit.X; Y = unit.Y; MinionType = unit.Type; }
/// <summary> /// If a minion is spawned after an event starts, this will activate the event on those minions /// </summary> void NewMinionSpawnedHandler(MinionType type) { /*if(_isRaining) * _level.LoopThroughMinions(RainDebuff);*/ if (_isWindBlowing) { _level.LoopThroughMinions(WindDebuff); } }
public bool amIStrongAgainst(MinionType me, MinionType opponent) { for(int i = 0; i < minionStrengths.Length; i++) { if((minionStrengths[i].minion == me) && (minionStrengths[i].strongAgainst == opponent)) { return true; } } return false; }
public Minion(int width, int height, MinionType minionType) : base("minion", width, height, Player.LevelUpModifiers) { this.minionType = minionType; AutomaticHitBox = false; Opacity = 0.33f; Order = 7; bulletHitMask = (Collision collision) => !(collision.Other is Player); minimumDiff = (float) ((0.66 + GameManager.Random.NextDouble())*minimumDiff); }
public MinionSounds getAccordingMinionSounds(MinionType minionType) { for(int i = 0; i < minionSounds.Length; i++) { if(minionSounds[i].minionType == minionType) { return minionSounds[i]; } } return null; }
public void displayAttack(MinionType attackerType) { switch(attackerType) { case MinionType.Ghost: ghostAttack.Emit(50); break; case MinionType.Warrior: warriorAttack.Emit(1); break; case MinionType.Wizard: wizardAttack.Emit(20); break; } }
public Material[] getMinionMaterials(MinionType type) { switch(type) { case MinionType.Ghost: return ghostsMaterials; case MinionType.Warrior: return warriorMaterials; case MinionType.Wizard: return wizardMaterials; default: return null; } }
public void CmdHauntSpawn(float _hauntDuration, Vector3 position, MinionType minType, GameObject explorer) { GameObject minion; switch (minType) { case MinionType.HauntMelee: minion = Instantiate(EnemyHauntPrefab[0], position, Quaternion.identity) as GameObject; break; default: minion = Instantiate(EnemyPrefab[0], position, Quaternion.identity) as GameObject; break; } NetworkServer.Spawn(minion); RpcSetParent(minion, explorer); //DisableMinion(minion); StartCoroutine(FinishHauntEtoM(_hauntDuration, minion,explorer)); }
public static List<GameObject> GetMinions(MinionType type, Vector3 posFrom, float distance = -1) { var temp = new List<GameObject>(); switch (type) { case MinionType.Ally: temp.AddRange( EntityManager.MinionsAndMonsters.AlliedMinions.Where( x => posFrom == Vector3.Zero || x.Position.Distance(posFrom) > distance) //Select all if posFrom is Vector3.Zero otherwise select .Select(minion => new MinionGameObject(minion))); break; case MinionType.Enemy: temp.AddRange( EntityManager.MinionsAndMonsters.EnemyMinions.Where( x => posFrom == Vector3.Zero || x.Position.Distance(posFrom) > distance) .Select(minion => new MinionGameObject(minion))); break; case MinionType.All: temp.AddRange( EntityManager.MinionsAndMonsters.AlliedMinions.Where( x => posFrom == Vector3.Zero || x.Position.Distance(posFrom) > distance) .Select(minion => new MinionGameObject(minion))); temp.AddRange( EntityManager.MinionsAndMonsters.EnemyMinions.Where( x => posFrom == Vector3.Zero || x.Position.Distance(posFrom) > distance) .Select(minion => new MinionGameObject(minion))); break; case MinionType.Debug: temp.AddRange(DebugPosistions.Select(x => new DebugGameObject(x))); break; case MinionType.Killable: temp.AddRange(Orbwalker.LaneClearMinionsList.Select(x => new MinionGameObject(x))); break; default: throw new ArgumentOutOfRangeException("MinionType", type, null); } return temp; }
public void CmdSingleSpawn(Vector3 position, MinionType minType) { SingleSpawn(position, minType); StartCoroutine(ClearOldMinions()); StartCoroutine(SetGridDirty()); }
public void CmdMultipleSpawn(Vector3 position, MinionType minType, int numMinions, float radius) { var container = new GameObject("Minion group"); container.transform.SetParent(minionContainer); List<Node> nodes = GridBehavior.Instance.getNodesNearPos(position, radius, node => !node.hasLight && node.canWalk) as List<Node>; nodes.Sort((a, b) => UnityEngine.Random.Range(-1, 2)); for (int n = 0; n < numMinions; n++) { SingleSpawn(nodes[n].position, minType, container.transform); } StartCoroutine(ClearOldMinions()); StartCoroutine(SetGridDirty()); }
//get will limits public void GetWillLimits(MinionType _type, out float _minVal,out float _maxVal) { //TODO: agregar bonuse de las estatuas _minVal=m_MinionsData[(int)_type].m_MinWill; _maxVal=m_MinionsData[(int)_type].m_MaxWill; }
private void SingleSpawn(Vector3 position, MinionType minType, Transform spawn = null) { spawn = spawn ?? minionContainer; GameObject robot; // Corrects any Z position that might be wrong. position.z = GridBehavior.Instance.getNodeAtPos(position).ZIndex; switch (minType) { case MinionType.Meelee: robot = Instantiate(EnemyPrefab[0], position, Quaternion.identity) as GameObject; break; case MinionType.AOEBomber: robot = Instantiate(EnemyPrefab[1], position, Quaternion.identity) as GameObject; break; case MinionType.Plant: // Prefab not completely done yet. // This is supposed to be on another managet (Poltergeist trap) but is here temporarily robot = Instantiate(EnemyPrefab[2], position, Quaternion.identity) as GameObject; break; default: robot = Instantiate(EnemyPrefab[0], position, Quaternion.identity) as GameObject; break; } robot.transform.SetParent(spawn); // PLants, as poltergeist trap, do not have a MinionController script. if (minType != MinionType.Plant) { robot.GetComponent<MinionController>().enabled = true; } NetworkServer.Spawn(robot); }
public static PoolManagerBase FindPool(MinionType type) { return GameObject.Find("Pool" + type.ToString()).GetComponent<PoolManagerBase>(); }
public void CmdSpawnUnit(MinionType _typeToSpawn) { Unit_ID.FindPlayer(_unit_ID.GetPlayerIndex()).GetComponent<SpawnerController>().spawnedCharacter = _typeToSpawn; }
void Awake() { MyType = GetComponent<MinionController>().Type; }
public float GetMoneyBonus(MinionType _type) { if (_type == MinionType.SonOfARitch||_type==MinionType.RARE) return m_SkillBars [1].GetBonus (); return 0; }
public float GetFaithBonus(MinionType _type) { if (_type == MinionType.Martir||_type==MinionType.RARE) return m_SkillBars [2].GetBonus (); return 0; }
public float GetWillBonus(MinionType _type) { if (_type == MinionType.Believer||_type==MinionType.RARE) return m_SkillBars [0].GetBonus (); return 0; }