Exemplo n.º 1
0
        public void PaintWorld(WorldLayer layer)
        {
            if (layer != WorldLayer.Ground)
            {
                return;
            }

            var packs = Hud.Game.MonsterPacks;

            if (!packs.Any())
            {
                return;
            }

            var padding = 6.0f * Hud.Window.Size.Height / 1200f;

            var maxHealth       = packs.Max(pack => pack.MonstersAlive.Any() ? pack.MonstersAlive.Max(monster => monster.MaxHealth) : 0);
            var middleBarHeight = Hud.Window.Size.Height * MiddleHealthBarHeight;
            var middleBarWidth  = Hud.Window.Size.Width * MiddleHealthBarWidth;

            foreach (var pack in packs)
            {
                var alive = !HideOnIllusions?pack.MonstersAlive.ToList() : pack.MonstersAlive.Where(x => (x.SummonerAcdDynamicId == 0) || (x.Rarity != ActorRarity.RareMinion)).ToList();

                if (alive.Count == 0)
                {
                    continue;
                }

                alive.Sort((a, b) =>
                {
                    var r = a.Rarity.CompareTo(b.Rarity);
                    if (r == 0)
                    {
                        r = -a.MaxHealth.CompareTo(b.MaxHealth);
                    }
                    return(r);
                });

                var center = Hud.Window.CreateWorldCoordinate(0, 0, 0);

                var n = 0;
                if (alive.Any(x => x.FloorCoordinate.IsOnScreen()))
                {
                    foreach (var monster in alive.Where(x => x.FloorCoordinate.IsOnScreen()))
                    {
                        center.Add(monster.FloorCoordinate);
                        n++;
                    }
                }
                else
                {
                    foreach (var monster in alive)
                    {
                        center.Add(monster.FloorCoordinate);
                        n++;
                    }
                }
                center.Set(center.X / n, center.Y / n, center.Z / n);

                var centerScreenCoordinate = center.ToScreenCoordinate(false);

                var y = centerScreenCoordinate.Y;

                if (pack.IsFullChampionPack)
                {
                    if (ChampionPackLineBrush != null && (alive.Count > 1))
                    {
                        PaintFloorLines(alive, ChampionPackLineBrush);
                    }
                    if (ChampionPackNameFont != null)
                    {
                        var layout = ChampionPackNameFont.GetTextLayout(pack.LeadSnoMonster.NameLocalized);
                        ChampionPackNameFont.DrawText(layout, centerScreenCoordinate.X - layout.Metrics.Width / 2, y);
                        y += layout.Metrics.Height + padding;
                    }
                }
                else
                {
                    if (RarePackLineBrush != null && (alive.Count > 1))
                    {
                        PaintFloorLines(alive, RarePackLineBrush);
                    }
                    if (RarePackNameFont != null)
                    {
                        var layout = RarePackNameFont.GetTextLayout(pack.LeadSnoMonster.NameLocalized);
                        RarePackNameFont.DrawText(layout, centerScreenCoordinate.X - layout.Metrics.Width / 2, y);
                        y += layout.Metrics.Height + padding;
                    }
                }

                var decoHeight = 0.0f;

                var snoMonsterAffixList = pack.AffixSnoList.ToList();
                snoMonsterAffixList.Sort((a, b) => - Priorities[a.Affix].CompareTo(Priorities[b.Affix]));

                foreach (var snoMonsterAffix in snoMonsterAffixList)
                {
                    GroundLabelDecorator decorator;
                    if (!AffixDecorators.TryGetValue(snoMonsterAffix.Affix, out decorator))
                    {
                        continue;
                    }

                    string affixName = null;
                    if (CustomAffixNames.ContainsKey(snoMonsterAffix.Affix))
                    {
                        affixName = CustomAffixNames[snoMonsterAffix.Affix];
                    }
                    else
                    {
                        affixName = snoMonsterAffix.NameLocalized;
                    }

                    if (decoHeight == 0.0f)
                    {
                        decoHeight = decorator.TextFont.GetTextLayout(affixName).Metrics.Height * 1.2f;
                    }

                    decorator.OffsetY = y - centerScreenCoordinate.Y;

                    decorator.Paint(null, center, affixName);
                }

                y += decoHeight + padding / 2;

                foreach (var monster in alive)
                {
                    var curW = (float)(middleBarWidth / maxHealth * monster.CurHealth);
                    var maxW = (float)(middleBarWidth / maxHealth * monster.MaxHealth);

                    HealthBackgroundMax.DrawRectangleGridFit(centerScreenCoordinate.X - maxW / 2, y, maxW, middleBarHeight);
                    switch (monster.Rarity)
                    {
                    case ActorRarity.Champion:
                        HealthBackgroundChampionRemaining.DrawRectangleGridFit(centerScreenCoordinate.X - maxW / 2, y, curW, middleBarHeight);
                        break;

                    case ActorRarity.Rare:
                        HealthBackgroundRareRemaining.DrawRectangleGridFit(centerScreenCoordinate.X - maxW / 2, y, curW, middleBarHeight);
                        break;

                    case ActorRarity.RareMinion:
                        HealthBackgroundRareMinionRemaining.DrawRectangleGridFit(centerScreenCoordinate.X - maxW / 2, y, curW, middleBarHeight);
                        break;
                    }

                    HealthBorder.DrawRectangleGridFit(centerScreenCoordinate.X - maxW / 2, y, maxW, middleBarHeight);

                    y += middleBarHeight;
                }
            }
        }
Exemplo n.º 2
0
	//JUSTIN

	// Use this for initialization
	void Start()
	{
		scoreHandle = GameObject.Find("Score").GetComponent<Score>();	//JUSTIN

		loadout = GameObject.FindGameObjectWithTag ("SaveManager").GetComponent<SavedGameManager> ().getCurrentGame ().getCurrentLoadout ();
		shrinkCollider = GetComponent<CircleCollider2D>(); 
		setLoadout ();

		hitCool = false;
		dead = false;

		//determines chassis health type
		if (chassisExterminator || chassisBooster || chassisShrink) {
			health = 3;
		} 
		else if (chassisQuick)
		{
			health = 2;
		} 
		else if (chassisFinal)
		{
			if((SceneIndex)SceneManager.GetActiveScene().buildIndex == SceneIndex.GAMEPLAY_4_2)
			{
				health = 5;
			}
			else
			{
				health = 1;
			}
		}

		//determines chassis movement speed type
		if (chassisExterminator || chassisFinal)
		{
			moveSpeed = 10f;
			precisionSpeed = 6f;
		} 
		else if (chassisBooster)
		{
			moveSpeed = 8f;
			precisionSpeed = 14f;
		} 
		else if (chassisShrink) 
		{
			moveSpeed = 6f;
			precisionSpeed = 4f;
		} 
		else if (chassisQuick)
		{
			moveSpeed = 12f;
			precisionSpeed = 8f;
		}



		hBorder = GameObject.FindGameObjectWithTag ("Border").GetComponent<HealthBorder> ();
		sf = GameObject.Find ("ScreenFade").GetComponent<ScreenFade> ();	
		hBorder.health = health;
		if (health == 5) {
			hBorder.fiveHealth = true;
		}
	}