Inheritance: MonoBehaviour
Example #1
0
    //increases fire rate, health, speed
    private IEnumerator Pickup(Collider2D player)
    {
        PlayerShooting shooting = player.GetComponent <PlayerShooting>();
        DamageHandler  damage   = player.GetComponent <DamageHandler>();
        PlayerMovement movement = player.GetComponent <PlayerMovement>();

        //increase fire rate and health
        shooting.fireDelay = shootDelay;
        damage.health     += puHealth;
        if (speed != 0)
        {
            movement.maxSpeed = speed;
        }

        //disable sprite renderer and collider so that the powerup can't interact with anything after its picked up, before it is destroyed
        GetComponent <SpriteRenderer>().enabled = false;
        GetComponent <Collider2D>().enabled     = false;

        yield return(new WaitForSeconds(2));

        Debug.Log("After delay");
        shooting.fireDelay = 0.25f;
        movement.maxSpeed  = 10f;

        //destroy powerup
        Destroy(gameObject);
    }
Example #2
0
        private void DoInit(string path)
        {
            Instance = this;
            //controlForm.Text = "Testing";
            PluginPath = path;

            // Load our settings
            PluginSettings.Instance.Load();

            // Setup process handlers
            _processHandlers = new List <ProcessHandlerBase>()
            {
                new ProcessProtectionZone(),
                new ProcessZoneBoundaries(),
                new ProcessExclusionZone(),
            };

            // Setup chat handlers
            _chatHandlers = new List <ChatHandlerBase>();

            _processThreads = new List <Thread>();
            _processThread  = new Thread(PluginProcessing);
            _processThread.Start();

            MyEntities.OnEntityAdd    -= OnEntityAdd;
            MyEntities.OnEntityAdd    += OnEntityAdd;
            MyEntities.OnEntityRemove -= OnEntityRemove;
            MyEntities.OnEntityRemove += OnEntityRemove;

            DamageHandler.Init();
            ProtectionMain.Instance.Init();
            Log.Info("Plugin '{0}' initialized. (Version: {1}  ID: {2})", Name, Version, Id);
        }
 /// <summary>
 /// Initializes the object
 /// </summary>
 /// <param name="damage">the damage</param>
 /// <param name="targetTag">the tag of the targeted characters</param>
 /// <param name="damageHandler">the delegate to call when the object damages something (optional)</param>
 public virtual void Initialize(float damage, string targetTag, DamageHandler damageHandler = null)
 {
     base.Initialize();
     this.damage = damage;
     this.targetTag = targetTag;
     this.damageHandler = damageHandler;
 }
Example #4
0
    void Update()
    {
        gamePause = PauseMenu.gameIsPaused;
        //Check if game is paused


        if (playerInstance == null)
        {
            respawnTimer -= Time.deltaTime;
            //Subtract time from respawn timer if player is dead

            if (respawnTimer <= 0 && numLives > 0)
            {
                SpawnPlayer();
                //Respawn player if lives remain and respawn timer ends
            }
        }

        damageHandler = playerInstance.GetComponent <DamageHandler>();
        //Get damagehandler from player

        currentHealth = damageHandler.health;
        //Get players current health

        //enemySpawner = GetComponent<EnemySpawner>();
        //Set up enemyspawner

        //currentEnemy = enemySpawner.currentEnemyCount;
        //Get current number of enemies
    }
Example #5
0
        public void InitHandler()   //初试化Handler
        {
            CreateGameHandler createGameHandler = new CreateGameHandler();

            handlerDictionary.Add(createGameHandler.opCode, createGameHandler);
            JoinGameHandler joinGameHandler = new JoinGameHandler();

            handlerDictionary.Add(joinGameHandler.opCode, joinGameHandler);
            TeamChooseHandler teamChooseHandler = new TeamChooseHandler();

            handlerDictionary.Add(teamChooseHandler.opCode, teamChooseHandler);
            SyncTransformHandler syncTransformHandler = new SyncTransformHandler();

            handlerDictionary.Add(syncTransformHandler.opCode, syncTransformHandler);
            DamageHandler damageHandler = new DamageHandler();

            handlerDictionary.Add(damageHandler.opCode, damageHandler);
            SyncDropWeaponHandler syncDropWeaponHandler = new SyncDropWeaponHandler();

            handlerDictionary.Add(syncDropWeaponHandler.opCode, syncDropWeaponHandler);
            DeleteDropWeaponHandler deleteDropWeaponHandler = new DeleteDropWeaponHandler();

            handlerDictionary.Add(deleteDropWeaponHandler.opCode, deleteDropWeaponHandler);
            RestartHandler restartHandler = new RestartHandler();

            handlerDictionary.Add(restartHandler.opCode, restartHandler);
        }
Example #6
0
    private void OnTriggerEnter2D(Collider2D collision)
    {
        //Игнор указанного лейра
        if (collision.gameObject.layer == LayerMask.NameToLayer(layerNameToIgnore))
        {
            return;
        }

        //Защита от нанесения урона сразу N противникам
        if (isHitted)
        {
            return;
        }
        isHitted = true;

        DamageHandler damageHandler = collision.gameObject.GetComponent <DamageHandler>();

        if (damageHandler != null)
        {
            damageHandler.HandleDamage(damage);
            playVFX();
            Destroy(gameObject);
        }
        else
        {
            playVFX();
            Destroy(gameObject);
        }
    }
Example #7
0
 internal static void OnLoad()
 {
     DefMenu = Load.UtliMenu.AddSubMenu("防守物品");
     DefMenu.AddGroupLabel("防守物品设置");
     DefMenu.Checkbox("Zhonyas", "使用中亚");
     DefMenu.Slider("Zhonyash", "血量为X时使用中亚", 35);
     DefMenu.Slider("Zhonyasn", "使用中亚如果预计受到的伤害多于[{0}%]", 50);
     DefMenu.AddSeparator();
     DefMenu.Checkbox("Seraph", "使用炽天使之拥");
     DefMenu.Slider("Seraphh", "血量为X时使用炽天使", 45);
     DefMenu.Slider("Seraphn", "使用炽天使如果预计受到的伤害多于[{0}%]", 45);
     DefMenu.AddSeparator();
     DefMenu.Checkbox("FaceOfTheMountain", "使用崇山圣盾");
     DefMenu.Slider("FaceOfTheMountainh", "血量为X时使用圣盾", 50);
     DefMenu.Slider("FaceOfTheMountainn", "使用圣盾如果预计受到的伤害多于[{0}%]", 50);
     DefMenu.AddSeparator();
     DefMenu.Checkbox("Solari", "使用钢铁烈阳之匣");
     DefMenu.Slider("Solarih", "血量为X时使用铁盒", 30);
     DefMenu.Slider("Solarin", "使用鸟盾如果预计受到的伤害多于 [{0}%]", 35);
     DefMenu.AddSeparator();
     DefMenu.Checkbox("Randuin", "使用兰顿之兆");
     DefMenu.Slider("Randuinh", "X名敌人时使用兰顿", 2, 1, 5);
     DefMenu.AddSeparator();
     DefMenu.AddGroupLabel("金身躲避");
     DefMenu.Checkbox("ZhonyasD", "躲避危险技能");
     DamageHandler.OnLoad();
     Zhonya.OnLoad();
     loaded = true;
 }
Example #8
0
    private static void HandleRegionDamage(GameSession session, SkillCast skillCast)
    {
        List <DamageHandler> damages = new();
        bool isCrit = DamageHandler.RollCrit(session.Player.Stats[StatId.CritRate].Total);

        foreach (IFieldActor <NpcMetadata> mob in session.FieldManager.State.Mobs.Values)
        {
            foreach (CoordF effectCoord in skillCast.EffectCoords)
            {
                if ((mob.Coord - effectCoord).Length() > skillCast.SkillAttack.RangeProperty.Distance)
                {
                    continue;
                }

                DamageHandler damage = DamageHandler.CalculateDamage(skillCast, session.Player.FieldPlayer, mob, isCrit);
                mob.Damage(damage, session);

                damages.Add(damage);
            }
        }

        if (damages.Count <= 0)
        {
            return;
        }

        session.FieldManager.BroadcastPacket(SkillDamagePacket.RegionDamage(skillCast, damages));
    }
 internal static void OnLoad()
 {
     DefMenu = Load.UtliMenu.AddSubMenu("Defence Items");
     DefMenu.AddGroupLabel("Savunma Ayarları");
     DefMenu.Checkbox("Zhonyas", "Kullan Zhonyas");
     DefMenu.Slider("Zhonyash", "Kullan Zhonyas canım şundan az [{0}%]", 35);
     DefMenu.Slider("Zhonyasn", "Kullan Zhonyas eğer daha fazla zarar geliyorsa [{0}%]", 50);
     DefMenu.AddSeparator();
     DefMenu.Checkbox("Seraph", "Kullan Seraph");
     DefMenu.Slider("Seraphh", "Kullan Seraph Canım şundan az [{0}%]", 45);
     DefMenu.Slider("Seraphn", "Kullan Seraph eğer daha fazla zarar geliyorsa [{0}%]", 45);
     DefMenu.AddSeparator();
     DefMenu.Checkbox("FaceOfTheMountain", "Kullan Dağın Sureti");
     DefMenu.Slider("FaceOfTheMountainh", "Kullan Dağın sureti için canım şundan az [{0}%]", 50);
     DefMenu.Slider("FaceOfTheMountainn", "Kullan Dağın eğer daha fazla zarar geliyorsa [{0}%]", 50);
     DefMenu.AddSeparator();
     DefMenu.Checkbox("Solari", "Kullan Solari");
     DefMenu.Slider("Solarih", "Kullan Solari can şundan azsa [{0}%]", 30);
     DefMenu.Slider("Solarin", "Kullan Solari eğer canımı şundan aşağı düşürecek hasar geliyorsa [{0}%]", 35);
     DefMenu.AddSeparator();
     DefMenu.Checkbox("Randuin", "Kullan Randuin (Omen)");
     DefMenu.Slider("Randuinh", "Kullan Randuin şu kadar düşmanda", 2, 1, 5);
     DefMenu.AddSeparator();
     DefMenu.AddGroupLabel("Zhonya tehlike seviyesi");
     DefMenu.Checkbox("ZhonyasD", "Tehlikeli büyülerde kullanma");
     DamageHandler.OnLoad();
     Zhonya.OnLoad();
     loaded = true;
 }
    private static void HandleRegionDamage(FieldManager field, SkillCast skillCast)
    {
        if (!field.State.Players.TryGetValue(skillCast.CasterObjectId, out Character caster))
        {
            // Handle NPCs/Triggers sending skills
            return;
        }

        List <DamageHandler> damages = new();

        foreach (IFieldActor <NpcMetadata> mob in field.State.Mobs.Values)
        {
            foreach (CoordF effectCoord in skillCast.EffectCoords)
            {
                if ((mob.Coord - effectCoord).Length() > skillCast.SkillAttack.RangeProperty.Distance)
                {
                    continue;
                }

                DamageHandler damage = DamageHandler.CalculateDamage(skillCast, caster, mob);
                mob.Damage(damage, caster.Value.Session);

                damages.Add(damage);
            }
        }

        if (damages.Count <= 0)
        {
            return;
        }

        field.BroadcastPacket(SkillDamagePacket.RegionDamage(skillCast, damages));
    }
Example #11
0
 private void InitializeDamageHandler()
 {
     if (Settings.UseImpactDamageHandler)
     {
         DamageHandler = new DamageHandler();
     }
 }
Example #12
0
    void addPoint()
    {
        DamageHandler sp = Pl.GetComponent <DamageHandler>();

        size    = sp.health;
        Hp.text = "Vida:  " + size + "%";
    }
Example #13
0
        public static Packet ApplyDamage(IFieldObject <Player> player, long skillSN, int unkValue, CoordF coords, List <IFieldObject <Mob> > mobs)
        {
            PacketWriter  pWriter   = PacketWriter.Of(SendOp.SKILL_DAMAGE);
            SkillCast     skillCast = SkillUsePacket.SkillCastMap[skillSN];
            DamageHandler damage    = DamageHandler.CalculateSkillDamage(skillCast);

            pWriter.WriteByte(1);
            pWriter.WriteLong(skillSN);
            pWriter.WriteInt(unkValue);
            pWriter.WriteInt(player.ObjectId);
            pWriter.WriteInt(player.ObjectId);
            pWriter.WriteInt(skillCast.SkillId);
            pWriter.WriteShort(skillCast.SkillLevel);
            // This values appears on some SkillsId, and others like BossSkill, sometimes is 0
            pWriter.WriteByte();                 // The value is not always 0
            pWriter.WriteByte();                 // The value is not always 0, also seems to crash if its not a correct value
            pWriter.Write(coords.ToShort());
            pWriter.Write(CoordS.From(0, 0, 0)); // Position of the image effect of the skillUse, seems to be rotation (0, 0, rotation).
            // TODO: Check if is a player or mob
            pWriter.WriteByte((byte)mobs.Count);
            for (int i = 0; i < mobs.Count; i++)
            {
                pWriter.WriteInt(mobs[i].ObjectId);
                pWriter.WriteByte((byte)damage.GetDamage() > 0 ? 1 : 0);
                pWriter.WriteBool(damage.IsCritical());
                if (damage.GetDamage() != 0)
                {
                    pWriter.WriteLong(-1 * (long)damage.GetDamage());
                }
            }

            return(pWriter);
        }
        public static void Init()
        {
            try
            {
                MenuIni = MainMenu.AddMenu("KappActivator", "KappActivator");
                MenuIni.CreateCheckBox("Champ", "Load Only Activator", false);
                DamageHandler = MenuIni.AddSubMenu("DamageHandler");
                DamageHandler.CreateCheckBox("Minions", "Detect Minions Damage", false);
                DamageHandler.CreateCheckBox("Heros", "Detect Heros Damage");
                DamageHandler.CreateCheckBox("Turrets", "Detect Turrets Damage");
                DamageHandler.CreateCheckBox("Minion", "Detect Minions Damage");
                DamageHandler.CreateCheckBox("Skillshots", "Detect Skillshots Damage");
                DamageHandler.CreateCheckBox("Targetedspells", "Detect Targetedspells Damage");
                DamageHandler.CreateSlider("Mod", "InComing Damage Modifier {0}%", 100, 0, 200);

                Items.Potions.Init();
                Cleanse.Qss.Init();
                Summoners.Init();
                Items.Offence.Init();
                Items.Defence.Init();
            }
            catch (Exception ex)
            {
                Logger.Send("Activator Load Error While Init", ex, Logger.LogLevel.Error);
            }
        }
Example #15
0
    public virtual void Init()
    {
        thisTransform = this.transform;
        teamHandler   = GameObject.FindGameObjectWithTag("TeamHandler").GetComponent <TeamHandler>();
        damageHandler = GameObject.FindGameObjectWithTag("DamageHandler").GetComponent <DamageHandler>();
        normalColor   = spellButtons[0].image.color;

        playerTeam       = teamHandler.playerTeam;
        playerLayerMask  = LayerMask.NameToLayer("Nothing");
        playerLayerMask  = ~playerLayerMask;
        playerLayerMask |= (1 << LayerMask.NameToLayer(playerTeam));
        playerLayer      = LayerMask.NameToLayer(playerTeam);

        potDoubleClick   = false;
        doubleClickTimer = 0.0f;

        Cursor.SetCursor(moveCursor, hotspot, cursorMode);

        for (int i = 0; i < groundMarkerPoolSize; i++)
        {
            GameObject temp = GameObject.Instantiate(groundMarkerObject.gameObject);
            temp.SetActive(false);
            groundMarkerPool.Add(temp.transform);
        }
        currTargetGroupIndex = 0;
        InitSpellUI();
        //selMask = selectLayerMask.value;
    }
Example #16
0
    void OnTriggerEnter2D(Collider2D colInfo)
    {
        //Explosion Sound
        AudioManager.instance.Play("Slap");

        //Create an impact effect like an explosion
        if (impactEffect != null)
        {
            Instantiate(impactEffect, transform.position, Quaternion.identity);
        }

        //Look for a DamageHandler script in object collided
        DamageHandler dh = colInfo.GetComponent <DamageHandler>();

        //Make sure target has a DamageHandler script, and if so then inflict damage.
        if (dh != null)
        {
            dh.TakeDamage(damageToPlayer, damageToProps);
        }

        //get rigidbody and add a repulsive force
        rb = colInfo.transform.GetComponent <Rigidbody2D>();
        if (rb != null)
        {
            rb.AddForce(transform.up * upForce);
            rb.AddForce(transform.right * impactForce);
        }

        Destroy(gameObject);
    }
Example #17
0
 internal static void OnLoad()
 {
     DefMenu = Load.UtliMenu.AddSubMenu("Defence Items");
     DefMenu.AddGroupLabel("Defence Settings");
     DefMenu.Checkbox("Zhonyas", "Use Zhonyas");
     DefMenu.Slider("Zhonyash", "Use Zhonyas health [{0}%]", 35);
     DefMenu.Slider("Zhonyasn", "Use Zhonyas if incoming Damage more than [{0}%]", 50);
     DefMenu.AddSeparator();
     DefMenu.Checkbox("Seraph", "Use Seraph");
     DefMenu.Slider("Seraphh", "Use Seraph health [{0}%]", 45);
     DefMenu.Slider("Seraphn", "Use Seraph if incoming Damage more than [{0}%]", 45);
     DefMenu.AddSeparator();
     DefMenu.Checkbox("FaceOfTheMountain", "Use Face Of The Mountain");
     DefMenu.Slider("FaceOfTheMountainh", "Use FOTM health [{0}%]", 50);
     DefMenu.Slider("FaceOfTheMountainn", "Use FOTM if incoming Damage more than [{0}%]", 50);
     DefMenu.AddSeparator();
     DefMenu.Checkbox("Solari", "Use Solari");
     DefMenu.Slider("Solarih", "Use Solari health [{0}%]", 30);
     DefMenu.Slider("Solarin", "Use Solari if incoming Damage more than [{0}%]", 35);
     DefMenu.AddSeparator();
     DefMenu.Checkbox("Randuin", "Use Randuin (Omen)");
     DefMenu.Slider("Randuinh", "Use Randuin On [{0}] Enemies", 2, 1, 5);
     DefMenu.AddSeparator();
     DefMenu.AddGroupLabel("Zhonya Danger Spells");
     DefMenu.Checkbox("ZhonyasD", "Deny Dangers Spells");
     DamageHandler.OnLoad();
     Zhonya.OnLoad();
     loaded = true;
 }
Example #18
0
 // Use this for initialization
 void Start()
 {
     timer  = 90;
     player = Player.GetComponent <DamageHandler>();
     enemy  = Enemy.GetComponent <EnemyDamageHandler>();
     StartCoroutine("LoseTime");
 }
Example #19
0
        public void Damage(float damage)
        {
            var stat = _stats[StatsId.LIFE_ID];

            stat.AddValue(damage);
            DamageHandler?.Invoke((int)damage);
        }
Example #20
0
    void OnTriggerEnter2D(Collider2D colInfo)
    {
        //Debug.Log("Water Touched!");
        if (colInfo.transform.tag == "Player")
        {
            AudioManager.instance.Play("Drowning");
        }
        //get rigidbody
        Rigidbody2D rb = colInfo.attachedRigidbody;

        if (rb != null)
        {
            rb.gravityScale = 0.1f;
            rb.velocity     = new Vector2(rb.velocity.x, rb.velocity.y) / 10;
        }

        //Look for a DamageHandler script in object collided
        DamageHandler target = colInfo.GetComponent <DamageHandler>();

        //Make sure target has a DamageHandler script, and if so then inflict damage.
        if (target != null)
        {
            target.TakeDamage(Damage, Damage);
        }

        //Create an impact effect like an explosion
        if (drowningEffect != null)
        {
            Instantiate(drowningEffect, transform.position, Quaternion.identity);
        }
    }
Example #21
0
        /// <summary>
        /// Initializes a new instance of the <see cref="DiedEventArgs"/> class.
        /// </summary>
        /// <param name="target"><inheritdoc cref="Target"/></param>
        /// <param name="damageHandler"><inheritdoc cref="DamageHandler"/></param>
        public DiedEventArgs(Player target, DamageHandlerBase damageHandler)
        {
            Killer = damageHandler is AttackerDamageHandler attackerDamageHandler?Player.Get(attackerDamageHandler.Attacker.Hub) : null;

            Target  = target;
            Handler = new DamageHandler(target, damageHandler);
        }
Example #22
0
 public static Vector3 FindSpawnPosition(Player ply, DamageHandler info)
 {
     if (ply.Role == RoleType.Scp106 && info.Type == DamageType.Recontainment)
     {
         if (PlayerMovementSync.FindSafePosition(ply.Position, out Vector3 safePos))
         {
             return(safePos);
         }
         else
         {
             return(ply.Position + new Vector3(0, 5, 0));
         }
     }
     else if (ply.CurrentRoom.Type == RoomType.Pocket)
     {
         return(new Vector3(0, -1998.67f, 2));
     }
     else if (ply.Role == RoleType.Spectator || ply.Role == RoleType.None)
     {
         return(new Vector3(0, 1001, 8));
     }
     else
     {
         return(ply.Position);
     }
 }
Example #23
0
    private void Snap()
    {
        transform.parent = null;
        foreach (GameObject player in GM.teams)
        {
            if (player == null)
            {
                continue;
            }
            if (teamID == player.GetComponent <PlayerSettings>().teamID)
            {
                //No damage to teamates
                continue;
            }

            dh = player.GetComponent <DamageHandler>();
            if (dh != null)
            {
                dh.TakeDamage(damageToPlayer, damageToProps, playerPercentHealthReduction, propsPercentHealthReduction);
            }
        }

        //Kill player that Snapped
        if (GM.teams[teamID, ID] != null)
        {
            dh = GM.teams[teamID, ID].GetComponent <DamageHandler>();
            if (dh != null)
            {
                dh.TakeDamage(9999, 0, 100, 0);
            }
        }
        gameObject.GetComponent <Rigidbody2D>().constraints = RigidbodyConstraints2D.None;
        Invoke("PlayDuel", 3f);
        Destroy(gameObject, 3f);
    }
Example #24
0
 private void Awake()
 {
     getBarInfo    = FindObjectOfType <GetBarInfo>();
     turnSystem    = FindObjectOfType <TurnSystem>();
     damageHandler = FindObjectOfType <DamageHandler>();
     gridGenerator = FindObjectOfType <EditedGridGenerator>();
 }
Example #25
0
        /// <summary>
        /// 初始化处理句柄
        /// </summary>
        public void InitHnadler()
        {
            LoginHandler loginHandler = new LoginHandler();

            dict_Handler.Add(loginHandler.opCode, loginHandler);

            DefaultHandler defaultHandler = new DefaultHandler();

            dict_Handler.Add(defaultHandler.opCode, defaultHandler);

            SyncPositionHandler syncPositionHandler = new SyncPositionHandler();

            dict_Handler.Add(syncPositionHandler.opCode, syncPositionHandler);

            SyncPlayerHandler syncPlayerHandler = new SyncPlayerHandler();

            dict_Handler.Add(syncPlayerHandler.opCode, syncPlayerHandler);

            DamageHandler damageHandler = new DamageHandler();

            dict_Handler.Add(damageHandler.opCode, damageHandler);

            SkillHandler skillHandler = new SkillHandler();

            dict_Handler.Add(skillHandler.opCode, skillHandler);
        }
Example #26
0
    private void OnCollisionEnter2D(Collision2D other)
    {
        //Check if tag match to target
        if (other.transform.tag == "Player")
        {
            Transform otherTransform = other.transform;

            //get Damage Handler component
            DamageHandler dh = otherTransform.GetComponent <DamageHandler>();
            if (dh != null)
            {
                //pass negative damage to heal
                dh.TakeDamage(damage, 0);

                if (gameObject.transform.position.x > otherTransform.position.x)
                {
                    direction = new Vector3(-1, 0, 0);
                }
                else
                {
                    direction = new Vector3(1, 0, 0);
                }

                Rigidbody2D rb = otherTransform.GetComponent <Rigidbody2D>();
                if (rb != null)
                {
                    //rb.velocity = new Vector3(0, 0, 0);
                    rb.AddForce(direction * pushBackForceTurn);
                }
            }
        }
    }
            private void Drawing_OnDraw(EventArgs args)
            {
                if (!Program.DrawMenu["draw.Damage"].Cast <CheckBox>().CurrentValue)
                {
                    return;
                }

                foreach (var aiHeroClient in EntityManager.Heroes.Enemies)
                {
                    if (!aiHeroClient.IsHPBarRendered)
                    {
                        continue;
                    }

                    var pos = new Vector2(aiHeroClient.HPBarPosition.X + _xOffset,
                                          aiHeroClient.HPBarPosition.Y + _yOffset);

                    var fullbar = (_barLength) * (aiHeroClient.HealthPercent / 100);
                    var damage  = (_barLength) *
                                  ((DamageHandler.ComboDamage(aiHeroClient) / aiHeroClient.MaxHealth) > 1
                                         ? 1
                                         : (DamageHandler.ComboDamage(aiHeroClient) / aiHeroClient.MaxHealth));
                    Line.DrawLine(Color.FromArgb(100, Color.Aqua), 9f, new Vector2(pos.X, pos.Y),
                                  new Vector2((float)(pos.X + (damage > fullbar ? fullbar : damage)), pos.Y));
                    Line.DrawLine(Color.Black, 3, new Vector2((float)(pos.X + (damage > fullbar ? fullbar : damage) + 1), pos.Y - 4), new Vector2((float)(pos.X + (damage > fullbar ? fullbar : damage) + 1), pos.Y + 5));
                }
            }
Example #28
0
 private void HitToDamage(DamageHandler damageHandler)
 {
     health -= damageHandler.GetPlayerDamage();
     if (health < 1)
     {
         Destruction();
     }
 }
Example #29
0
        /// <summary>
        /// Initializes a new instance of the <see cref="DyingEventArgs"/> class.
        /// </summary>
        /// <param name="target"><inheritdoc cref="Target"/></param>
        /// <param name="damageHandler"><inheritdoc cref="DamageHandler"/></param>
        public DyingEventArgs(Player target, DamageHandlerBase damageHandler)
        {
            ItemsToDrop = new List <Item>(target.Items.ToList());
            Killer      = damageHandler is AttackerDamageHandler attackerDamageHandler?Player.Get(attackerDamageHandler.Attacker.Hub) : null;

            Target  = target;
            Handler = new DamageHandler(target, damageHandler);
        }
Example #30
0
    public void SetTile(int x, int y, TileType type)
    {
        if (x <= 1 || x >= mWidth - 2 || y <= 1 || y >= mHeight - 2)
        {
            return;
        }

        tiles[x, y] = type;

        if (type == TileType.Block)
        {
            tilesSprites[x, y] = Instantiate <SpriteRenderer>(tilePrefab);
            tilesSprites[x, y].transform.parent   = transform;
            tilesSprites[x, y].gameObject.layer   = 8;
            tilesSprites[x, y].transform.position = position + new Vector3(cTileSize * x, cTileSize * y, 10.0f);
            DamageHandler damage = tilesSprites[x, y].gameObject.GetComponent <DamageHandler>();
            damage.x       = x;
            damage.y       = y;
            damage.mapdata = this;

            ClickableTile clickedthis = tilesSprites[x, y].gameObject.GetComponent <ClickableTile>();
            clickedthis.TileX = x;
            clickedthis.TileY = y;

            mGrid[x, y] = 0;
            AutoTile(type, x, y);
            tilesSprites[x, y].enabled = true;
        }
        else if (type == TileType.OneWay)
        {
            tilesSprites[x, y] = Instantiate <SpriteRenderer>(tilePrefab);
            tilesSprites[x, y].transform.parent   = transform;
            tilesSprites[x, y].gameObject.layer   = 8;
            tilesSprites[x, y].transform.position = position + new Vector3(cTileSize * x, cTileSize * y, 10.0f);

            DamageHandler damage = tilesSprites[x, y].gameObject.GetComponent <DamageHandler>();
            damage.x       = x;
            damage.y       = y;
            damage.mapdata = this;

            mGrid[x, y] = 1;
            tilesSprites[x, y].enabled = true;

            tilesSprites[x, y].transform.localScale  = new Vector3(1.0f, 1.0f, 1.0f);
            tilesSprites[x, y].transform.eulerAngles = new Vector3(0.0f, 0.0f, 0.0f);
            tilesSprites[x, y].sprite = mDirtSprites[2];
        }
        else
        {
            mGrid[x, y] = 1;
        }

        AutoTile(type, x - 1, y);
        AutoTile(type, x + 1, y);
        AutoTile(type, x, y - 1);
        AutoTile(type, x, y + 1);
    }
Example #31
0
    // Start is called before the first frame update
    void Start()
    {
        renderer         = transform.parent.GetComponentInChildren <MeshRenderer>();
        canReceiveDamage = true;

        currentHP = maxHP;
        OnDamage += (() => DamageEffect());
        OnDamage += (() => StartCoroutine("Invincibility"));
    }
 /// <summary>
 /// Initializes the projectile
 /// </summary>
 /// <param name="targetTag">the tag of the targeted characters</param>
 /// <param name="damage">the projectile's damage</param>
 /// <param name="moveSpeed">the projectile's movement speed</param>
 /// <param name="damageHandler">the delegate to call when the object damages something (optional)</param>
 protected virtual void Initialize(string targetTag, float damage, float moveSpeed, DamageHandler damageHandler = null)
 {
     base.Initialize(damage, targetTag, damageHandler);
     this.moveSpeed = moveSpeed;
     lifeTimer = new Timer(0);
     if (moveSpeed > 0)
     {
         rbody.velocity = new Vector2(moveSpeed, 0);
         lifeTimer.TotalSeconds = Constants.PROJ_MAX_DIST / moveSpeed;
         lifeTimer.Register(LifeTimerFinished);
         lifeTimer.Start();
     }
 }
        public static void DealDamage(Targetable sender, List<Targetable> receivers, int damageAmount, DamageType damageType)
        {
            foreach (Targetable receiver in receivers)
            {
                int damageModifiers = 0;
                if (damageDealtHandlers.Count != 0)
                {
                    DamageHandler[] dummyDamageHandlers = new DamageHandler[damageDealtHandlers.Count];
                    damageDealtHandlers.CopyTo(dummyDamageHandlers);
                    foreach (DamageHandler dmgHand in dummyDamageHandlers)
                    {
                        damageModifiers += dmgHand(sender, receiver, ref damageAmount, damageType);

                        if (damageAmount == 0){ //meaning the user is immune
                            damageModifiers = 0; //could add another pointer param for invincible in dmgHand
                            break;
                        }
                    }
                }
                if (damageModifiers + damageAmount > receiver.maxHealth)
                    receiver.lifeTotal = receiver.maxHealth;
                else
                    receiver.lifeTotal -= damageModifiers + damageAmount;
            }

            /*
            if (heroes != null)
            {
                foreach (Hero hero in heroes)
                {
                    hero.lifeTotal -= damageModifiers + damageAmount;
                    Console.WriteLine(hero.lifeTotal);
                }
            }
            if (villain != null)
            {
                villain.lifeTotal -= damageModifiers + damageAmount;
                Console.WriteLine(villain.lifeTotal);
            }
            if (minions != null)
            {
                foreach (Minion minion in minions)
                {
                    minion.lifeTotal -= damageModifiers + damageAmount;
                    Console.WriteLine(minion.lifeTotal);
                }
            }
            */
        }
 /// <summary>
 /// Initializes the projectile
 /// </summary>
 /// <param name="fromPosition">the position of the projectile</param>
 /// <param name="toPosition">the target position</param>
 /// <param name="targetTag">the tag of the targeted characters</param>
 /// <param name="damage">the projectile's damage</param>
 /// <param name="moveSpeed">the projectile's movement speed</param>
 /// <param name="damageHandler">the delegate to call when the object damages something (optional)</param>
 public virtual void Initialize(Vector2 fromPosition, Vector2 toPosition, string targetTag, float damage, float moveSpeed, DamageHandler damageHandler = null)
 {
     Initialize(targetTag, damage, moveSpeed, damageHandler);
     SetLocationAndDirection(fromPosition, toPosition);
 }
    void Start()
    {
        // MAKES SURE THERE IS A RIGIDBODY
        rb = GetComponent<Rigidbody>();
        if (rb == null) {
            gameObject.SetActive(false);
            if (showDebugMessages) {
                Debug.Log("NO RIGIDBODY ON: " + name + ". IT WAS DEACTIVATED.");
            }
        }

        // FINDS WHERE THE SHIP IS
        if (findTargetAutomatically) {
            target = ShipVisibility.GetShip().transform;
            playerDamageHandler = target.gameObject.GetComponent<DamageHandler>();
        }

        // CHECKS FOR PATROL REQUIREMENTS
        if (allowedToPatrol) {
            if (initialPatrolPoint == null) {
                allowedToPatrol = false;
                if (showDebugMessages) {
                    Debug.Log(name + " WAS SET TO PATROL, BUT HAD NO INITIAL PATROL POINT; PATROL TURNED OFF");
                }
            } else {
                currPatrolpoint = initialPatrolPoint;
                patrolForward = true;
            }
        }

        // CHECKS FOR WANDER REQUIREMENTS
        if (allowedToWander) {
            if (wanderpoints.Length == 0) {
                useWanderpoints = false;
            } else {
                useWanderpoints = true;

                wanderpointList = new List<Transform>();
                foreach (Transform w in wanderpoints) {
                    wanderpointList.Add(w);
                }
            }
        }

        // SETS UP OTHER VARIABLES
        headToPlayer = false;
        headToWaypoint = false;
        chasing = false; chased = false;

        // BEGINS LOOKING FOR THINGS
        StartCoroutine(LookForTarget());
    }
 /// <summary>
 /// Initializes the projectile
 /// </summary>
 /// <param name="position">the position of the projectile</param>
 /// <param name="angle">the angle, in degrees</param>
 /// <param name="targetTag">the tag of the targeted characters</param>
 /// <param name="damage">the projectile's damage</param>
 /// <param name="moveSpeed">the projectile's movement speed</param>
 /// <param name="damageHandler">the delegate to call when the object damages something (optional)</param>
 public virtual void Initialize(Vector2 position, float angle, string targetTag, float damage, float moveSpeed, DamageHandler damageHandler = null)
 {
     Initialize(targetTag, damage, moveSpeed, damageHandler);
     SetLocationAndDirection(position, angle);
 }
 /// <summary>
 /// Fires a projectile attack straight forward from the character
 /// </summary>
 /// <param name="prefab">the projectile prefab</param>
 /// <param name="energyCost">the energy cost of the attack</param>
 /// <param name="cooldown">the cooldown timer to start</param>
 /// <param name="damage">the projectile's damage</param>
 /// <param name="projSpeed">the projectile's movement speed</param>
 /// <returns>the projectile, if one was fired</returns>
 protected virtual ProjScript FireStraightProjectileAttack(GameObject prefab, float energyCost, Timer cooldown, float damage, 
     float projSpeed, DamageHandler damageHandler = null)
 {
     ProjScript projectile = FireProjectileAttack(prefab, energyCost, cooldown);
     if (projectile != null)
     { projectile.Initialize(FireLocation, ArmAngle, targetTag, damage, projSpeed, damageHandler); }
     return projectile;
 }
 /// <summary>
 /// Initializes the object
 /// </summary>
 /// <param name="damage">the damage</param>
 /// <param name="targetTag">the tag of the targeted characters</param>
 /// <param name="damageHandler">the delegate to call when the object damages something (optional)</param>
 public override void Initialize(float damage, string targetTag, DamageHandler damageHandler = null)
 {
     base.Initialize(damage, targetTag, damageHandler);
     boxCollider = GetComponent<BoxCollider2D>();
 }