private void UpdateStats(float percentage)
 {
     healthPool.onDamaged -= OnDamage;
     //
     curLayer = StatLayer.Lerp(minRollLayer, maxRollLayer, percentage);
     statKeeper.selfStats.addLayer(PV.ViewID, curLayer);
     //
     healthPool.onDamaged += OnDamage;
 }
示例#2
0
    /// <summary>
    ///
    /// </summary>
    /// <param name="minLayer"></param>
    /// <param name="maxLayer"></param>
    /// <param name="percentage">A value between 0 and 1. 0: minLayer, 0.5: in between, 1: maxLayer</param>
    /// <returns></returns>
    public static StatLayer Lerp(StatLayer minLayer, StatLayer maxLayer, float percentage)
    {
        StatLayer layer = new StatLayer();

        layer.moveSpeed = LerpStat(minLayer.moveSpeed, maxLayer.moveSpeed, percentage);
        layer.maxHits   = LerpStat(minLayer.maxHits, maxLayer.maxHits, percentage);
        layer.fireRate  = LerpStat(minLayer.fireRate, maxLayer.fireRate, percentage);
        layer.damage    = LerpStat(minLayer.damage, maxLayer.damage, percentage);
        layer.size      = LerpStat(minLayer.size, maxLayer.size, percentage);
        return(layer);
    }
示例#3
0
    public StatLayer Add(StatLayer addend)
    {
        StatLayer layer = new StatLayer();

        layer.moveSpeed = AddStat(this.moveSpeed, addend.moveSpeed);
        layer.maxHits   = AddStat(this.maxHits, addend.maxHits);
        layer.fireRate  = AddStat(this.fireRate, addend.fireRate);
        layer.damage    = AddStat(this.damage, addend.damage);
        layer.size      = AddStat(this.size, addend.size);
        return(layer);
    }
示例#4
0
    public StatLayer Multiply(StatLayer multiplier)
    {
        StatLayer layer = new StatLayer();

        layer.moveSpeed = MultiplyStat(this.moveSpeed, multiplier.moveSpeed);
        layer.maxHits   = MultiplyStat(this.maxHits, multiplier.maxHits);
        layer.fireRate  = MultiplyStat(this.fireRate, multiplier.fireRate);
        layer.damage    = MultiplyStat(this.damage, multiplier.damage);
        layer.size      = MultiplyStat(this.size, multiplier.size);
        return(layer);
    }
示例#5
0
    //TODO: Potentially remove this method and refactor the thing that uses it
    public StatLayer Charge(float multiplier, StatLayer percentage)
    {
        StatLayer layer = new StatLayer();

        layer.moveSpeed = ChargeStat(this.moveSpeed, multiplier, percentage.moveSpeed);
        layer.maxHits   = ChargeStat(this.maxHits, multiplier, percentage.maxHits);
        layer.fireRate  = ChargeStat(this.fireRate, multiplier, percentage.fireRate);
        layer.damage    = ChargeStat(this.damage, multiplier, percentage.damage);
        layer.size      = ChargeStat(this.size, multiplier, percentage.size);
        return(layer);
    }
示例#6
0
    public StatLayer Add(float addend)
    {
        if (addend == 0)
        {
            throw new ArgumentException($"addend is 0! {addend}");
        }
        StatLayer layer = new StatLayer();

        layer.moveSpeed = AddStat(this.moveSpeed, addend);
        layer.maxHits   = AddStat(this.maxHits, addend);
        layer.fireRate  = AddStat(this.fireRate, addend);
        layer.damage    = AddStat(this.damage, addend);
        layer.size      = AddStat(this.size, addend);
        return(layer);
    }
示例#7
0
    public StatLayer Multiply(float multiplier)
    {
        if (multiplier < 0)
        {
            throw new ArgumentException($"multiplier is less than 0! {multiplier}");
        }
        StatLayer layer = new StatLayer();

        layer.moveSpeed = MultiplyStat(this.moveSpeed, multiplier);
        layer.maxHits   = MultiplyStat(this.maxHits, multiplier);
        layer.fireRate  = MultiplyStat(this.fireRate, multiplier);
        layer.damage    = MultiplyStat(this.damage, multiplier);
        layer.size      = MultiplyStat(this.size, multiplier);
        return(layer);
    }
示例#8
0
    void explode()
    {
        List <Rigidbody2D> rb2ds = new List <Rigidbody2D>();

        RaycastHit2D[] rch2ds = Physics2D.CircleCastAll(transform.position, explodeRange, Vector2.zero);
        for (int i = 0; i < rch2ds.Length; i++)
        {
            Rigidbody2D rb2d = rch2ds[i].rigidbody;
            if (!rb2d)
            {
                continue;
            }
            if (!rb2ds.Contains(rb2d))
            {
                rb2ds.Add(rb2d);
            }
        }
        foreach (Rigidbody2D rb2d in rb2ds)
        {
            HealthPool hp = rb2d.gameObject.FindComponent <HealthPool>();
            if (hp && entityTypes.Contains(hp.entityType))
            {
                Vector2 explodeDir    = (rb2d.transform.position - transform.position).normalized;
                Vector2 explodeVector = explodeDir * explodePower;
                rb2d.velocity = explodeVector;
                //PlayerMovement
                PlayerMovement playerMovement = rb2d.gameObject.FindComponent <PlayerMovement>();
                if (playerMovement)
                {
                    //TODO: refactor this once MovementLayer has been implemented
                    float speed = explodePower / playerMovement.MovementSpeed;
                    playerMovement.forceMovement(explodeVector, true);
                    int       viewID    = gameObject.FindComponent <PhotonView>().ViewID;
                    StatLayer statLayer = new StatLayer(StatLayer.STAT_IGNORE)
                    {
                        moveSpeed = speed
                    };
                    StatKeeper statKeeper = playerMovement.gameObject.FindComponent <StatKeeper>();
                    statKeeper.selfStats.addLayer(viewID, statLayer);
                    TimerManager.StartTimer(forceMoveDuration, () =>
                    {
                        playerMovement.forceMovement(false);
                        statKeeper.selfStats.removeLayer(viewID);
                    });
                }
            }
        }
    }
示例#9
0
    private static object DeserializeStatLayer(StreamBuffer inStream, short length)
    {
        StatLayer sl = new StatLayer();

        lock (memStatLayer)
        {
            inStream.Read(memStatLayer, 0, length);// byteArraySize);
            int index = 0;
            Protocol.Deserialize(out sl.moveSpeed, memStatLayer, ref index);
            Protocol.Deserialize(out sl.maxHits, memStatLayer, ref index);
            Protocol.Deserialize(out sl.fireRate, memStatLayer, ref index);
            Protocol.Deserialize(out sl.damage, memStatLayer, ref index);
            Protocol.Deserialize(out sl.size, memStatLayer, ref index);
        }
        return(sl);
    }
示例#10
0
    private static short SerializeStatLayer(StreamBuffer outStream, object customobject)
    {
        StatLayer sl = (StatLayer)customobject;

        lock (memStatLayer)
        {
            byte[] bytes = memStatLayer;
            int    index = 0;
            Protocol.Serialize(sl.moveSpeed, bytes, ref index);
            Protocol.Serialize(sl.maxHits, bytes, ref index);
            Protocol.Serialize(sl.fireRate, bytes, ref index);
            Protocol.Serialize(sl.damage, bytes, ref index);
            Protocol.Serialize(sl.size, bytes, ref index);
            outStream.Write(bytes, 0, byteArraySize);
        }
        return(byteArraySize);
    }
示例#11
0
 void RPC_UpdateStats(StatLayer selfStats)
 {
     GetComponentInChildren <StatKeeper>().selfStats.Stats = selfStats;
 }
 protected override void InitializeSettings()
 {
     base.InitializeSettings();
     //Init layers
     minRollLayer = new StatLayer(1);
 }