Merge branch 'master' of http://192.168.0.87:10010/r/snxxz_scripts

client_Hale

2018-09-22 99ec4075b3cf616d4047c830175be62221ef7104

Merge branch 'master' of http://192.168.0.87:10010/r/snxxz_scripts

 Core/GameEngine/Model/Config/DogzConfig.cs

@@ -1,6 +1,6 @@
//--------------------------------------------------------
//    [Author]:            第二世界
//    [  Date ]:           Friday, August 17, 2018
//    [  Date ]:           Friday, September 21, 2018
//--------------------------------------------------------

using UnityEngine;
@@ -17,6 +17,7 @@
        public int[] BaseAttrTypes;

        public int[] BaseAttrValues;

        public int[] HelpBattleSkills;

        public int FightPowerEx { get ; private set ; }

        public int[] EquipPlaceColorList;

        public override string getKey()
@@ -54,7 +55,9 @@
                     int.TryParse(HelpBattleSkillsStringArray[i],out HelpBattleSkills[i]);
                }

            

                string[] EquipPlaceColorListStringArray = rawContents[6].Trim().Split(StringUtility.splitSeparator,StringSplitOptions.RemoveEmptyEntries);
                FightPowerEx=IsNumeric(rawContents[6]) ? int.Parse(rawContents[6]):0; 
			
                string[] EquipPlaceColorListStringArray = rawContents[7].Trim().Split(StringUtility.splitSeparator,StringSplitOptions.RemoveEmptyEntries);
                EquipPlaceColorList = new int[EquipPlaceColorListStringArray.Length];
                for (int i=0;i<EquipPlaceColorListStringArray.Length;i++)
                {

 Core/GameEngine/Model/Config/DogzConfig.cs.meta

@@ -1,6 +1,6 @@
fileFormatVersion: 2
guid: 940b0f1e335cf3749bb18fbee7090526
timeCreated: 1534489434
timeCreated: 1537530330
licenseType: Pro
MonoImporter:
  serializedVersion: 2

 Core/GameEngine/Model/Config/RuneTowerFloorConfig.cs

@@ -1,14 +1,14 @@
//--------------------------------------------------------
//    [Author]:            第二世界
//    [  Date ]:           Friday, August 10, 2018
//--------------------------------------------------------

using UnityEngine;
using System;

namespace TableConfig {

    
//--------------------------------------------------------

//    [Author]:            第二世界

//    [  Date ]:           Friday, September 21, 2018

//--------------------------------------------------------



using UnityEngine;

using System;



namespace TableConfig {



    
    public partial class RuneTowerFloorConfig : ConfigBase {



        public int ID { get ; private set ; }

@@ -24,13 +24,14 @@
        public int UnLockCompose { get ; private set ; }

        public int RuneDrop { get ; private set ; }

        public int Fixed { get ; private set ; }


        public int AutoExit { get ; private set ; }



        public override string getKey()

        {

            return ID.ToString();

        }

        public override void Parse() {
        }



        public override void Parse() {

            try

            {

                ID=IsNumeric(rawContents[0]) ? int.Parse(rawContents[0]):0; 

@@ -58,17 +59,19 @@
                RuneDrop=IsNumeric(rawContents[11]) ? int.Parse(rawContents[11]):0; 

            

                Fixed=IsNumeric(rawContents[12]) ? int.Parse(rawContents[12]):0; 

			
                AutoExit=IsNumeric(rawContents[13]) ? int.Parse(rawContents[13]):0; 
            }

            catch (Exception ex)

            {

                DebugEx.Log(ex);

            }
        }
	
    }

}




            }

        }

	
    }



}










 Core/GameEngine/Model/Config/RuneTowerFloorConfig.cs.meta

@@ -1,6 +1,6 @@
fileFormatVersion: 2
guid: eb8552f7e3b6ad843878daecebc9eb01
timeCreated: 1533871891
timeCreated: 1537535813
licenseType: Pro
MonoImporter:
  serializedVersion: 2

 Core/GameEngine/Model/Config/WHYJRewardConfig.cs

New file
@@ -0,0 +1,44 @@
//--------------------------------------------------------
//    [Author]:            第二世界
//    [  Date ]:           Friday, September 21, 2018
//--------------------------------------------------------

using UnityEngine;
using System;

namespace TableConfig {

    
    public partial class WHYJRewardConfig : ConfigBase {

        public int ID { get ; private set ; }

        public string Reward { get ; private set; } 
        public string Quantity { get ; private set; } 

        public override string getKey()
        {
            return ID.ToString();
        }

        public override void Parse() {
            try
            {
                ID=IsNumeric(rawContents[0]) ? int.Parse(rawContents[0]):0; 
			
                Reward = rawContents[1].Trim();

			
                Quantity = rawContents[2].Trim();
            }
            catch (Exception ex)
            {
                DebugEx.Log(ex);
            }
        }
	
    }

}





 Core/GameEngine/Model/Config/WHYJRewardConfig.cs.meta

New file
@@ -0,0 +1,12 @@
fileFormatVersion: 2
guid: 00dab7d472dcc5644902b144de22ce01
timeCreated: 1537529264
licenseType: Free
MonoImporter:
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant: 

 Core/GameEngine/Model/ConfigManager.cs

@@ -191,7 +191,7 @@
        AddAsyncTask<FairyGrabBossConfig>();

        AddAsyncTask<DungeonSpecialStateTimeConfig>();

        AddAsyncTask<DailyQuestSpecialOpenTimeConfig>();



        AddAsyncTask<WHYJRewardConfig>();

        while (!AllCompleted())

        {

            var completedCount = 0;


 Core/NetworkPackage/ServerPack/HA0_Sys/HA005_tagOpenServerDay.cs

@@ -1,26 +1,37 @@
using UnityEngine;

using System.Collections;



//A0 05 同步开服天数 #tagOpenServerDay



public class HA005_tagOpenServerDay : GameNetPackBasic

{

    public ushort Day;    // 已开服天数，从0开始

    public byte IsMixServer;    //是否是合服服务器

    public ushort MixDay;    // 已合服天数，从0开始

    public string OpenServerTime;    //开服时间yyyy-MM-dd HH:mm:ss



    public HA005_tagOpenServerDay()

    {

        _cmd = (ushort)0xA005;

    }



    public override void ReadFromBytes(byte[] vBytes)

    {

        TransBytes(out Day, vBytes, NetDataType.WORD);

        TransBytes(out IsMixServer, vBytes, NetDataType.BYTE);

        TransBytes(out MixDay, vBytes, NetDataType.WORD);

        TransBytes(out OpenServerTime, vBytes, NetDataType.Chars, 19);

    }



}
//A0 05 同步开服天数 #tagOpenServerDay



public class HA005_tagOpenServerDay : GameNetPackBasic {

    public ushort Day;    // 已开服天数，从0开始

    public byte IsMixServer;    //是否是合服服务器

    public ushort MixDay;    // 已合服天数，从0开始

    public byte OpenWeekday;    //开服是周几，1代表周一

    public ushort NowYear;    //服务器当前时间 - 年

    public byte NowMonth;

    public byte NowDay;

    public byte NowHour;

    public byte NowMinute;

    public byte NowSecond;

    public uint NowMicSecond;



    public HA005_tagOpenServerDay () {

        _cmd = (ushort)0xA005;

    }



    public override void ReadFromBytes (byte[] vBytes) {

        TransBytes (out Day, vBytes, NetDataType.WORD);

        TransBytes (out IsMixServer, vBytes, NetDataType.BYTE);

        TransBytes (out MixDay, vBytes, NetDataType.WORD);

        TransBytes (out OpenWeekday, vBytes, NetDataType.BYTE);

        TransBytes (out NowYear, vBytes, NetDataType.WORD);

        TransBytes (out NowMonth, vBytes, NetDataType.BYTE);

        TransBytes (out NowDay, vBytes, NetDataType.BYTE);

        TransBytes (out NowHour, vBytes, NetDataType.BYTE);

        TransBytes (out NowMinute, vBytes, NetDataType.BYTE);

        TransBytes (out NowSecond, vBytes, NetDataType.BYTE);

        TransBytes (out NowMicSecond, vBytes, NetDataType.DWORD);

    }



}


 Plugins.meta

New file
@@ -0,0 +1,9 @@
fileFormatVersion: 2
guid: d463e02633381cd46902c21b8d51f83e
folderAsset: yes
timeCreated: 1537519875
licenseType: Pro
DefaultImporter:
  userData: 
  assetBundleName: 
  assetBundleVariant: 

 Plugins/Trails.meta

New file
@@ -0,0 +1,9 @@
fileFormatVersion: 2
guid: 77d1032b5eb62ce4da86e600bc8884c8
folderAsset: yes
timeCreated: 1537519883
licenseType: Pro
DefaultImporter:
  userData: 
  assetBundleName: 
  assetBundleVariant: 

 Plugins/Trails/CircularBuffer.cs

New file
@@ -0,0 +1,287 @@
using System;
using System.Collections;
using System.Collections.Generic;

namespace PigeonCoopToolkit.Utillities
{
    public class CircularBuffer<T> : IList<T>, ICollection<T>, 
                                IEnumerable<T>, IEnumerable
    {
      /// <summary>
      /// Creates a new instance of a <see cref="RingBuffer&lt;T&gt;"/> with a 
      /// specified cache size.
      // http://florianreischl.blogspot.com/2010/01/generic-c-ringbuffer.html
      /// </summary>
      /// <param name="capacity">The maximal count of items to be stored within 
      /// the ring buffer.</param>
        public CircularBuffer(int capacity)
        {
         // validate capacity
         if (capacity <= 0)
            throw new ArgumentException("Must be greater than zero", "capacity");
         // set capacity and init the cache
         Capacity = capacity;
         _buffer = new T[capacity];
      }

      /// <summary>
      /// the internal buffer
      /// </summary>
      T[] _buffer;
      /// <summary>
      /// The all-over position within the ring buffer. The position 
      /// increases continously by adding new items to the buffer. This 
      /// value is needed to calculate the current relative position within the 
      /// buffer.
      /// </summary>
      int _position;
      /// <summary>
      /// The current version of the buffer, this is required for a correct 
      /// exception handling while enumerating over the items of the buffer.
      /// </summary>
      long _version;

      /// <summary>
      /// Gets or sets an item for a specified position within the ring buffer.
      /// </summary>
      /// <param name="index">The position to get or set an item.</param>
      /// <returns>The fond item at the specified position within the ring buffer.
      /// </returns>
      /// <exception cref="IndexOutOfRangeException"></exception>
      public T this[int index] {
         get {
            // validate the index
            if (index < 0 || index >= Count)
               throw new IndexOutOfRangeException();
            // calculate the relative position within the rolling base array
            int index2 = (_position - Count + index) % Capacity;
            return _buffer[index2]; 
         }
         set { Insert(index, value); }
      }

      /// <summary>
      /// Gets the maximal count of items within the ring buffer.
      /// </summary>
      public int Capacity { get; private set; }
      /// <summary>
      /// Get the current count of items within the ring buffer.
      /// </summary>
      public int Count { get; private set; }
      
      /// <summary>
      /// Adds a new item to the buffer.
      /// </summary>
      /// <param name="item">The item to be added to the buffer.</param>
      public void Add(T item) {
         // add a new item to the current relative position within the
         // buffer and increase the position
         _buffer[_position++ % Capacity] = item;
         // increase the count if capacity is not yet reached
         if (Count < Capacity) Count++;
         // buffer changed; next version
         _version++;
      }

      /// <summary>
      /// Clears the whole buffer and releases all referenced objects 
      /// currently stored within the buffer.
      /// </summary>
      public void Clear() {
         for (int i = 0; i < Count; i++)
            _buffer[i] = default(T);
         _position = 0;
         Count = 0;
         _version++;
      }

      /// <summary>
      /// Determines if a specified item is currently present within
      /// the buffer.
      /// </summary>
      /// <param name="item">The item to search for within the current
      /// buffer.</param>
      /// <returns>True if the specified item is currently present within 
      /// the buffer; otherwise false.</returns>
      public bool Contains(T item) {
         int index = IndexOf(item);
         return index != -1;
      }

      /// <summary>
      /// Copies the current items within the buffer to a specified array.
      /// </summary>
      /// <param name="array">The target array to copy the items of 
      /// the buffer to.</param>
      /// <param name="arrayIndex">The start position witihn the target
      /// array to start copying.</param>
      public void CopyTo(T[] array, int arrayIndex) {
         for (int i = 0; i < Count; i++) {
            array[i + arrayIndex] = _buffer[(_position - Count + i) % Capacity];
         }
      }

      /// <summary>
      /// Gets an enumerator over the current items within the buffer.
      /// </summary>
      /// <returns>An enumerator over the current items within the buffer.
      /// </returns>
      public IEnumerator<T> GetEnumerator() {
         long version = _version;
         for (int i = 0; i < Count; i++) {
            if (version != _version)
               throw new InvalidOperationException("Collection changed");
            yield return this[i];
         }
      }

      /// <summary>
      /// Gets the position of a specied item within the ring buffer.
      /// </summary>
      /// <param name="item">The item to get the current position for.</param>
      /// <returns>The zero based index of the found item within the 
      /// buffer. If the item was not present within the buffer, this
      /// method returns -1.</returns>
      public int IndexOf(T item) {
         // loop over the current count of items
         for (int i = 0; i < Count; i++) {
            // get the item at the relative position within the internal array
            T item2 = _buffer[(_position - Count + i) % Capacity];
            // if both items are null, return true
            if (null == item && null == item2)
               return i;
            // if equal return the position
            if (item != null && item.Equals(item2))
               return i;
         }
         // nothing found
         return -1;
      }

      /// <summary>
      /// Inserts an item at a specified position into the buffer.
      /// </summary>
      /// <param name="index">The position within the buffer to add 
      /// the new item.</param>
      /// <param name="item">The new item to be added to the buffer.</param>
      /// <exception cref="IndexOutOfRangeException"></exception>
      /// <remarks>
      /// If the specified index is equal to the current count of items
      /// within the buffer, the specified item will be added.
      /// 
      /// <b>Warning</b>
      /// Frequent usage of this method might become a bad idea if you are 
      /// working with a large buffer capacity. The insertion of an item
      /// at a specified position within the buffer causes causes all present 
      /// items below the specified position to be moved one position.
      /// </remarks>
      public void Insert(int index, T item) {
         // validate index
         if (index < 0 || index > Count)
            throw new IndexOutOfRangeException();
         // add if index equals to count
         if (index == Count) {
            Add(item);
            return;
         }

         // get the maximal count of items to be moved
         int count = Math.Min(Count, Capacity - 1) - index;
         // get the relative position of the new item within the buffer
         int index2 = (_position - Count + index) % Capacity;

         // move all items below the specified position
         for (int i = index2 + count; i > index2; i--) {
            int to = i % Capacity;
            int from = (i - 1) % Capacity;
            _buffer[to] = _buffer[from];
         }

         // set the new item
         _buffer[index2] = item;

         // adjust storage information
         if (Count < Capacity) {
            Count++;
            _position++;
         }
         // buffer changed; next version
         _version++;
      }

      /// <summary>
      /// Removes a specified item from the current buffer.
      /// </summary>
      /// <param name="item">The item to be removed.</param>
      /// <returns>True if the specified item was successfully removed
      /// from the buffer; otherwise false.</returns>
      /// <remarks>
      /// <b>Warning</b>
      /// Frequent usage of this method might become a bad idea if you are 
      /// working with a large buffer capacity. The removing of an item 
      /// requires a scan of the buffer to get the position of the specified
      /// item. If the item was found, the deletion requires a move of all 
      /// items stored abouve the found position.
      /// </remarks>
      public bool Remove(T item) {
         // find the position of the specified item
         int index = IndexOf(item);
         // item was not found; return false
         if (index == -1)
            return false;
         // remove the item at the specified position
         RemoveAt(index);
         return true;
      }

      /// <summary>
      /// Removes an item at a specified position within the buffer.
      /// </summary>
      /// <param name="index">The position of the item to be removed.</param>
      /// <exception cref="IndexOutOfRangeException"></exception>
      /// <remarks>
      /// <b>Warning</b>
      /// Frequent usage of this method might become a bad idea if you are 
      /// working with a large buffer capacity. The deletion requires a move 
      /// of all items stored abouve the found position.
      /// </remarks>
      public void RemoveAt(int index) {
         // validate the index
         if (index < 0 || index >= Count)
            throw new IndexOutOfRangeException();
         // move all items above the specified position one step
         // closer to zeri
         for (int i = index; i < Count - 1; i++) {
            // get the next relative target position of the item
            int to = (_position - Count + i) % Capacity;
            // get the next relative source position of the item
            int from = (_position - Count + i + 1) % Capacity;
            // move the item
            _buffer[to] = _buffer[from];
         }
         // get the relative position of the last item, which becomes empty
         // after deletion and set the item as empty
         int last = (_position - 1) % Capacity;
         _buffer[last] = default(T);
         // adjust storage information
         _position--;
         Count--;
         // buffer changed; next version
         _version++;
      }

      /// <summary>
      /// Gets if the buffer is read-only. This method always returns false.
      /// </summary>
      bool ICollection<T>.IsReadOnly { get { return false; } }

      /// <summary>
      /// See generic implementation of <see cref="GetEnumerator"/>.
      /// </summary>
      /// <returns>See generic implementation of <see cref="GetEnumerator"/>.
      /// </returns>
      IEnumerator IEnumerable.GetEnumerator() {
         return this.GetEnumerator();
      }
   }
}

 Plugins/Trails/CircularBuffer.cs.meta

New file
@@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: 51a19be087405654c8b4b50c67fa9200
MonoImporter:
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 

 Plugins/Trails/GizmosExtra.cs

New file
@@ -0,0 +1,33 @@
using UnityEngine;

namespace PigeonCoopToolkit.Utillities
{
    public static class GizmosExtra
    {

        public static void GizmosDrawCircle(Vector3 position, Vector3 up, float size, int divisions)
        {
            Vector3 offset = (Quaternion.Euler(90,0,0) * (up* size)) ;

            for (int i = 0; i < divisions; i++)
            {

                Vector3 newOffset = Quaternion.AngleAxis(360f / divisions, up) * offset;
                Gizmos.DrawLine(position + offset, position + newOffset);
                offset = newOffset;
            }
        }

        public static void GizmosDrawArrow(Vector3 from, Vector3 to, float arrowSize)
        {
            Gizmos.DrawLine(from, to);

            Vector3 dir = to - from;
            dir = dir.normalized*arrowSize;

            Gizmos.DrawLine(to, to - Quaternion.Euler(0, 0, 45)*dir);
            Gizmos.DrawLine(to, to - Quaternion.Euler(0, 0, -45)*dir);

        }
    }
}

 Plugins/Trails/GizmosExtra.cs.meta

New file
@@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: ac8be081485ba1141bd28334fe9eabec
MonoImporter:
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 

 Plugins/Trails/Range.cs

New file
@@ -0,0 +1,15 @@
namespace PigeonCoopToolkit.Utillities
{
    [System.Serializable]
    public class Range
    {
        public float Min;
        public float Max;

        public bool WithinRange(float value)
        {
            return Min <= value && Max >= value;
        }
    }

}

 Plugins/Trails/Range.cs.meta

New file
@@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: db4c92c149ebf004a83b3776345ca8d4
MonoImporter:
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 

 Plugins/Trails/SmokePlume.cs

New file
@@ -0,0 +1,74 @@
using UnityEngine;

namespace PigeonCoopToolkit.Effects.Trails
{
    [AddComponentMenu("Pigeon Coop Toolkit/Effects/Smoke Plume")]
    public class SmokePlume : TrailRenderer_Base
    {
        public float TimeBetweenPoints = 0.1f;
        public Vector3 ConstantForce = Vector3.up * 0.5f;
        public float RandomForceScale = 0.05f;
        public int MaxNumberOfPoints = 50;
        private float _timeSincePoint;

        protected override void Start()
        {
            base.Start();
            _timeSincePoint = 0;
        }

        protected override void OnStartEmit()
        {
            _timeSincePoint = 0;
        }

        protected override void Reset()
        {
            base.Reset();
            TrailData.SizeOverLife = new AnimationCurve(new Keyframe(0, 0), new Keyframe(0.5f, 0.2f), new Keyframe(1, 0.2f));
            TrailData.Lifetime = 6f;
            ConstantForce = Vector3.up*0.5f;
            TimeBetweenPoints = 0.1f;
            RandomForceScale = 0.05f;
            MaxNumberOfPoints = 50;
        }

        protected override void Update()
        {
            if (_emit)
            {
                _timeSincePoint += _noDecay ? 0 : Time.deltaTime;

                if (_timeSincePoint >= TimeBetweenPoints)
                {
                    AddPoint(new SmokeTrailPoint(), _t.position);
                    _timeSincePoint = 0;
                }
            }

            base.Update();
        }

        protected override void InitialiseNewPoint(PCTrailPoint newPoint)
        {
            ((SmokeTrailPoint)newPoint).RandomVec = Random.onUnitSphere * RandomForceScale;
        }

        protected override void UpdateTrail(PCTrail trail, float deltaTime)
        {
            if (_noDecay)
                return;

            foreach (PCTrailPoint point in trail.Points)
            {
                point.Position += ConstantForce * deltaTime;
            }
        }
        protected override int GetMaxNumberOfPoints()
        {
            return MaxNumberOfPoints;
        }
    }

    
}

 Plugins/Trails/SmokePlume.cs.meta

New file
@@ -0,0 +1,15 @@
fileFormatVersion: 2
guid: b5748bb800508004a81afe3d7526bcb1
labels:
- BetterTrails
- TrailRenderer
- Smoke
- Trail
- Effects
- skidmarks
MonoImporter:
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 1000
  icon: {fileID: 2800000, guid: 9c8d55a9e91d98e4e925cd09f877adc5, type: 3}
  userData: 

 Plugins/Trails/SmokeTrail.cs

New file
@@ -0,0 +1,76 @@
using UnityEngine;

namespace PigeonCoopToolkit.Effects.Trails
{
    [AddComponentMenu("Pigeon Coop Toolkit/Effects/Smoke Trail")]
    public class SmokeTrail : TrailRenderer_Base
    {
        public float MinVertexDistance = 0.1f;
        public int MaxNumberOfPoints = 50;
        private Vector3 _lastPosition;
        private float _distanceMoved;
        public float RandomForceScale = 1;

        protected override void Start()
        {
            base.Start();
            _lastPosition = _t.position;
        }

        protected override void Update()
        {
            if (_emit)
            {
                _distanceMoved += Vector3.Distance(_t.position, _lastPosition);

                if (_distanceMoved != 0 && _distanceMoved >= MinVertexDistance)
                {
                    AddPoint(new SmokeTrailPoint(), _t.position);
                    _distanceMoved = 0;
                }
                _lastPosition = _t.position;

            }

            base.Update();
        }

        protected override void OnStartEmit()
        {
            _lastPosition = _t.position;
            _distanceMoved = 0;
        }

        protected override void Reset()
        {
            base.Reset();
            MinVertexDistance = 0.1f;
            RandomForceScale = 1;
        }

        protected override void InitialiseNewPoint(PCTrailPoint newPoint)
        {
            ((SmokeTrailPoint)newPoint).RandomVec = Random.onUnitSphere * RandomForceScale;
        }
        protected override void OnTranslate(Vector3 t)
        {
            _lastPosition += t;
        }

        protected override int GetMaxNumberOfPoints()
        {
            return MaxNumberOfPoints;
        }
    }

    public class SmokeTrailPoint : PCTrailPoint
    {
        public Vector3 RandomVec;

        public override void Update(float deltaTime)
        {
            base.Update(deltaTime);
            Position += RandomVec * deltaTime;
        }
    }
}

 Plugins/Trails/SmokeTrail.cs.meta

New file
@@ -0,0 +1,15 @@
fileFormatVersion: 2
guid: 98335f20237e3de42a9f0b6415312e23
labels:
- BetterTrails
- TrailRenderer
- Smoke
- Trail
- Effects
- skidmarks
MonoImporter:
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 1000
  icon: {fileID: 2800000, guid: f99224b2104474d47b91284e88f8af87, type: 3}
  userData: 

 Plugins/Trails/SmoothTrail.cs

New file
@@ -0,0 +1,213 @@
using PigeonCoopToolkit.Utillities;
using UnityEngine;

namespace PigeonCoopToolkit.Effects.Trails
{
    [AddComponentMenu("Pigeon Coop Toolkit/Effects/Smooth Trail")]
    public class SmoothTrail : TrailRenderer_Base
    {
        public float MinControlPointDistance = 0.1f;
        public int MaxControlPoints = 15;
        public int PointsBetweenControlPoints = 4;

        private Vector3 _lastPosition;
        private float _distanceMoved;
        private CircularBuffer<ControlPoint> _controlPoints;

        private class ControlPoint
        {
            public Vector3 p;
            public Vector3 forward;
        }
        
        protected override void Start()
        {
            base.Start();
            _lastPosition = _t.position;
        }

        protected override void Update()
        {
            if (_emit)
            {
                _distanceMoved += Vector3.Distance(_t.position, _lastPosition);

                if (!Mathf.Approximately(_distanceMoved, 0) && _distanceMoved >= MinControlPointDistance)
                {
                    AddControlPoint(_t.position);
                    _distanceMoved = 0;
                }
                else
                {
                    _controlPoints[_controlPoints.Count - 1].p = _t.position;

                    if (TrailData.UseForwardOverride)
                    {
                        _controlPoints[_controlPoints.Count - 1].forward = TrailData.ForwardOverrideRelative
                                       ? _t.TransformDirection(TrailData.ForwardOverride.normalized)
                                       : TrailData.ForwardOverride.normalized;
                    }

                }

                _lastPosition = _t.position;
            }

            base.Update();
        }

        protected override void OnStartEmit()
        {
            _lastPosition = _t.position;
            _distanceMoved = 0;
            _controlPoints = new CircularBuffer<ControlPoint>(MaxControlPoints);

            _controlPoints.Add(new ControlPoint { p = _lastPosition });

            if (TrailData.UseForwardOverride)
            {
                _controlPoints[0].forward = TrailData.ForwardOverrideRelative
                               ? _t.TransformDirection(TrailData.ForwardOverride.normalized)
                               : TrailData.ForwardOverride.normalized;
            }

            AddPoint(new PCTrailPoint(), _lastPosition);

            AddControlPoint(_lastPosition);
        }

        protected override void UpdateTrail(PCTrail trail, float deltaTime)
        {
            if (trail.IsActiveTrail == false)
                return;

            //TODO Must optimize this further, I don't need to keep recalculating point positions unless we are
            //dealng with the points between the last and 2nd last CP (+ the last CP itself)
            int trailPointIndex = 0;
            for (int i = 0; i < _controlPoints.Count; i++)
            {
                trail.Points[trailPointIndex].Position = _controlPoints[i].p;

                if (TrailData.UseForwardOverride)
                {
                    trail.Points[trailPointIndex].Forward = _controlPoints[i].forward;
                }

                trailPointIndex++;

                if (i < _controlPoints.Count - 1)
                {
                    Vector3 Handle1, Handle2;
                    float distanceBetween = Vector3.Distance(_controlPoints[i].p, _controlPoints[i + 1].p) / 2;
                    if (i == 0)
                    {
                        Handle1 = _controlPoints[i].p + (_controlPoints[i + 1].p - _controlPoints[i].p).normalized * distanceBetween;
                    }
                    else
                    {
                        Handle1 = _controlPoints[i].p + (_controlPoints[i + 1].p - _controlPoints[i - 1].p).normalized * distanceBetween;
                    }

                    int nextI = i + 1;

                    if (nextI == _controlPoints.Count - 1)
                    {
                        Handle2 = _controlPoints[nextI].p + (_controlPoints[nextI - 1].p - _controlPoints[nextI].p).normalized * distanceBetween;
                    }
                    else
                    {
                        Handle2 = _controlPoints[nextI].p + (_controlPoints[nextI - 1].p - _controlPoints[nextI + 1].p).normalized * distanceBetween;
                    }

                    PCTrailPoint currentHandle = trail.Points[trailPointIndex-1];
                    PCTrailPoint nextHandle = trail.Points[(trailPointIndex-1) + PointsBetweenControlPoints+1];

                    
                    for (int pointBetween = 0; pointBetween < PointsBetweenControlPoints; pointBetween++)
                    {
                        float t= (((float)pointBetween + 1f) / ((float)PointsBetweenControlPoints + 1f));
                        trail.Points[trailPointIndex].Position = GetPointAlongCurve(_controlPoints[i].p, Handle1, _controlPoints[i + 1].p, Handle2, t, 0.3f);
                        trail.Points[trailPointIndex].SetTimeActive(Mathf.Lerp(currentHandle.TimeActive(), nextHandle.TimeActive(), t));

                        if (TrailData.UseForwardOverride)
                        {
                            trail.Points[trailPointIndex].Forward = Vector3.Lerp(currentHandle.Forward, nextHandle.Forward, t);
                        }


                        trailPointIndex++;
                    }

                }
            }

            int lastControlPointPointIndex = ((_controlPoints.Count - 1) + ((_controlPoints.Count - 1) * PointsBetweenControlPoints));
            int prevControlPointPointIndex = lastControlPointPointIndex - PointsBetweenControlPoints - 1;
            int activePointCount = lastControlPointPointIndex + 1;

            float distanceFromStart = trail.Points[prevControlPointPointIndex].GetDistanceFromStart();
            for (int i = prevControlPointPointIndex + 1; i < activePointCount; i++)
            {
                distanceFromStart += Vector3.Distance(trail.Points[i - 1].Position, trail.Points[i].Position);
                trail.Points[i].SetDistanceFromStart(distanceFromStart);
            }

        }

        protected override void Reset()
        {
            base.Reset();
            MinControlPointDistance = 0.1f;
            MaxControlPoints = 15;
            PointsBetweenControlPoints = 4;
        }

        protected override void OnTranslate(Vector3 t)
        {
            _lastPosition += t;

            for (int i = 0; i < _controlPoints.Count; i++)
                _controlPoints[i].p += t;
        }

        private void AddControlPoint(Vector3 position)
        {
            for (int i = 0; i < PointsBetweenControlPoints; i++)
            {
                AddPoint(new PCTrailPoint(), position);
            }

            AddPoint(new PCTrailPoint(), position);

            ControlPoint newCP = new ControlPoint { p = position };

            if (TrailData.UseForwardOverride)
            {
                newCP.forward = TrailData.ForwardOverrideRelative
                               ? _t.TransformDirection(TrailData.ForwardOverride.normalized)
                               : TrailData.ForwardOverride.normalized;
            }

            _controlPoints.Add(newCP);
        }

        protected override int GetMaxNumberOfPoints()
        {
            return ((MaxControlPoints) + ((MaxControlPoints) * PointsBetweenControlPoints));
        }

        public Vector3 GetPointAlongCurve(Vector3 curveStart, Vector3 curveStartHandle, Vector3 curveEnd, Vector3 curveEndHandle, float t, float crease)
        {
            float oneMinT = 1 - t;
            float oneMinTPow3 = Mathf.Pow(oneMinT, 3);
            float oneMinTPow2 = Mathf.Pow(oneMinT, 2);

            float oneMinCrease = 1 - crease;
            return ((oneMinTPow3 * curveStart * oneMinCrease) + (3 * oneMinTPow2 * t * curveStartHandle * crease) + (3 * oneMinT * Mathf.Pow(t, 2) * curveEndHandle * crease) +
                   (Mathf.Pow(t, 3) * curveEnd * oneMinCrease))
                   /
                   ((oneMinTPow3 * oneMinCrease) + (3 * oneMinTPow2 * t * crease) + (3 * oneMinT * Mathf.Pow(t, 2) * crease) +
                   (Mathf.Pow(t, 3) * oneMinCrease));
        }
    }
}

 Plugins/Trails/SmoothTrail.cs.meta

New file
@@ -0,0 +1,15 @@
fileFormatVersion: 2
guid: 62cd7e0b3a08cf84e82658d9a3eaeb32
labels:
- BetterTrails
- TrailRenderer
- Smoke
- Trail
- Effects
- skidmarks
MonoImporter:
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 1000
  icon: {fileID: 2800000, guid: 8d56c6f37ee95884baa3b4f7e4837399, type: 3}
  userData: 

 Plugins/Trails/Trail.cs

New file
@@ -0,0 +1,60 @@
using UnityEngine;

namespace PigeonCoopToolkit.Effects.Trails
{
    [AddComponentMenu("Pigeon Coop Toolkit/Effects/Trail")]
    public class Trail : TrailRenderer_Base
    {
        public float MinVertexDistance = 0.1f;
        public int MaxNumberOfPoints = 50;
        private Vector3 _lastPosition;
        private float _distanceMoved;

        protected override void Start()
        {
            base.Start();
            _lastPosition = _t.position;
        }

        protected override void Update()
        {
            if(_emit)
            {
                _distanceMoved += Vector3.Distance(_t.position, _lastPosition);

                if (_distanceMoved != 0 && _distanceMoved >= MinVertexDistance)
                {
                    AddPoint(new PCTrailPoint(), _t.position);
                    _distanceMoved = 0;
                }

                _lastPosition = _t.position;

            }

            base.Update();
        }

        protected override void OnStartEmit()
        {
            _lastPosition = _t.position;
            _distanceMoved = 0;
        }

        protected override void Reset()
        {
            base.Reset();
            MinVertexDistance = 0.1f;
        }

        protected override void OnTranslate(Vector3 t)
        {
            _lastPosition += t;
        }

        protected override int GetMaxNumberOfPoints()
        {
            return MaxNumberOfPoints;
        }
    }
}

 Plugins/Trails/Trail.cs.meta

New file
@@ -0,0 +1,15 @@
fileFormatVersion: 2
guid: 5f742ccbd25717e438dd6fdea4d66bad
labels:
- BetterTrails
- TrailRenderer
- Smoke
- Trail
- Effects
- skidmarks
MonoImporter:
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 1000
  icon: {fileID: 2800000, guid: 888165c9c85ad6b429824b89f1f4f698, type: 3}
  userData: 

 Plugins/Trails/TrailRenderer_Base.cs

New file
@@ -0,0 +1,666 @@
using System.Collections.Generic;
using System.Linq;
using PigeonCoopToolkit.Utillities;
using UnityEngine;
using System;

namespace PigeonCoopToolkit.Effects.Trails
{
    public abstract class TrailRenderer_Base : MonoBehaviour
    {
        public PCTrailRendererData TrailData;
        public bool Emit = false;

        protected bool _emit;
        protected bool _noDecay;

        private PCTrail _activeTrail;
        private List<PCTrail> _fadingTrails;
        protected Transform _t;


        private static Dictionary<Material, List<PCTrail>> _matToTrailList;
        private static List<Mesh> _toClean; 
 
        private static bool _hasRenderer = false;
        private static int GlobalTrailRendererCount = 0;

        protected virtual void Awake()
        {
            GlobalTrailRendererCount++;

            if(GlobalTrailRendererCount == 1)
            {
                _matToTrailList = new Dictionary<Material, List<PCTrail>>();
                _toClean = new List<Mesh>();
            }

            
            _fadingTrails = new List<PCTrail>();
            _t = transform;
            _emit = Emit;

            if (_emit)
            {
                _activeTrail = new PCTrail(GetMaxNumberOfPoints());
                _activeTrail.IsActiveTrail = true;
                OnStartEmit();
            }
        }

        protected virtual void Start()
        {
            
        }

        protected virtual void LateUpdate()
        {
            if(_hasRenderer)
                return;


            _hasRenderer = true;
            

            foreach (KeyValuePair<Material, List<PCTrail>> keyValuePair in _matToTrailList)
            {
                CombineInstance[] combineInstances = new CombineInstance[keyValuePair.Value.Count];

                for (int i = 0; i < keyValuePair.Value.Count; i++)
                {
                    combineInstances[i] = new CombineInstance
                    {
                        mesh = keyValuePair.Value[i].Mesh,
                        subMeshIndex = 0,
                        transform = Matrix4x4.identity
                    };
                }

                Mesh combinedMesh = new Mesh();
                combinedMesh.CombineMeshes(combineInstances, true, false);
                _toClean.Add(combinedMesh);

                DrawMesh(combinedMesh, keyValuePair.Key);

                keyValuePair.Value.Clear();
            }
        }

        protected virtual void Update()
        {
            if (_hasRenderer)
            {
                _hasRenderer = false;

                if (_toClean.Count > 0)
                {
                    foreach (Mesh mesh in _toClean)
                    {
                        if (Application.isEditor)
                            DestroyImmediate(mesh, true);
                        else
                            Destroy(mesh);
                    }
                }

                _toClean.Clear();

            }

            if (_matToTrailList.ContainsKey(TrailData.TrailMaterial) == false)
            {
                _matToTrailList.Add(TrailData.TrailMaterial, new List<PCTrail>());
            }
            

            if(_activeTrail != null)
            {
                UpdatePoints(_activeTrail, Time.deltaTime);
                UpdateTrail(_activeTrail, Time.deltaTime);
                GenerateMesh(_activeTrail);
                _matToTrailList[TrailData.TrailMaterial].Add(_activeTrail);
            }
             
            for (int i = _fadingTrails.Count-1; i >= 0; i--)
            {
                if (_fadingTrails[i] == null || _fadingTrails[i].Points.Any(a => a.TimeActive() < TrailData.Lifetime) == false)
                {
                    if (_fadingTrails[i] != null)
                        _fadingTrails[i].Dispose();

                    _fadingTrails.RemoveAt(i);
                    continue;
                }

                UpdatePoints(_fadingTrails[i], Time.deltaTime);
                UpdateTrail(_fadingTrails[i], Time.deltaTime);
                GenerateMesh(_fadingTrails[i]);
                _matToTrailList[TrailData.TrailMaterial].Add(_fadingTrails[i]);
            }

            CheckEmitChange();
        }

        protected virtual void OnDestroy()
        {
            GlobalTrailRendererCount--;

            if(GlobalTrailRendererCount == 0)
            {
                if(_toClean != null && _toClean.Count > 0)
                {
                    foreach (Mesh mesh in _toClean)
                    {
                        if (Application.isEditor)
                            DestroyImmediate(mesh, true);
                        else
                            Destroy(mesh);
                    }
                }

                _toClean = null;
                _matToTrailList.Clear();
                _matToTrailList = null;
            }

            if (_activeTrail != null)
            {
                _activeTrail.Dispose();
                _activeTrail = null;
            }

            if (_fadingTrails != null)
            {
                foreach (PCTrail fadingTrail in _fadingTrails)
                {
                    if (fadingTrail != null)
                        fadingTrail.Dispose();
                }

                _fadingTrails.Clear();
            }
        }

        protected virtual void OnStopEmit()
        {
            
        }

        protected virtual void OnStartEmit()
        {
        }

        protected virtual void OnTranslate(Vector3 t)
        {
        }

        protected abstract int GetMaxNumberOfPoints();

        protected virtual void Reset()
        {
            if(TrailData == null)
                TrailData = new PCTrailRendererData();

            TrailData.Lifetime = 1;

            TrailData.UsingSimpleColor = false;
            TrailData.UsingSimpleSize = false;

            TrailData.ColorOverLife = new Gradient();
            TrailData.SimpleColorOverLifeStart = Color.white;
            TrailData.SimpleColorOverLifeEnd = new Color(1, 1, 1, 0);

            TrailData.SizeOverLife = new AnimationCurve(new Keyframe(0, 1), new Keyframe(1, 0));
            TrailData.SimpleSizeOverLifeStart = 1;
            TrailData.SimpleSizeOverLifeEnd = 0;
        }

        protected virtual void InitialiseNewPoint(PCTrailPoint newPoint)
        {

        }

        protected virtual void UpdateTrail(PCTrail trail, float deltaTime)
        {

        }

        protected void AddPoint(PCTrailPoint newPoint, Vector3 pos)
        {
            if (_activeTrail == null)
                return;

            newPoint.Position = pos;
            newPoint.PointNumber = _activeTrail.Points.Count == 0 ? 0 : _activeTrail.Points[_activeTrail.Points.Count - 1].PointNumber + 1;
            InitialiseNewPoint(newPoint);

            newPoint.SetDistanceFromStart(_activeTrail.Points.Count == 0
                                              ? 0
                                              : _activeTrail.Points[_activeTrail.Points.Count - 1].GetDistanceFromStart() + Vector3.Distance(_activeTrail.Points[_activeTrail.Points.Count - 1].Position, pos));

            if(TrailData.UseForwardOverride)
            {
                newPoint.Forward = TrailData.ForwardOverrideRelative
                                       ? _t.TransformDirection(TrailData.ForwardOverride.normalized)
                                       : TrailData.ForwardOverride.normalized;
            }

            _activeTrail.Points.Add(newPoint);
        }

        private void GenerateMesh(PCTrail trail)
        {
            trail.Mesh.Clear(false);

            Vector3 camForward = Camera.main != null ? Camera.main.transform.forward : Vector3.forward;

            if(TrailData.UseForwardOverride)
            {
                camForward = TrailData.ForwardOverride.normalized;
            }

            trail.activePointCount = NumberOfActivePoints(trail);

            if (trail.activePointCount < 2)
                return;


            int vertIndex = 0;
            for (int i = 0; i < trail.Points.Count; i++)
            {
                PCTrailPoint p = trail.Points[i];
                float timeAlong = p.TimeActive()/TrailData.Lifetime;

                if(p.TimeActive() > TrailData.Lifetime)
                {
                    continue;
                }

                if (TrailData.UseForwardOverride && TrailData.ForwardOverrideRelative)
                    camForward = p.Forward;

                Vector3 cross = Vector3.zero;

                if (i < trail.Points.Count - 1)
                {
                    cross =
                        Vector3.Cross((trail.Points[i + 1].Position - p.Position).normalized, camForward).
                            normalized;
                }
                else
                {
                    cross =
                        Vector3.Cross((p.Position - trail.Points[i - 1].Position).normalized, camForward).
                            normalized;
                }


                //yuck! lets move these into their own functions some time
                Color c = TrailData.StretchColorToFit ?
                    (TrailData.UsingSimpleColor ? Color.Lerp(TrailData.SimpleColorOverLifeStart, TrailData.SimpleColorOverLifeEnd, 1 - ((float)vertIndex / (float)trail.activePointCount / 2f)) : TrailData.ColorOverLife.Evaluate(1 - ((float)vertIndex / (float)trail.activePointCount / 2f))) :
                    (TrailData.UsingSimpleColor ? Color.Lerp(TrailData.SimpleColorOverLifeStart,TrailData.SimpleColorOverLifeEnd,timeAlong) : TrailData.ColorOverLife.Evaluate(timeAlong));
                
                float s = TrailData.StretchSizeToFit ? 
                    (TrailData.UsingSimpleSize ? Mathf.Lerp(TrailData.SimpleSizeOverLifeStart,TrailData.SimpleSizeOverLifeEnd,1 - ((float)vertIndex / (float)trail.activePointCount / 2f)) : TrailData.SizeOverLife.Evaluate(1 - ((float)vertIndex / (float)trail.activePointCount / 2f))) : 
                    (TrailData.UsingSimpleSize ? Mathf.Lerp(TrailData.SimpleSizeOverLifeStart,TrailData.SimpleSizeOverLifeEnd, timeAlong) : TrailData.SizeOverLife.Evaluate(timeAlong));
                
                
                trail.verticies[vertIndex] = p.Position + cross * s;

                if(TrailData.MaterialTileLength <= 0)
                {
                    trail.uvs[vertIndex] = new Vector2((float)vertIndex / (float)trail.activePointCount / 2f, 0);
                }
                else
                {
                    trail.uvs[vertIndex] = new Vector2(p.GetDistanceFromStart() / TrailData.MaterialTileLength, 0);
                }

                trail.normals[vertIndex] = camForward;
                trail.colors[vertIndex] = c;
                vertIndex++;
                trail.verticies[vertIndex] = p.Position - cross * s;

                if (TrailData.MaterialTileLength <= 0)
                {
                    trail.uvs[vertIndex] = new Vector2((float)vertIndex / (float)trail.activePointCount / 2f, 1);
                }
                else
                {
                    trail.uvs[vertIndex] = new Vector2(p.GetDistanceFromStart() / TrailData.MaterialTileLength, 1);
                }

                trail.normals[vertIndex] = camForward;
                trail.colors[vertIndex] = c;

                vertIndex++;
            }

            Vector2 finalPosition = trail.verticies[vertIndex-1];
            for(int i = vertIndex; i < trail.verticies.Length; i++)
            {
                trail.verticies[i] = finalPosition;
            }

            int indIndex = 0;
            for (int pointIndex = 0; pointIndex < 2 * (trail.activePointCount - 1); pointIndex++)
            {
                if(pointIndex%2==0)
                {
                    trail.indicies[indIndex] = pointIndex;
                    indIndex++;
                    trail.indicies[indIndex] = pointIndex + 1;
                    indIndex++;
                    trail.indicies[indIndex] = pointIndex + 2;
                }
                else
                {
                    trail.indicies[indIndex] = pointIndex + 2;
                    indIndex++;
                    trail.indicies[indIndex] = pointIndex + 1;
                    indIndex++;
                    trail.indicies[indIndex] = pointIndex;
                }

                indIndex++;
            }

            int finalIndex = trail.indicies[indIndex-1];
            for (int i = indIndex; i < trail.indicies.Length; i++)
            {
                trail.indicies[i] = finalIndex;
            }

            trail.Mesh.vertices = trail.verticies;
            trail.Mesh.SetIndices(trail.indicies, MeshTopology.Triangles, 0);
            trail.Mesh.uv = trail.uvs;
            trail.Mesh.normals = trail.normals;
            trail.Mesh.colors = trail.colors;
        }

        private void DrawMesh(Mesh trailMesh, Material trailMaterial)
        {
            Graphics.DrawMesh(trailMesh, Matrix4x4.identity, trailMaterial, gameObject.layer);
        }

        private void UpdatePoints(PCTrail line, float deltaTime)
        {
            for (int i = 0; i < line.Points.Count; i++)
            {
                line.Points[i].Update(_noDecay ? 0 : deltaTime);
            }
        }

        [Obsolete("UpdatePoint is deprecated, you should instead override UpdateTrail and loop through the individual points yourself (See Smoke or Smoke Plume scripts for how to do this).", true)]
        protected virtual void UpdatePoint(PCTrailPoint pCTrailPoint, float deltaTime)
        {
        }

        private void CheckEmitChange()
        {
            if (_emit != Emit)
            {
                _emit = Emit;
                if (_emit)
                {
                    _activeTrail = new PCTrail(GetMaxNumberOfPoints());
                    _activeTrail.IsActiveTrail = true;
                    
                    OnStartEmit();
                }
                else
                {
                    OnStopEmit();
                    _activeTrail.IsActiveTrail = false;
                    _fadingTrails.Add(_activeTrail);
                    _activeTrail = null;
                }
            }
        }

        private int NumberOfActivePoints(PCTrail line)
        {
            int count = 0;
            for (int index = 0; index < line.Points.Count; index++)
            {
                if (line.Points[index].TimeActive() < TrailData.Lifetime) count++;
            }
            return count;
        }

        [UnityEngine.ContextMenu("Toggle inspector size input method")]
        protected void ToggleSizeInputStyle()
        {
            TrailData.UsingSimpleSize = !TrailData.UsingSimpleSize;
        }
        [UnityEngine.ContextMenu("Toggle inspector color input method")]
        protected void ToggleColorInputStyle()
        {
            TrailData.UsingSimpleColor = !TrailData.UsingSimpleColor;
        }

        public void LifeDecayEnabled(bool enabled)
        {
            _noDecay = !enabled;
        }

        /// <summary>
        /// Translates every point in the vector t
        /// </summary>
        public void Translate(Vector3 t)
        {
            if (_activeTrail != null)
            {
                for (int i = 0; i < _activeTrail.Points.Count; i++)
                {
                    _activeTrail.Points[i].Position += t;
                }
            }

            if (_fadingTrails != null)
            {
                foreach (PCTrail fadingTrail in _fadingTrails)
                {
                    for (int i = 0; i < fadingTrail.Points.Count; i++)
                    {
                        fadingTrail.Points[i].Position += t;
                    }
                }
            }

            OnTranslate(t);
        }

        /// <summary>
        /// Insert a trail into this trail renderer. 
        /// </summary>
        /// <param name="from">The start position of the trail.</param>
        /// <param name="to">The end position of the trail.</param>
        /// <param name="distanceBetweenPoints">Distance between each point on the trail</param>
        public void CreateTrail(Vector3 from, Vector3 to, float distanceBetweenPoints)
        {
            float distanceBetween = Vector3.Distance(from, to);

            Vector3 dirVector = to - from;
            dirVector = dirVector.normalized;

            float currentLength = 0;

            CircularBuffer<PCTrailPoint> newLine = new CircularBuffer<PCTrailPoint>(GetMaxNumberOfPoints());
            int pointNumber = 0;
            while (currentLength < distanceBetween) 
            {
                PCTrailPoint newPoint = new PCTrailPoint();
                newPoint.PointNumber = pointNumber;
                newPoint.Position = from + dirVector*currentLength;
                newLine.Add(newPoint);
                InitialiseNewPoint(newPoint);

                pointNumber++;

                if (distanceBetweenPoints <= 0)
                    break;
                else
                    currentLength += distanceBetweenPoints;
            }

            PCTrailPoint lastPoint = new PCTrailPoint();
            lastPoint.PointNumber = pointNumber;
            lastPoint.Position = to;
            newLine.Add(lastPoint);
            InitialiseNewPoint(lastPoint);

            PCTrail newTrail = new PCTrail(GetMaxNumberOfPoints());
            newTrail.Points = newLine;

            _fadingTrails.Add(newTrail);
        }
        
        /// <summary>
        /// Clears all active trails from the system.
        /// </summary>
        /// <param name="emitState">Desired emit state after clearing</param>
        public void ClearSystem(bool emitState)
        {
            if(_activeTrail != null)
            {
                _activeTrail.Dispose();
                _activeTrail = null;
            }

            if (_fadingTrails != null)
            {
                foreach (PCTrail fadingTrail in _fadingTrails)
                {
                    if (fadingTrail != null)
                        fadingTrail.Dispose();
                }

                _fadingTrails.Clear();
            }

            Emit = emitState;
            _emit = !emitState;

            CheckEmitChange();
        }

        /// <summary>
        /// Get the number of active seperate trail segments.
        /// </summary>
        public int NumSegments()
        {
            int num = 0;
            if (_activeTrail != null && NumberOfActivePoints(_activeTrail) != 0)
                num++;

            num += _fadingTrails.Count;
            return num;
        }
    }

    public class PCTrail : System.IDisposable
    {
        public CircularBuffer<PCTrailPoint> Points;
        public Mesh Mesh;

        public Vector3[] verticies;
        public Vector3[] normals;
        public Vector2[] uvs; 
        public Color[] colors; 
        public int[] indicies;
        public int activePointCount;

        public bool IsActiveTrail = false;

        public PCTrail(int numPoints)
        {
            Mesh = new Mesh();
            Mesh.MarkDynamic();

            verticies = new Vector3[2 * numPoints];
            normals = new Vector3[2 * numPoints];
            uvs = new Vector2[2 * numPoints];
            colors = new Color[2 * numPoints];
            indicies = new int[2 * (numPoints) * 3];

            Points = new CircularBuffer<PCTrailPoint>(numPoints);
        }

        #region Implementation of IDisposable

        public void Dispose()
        {
            if(Mesh != null)
            {
                if(Application.isEditor)
                    UnityEngine.Object.DestroyImmediate(Mesh, true);
                else
                    UnityEngine.Object.Destroy(Mesh);
            }

            Points.Clear();
            Points = null;
        }

        #endregion
    }

    public class PCTrailPoint  
    {
        public Vector3 Forward;
        public Vector3 Position;
        public int PointNumber;

        private float _timeActive = 0;
        private float _distance;

        public virtual void Update(float deltaTime)
        {
            _timeActive += deltaTime;
        }

        public float TimeActive()
        {
            return _timeActive;
        }

        public void SetTimeActive(float time)
        {
            _timeActive = time;
        }

        public void SetDistanceFromStart(float distance)
        {
            _distance = distance;
        }

        public float GetDistanceFromStart()
        {
            return _distance;
        }
    }

    [System.Serializable]
    public class PCTrailRendererData
    {
        public Material TrailMaterial;
        public float Lifetime = 1;
        public bool UsingSimpleSize = false;
        public float SimpleSizeOverLifeStart;
        public float SimpleSizeOverLifeEnd;
        public AnimationCurve SizeOverLife = new AnimationCurve();
        public bool UsingSimpleColor = false;
        public Color SimpleColorOverLifeStart;
        public Color SimpleColorOverLifeEnd;
        public Gradient ColorOverLife;
        public bool StretchSizeToFit;
        public bool StretchColorToFit;
        public float MaterialTileLength = 0;
        public bool UseForwardOverride;
        public Vector3 ForwardOverride;
        public bool ForwardOverrideRelative;
    }
}



 Plugins/Trails/TrailRenderer_Base.cs.meta

New file
@@ -0,0 +1,15 @@
fileFormatVersion: 2
guid: 87716fa8801130a4994e129a3b6b2fa6
labels:
- BetterTrails
- TrailRenderer
- Smoke
- Trail
- Effects
- skidmarks
MonoImporter:
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 1000
  icon: {instanceID: 0}
  userData: 

 Plugins/Trails/VersionInformation.cs

New file
@@ -0,0 +1,42 @@
namespace PigeonCoopToolkit.Generic
{
    [System.Serializable]
    public class VersionInformation
    {
        public string Name;
        public int Major = 1;
        public int Minor = 0;
        public int Patch = 0;

        public VersionInformation(string name, int major, int minor, int patch)
        {
            Name = name;
            Major = major;
            Minor = minor;
            Patch = patch;
        }

        public override string ToString()
        {
            return string.Format("{0} {1}.{2}.{3}", Name, Major, Minor, Patch);
        }

        public bool Match(VersionInformation other, bool looseMatch)
        {
            if(looseMatch)
            {
                return other.Name == Name &&
                       other.Major == Major &&
                       other.Minor == Minor;
            }
            else
            {
                return other.Name == Name &&
                       other.Major == Major &&
                       other.Minor == Minor &&
                       other.Patch == Patch;
            }
        }

    }
}

 Plugins/Trails/VersionInformation.cs.meta

New file
@@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: 1d58a7e753bea0e4c84779d092563363
MonoImporter:
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 

 System/Chat/ChatCenter.cs

@@ -766,7 +766,7 @@
            {

                ChatCtrl.Inst.presentChatType = ChatInfoType.Fairy;

                WindowCenter.Instance.CloseImmediately<MainInterfaceWin>();

                WindowCenter.Instance.Open<SocialWin>(false, 2);

                WindowCenter.Instance.Open<SocialWin>();

            }

        }

        #endregion


 System/Chat/ChatTip.cs

@@ -155,7 +155,7 @@
        {

            ChatCtrl.Inst.presentChatType = ChatInfoType.Fairy;

            WindowCenter.Instance.CloseImmediately<MainInterfaceWin>();

            WindowCenter.Instance.Open<SocialWin>(false, 2);

            WindowCenter.Instance.Open<SocialWin>();

            return;

        }

        WindowCenter.Instance.Open<ChatWin>();

@@ -228,11 +228,11 @@
        {

            case ChatInfoType.Team:

                WindowCenter.Instance.CloseImmediately<MainInterfaceWin>();

                WindowCenter.Instance.Open<SocialWin>(false, 1);

                WindowCenter.Instance.Open<SocialWin>(false, 2);

                break;

            case ChatInfoType.Fairy:

                WindowCenter.Instance.CloseImmediately<MainInterfaceWin>();

                WindowCenter.Instance.Open<SocialWin>(false, 2);

                WindowCenter.Instance.Open<SocialWin>();

                break;

            default:

                WindowCenter.Instance.Open<ChatWin>();


 System/DailyQuest/DailyQuestData.cs

@@ -229,9 +229,9 @@
        }



        var isSpecialDay = TimeUtility.OpenWeekCnt <= 1;

        var openDayWeek = (int)TimeUtility.openServerTime.DayOfWeek;

        var openDayWeek = (int)TimeUtility.openServerDayOfWeek;

        var dayIndex = TimeUtility.OpenDay + 1;

        if (isSpecialDay && specialOpenTimes.ContainsKey(openDayWeek) && specialOpenTimes[openDayWeek].ContainsKey(dayIndex))

        if (isSpecialDay)

        {

            if (specialOpenTimes.ContainsKey(openDayWeek) && specialOpenTimes[openDayWeek].ContainsKey(dayIndex))

            {

@@ -278,7 +278,7 @@
    public bool TryGetTodayNearestOpenTime(out HourMinute _hourMinute)

    {

        var isSpecialDay = TimeUtility.OpenWeekCnt <= 1;

        var openDayWeek = (int)TimeUtility.openServerTime.DayOfWeek;

        var openDayWeek = (int)TimeUtility.openServerDayOfWeek;

        var dayIndex = TimeUtility.OpenDay + 1;

        if (isSpecialDay)

        {

@@ -336,7 +336,7 @@


    public bool ContainTimeNode(int week, int timeNode)

    {

        var openDayWeek = (int)TimeUtility.openServerTime.DayOfWeek;

        var openDayWeek = (int)TimeUtility.openServerDayOfWeek;



        List<HourMinute> hourMinutes = null;

        var dayDelta = (week == 0 ? 7 : week) - (openDayWeek == 0 ? 7 : openDayWeek);

@@ -365,7 +365,7 @@


    private bool ContainWeek(int week)

    {

        var openDayWeek = (int)TimeUtility.openServerTime.DayOfWeek;

        var openDayWeek = (int)TimeUtility.openServerDayOfWeek;

        var todayWeek = (int)TimeUtility.ServerNow.DayOfWeek;

        var dayDelta = (week == 0 ? 7 : week) - (openDayWeek == 0 ? 7 : openDayWeek);



@@ -430,7 +430,7 @@
        var isSpecificDay = TimeUtility.OpenWeekCnt <= 1;

        if (isSpecificDay)

        {

            var openDayWeek = (int)TimeUtility.openServerTime.DayOfWeek;

            var openDayWeek = (int)TimeUtility.openServerDayOfWeek;

            var todayWeek = (int)TimeUtility.ServerNow.DayOfWeek;

            var dayDelta = ((week == 0 ? 7 : week) - (todayWeek == 0 ? 7 : todayWeek));

            var dayIndex = TimeUtility.OpenDay + 1 + dayDelta;


 System/DailyQuest/DailyQuestModel.cs

@@ -146,6 +146,11 @@
            UpdateRedpoints();

        }



        public List<int> GetDailyQuests()

        {

            return new List<int>(dailyQuests.Keys);

        }



        public List<int> GetDailyQuests(DailyQuestCategory _category)

        {

            var quests = new List<int>();

@@ -499,11 +504,6 @@
        private void OnFairyLeagueBattle()

        {

            UpdateDailyActionRedpoint((int)DailyQuestType.FairyLeague);

        }



        public Dictionary<int, DailyQuestData> GetDailyQuestlist()

        {

            return dailyQuests;

        }



        public void UpdateRedpoints()


 System/DailyQuest/DailyQuestWin.cs

@@ -85,8 +85,8 @@
            if (guidingDailyQuestId != 0)

            {

                var preferTimeLimit = false;

                var dailyQuests = model.GetDailyQuestlist();

                foreach (var quest in dailyQuests.Keys)

                var dailyQuests = model.GetDailyQuests();

                foreach (var quest in dailyQuests)

                {

                    var dailyQuestState = model.GetQuestState(quest);

                    DailyQuestOpenTime openTime;


 System/Dogz/DogzActiveWin.cs

@@ -16,7 +16,7 @@
        [SerializeField] ScrollerController m_Controller;

        [SerializeField] List<DogzSkillData> m_DogzSkills;

        [SerializeField] List<DogzEquip> m_DogzEquips;

        [SerializeField] List<Button> m_DogzUnEquipBtns;

        [SerializeField] List<DogzUnEquip> m_DogzUnEquipBtns;

        [SerializeField] List<Text> m_PropertyTypes;

        [SerializeField] List<Text> m_PropertyValues;

        [SerializeField] Image m_DogzHeadIcon;

@@ -25,7 +25,11 @@
        [SerializeField] Button m_TakeOffEquipBtn;

        [SerializeField] Button m_EquipPackBtn;

        [SerializeField] Button m_CallBackBtn;

        [SerializeField] RedpointBehaviour assistBtnRedBehav;

        [SerializeField] Text m_CallBackBtnTxt;

        [SerializeField] UIEffect alreadyAssistEffect;

        [SerializeField] UIEffect assistEffect;

        [SerializeField] UIEffect assistTextEffect;

        DogzModel m_Model;

        DogzModel model

        {

@@ -51,7 +55,7 @@
            for (int i = 0; i < m_DogzUnEquipBtns.Count; i++)

            {

                var _index = i;

                m_DogzUnEquipBtns[i].onClick.AddListener(() =>

                m_DogzUnEquipBtns[i].DogzUnEquipBtn.AddListener(() =>

                {

                    OpenDogzEquip(_index);

                });

@@ -66,8 +70,6 @@
            model.UpdateSelectDogzEvent += UpdateSelectDogzEvent;

            model.UpdateAssistDogzEvent += UpdateDogzAssistCnt;

            model.RefreshDogzEquipAct += RefreshDogzEquipEvent;





        }



        protected override void OnAfterOpen()

@@ -98,6 +100,8 @@
                }

                m_Controller.Restart();

            }

            int jumpIndex = model.presentSelectDogz - 1 > 0 ? model.presentSelectDogz - 1 : 0;

            m_Controller.JumpIndex(jumpIndex);

        }

        private void UpdateSelectDogzEvent()

        {

@@ -106,6 +110,7 @@
            UpdateDogzEquip();

            UpdateDogzProperty();

            UpdateDogzBtn();

            assistBtnRedBehav.redpointId = model.GetDogzAssistRedpointById(model.presentSelectDogz).id;

        }

        private void UpdateDogzSkill()

        {

@@ -144,9 +149,12 @@
        private void RefreshDogzEquipEvent(int dogzId)

        {

            if (dogzId != model.presentSelectDogz) return;



            m_Controller.m_Scorller.RefreshActiveCellViews();

            UpdateDogzEquip();

            UpdateDogzProperty();

            UpdateDogzBtn();



        }



        private void UpdateDogzEquip()

@@ -154,11 +162,30 @@
            var _dogzCfg = Config.Instance.Get<DogzConfig>(model.presentSelectDogz);

            m_DogzHeadIcon.SetSprite(_dogzCfg.HeadIcon);

            m_DogzHeadIcon.SetNativeSize();

            var _dogzEquips = model.GetDogzEquips(model.presentSelectDogz);

            alreadyAssistEffect.Stop();

            if (_dogzEquips != null && _dogzEquips.Count == 5)

            {

                m_DogzHeadIcon.material = MaterialUtility.GetUIDefaultGraphicMaterial();

                if(model.TryGetAssistDogzState(model.presentSelectDogz))

                {

                    if(!alreadyAssistEffect.IsPlaying)

                    {

                        alreadyAssistEffect.Play();

                    }

                }

            }

            else

            {

                m_DogzHeadIcon.material = MaterialUtility.GetDefaultSpriteGrayMaterial();

            }



            for (int i = 0; i < m_DogzEquips.Count; i++)

            {

                ItemModel _data;

                bool _equiped = model.TryGetDogzEquip(model.presentSelectDogz, i+101, out _data);

                m_DogzUnEquipBtns[i].gameObject.SetActive(!_equiped);

                m_DogzUnEquipBtns[i].DogzUnEquipBtn.gameObject.SetActive(!_equiped);

                m_DogzUnEquipBtns[i].RedpointBeh.redpointId = model.GetDogzEquipPlaceRedpointById(model.presentSelectDogz,i).id;

                m_DogzEquips[i].gameObject.SetActive(_equiped);

                if (_equiped)

                {

@@ -228,13 +255,16 @@
                }

            }

        }



        private void UpdateDogzAssistCnt()

        {

            m_Controller.m_Scorller.RefreshActiveCellViews();

            m_DogzAssistCnt.text = Language.Get("TreasurePrivilege_Dogz_1", StringUtility.Contact(model.GetAssistDogzCount(), "/", model.DogzAssistDefaultCnt));

            UpdateDogzBtn();

            UpdateDogzProperty();

            UpdateDogzEquip();

        }



        private void UpdateDogzBtn()

        {

            var _dogzEquips = model.GetDogzEquips(model.presentSelectDogz);

@@ -269,6 +299,8 @@
                {

                    if(model.GetAssistDogzCount() < model.DogzAssistDefaultCnt)

                    {

                        assistEffect.Play();

                        assistTextEffect.Play();

                        model.SendChangeDogzAssist(1);

                    }

                    else

@@ -302,6 +334,15 @@
            [SerializeField] Button m_SkillBtn;

            public Button SkillBtn { get { return m_SkillBtn; } }

        }



        [Serializable]

        public class DogzUnEquip

        {

            [SerializeField] Button m_DogzUnEquipBtn;

            public Button DogzUnEquipBtn { get { return m_DogzUnEquipBtn; } }

            [SerializeField] RedpointBehaviour m_RedpointBeh;

            public RedpointBehaviour RedpointBeh { get { return m_RedpointBeh; } }

        }

    }

}




 System/Dogz/DogzCell.cs

@@ -14,6 +14,7 @@
        [SerializeField] Text m_DogzName;

        [SerializeField] Text m_DogzGrade;

        [SerializeField] Button m_DogzBtn;

        [SerializeField] RedpointBehaviour redpointBehav;



        DogzModel m_Model;

        DogzModel model

@@ -34,6 +35,7 @@
            bool isActive = (_dogzEquips == null || _dogzEquips.Count < 5) ? false : true;

            m_DogzName.text = _dogzCfg.Name;

            m_DogzGrade.text = StringUtility.Contact("评分：", 100);

            redpointBehav.redpointId = model.GetSingleDogzRedpointById(_dogzCfg.ID).id;

            if (isActive)

            {

                m_DogzIcon.material = MaterialUtility.GetUIDefaultGraphicMaterial();


 System/Dogz/DogzModel.cs

@@ -14,6 +14,7 @@
        public override void Init()

        {

            ParseConfig();

            SetDogzAndEquipPlaceRedKey();

        }



        public void OnBeforePlayerDataInitialize()

@@ -37,6 +38,9 @@
            SetDogzEquipInfo();

            playerPack.RefreshItemCountAct -= RefreshDogzEquipInfo;

            playerPack.RefreshItemCountAct += RefreshDogzEquipInfo;

            UpdateDogzAssistRed();

            UpdateDogzEquipPlaceRed();

            UpdateAssistNumRed();

        }



        public override void UnInit()

@@ -104,15 +108,15 @@
            switch (_index)

            {

                case 0:

                    return "兽角";

                    return Language.Get("DogzEquip1");

                case 1:

                    return "魔眼";

                    return Language.Get("DogzEquip2");

                case 2:

                    return "獠牙";

                    return Language.Get("DogzEquip3");

                case 3:

                    return "兽爪";

                    return Language.Get("DogzEquip4");

                case 4:

                    return "鳞甲";

                    return Language.Get("DogzEquip5");

                default:

                    return string.Empty;

            }

@@ -124,15 +128,17 @@
            {

                case 0:

                case 1:

                    return "白色";

                    return Language.Get("DogzWhite");

                case 2:

                    return "蓝色";

                    return Language.Get("DogzBlue");

                case 3:

                    return "紫色";

                    return Language.Get("DogzPurple");

                case 4:

                    return "橙色";

                    return Language.Get("DogzOrange");

                case 5:

                    return "红色";

                    return Language.Get("DogzRed");

                case 6:

                    return Language.Get("DogzPink");

                default:

                    return string.Empty;

            }

@@ -155,13 +161,23 @@
            }

        }



        public event Action<int> OpenFuncEvent;

        public void OpenDogzFuncEvent(int functionOrder)

        public event Action<int,int> OpenFuncEvent;

        public void OpenDogzFuncEvent(int functionOrder,int equipIndex)

        {

            if(OpenFuncEvent != null)

            {

                OpenFuncEvent(functionOrder);

                OpenFuncEvent(functionOrder,equipIndex);

            }

        }



        public bool CheckIsAddAssistNum()

        {

            var _itemConfig = Config.Instance.Get<ItemConfig>(AddAssistItem);

            if(GetAssistItemCnt() <= playerPack.GetItemCountByID(PackType.rptItem, AddAssistItem))

            {

                return true;

            }

            return false;

        }



        #region 协议

@@ -175,6 +191,8 @@
            {

                UpdateAssistDogzEvent();

            }

            UpdateDogzAssistRed();

            UpdateDogzEquipPlaceRed();

        }



        public event Action UpdateAssistDogzEvent;

@@ -194,6 +212,9 @@
            {

                UpdateAssistDogzEvent();

            }



            UpdateDogzAssistRed();

            UpdateDogzEquipPlaceRed();

        }



        public int GetAssistDogzCount()

@@ -218,7 +239,7 @@


        public void SetDogzEquipInfo()

        {

            m_DogzEquipDict = new Dictionary<int, List<ItemModel>>();

            m_DogzEquipDict.Clear();

            SinglePackModel singlePack = playerPack.GetSinglePackModel(PackType.rptDogzEquip);

            if (singlePack == null) return;



@@ -244,63 +265,75 @@
        public Action<int> RefreshDogzEquipAct;

        private void RefreshDogzEquipInfo(PackType type, int index, int id)

        {

            if (type != PackType.rptDogzEquip) return;



            ItemModel itemModel = playerPack.GetItemModelByIndex(type, index);

            int dogzId = GetDogzIDByIndex(index);

            List<ItemModel> modellist = GetDogzEquips(dogzId);

            if(modellist != null)

            if(type == PackType.rptItem && id == AddAssistItem)

            {

                if (itemModel != null)

                UpdateAssistNumRed();

            }

            else if(type == PackType.rptDogzItem)

            {

                UpdateDogzAssistRed();

                UpdateDogzEquipPlaceRed();

            }

            else if(type == PackType.rptDogzEquip)

            {

                ItemModel itemModel = playerPack.GetItemModelByIndex(type, index);

                int dogzId = GetDogzIDByIndex(index);

                List<ItemModel> modellist = GetDogzEquips(dogzId);

                if (modellist != null)

                {

                    bool isAdd = true;

                    for (int i = 0; i < modellist.Count; i++)

                    if (itemModel != null)

                    {

                        if (modellist[i].itemInfo.ItemPlace == index)

                        bool isAdd = true;

                        for (int i = 0; i < modellist.Count; i++)

                        {

                            isAdd = false;

                            modellist[i] = itemModel;

                            break;

                            if (modellist[i].itemInfo.ItemPlace == index)

                            {

                                isAdd = false;

                                modellist[i] = itemModel;

                                break;

                            }

                        }

                        if (isAdd)

                        {

                            modellist.Add(itemModel);

                        }

                    }

                    if(isAdd)

                    else

                    {

                       modellist.Add(itemModel);

                        for (int i = 0; i < modellist.Count; i++)

                        {

                            if (modellist[i].itemInfo.ItemPlace == index)

                            {

                                modellist.RemoveAt(i);

                                break;

                            }

                        }

                    }

                }

                else

                {

                    for (int i = 0; i < modellist.Count; i++)

                    if (itemModel != null)

                    {

                        if (modellist[i].itemInfo.ItemPlace == index)

                        {

                            modellist.RemoveAt(i);

                            break;

                        }

                        List<ItemModel> equipDatas = new List<ItemModel>();

                        equipDatas.Add(itemModel);

                        m_DogzEquipDict.Add(dogzId, equipDatas);

                    }

                }

            }

            else

            {

                if(itemModel != null)

                {

                    List<ItemModel> equipDatas = new List<ItemModel>();

                    equipDatas.Add(itemModel);

                    m_DogzEquipDict.Add(dogzId,equipDatas);

                }

            }

          


            if(RefreshDogzEquipAct != null)

            {

                RefreshDogzEquipAct(dogzId);

                if (RefreshDogzEquipAct != null)

                {

                    RefreshDogzEquipAct(dogzId);

                }



                UpdateDogzAssistRed();

                UpdateDogzEquipPlaceRed();

            }

        }



        /// <summary>

        /// 获得神兽穿戴的装备数据

        /// </summary>

        public Dictionary<int, List<ItemModel>> m_DogzEquipDict { get; private set; }

        private Dictionary<int, List<ItemModel>> m_DogzEquipDict = new Dictionary<int, List<ItemModel>>();



        public List<ItemModel> GetDogzEquips(int _dogzId)

        {

@@ -510,13 +543,13 @@
        }



        public List<ItemModel> selectEquipPlacelist { get; private set; }

        public List<ItemModel> GetDogzItemListByIndex(int index)

        public List<ItemModel> GetDogzItemListByIndex(int dogzId,int index)

        {

            SinglePackModel singlePack = playerPack.GetSinglePackModel(PackType.rptDogzItem);

            selectEquipPlacelist.Clear();

            if (singlePack == null) return selectEquipPlacelist;



            var _itemColor = GetDogzEquipLimitByIndex(presentSelectDogz, index);

            var _itemColor = GetDogzEquipLimitByIndex(dogzId, index);

            var _equipPlace = GetDogzEquipPlaceByIndex(index);

            Dictionary<int, ItemModel> pairs = singlePack.GetPackModelIndexDict();

            foreach (var value in pairs.Values)

@@ -547,41 +580,276 @@
        }

        #endregion



        #region 装备详细信息

        public DogzEquipData viewDetailData { get; private set; }



        public bool viewDetailCompare { get; private set; }



        public void ViewDetail(int _itemId, bool compare = false)

        {

            //viewDetailData = new DogzEquipData(_itemId);

            //viewDetailCompare = compare;

            //if (!WindowCenter.Instance.CheckOpen<DogzDetailsWin>())

            //{

            //    WindowCenter.Instance.Open<DogzDetailsWin>();

            //}

        }



        public int DogzEquipScore(DogzEquipData data)

        {

            return 0;

        }

        #endregion



        #region 默认选择逻辑处理

        public void SetDefaultSelectDogz()

        {

            var configs = Config.Instance.GetAllValues<DogzConfig>();

            presentSelectDogz = configs[0].ID;

            foreach (var key in dogzAssistStateDict.Keys)

            foreach (var key in m_DogzEquipLimit.Keys)

            {

                if(dogzAssistStateDict[key] == 1)

                Redpoint redpoint = GetSingleDogzRedpointById(key);

                if (redpoint.state == RedPointState.Simple)

                {

                    if(presentSelectDogz < key)

                    presentSelectDogz = key;

                    break;

                }

            }

        }

        #endregion



        #region 红点逻辑处理

        public const int MAINDOGZ_REDKEY = 112;

        public const int DOGZFUNC_REDKEY = 11201;

        public const int ADDASSISTDOGZ_REDKEY = 1120100002;

        public Redpoint mainDogzRedpoint = new Redpoint(MainRedDot.RedPoint_key, MAINDOGZ_REDKEY);

        public Redpoint dogzFuncRedpoint = new Redpoint(MAINDOGZ_REDKEY,DOGZFUNC_REDKEY);

        public Redpoint addAssistDogzRedpoint = new Redpoint(DOGZFUNC_REDKEY,ADDASSISTDOGZ_REDKEY);

        private Dictionary<int, Redpoint> singleDogzRedDict = new Dictionary<int, Redpoint>();

        private Dictionary<int, Redpoint> dogzAssistRedDict = new Dictionary<int, Redpoint>();

        private Dictionary<int, Dictionary<int, Redpoint>> dogzEquipPlaceRedDict = new Dictionary<int, Dictionary<int, Redpoint>>();

        public void SetDogzAndEquipPlaceRedKey()

        {

            singleDogzRedDict.Clear();

            dogzEquipPlaceRedDict.Clear();

            dogzAssistRedDict.Clear();

            int i = 0;

            foreach(var dogzId in m_DogzEquipLimit.Keys)

            {

                i += 1;

                int dogzRedKey = DOGZFUNC_REDKEY * 100 + i;

                Redpoint dogzRedPoint = new Redpoint(DOGZFUNC_REDKEY,dogzRedKey);

                singleDogzRedDict.Add(dogzId, dogzRedPoint);

                int dogzAssistRedKey = dogzRedKey * 100 + i;

                Redpoint dogzAssistRedPoint = new Redpoint(dogzRedKey, dogzAssistRedKey);

                dogzAssistRedDict.Add(dogzId,dogzAssistRedPoint);

                Dictionary<int, Redpoint> equipPlaceRedDict = new Dictionary<int, Redpoint>();

                dogzEquipPlaceRedDict.Add(dogzId,equipPlaceRedDict);

                int equipPlaceNum = m_DogzEquipLimit[dogzId].Count;

                for (int j = 0; j < equipPlaceNum; j++)

                {

                    int equipPlaceRedKey = dogzRedKey * 10 + j;

                    Redpoint equipPlaceRedpoint = new Redpoint(dogzRedKey,equipPlaceRedKey);

                    equipPlaceRedDict.Add(j, equipPlaceRedpoint);

                }



            }

        }



        public Redpoint GetSingleDogzRedpointById(int dogzId)

        {

            Redpoint redpoint = null;

            singleDogzRedDict.TryGetValue(dogzId, out redpoint);

            return redpoint;

        }



        public Redpoint GetDogzAssistRedpointById(int dogzId)

        {

            Redpoint redpoint = null;

            dogzAssistRedDict.TryGetValue(dogzId,out redpoint);

            return redpoint;

        }



        public Redpoint GetDogzEquipPlaceRedpointById(int dogzId,int index)

        {

            Redpoint redpoint = null;

            if(dogzEquipPlaceRedDict.ContainsKey(dogzId))

            {

                dogzEquipPlaceRedDict[dogzId].TryGetValue(index, out redpoint);

            }

            return redpoint;

        }



        public void UpdateDogzAssistRed()

        {

            foreach(var value in dogzAssistRedDict.Values)

            {

                value.state = RedPointState.None;

            }

            bool isMaxAssistNum = GetAssistDogzCount() >= DogzAssistDefaultCnt ? true : false;

            if(!isMaxAssistNum)

            {

                int maxDogzId = 0;

                foreach(var dogzId in m_DogzEquipLimit.Keys)

                {

                    var equips = GetDogzEquips(dogzId);

                    int equipNum = equips == null ? 0 : equips.Count;

                    if(equipNum >= 5 && maxDogzId < dogzId

                        && !TryGetAssistDogzState(dogzId))

                    {

                        presentSelectDogz = key;

                        maxDogzId = dogzId;

                    }

                }

                if(maxDogzId > 0)

                {

                    Redpoint assistRedpoint = GetDogzAssistRedpointById(maxDogzId);

                    if(assistRedpoint.state == RedPointState.None)

                    {

                        assistRedpoint.state = RedPointState.Simple;

                    }

                }

            }

            else

            {

                foreach (var dogzId in m_DogzEquipLimit.Keys)

                {

                    var equips = GetDogzEquips(dogzId);

                    int equipNum = equips == null ? 0 : equips.Count;

                    if(!TryGetAssistDogzState(dogzId) && equipNum == 5)

                    {

                        Redpoint assistRedpoint = GetDogzAssistRedpointById(dogzId);

                        if (assistRedpoint.state == RedPointState.None)

                        {

                            assistRedpoint.state = RedPointState.Simple;

                        }

                        break;

                    }

                }

            }

        }



        public void UpdateDogzEquipPlaceRed()

        {

            foreach(var value in dogzEquipPlaceRedDict.Values)

            {

                foreach(var value2 in value.Values)

                {

                    value2.state = RedPointState.None;

                }

            }



            foreach(var value in dogzAssistRedDict.Values)

            {

                if(value.state == RedPointState.Simple)

                {

                    return;

                }

            }

            bool isMaxAssistNum = GetAssistDogzCount() >= DogzAssistDefaultCnt ? true : false;

            if (!isMaxAssistNum)

            {

                int maxEquipNum = 0;

                int spaceDogzId = 0;

                foreach (var dogzId in m_DogzEquipLimit.Keys)

                {

                    var equips = GetDogzEquips(dogzId);

                    int equipNum = equips == null ? 0 : equips.Count;

                    if (equipNum < 5)

                    {

                        if (spaceDogzId == 0)

                        {

                            if (maxEquipNum <= equipNum)

                            {

                                maxEquipNum = equipNum;

                                spaceDogzId = dogzId;

                            }

                        }

                        else

                        {

                            if (maxEquipNum < equipNum)

                            {

                                maxEquipNum = equipNum;

                                spaceDogzId = dogzId;

                            }

                        }

                    }

                }



                if(spaceDogzId != 0)

                {

                    for(int i = 0; i < 5; i++)

                    {

                        ItemModel _data;

                        bool _equiped = TryGetDogzEquip(spaceDogzId, i + 101, out _data);

                        if(!_equiped)

                        {

                            GetDogzItemListByIndex(spaceDogzId,i);

                            if (selectEquipPlacelist.Count > 0)

                            {

                                Redpoint equipPlaceRedpoint = GetDogzEquipPlaceRedpointById(spaceDogzId,i);

                                if(equipPlaceRedpoint.state == RedPointState.None)

                                {

                                    equipPlaceRedpoint.state = RedPointState.Simple;

                                }

                                break;

                            }

                        }

                    }

                }

            }

            else

            {

                int minAlreadyAssistId = 0;

                foreach (var dogzId in m_DogzEquipLimit.Keys)

                {

                    if(TryGetAssistDogzState(dogzId)

                        && minAlreadyAssistId != 0

                        && minAlreadyAssistId < dogzId)

                    {

                        minAlreadyAssistId = dogzId;

                    }

                }



                foreach (var dogzId in m_DogzEquipLimit.Keys)

                {

                    var equips = GetDogzEquips(dogzId);

                    int equipNum = equips == null ? 0 : equips.Count;

                    bool isBetterDogz = true;

                    if(!TryGetAssistDogzState(dogzId) && dogzId > minAlreadyAssistId && equipNum < 5)

                    {

                        for (int i = 0; i < 5; i++)

                        {

                            ItemModel _data;

                            bool _equiped = TryGetDogzEquip(dogzId, i + 101, out _data);

                            if (!_equiped)

                            {

                                GetDogzItemListByIndex(dogzId,i);

                                if (selectEquipPlacelist.Count < 1)

                                {

                                    isBetterDogz = false;

                                    break;

                                }

                            }

                        }

                    }

                    else

                    {

                        isBetterDogz = false;

                    }



                    if(isBetterDogz)

                    {

                        for (int i = 0; i < 5; i++)

                        {

                            ItemModel _data;

                            bool _equiped = TryGetDogzEquip(dogzId, i + 101, out _data);

                            if (!_equiped)

                            {

                                Redpoint equipPlaceRedpoint = GetDogzEquipPlaceRedpointById(dogzId, i);

                                if (equipPlaceRedpoint.state == RedPointState.None)

                                {

                                    equipPlaceRedpoint.state = RedPointState.Simple;

                                    break;

                                }

                            }

                        }

                        break;

                    }

                }

            }

        }



        public void UpdateAssistNumRed()

        {

          if(CheckIsAddAssistNum())

           {

                if(addAssistDogzRedpoint.state == RedPointState.None)

                {

                    addAssistDogzRedpoint.state = RedPointState.Simple;

                }

            }

          else

            {

                addAssistDogzRedpoint.state = RedPointState.None;

            }

        }

        #endregion


 System/Dogz/DogzPackWin.cs

@@ -16,7 +16,7 @@
    public class DogzPackWin : Window

    {

        [SerializeField] List<DogzEquip> m_DogzEquips;

        [SerializeField] List<Button> m_DogzUnEquipBtns;

        [SerializeField] List<DogzUnEquip> m_DogzUnEquipBtns;

        [SerializeField] List<Text> m_DogzUnEquipContents;

        [SerializeField] Image m_DogzHeadIcon;

        [SerializeField] Button m_CloseBtn;

@@ -106,7 +106,8 @@
                ItemModel _data;

                int index = i;

                bool _equiped = dogzModel.TryGetDogzEquip(dogzModel.presentSelectDogz, i+101, out _data);

                m_DogzUnEquipBtns[i].gameObject.SetActive(!_equiped);

                m_DogzUnEquipBtns[i].DogzUnEquipBtn.gameObject.SetActive(!_equiped);

                m_DogzUnEquipBtns[i].RedpointBeh.redpointId = dogzModel.GetDogzEquipPlaceRedpointById(dogzModel.presentSelectDogz,i).id;

                m_DogzEquips[i].gameObject.SetActive(_equiped);

                if (_equiped)

                {

@@ -118,15 +119,15 @@
                    m_DogzUnEquipContents[i].text = StringUtility.Contact(DogzModel.GetItemColorName(_itemColor),

                        DogzModel.GetDogzPartNameByIndex(i));

                    m_DogzUnEquipContents[i].color = UIHelper.GetUIColor(_itemColor);

                    m_DogzUnEquipBtns[i].RemoveAllListeners();

                    m_DogzUnEquipBtns[i].AddListener(() => { ClickEquipIndex(index); });

                    m_DogzUnEquipBtns[i].DogzUnEquipBtn.RemoveAllListeners();

                    m_DogzUnEquipBtns[i].DogzUnEquipBtn.AddListener(() => { ClickEquipIndex(index); });

                }

            }

        }



        private void ClickEquipIndex(int index)

        {

            dogzModel.GetDogzItemListByIndex(index);

            dogzModel.GetDogzItemListByIndex(dogzModel.presentSelectDogz,index);

            if(dogzModel.selectEquipPlacelist.Count > 0)

            {

                WindowCenter.Instance.Open<SelectDogzItemWin>();

@@ -177,6 +178,7 @@
        private void GetEquipBtn()

        {

            //--界面跳转

            WindowJumpMgr.Instance.WindowJumpTo(JumpUIType.DogzDungeon);

        }



        private void ClickStarSelect()

@@ -188,6 +190,15 @@
        {

            qualitySort.gameObject.SetActive(!qualitySort.gameObject.activeInHierarchy);

        }



        [Serializable]

        public class DogzUnEquip

        {

            [SerializeField] Button m_DogzUnEquipBtn;

            public Button DogzUnEquipBtn { get { return m_DogzUnEquipBtn; } }

            [SerializeField] RedpointBehaviour m_RedpointBeh;

            public RedpointBehaviour RedpointBeh { get { return m_RedpointBeh; } }

        }

    }



}


 System/Dogz/DogzWin.cs

@@ -70,8 +70,9 @@
        }





        private void OnOpenFuncEvent(int order)

        private void OnOpenFuncEvent(int order,int equipIndex)

        {

            ModelCenter.Instance.GetModel<GodBeastModel>().ItemPlace = equipIndex;

            funcBtnGroup.TriggerByOrder(order);

            if(WindowCenter.Instance.CheckOpen<DogzPackWin>())

            {


 System/DogzDungeon/DogzDungeonModel.cs

@@ -13,14 +13,11 @@
        public const int DATA_MAPID = 21110;

        int m_SelectedBoss = 0;
        public int selectedBoss
        {
            get
            {
        public int selectedBoss {
            get {
                return this.m_SelectedBoss;
            }
            set
            {
            set {
                if (this.m_SelectedBoss != value)
                {
                    this.m_SelectedBoss = value;
@@ -33,11 +30,9 @@
        }

        int m_WearyValue = 0;
        public int wearyValue
        {
        public int wearyValue {
            get { return m_WearyValue; }
            set
            {
            set {
                if (m_WearyValue != value)
                {
                    m_WearyValue = value;
@@ -50,11 +45,9 @@
        }

        int m_BigBoxCollectCount = 0;
        public int bigBoxCollectCount
        {
        public int bigBoxCollectCount {
            get { return m_BigBoxCollectCount; }
            set
            {
            set {
                if (m_BigBoxCollectCount != value)
                {
                    m_BigBoxCollectCount = value;
@@ -67,8 +60,7 @@
        }

        int m_SmallBoxCollectCount = 0;
        public int smallBoxCollectCount
        {
        public int smallBoxCollectCount {
            get { return m_SmallBoxCollectCount; }
            set { m_SmallBoxCollectCount = value; }
        }
@@ -272,18 +264,39 @@

        public void UpdateBoxOrEliteRefreshTime(HA904_tagGCDogzNPCRefreshTime _refreshTimes)
        {
            var containBox = false;
            var boxRefreshSecond = 0;

            var containElite = false;
            var eliteRefreshSecond = 0;

            for (int i = 0; i < _refreshTimes.InfoList.Length; i++)
            {
                var info = _refreshTimes.InfoList[i];
                if (bigBoxNpcId == info.NPCID || smallBoxNpcId == info.NPCID)
                {
                    dogzDungeonBox.UpdateBoxRefreshTime((int)info.RefreshSecond);
                    RequestBoxSurplusInfo();
                    containBox = true;
                    boxRefreshSecond = (int)info.RefreshSecond;
                }

                if (eliteMonsters.Contains((int)info.NPCID))
                {
                    dogzDungeonElite.UpdateEliteRefreshTime((int)info.RefreshSecond);
                    containElite = true;
                    eliteRefreshSecond = (int)info.RefreshSecond;
                }
            }

            if (WindowCenter.Instance.CheckOpen("DogzDungeonWin"))
            {
                if (containBox)
                {
                    dogzDungeonBox.UpdateBoxRefreshTime(boxRefreshSecond);
                    RequestBoxSurplusInfo();
                }

                if (containElite)
                {
                    dogzDungeonElite.UpdateEliteRefreshTime(eliteRefreshSecond);
                    RequestEliteSurplusInfo();
                }
            }
@@ -344,10 +357,8 @@
    public class DogzDungeonElite
    {
        public Dictionary<int, int> eliteCounts = new Dictionary<int, int>();
        public int eliteSurplus
        {
            get
            {
        public int eliteSurplus {
            get {
                var count = 0;
                foreach (var eliteCount in eliteCounts.Values)
                {
@@ -392,10 +403,8 @@
    public class DogzDungeonBossData
    {
        public int id { get; private set; }
        public bool isUnLocked
        {
            get
            {
        public bool isUnLocked {
            get {
                var config = Config.Instance.Get<NPCConfig>(id);
                return PlayerDatas.Instance.baseData.LV >= config.NPCLV;
            }

 System/Dungeon/DungenWHYJ.cs

New file
@@ -0,0 +1,107 @@
//--------------------------------------------------------
//    [Author]:           第二世界
//    [  Date ]:           Friday, September 21, 2018
//--------------------------------------------------------
using UnityEngine;
using System.Collections;
using UnityEngine.UI;
using TableConfig;
using System;



namespace Snxxz.UI

{

    public class DungenWHYJ : MonoBehaviour

    {

        [SerializeField] Button m_WHYJButton;

        [SerializeField] GameObject m_Container_WHYJ;

        [SerializeField] Transform m_Horizontal;

        DungeonModel model { get { return ModelCenter.Instance.GetModel<DungeonModel>(); } }



        public void Init()

        {

            model.dungeonFightStageChangeEevent -= dungeonFightStageChangeEevent;

            model.dungeonFightStageChangeEevent += dungeonFightStageChangeEevent;

            model.updateMissionEvent -= updateMissionEvent;

            model.updateMissionEvent += updateMissionEvent;

            if (model.dungeonFightStage == DungeonFightStage.Prepare)

            {

                m_Container_WHYJ.SetActive(true);

            }

            else

            {

                m_Container_WHYJ.SetActive(false);

            }

            SetTranItemCell();

        }



        private void updateMissionEvent()

        {

            SetTranItemCell();

        }



        private void Start()

        {

            m_WHYJButton.AddListener(OnClickButton);

        }
        private void OnEnable()

        {

           
        }
        private void OnDisable()

        {

           
        }



        private void dungeonFightStageChangeEevent(DungeonFightStage obj)

        {

            if (obj == DungeonFightStage.Prepare)

            {

                if (!m_Container_WHYJ.activeSelf)

                {

                    m_Container_WHYJ.SetActive(true);

                }

            }

            else if(obj == DungeonFightStage.Normal)

            {

                if (m_Container_WHYJ.activeSelf)

                {

                    m_Container_WHYJ.SetActive(false);

                }

            }

        }



        private void SetTranItemCell()

        {

            int lineID = model.mission.lineID;

            var WHYJConfig = Config.Instance.Get<WHYJRewardConfig>(lineID+1);

            int[] RewardList = ConfigParse.GetMultipleStr<int>(WHYJConfig.Reward);

            int[] QuantityList = ConfigParse.GetMultipleStr<int>(WHYJConfig.Quantity);

            for (int i = 0; i < m_Horizontal.childCount; i++)

            {

                if (i < RewardList.Length)

                {

                    m_Horizontal.GetChild(i).gameObject.SetActive(true);

                    ItemCell ItemCell = m_Horizontal.GetChild(i).GetComponent<ItemCell>();

                    ItemCellModel cellModel = new ItemCellModel(RewardList[i], true, (ulong)QuantityList[i], 0);

                    ItemCell.Init(cellModel);

                }

                else

                {

                    m_Horizontal.GetChild(i).gameObject.SetActive(false);

                }



            }



        }
        private void OnClickButton()

        {

            m_Container_WHYJ.SetActive(!m_Container_WHYJ.activeSelf);

        }
    }

}




 System/Dungeon/DungenWHYJ.cs.meta

New file
@@ -0,0 +1,12 @@
fileFormatVersion: 2
guid: 979d7cffed796d145bb0cc4290a14943
timeCreated: 1537527871
licenseType: Free
MonoImporter:
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant: 

 System/Dungeon/DungeonFightWin.cs

@@ -30,7 +30,8 @@
        [SerializeField] DungeonItemCollect m_ItemCollect;

        [SerializeField] DungeonGuardSkyBehaviour m_GuardSky;

        [SerializeField] DungeonBossBriefInfoContainer m_BossInfosContainer;



        [SerializeField] GameObject m_Container_WHYJ;

        [SerializeField] DungenWHYJ m_DungenWHYJ;

        bool excutedAutoExit = false;

        float timer = 0f;

        DateTime endTime = DateTime.Now;

@@ -97,6 +98,15 @@


            model.dungeonCoolDownEvent += OnLeaveMapTimeEvent;

            MainInterfaceWin.Event_Duplicates += OnChangeFuncBtnPosEvent;

            if (WHYJBool())

            {

                m_Container_WHYJ.SetActive(true);

                m_DungenWHYJ.Init();

            }

            else

            {

                m_Container_WHYJ.SetActive(false);

            }

        }



        protected override void OnAfterOpen()

@@ -265,7 +275,7 @@
                        var config = Config.Instance.Get<RuneTowerFloorConfig>(runeTowerModel.currentFloor);

                        var lastFloor = (int)ModelCenter.Instance.GetModel<RuneModel>().RuneTowerOpenLV;

                        var lastFloorConfig = Config.Instance.Get<RuneTowerFloorConfig>(lastFloor);

                        if (model.dungeonResult.isPass == 1 && config.TowerId == lastFloorConfig.TowerId)

                        if (model.dungeonResult.isPass == 1 && config.TowerId == lastFloorConfig.TowerId && lastFloorConfig.AutoExit == 0)

                        {

                            var runeTowerStage = StageManager.Instance.CurrentStage as RuneTowerDungeonStage;

                            runeTowerStage.PerformChallengeNextLevel();

@@ -365,6 +375,18 @@


        }



        private bool WHYJBool()//判断是否在娲皇遗迹副本

        {

            var dataMapId = model.GetDataMapIdByMapId(PlayerDatas.Instance.baseData.MapID);

            if (dataMapId == GeneralConfig.Instance.ruinsTranscriptMapId)

            {

                return true;

            }

            else

            {

                return false;

            }

        }

    }



}


 System/Dungeon/DungeonNuwaVictoryWin.cs

@@ -147,11 +147,18 @@
                m_NumberOfPliesText.text = Language.Get("DungeonVictoryWin_NumberOfPliesText", str);

            }

        }



        List<ServerItem> Serveritem = new List<ServerItem>();

        protected override void DrawItemRewards()

        {

            var merged = false;

            Serveritem.Clear();

               var merged = false;

            var serveritems = dungeonModel.dungeonResult.itemInfo;



            for (int i = 0; i < serveritems.Length; i++)

            {

                Serveritem.Add(serveritems[i]);

            }

            Serveritem.Sort(Compare);

            var hasReward = (serveritems != null && serveritems.Length > 0) || dungeonModel.specialItemCollectRecord.count > 0;



            m_RewardIndexs.Clear();

@@ -164,12 +171,12 @@
            }

            m_ContainerReward.gameObject.SetActive(hasReward);



            if (serveritems != null)

            if (Serveritem != null)

            {

                var items = new List<ItemModel>();

                for (int i = 0; i < serveritems.Length; i++)

                for (int i = 0; i < Serveritem.Count; i++)

                {

                    var serverItem = serveritems[i];

                    var serverItem = Serveritem[i];

                    var itemModel = new ItemModel(PackType.rptItem);

                    var itemInfo = new ItemInfo();

                    itemInfo.ItemID = serverItem.ItemID;

@@ -190,7 +197,8 @@
                    itemModel.SetItemModel(itemInfo);

                    items.Add(itemModel);

                }

                items.Sort(Compare);

             //   items.Sort(Compare);



                for (int i = 0; i < passRewardBehaviours.Length; i++)

                {

                    var behaviour = passRewardBehaviours[i];

@@ -198,7 +206,7 @@
                    {

                        behaviour.transform.parent.gameObject.SetActive(true);

                        behaviour.gameObject.SetActive(false);

                        behaviour.serverItem = serveritems[i];

                        behaviour.serverItem = Serveritem[i];

                        behaviour.Init(items[i]);

                        m_RewardIndexs.Add(m_SpecialItemCollect == null ? i : i + 1);

                    }

@@ -231,10 +239,10 @@
            }

        }



        int Compare(ItemModel x, ItemModel y)//数组排列

        int Compare(ServerItem x, ServerItem y)//数组排列

        {

            ItemConfig itemConfigx = Config.Instance.Get<ItemConfig>(x.itemId);

            ItemConfig itemConfigy = Config.Instance.Get<ItemConfig>(y.itemId);

            ItemConfig itemConfigx = Config.Instance.Get<ItemConfig>(x.ItemID);

            ItemConfig itemConfigy = Config.Instance.Get<ItemConfig>(y.ItemID);

            if (itemConfigx.ItemColor.CompareTo(itemConfigy.ItemColor) != 0)

                return -itemConfigx.ItemColor.CompareTo(itemConfigy.ItemColor);

            return 1;


 System/Dungeon/DungeonRuneTowerVictoryWin.cs

@@ -46,7 +46,7 @@
                var config = Config.Instance.Get<RuneTowerFloorConfig>(runeTowerModel.currentFloor);

                var lastFloor = (int)ModelCenter.Instance.GetModel<RuneModel>().RuneTowerOpenLV;

                var lastFloorConfig = Config.Instance.Get<RuneTowerFloorConfig>(lastFloor);

                m_RuneTowerNext.gameObject.SetActive(config.TowerId == lastFloorConfig.TowerId);

                m_RuneTowerNext.gameObject.SetActive(lastFloorConfig.AutoExit == 0 && config.TowerId == lastFloorConfig.TowerId);



                DisplayRunesUnLock(lastFloor);

            }


 System/Dungeon/NormalDungeonEntranceWin.cs

@@ -46,7 +46,10 @@
        [SerializeField] ButtonEx m_GroupStart;

        [SerializeField] ButtonEx m_SingleStart;

        [SerializeField] ButtonEx m_AutoGroupStart;

        [SerializeField] ButtonEx m_Group;

        [SerializeField] Button m_CloseWin;



        [SerializeField] RectTransform m_ContainerGroup;



        DungeonModel model { get { return ModelCenter.Instance.GetModel<DungeonModel>(); } }

        TeamModel teamModel { get { return ModelCenter.Instance.GetModel<TeamModel>(); } }

@@ -63,6 +66,7 @@
            m_SingleStart.AddListener(ChallengeDungeon);

            m_AutoGroupStart.AddListener(AutoGroupChallenge);

            m_Sweep.AddListener(SweepDungeon);

            m_Group.AddListener(OpenGroup);

            m_CloseWin.AddListener(CloseClick);

        }



@@ -99,6 +103,12 @@
        }

        #endregion



        private void OpenGroup()

        {

            var openGroup = m_ContainerGroup.gameObject.activeSelf;

            m_ContainerGroup.gameObject.SetActive(!openGroup);

        }



        private void UpdateDungeonEnterCD()

        {

            var dungeonId = model.GetDungeonId(model.currentDungeon);

@@ -118,6 +128,9 @@
            m_SingleStart.gameObject.SetActive(fbType == 1 || fbType == 2);

            m_AutoGroupStart.gameObject.SetActive(fbType == 2 || fbType == 3);



            m_ContainerGroup.gameObject.SetActive(false);

            m_Group.gameObject.SetActive(fbType == 2 || fbType == 3);



            m_EntranceBG.SetSprite(dungeonOpenTimeConfig.PanelImg);



            m_DungeonTitle.text = dungeonConfig.FBName;


 System/Dungeon/TrialDungeonEntranceWin.cs

@@ -40,6 +40,9 @@
        [SerializeField] Image m_BossRealm;

        [SerializeField] Text m_BossName;



        [SerializeField] RectTransform m_ContainerGroup;

        [SerializeField] Button m_Group;



        [SerializeField] TrialRewardsBehaviour[] m_RewardBehaviours;

        [SerializeField] ScrollRect m_RewardScroller;



@@ -72,6 +75,7 @@
            m_SingleStart.AddListener(ChallengeDungeon);

            m_AutoGroupStart.AddListener(AutoGroupChallenge);

            m_CloseWin.AddListener(CloseClick);

            m_Group.AddListener(OpenGroup);

        }



        protected override void OnPreOpen()

@@ -81,6 +85,9 @@
            m_GroupStart.image.material = CheckChallenge() ? MaterialUtility.GetUIDefaultGraphicMaterial() : MaterialUtility.GetDefaultSpriteGrayMaterial();

            m_SingleStart.image.material = CheckChallenge() ? MaterialUtility.GetUIDefaultGraphicMaterial() : MaterialUtility.GetDefaultSpriteGrayMaterial();

            m_AutoGroupStart.image.material = CheckChallenge() ? MaterialUtility.GetUIDefaultGraphicMaterial() : MaterialUtility.GetDefaultSpriteGrayMaterial();

            m_Group.image.material = CheckChallenge() ? MaterialUtility.GetUIDefaultGraphicMaterial() : MaterialUtility.GetDefaultSpriteGrayMaterial();

            m_ContainerGroup.gameObject.SetActive(false);



            DrawDungeonBaseInfo();

            DrawRewards();

        }

@@ -100,6 +107,15 @@
        }

        #endregion



        private void OpenGroup()

        {

            if (!CheckChallenge())

            {

                return;

            }

            var openGroup = m_ContainerGroup.gameObject.activeSelf;

            m_ContainerGroup.gameObject.SetActive(!openGroup);

        }



        private void DrawDungeonBaseInfo()

        {

@@ -113,6 +129,7 @@
            m_GroupStart.gameObject.SetActive(fbType == 2 || fbType == 3);

            m_SingleStart.gameObject.SetActive(fbType == 1 || fbType == 2);

            m_AutoGroupStart.gameObject.SetActive(fbType == 2 || fbType == 3);

            m_Group.gameObject.SetActive(fbType == 2 || fbType == 3);



            var playerLevel = PlayerDatas.Instance.baseData.LV;

            m_LevelLimit.gameObject.SetActive(playerLevel < dungeonConfig.LVLimitMin);


 System/Dungeon/TrialDungeonModel.cs

@@ -113,9 +113,17 @@


        private void RefreshItemCountAct(PackType packType, int arg2, int itemId)

        {

            if (packType == PackType.rptItem && trialTokens.Contains(itemId))

            var config = Config.Instance.Get<ItemConfig>(itemId);

            if (config == null)

            {

                UpdateRedpoint();

                return;

            }

            if (packType == PackType.rptItem)

            {

                if (trialTokens.Contains(itemId) || config.EquipPlace > 0)

                {

                    UpdateRedpoint();

                }

            }

            else if (packType == PackType.rptEquip)

            {

@@ -263,8 +271,29 @@
            {

                return 0;

            }

            var singlepack = packModel.GetSinglePackModel(PackType.rptEquip);

            if (singlepack == null)

            var singlepack = packModel.GetSinglePackModel(PackType.rptItem);

            if (singlepack != null)

            {

                var dict = singlepack.GetPackModelIndexDict();

                if (dict != null)

                {

                    foreach (var itemModel in dict.Values)

                    {

                        if (itemModel.chinItemModel.EquipPlace == config.EquipPlace

                            && (itemModel.chinItemModel.JobLimit / 100 == PlayerDatas.Instance.baseData.Job

                            || itemModel.chinItemModel.JobLimit == 0))

                        {

                            var compare = EquipCompare(itemModel, config);

                            if (compare == -1 || compare == 0)

                            {

                                return compare;

                            }

                        }

                    }

                }

            }

            singlepack = packModel.GetSinglePackModel(PackType.rptEquip);

            if (singlepack != null)

            {

                return 1;

            }

@@ -273,7 +302,12 @@
            {

                return 1;

            }

            var compareConfig = Config.Instance.Get<ItemConfig>(equipItem.itemId);

            return EquipCompare(equipItem, config);

        }



        int EquipCompare(ItemModel compareItem, ItemConfig config)

        {

            var compareConfig = Config.Instance.Get<ItemConfig>(compareItem.itemId);

            if (compareConfig == null)

            {

                return 1;


 System/Dungeon/TrialExchangeWin.cs

@@ -82,6 +82,7 @@
            model.SelectEquipClassEvent += SelectEquipClassEvent;

            packModel.RefreshItemCountAct += RefreshItemCountAct;

            Display();

            JumpToRedpoint();

        }



        protected override void OnAfterOpen()

@@ -170,10 +171,18 @@


        private void RefreshItemCountAct(PackType packtype, int arg2, int itemId)

        {

            if (packtype == PackType.rptItem && model.trialTokens.Contains(itemId))

            var config = Config.Instance.Get<ItemConfig>(itemId);

            if (config == null)

            {

                m_Controller.m_Scorller.RefreshActiveCellViews();

                DisplayTokens();

                return;

            }

            if (packtype == PackType.rptItem)

            {

                if (model.trialTokens.Contains(itemId) || config.EquipPlace > 0)

                {

                    m_Controller.m_Scorller.RefreshActiveCellViews();

                    DisplayTokens();

                }

            }

            else if (packtype == PackType.rptEquip)

            {

@@ -215,6 +224,62 @@
            DisplayTokens();

            bool _up = m_SelectClassBehaviour.gameObject.activeSelf;

            m_SelectClassUp.transform.localEulerAngles = Vector3.zero.SetZ(_up ? 0 : 180);

            JumpToRedpoint();

        }



        private void JumpToRedpoint()

        {

            if (model.selectEquipClass == 1)

            {

                var trialClasses = model.GetTotalClass();

                var index = 0;

                for (int i = 0; i < trialClasses.Count; i++)

                {

                    var line = 0;

                    index += 1;

                    if (JumpToRedpoint(trialClasses[i], out line))

                    {

                        m_Controller.JumpIndex(index + line);

                        return;

                    }

                    else

                    {

                        List<TrialExchangeConfig> list;

                        if (model.TryGetTrialExchanges(trialClasses[i], out list))

                        {

                            index += Mathf.CeilToInt((float)list.Count / 3);

                        }

                    }

                }

            }

            else

            {

                var line = 0;

                JumpToRedpoint(model.selectEquipClass, out line);

                m_Controller.JumpIndex(line);

            }

        }



        private bool JumpToRedpoint(int _class, out int line)

        {

            var itemId = 0;

            line = 0;

            if (model.IsAnySatisfyExchangeBetterEquip(_class, out itemId))

            {

                List<TrialExchangeConfig> list;

                if (model.TryGetTrialExchanges(_class, out list))

                {

                    for (int i = 0; i < list.Count; i++)

                    {

                        if (list[i].id == itemId)

                        {

                            line = i / 3;

                            return true;

                        }

                    }

                }

            }

            return false;

        }

    }




 System/FairyAu/FairyGrabBossHelpBehaviour.cs

@@ -73,6 +73,12 @@
                    model.RemoveHelp();

                    return;

                }

                if (PlayerDatas.Instance.extersion.bossState == 1)

                {

                    SysNotifyMgr.Instance.ShowTip("Boss_Leave");

                    model.RemoveHelp();

                    return;

                }

                if (!model.IsBossAlive(help.npcId))

                {

                    ConfirmCancel.ShowPopConfirm(Language.Get("Mail101"), Language.Get("FairyGrabBossNotAlive"), (bool isOk) =>

@@ -85,6 +91,7 @@
                      });

                    return;

                }

                model.RemoveHelp();

                MapTransferUtility.Instance.MoveToNPC(help.npcId);

            }

        }


 System/FairyAu/FairyGrabBossWin.cs

@@ -23,11 +23,13 @@
        [SerializeField] RectTransform m_ContainerUnOpen;

        [SerializeField] RectTransform m_ContainerOpen;

        [SerializeField] Text m_SurplusTime;

        [SerializeField] Text m_OpenDate;



        FairyGrabBossModel model { get { return ModelCenter.Instance.GetModel<FairyGrabBossModel>(); } }

        DungeonModel dungeonModel { get { return ModelCenter.Instance.GetModel<DungeonModel>(); } }

        BossHomeModel bossHomeModel { get { return ModelCenter.Instance.GetModel<BossHomeModel>(); } }

        FindPreciousModel findPreciousModel { get { return ModelCenter.Instance.GetModel<FindPreciousModel>(); } }

        DailyQuestModel dailyQuestModel { get { return ModelCenter.Instance.GetModel<DailyQuestModel>(); } }



        float m_Timer = 0f;

        const float Interval = 10f;

@@ -51,11 +53,13 @@
            DisplaySurplusTime();

            DisplayBossInfo();

            DisplayHighestFairy();

            DisplayOpenDate();

            GlobalTimeEvent.Instance.secondEvent += SecondEvent;

            model.bossSelectedEvent += BossSelectedEvent;

            model.bossProgressUpdate += BossProgressUpdate;

            model.bossAllProgressUpdate += BossAllProgressUpdate;

            model.stateUpdate += StateUpdate;

            TimeUtility.OnServerOpenDayRefresh += OnServerOpenDayRefresh;

            m_Timer = 0;

        }



@@ -79,6 +83,7 @@
            model.bossProgressUpdate -= BossProgressUpdate;

            model.bossAllProgressUpdate -= BossAllProgressUpdate;

            model.stateUpdate -= StateUpdate;

            TimeUtility.OnServerOpenDayRefresh -= OnServerOpenDayRefresh;

        }



        protected override void OnAfterClose()

@@ -97,6 +102,11 @@
        }

        #endregion



        private void OnServerOpenDayRefresh()

        {

            DisplayOpenDate();

        }



        void DisplayBosses()

        {

            var bosses = new List<int>();

@@ -106,6 +116,19 @@
            m_Bosses.MoveToCenter(bosses.IndexOf(model.selectBoss));

        }



        void DisplayOpenDate()

        {

            DailyQuestOpenTime dailyQuestOpenTime;

            if (dailyQuestModel.TryGetOpenTime((int)DailyQuestType.FairyGrabBoss, out dailyQuestOpenTime))

            {

                m_OpenDate.text = Language.Get("FairyGrabBossOpenDate", dailyQuestOpenTime.ToOpenTimeString());

            }

            else

            {

                m_OpenDate.text = string.Empty;

            }

        }



        void DisplayBossInfo()

        {

            List<Item> dropItems;


 System/FairyAu/FairyLeagueModel.cs

@@ -17,8 +17,7 @@
        {

            get

            {

                var openServerTime = TimeUtility.openServerTime;

                var openServerWeekDay = openServerTime.DayOfWeek == DayOfWeek.Sunday ? 7 : (int)openServerTime.DayOfWeek;

                var openServerWeekDay = TimeUtility.openServerDayOfWeek == DayOfWeek.Sunday ? 7 : (int)TimeUtility.openServerDayOfWeek;

                if (specialLeagueTimes.ContainsKey(openServerWeekDay))

                {

                    var dict = specialLeagueTimes[openServerWeekDay];

@@ -40,8 +39,7 @@
        {

            get

            {

                var openServerTime = TimeUtility.openServerTime;

                var openServerWeekDay = openServerTime.DayOfWeek == DayOfWeek.Sunday ? 7 : (int)openServerTime.DayOfWeek;

                var openServerWeekDay = TimeUtility.openServerDayOfWeek == DayOfWeek.Sunday ? 7 : (int)TimeUtility.openServerDayOfWeek;

                if (specialLeagueTimes.ContainsKey(openServerWeekDay))

                {

                    var dict = specialLeagueTimes[openServerWeekDay];

@@ -976,7 +974,7 @@
                {

                    return x.stage == FairyLeagueStage.Fight;

                });

                var time = TimeUtility.openServerTime.AddTicks((weekTime.rings[0].openServerDay - 1) * TimeSpan.TicksPerDay);

                var time = TimeUtility.ServerNow.AddTicks((weekTime.rings[0].openServerDay - TimeUtility.OpenDay - 1) * TimeSpan.TicksPerDay);

                time = new DateTime(time.Year, time.Month, time.Day, fightStage.startHour, fightStage.startMinute, 0);

                seconds = (int)(time - TimeUtility.ServerNow).TotalSeconds;

                seconds = Mathf.Max(seconds, 0);

@@ -988,8 +986,7 @@
        {

            if (TimeUtility.OpenWeekCnt <= 1)

            {

                var openServerTime = TimeUtility.openServerTime;

                var openServerWeekDay = openServerTime.DayOfWeek == DayOfWeek.Sunday ? 7 : (int)openServerTime.DayOfWeek;

                var openServerWeekDay = TimeUtility.openServerDayOfWeek == DayOfWeek.Sunday ? 7 : (int)TimeUtility.openServerDayOfWeek;

                if (specialLeagueTimes.ContainsKey(openServerWeekDay))

                {

                    var dict = specialLeagueTimes[openServerWeekDay];


 System/HappyXB/HappyXBModel.cs

@@ -611,39 +611,47 @@
                int needToolCnt = 0;

                if (IsHaveManyXBTool(xbType, out toolCnt, out needToolCnt))

                {

                    needToolCnt = needToolCnt - toolCnt;

                    int needMoney = needToolCnt * funcSet.xbPrices[0];

                    if (needMoney > 0)

                    if(toolCnt >= needToolCnt)

                    {

                        ItemConfig itemConfig = Config.Instance.Get<ItemConfig>(funcSet.costToolIds[1]);

                        ConfirmCancel.ShowPopConfirm(Language.Get("Mail101"), Language.Get("HappyXBCostTools", funcSet.costToolNums[1], itemConfig.ItemName, needMoney, needToolCnt), (bool isOk) =>

                        {

                            if (isOk)

                            {

                                CheckXBManyLimit(needMoney, xbType);

                            }

                            return;

                        });

                        CheckXBManyLimit(0, xbType, 2);

                    }

                    else

                    {

                        CheckXBManyLimit(0, xbType);

                        CheckXBManyLimit(funcSet.xbPrices[1], xbType,0);

                    }

                    //needToolCnt = needToolCnt - toolCnt;

                    //int needMoney = needToolCnt * funcSet.xbPrices[0];

                    //if (needMoney > 0)

                    //{

                    //    ItemConfig itemConfig = Config.Instance.Get<ItemConfig>(funcSet.costToolIds[1]);

                    //    ConfirmCancel.ShowPopConfirm(Language.Get("Mail101"), Language.Get("HappyXBCostTools", funcSet.costToolNums[1], itemConfig.ItemName, needMoney, needToolCnt), (bool isOk) =>

                    //    {

                    //        if (isOk)

                    //        {

                    //            CheckXBManyLimit(needMoney, xbType,0);

                    //        }

                    //        return;

                    //    });

                    //}

                    //else

                    //{

                    //    CheckXBManyLimit(0, xbType,2);

                    //}



                }

                else

                {

                    CheckXBManyLimit(funcSet.xbPrices[1],xbType);

                    CheckXBManyLimit(funcSet.xbPrices[1],xbType,0);

                }



            }

        }



        public void CheckXBManyLimit(int needMoney,int xbtype)

        public void CheckXBManyLimit(int needMoney,int xbtype,int costType)

        {

            if (UIHelper.GetMoneyCnt(1) >= (ulong)needMoney)

            {

                SendXBQuest(xbtype, 1, 2);

                SendXBQuest(xbtype, 1, costType);

            }

            else

            {


 System/HttpRequest/HttpRequest.cs

@@ -11,73 +11,6 @@
    public const string defaultHttpContentType = "application/x-www-form-urlencoded";

    public const string jsonHttpContentType = "application/json ; charset=utf-8";



    public void RequestWWW(string _url, int _retry = 3, Action<bool, string> _result = null)

    {

        StartCoroutine(Co_RequestWWW(_url, null, _retry, _result));

    }



    public void RequestWWW(string _url, IDictionary<string, string> _parameters, int _retry = 3, Action<bool, string> _result = null)

    {

        StartCoroutine(Co_RequestWWW(_url, _parameters, _retry, _result));

    }



    IEnumerator Co_RequestWWW(string _url, IDictionary<string, string> _parameters, int _retry = 3, Action<bool, string> _result = null)

    {

        if (_url == null || _url.Length == 0)

        {

            DebugEx.LogError("PHPDataComm post 参数有错");

            if (_result != null)

            {

                _result(false, string.Empty);

                _result = null;

            }

            yield break;

        }



        int i = 0;

        bool isSuccess = false;



        byte[] data = null;

        if (_parameters != null)

        {

            data = Encoding.UTF8.GetBytes(HashtablaToString(_parameters));

        }



        var PostData = data == null ? new WWW(_url) : new WWW(_url, data);



        while (!PostData.isDone)

        {

            yield return null;

        }



        if (PostData.error != null)

        {

            Debug.LogErrorFormat("WWW 数据通信,请求数据失败：{0},已经尝试,{1},次", PostData.error, i);

        }

        else

        {

            if (!string.IsNullOrEmpty(PostData.text))

            {

                DebugEx.LogFormat("WWW 数据通信,请求数据成功：{0}", PostData.text);

                isSuccess = true;

                if (_result != null)

                {

                    _result(true, PostData.text);

                    _result = null;

                }

            }

        }



        if (!isSuccess)

        {

            if (_result != null)

            {

                _result(false, string.Empty);

                _result = null;

            }

        }

    }



    public void RequestHttpPost(string _url, IDictionary<string, string> _parameters, string _contentType, int _retry = 3, Action<bool, string> _result = null)

    {

        var content = HashtablaToString(_parameters);


 System/KnapSack/Logic/ItemTipsModel.cs

@@ -742,9 +742,13 @@
               dogzModel.CheckPutOff(dogzModel.GetDogzEquipPlaceByIndex(attrData.index));

            });



            attrData.SetTipsFuncBtn(ItemWinBtnType.strength, (ItemWinBtnType, ItemAttrData) => {

                dogzModel.OpenDogzFuncEvent(1);

            });

            if(dogzModel.TryGetAssistDogzState(dogzModel.presentSelectDogz))

            {

                attrData.SetTipsFuncBtn(ItemWinBtnType.strength, (ItemWinBtnType, ItemAttrData) => {

                    dogzModel.OpenDogzFuncEvent(1, attrData.index);

                });

            }

          
        }



        /// <summary>


 System/MainInterfacePanel/HighSettingFadeInFadeOut.cs

@@ -498,7 +498,7 @@
                        }

                        if (!AnimationFadeOutDicLow.ContainsKey(highBtnRecord.Index))

                        {

                            if (isPlayerUIeffect.RedPointId == 201 || isPlayerUIeffect.RedPointId == 210)

                            if (isPlayerUIeffect.RedPointId == 201 /*|| isPlayerUIeffect.RedPointId == 210*/)//201(福利)，210（仙宝寻主）

                            {

                                if (RedpointCenter.Instance.GetRedpointState(isPlayerUIeffect.RedPointId) == RedPointState.GetReward)

                                {


 System/MainInterfacePanel/MainInterfaceWin.cs

@@ -716,7 +716,7 @@
        void DownButton(GameObject go)

        {

            _ExpRate.gameObject.SetActive(true);



          //  WindowCenter.Instance.Open<WheelOfFortuneWin>();

        }

        void UpButton(GameObject go)

        {


 System/MainInterfacePanel/SkillTaskWin.cs

@@ -22,6 +22,7 @@
        [SerializeField] Button m_OpenNowBtn;

        [SerializeField] Button m_GoToBtn;
        [SerializeField] Button m_ClaoseBtn;
        [SerializeField] Image m_Image;//孔数
        PlayerMainDate m_MainModel;

        PlayerMainDate mainModel { get { return m_MainModel ?? (m_MainModel = ModelCenter.Instance.GetModel<PlayerMainDate>()); } }

        PlayerTaskDatas m_TaskModel;

@@ -51,11 +52,20 @@
            if (taskinfo != null)

            {

                m_Text_Condition_1.text = taskinfo.show_writing;

                if (taskmodel._DicTaskInformation.ContainsKey(mainModel.TaskSkillID))

                {

                    Dictionary<string, string> SkillDic = new Dictionary<string, string>();

                    SkillDic = taskmodel._DicTaskInformation[mainModel.TaskSkillID];

                    string strA = "on_kill_" + mainModel.TaskSkillID.ToString();

                    string strB = "get_byid_" + mainModel.TaskSkillID.ToString();

                    m_Text_Condition_1.SetReplaceInfo(SkillDic);

                }

            }

            if (mainModel.TaskId_Skill.Contains(mainModel.TaskSkillID))

            {

                int Index = mainModel.TaskId_Skill.IndexOf(mainModel.TaskSkillID);

                m_Text_Reward_1.text = string.Format(Language.Get("PassiveSkillTask1"), (mainModel.SkillIndex[Index] + 1));

                SetImageSprite(mainModel.SkillIndex[Index] + 1);

                m_NeedMoney_Text.text = string.Format(Language.Get("PassiveSkillTask2"), mainModel.NeedFairyJade[Index]);

            }

        }
@@ -97,7 +107,7 @@
                        if (Gold >= NeedMoney)

                        {

                            taskmodel.CompletionOfTask(mainModel.TaskSkillID);

                            WindowJumpMgr.Instance.WindowJumpTo(JumpUIType.SkillFunc2);

                            WindowJumpMgr.Instance.WindowJumpTo(JumpUIType.SkillFunc2Type2);

                        }

                        else

                        {

@@ -118,6 +128,32 @@
            m_Text_Condition_1.ExcuteHref();



            // Close();

        }



        private void SetImageSprite(int Index)

        {

            switch (Index)

            {

                case 1:

                    m_Image.SetSprite("Slot_1");

                    break;

                case 2:

                    m_Image.SetSprite("Slot_2");

                    break;

                case 3:

                    m_Image.SetSprite("Slot_3");

                    break;

                case 4:

                    m_Image.SetSprite("Slot_4");

                    break;

                case 5:

                    m_Image.SetSprite("Slot_5");

                    break;

                case 6:

                    m_Image.SetSprite("Slot_6");

                    break;



            }

        }
        #endregion



 System/MainInterfacePanel/TaskAllocation.cs

@@ -137,7 +137,7 @@
                            {

                                return;

                            }

                            WindowJumpMgr.Instance.WindowJumpTo(JumpUIType.SkillFunc2);

                            WindowJumpMgr.Instance.WindowJumpTo(JumpUIType.SkillFunc2Type2);

                        }

                        else

                        {


 System/Store/StoreModel.cs

@@ -1128,7 +1128,10 @@


    private void OnMoveTopPart(bool isMove)

    {

        SetPushPetAndMountWinState(!isMove);

        if(!isLogin)

        {

            SetPushPetAndMountWinState(!isMove);

        }

    }



    private void windowAfterOpen(Window win)

@@ -1141,6 +1144,8 @@


    private void windowAfterClose(Window win)

    {

        if (isLogin) return;



        if(win is MainInterfaceWin)

        {

            SetPushPetAndMountWinState(true);


 System/Strengthening/GodBeastAttributes.cs

@@ -76,6 +76,7 @@
        {

            GodBeast_Number = 0;

            GodBeast_Part = 0;

            
            GodBeastReinforcementWin.ChooseToModify -= ChooseToModify;

            godBeastModel.AbsorbEvent -= AbsorbEvent;

        }

@@ -91,7 +92,11 @@


        private void OnClickToggle(bool Isbool)

        {

            AttributeAssignment();

            if (GodBeastNumber != 0 && GodBeastPart != 0)

            {

                AttributeAssignment();

            }

          
        }

        private void OnClickStrengthBtn()

        {

@@ -163,6 +168,8 @@
            }

            else

            {

                GodBeastNumber = 0;

                GodBeastPart = 0;

                m_ItemCell.gameObject.SetActive(false);

                m_ExpSlider.stage = 0;

                m_ExpSlider.delay = 0f;


 System/Strengthening/GodBeastReinforcementWin.cs

@@ -39,6 +39,7 @@
        public static event Action<int> ChooseToModify;

        private List<GodBeastClass> GodBeastList = new List<GodBeastClass>();
        private int CurrentlySelected = 0;
        private int JumpIndex = 0;
        #region Built-in
        protected override void BindController()
        {
@@ -53,7 +54,7 @@
        {

            CurrentlySelected = 0;

            GetGodBeast();//获取神兽强化装备信息



            m_ScrollerController.OnRefreshCell += OnRefreshGridCell;
            if (godBeastModel.ItemPlace != -1)

            {

                for (int i = 0; i < GodBeastList.Count; i++)

@@ -67,7 +68,7 @@
                        {

                            return x.ItemPlace == godBeastModel.ItemPlace;

                        });

                        m_ScrollerController.JumpIndex(Index);

                        JumpIndex = Index;

                    }

                }

            }

@@ -77,14 +78,17 @@
                {

                    CurrentlySelected = GodBeastList[0].LocationMarker;

                    GetDogZBagIndex();

                    m_ScrollerController.JumpIndex(0);

                    JumpIndex = 0;                 
                }

            }

            m_ScrollerController.OnRefreshCell += OnRefreshGridCell;
            }
            OnCreateGridLineCell(m_ScrollerController);

            m_GodBeastSlidingList.Init();
            m_GodBeastAttributes.Init();
            m_GodBeastAttributes.GetGodBeastLocationMarker(CurrentlySelected);
            m_GodBeastAttributes.GetGodBeastLocationMarker(CurrentlySelected);

            m_ScrollerController.JumpIndex(JumpIndex);







        }

        protected override void OnAfterOpen()
@@ -95,6 +99,7 @@

        protected override void OnPreClose()
        {

            JumpIndex = 0;

            godBeastModel.ItemPlace = -1;

           // godBeastModel.Absorption_Dic.Clear();

            playerPack.RefreshItemCountAct -= RefreshItemCountAct;


 System/SystemSetting/ActivityPushCell.cs

@@ -12,20 +12,22 @@
        [SerializeField] GameObject bgObj;



        SetPrivateModel privateModel { get { return ModelCenter.Instance.GetModel<SetPrivateModel>(); } }

        DailyQuestModel dailyQuestModel { get { return ModelCenter.Instance.GetModel<DailyQuestModel>(); } }



        public void SetModel(int dailyId)

        {

            string title = "";

            string weekDay = "";

            string openTime = "";

            privateModel.GetDailyInfoById(dailyId,out title,out weekDay,out openTime);

            privateModel.GetDailyInfoById(dailyId, out title, out weekDay, out openTime);

            nameText.text = title;

            weekDayText.text = weekDay;

            timeText.text = openTime;

            int index = privateModel.GetSwitchIndexById(dailyId);

            pushBtn.SetInit(index,privateModel.GetSwitchStateByIndex(index));

            pushBtn.switchBtn.RemoveAllListeners();

            pushBtn.switchBtn.AddListener(() =>



            var quests = dailyQuestModel.GetDailyQuests(DailyQuestModel.DailyQuestCategory.TimeLimit);

            int index = privateModel.GetSwitchIndexById(dailyId, quests);

            pushBtn.SetInit(index, privateModel.GetSwitchStateByIndex(index));

            pushBtn.switchBtn.SetListener(() =>

            {

                if (pushBtn.onObj.activeInHierarchy)

                {

@@ -41,14 +43,7 @@
                }

            });



            if(this.index % 2 == 0)

            {

                bgObj.SetActive(true);

            }

            else

            {

                bgObj.SetActive(false);

            }

            bgObj.SetActive(this.index % 2 == 0);

        }

    }

}


 System/SystemSetting/SetPrivateModel.cs

@@ -9,11 +9,7 @@
{

    public class SetPrivateModel : Model, IBeforePlayerDataInitialize, IAfterPlayerDataInitialize, IPlayerLoginOk

    {

        DailyQuestModel m_dailyModel;

        DailyQuestModel dailyModel

        {

            get { return m_dailyModel ?? (m_dailyModel = ModelCenter.Instance.GetModel<DailyQuestModel>()); }

        }

        DailyQuestModel dailyModel { get { return ModelCenter.Instance.GetModel<DailyQuestModel>(); } }

        VipModel vipModel { get { return ModelCenter.Instance.GetModel<VipModel>(); } }



        public List<int> hangUpPushlist = new List<int>();

@@ -146,7 +142,7 @@
            List<int> dailyIdlist = GetOpenDailyIdlist(true);

            for (int i = 0; i < dailyIdlist.Count; i++)

            {

                bool isOpen = GetSwitchStateByIndex(GetSwitchIndexById(dailyIdlist[i]));

                bool isOpen = GetSwitchStateByIndex(GetSwitchIndexById(dailyIdlist[i], dailyIdlist));

                if (isOpen)

                {

                    List<JsonData> pushNotifylist = GetPushJsonData(dailyIdlist[i]);

@@ -459,9 +455,8 @@
            }

        }



        public int GetSwitchIndexById(int id)

        public int GetSwitchIndexById(int id, List<int> quests)

        {

            var quests = dailyModel.GetDailyQuests(DailyQuestModel.DailyQuestCategory.TimeLimit);

            for (int i = 0; i < quests.Count; i++)

            {

                if (quests[i] == id)

@@ -513,15 +508,17 @@


        private void RefreshDailyQuest()

        {

            foreach (var dailyQuest in dailyModel.GetDailyQuestlist().Values)

            var quests = dailyModel.GetDailyQuests(DailyQuestModel.DailyQuestCategory.TimeLimit);

            foreach (var dailyQuest in dailyModel.GetDailyQuests())

            {

                var isUnLocked = TestDailyQuestUnLock(dailyQuest.id);

                var isUnLocked = TestDailyQuestUnLock(dailyQuest);

                if (isUnLocked)

                {

                    ModelCenter.Instance.GetModel<SetPrivateModel>().CheckActivityOpenTime(dailyQuest.id);

                    CheckActivityOpenTime(dailyQuest, quests);

                }

            }

        }



        public bool TestDailyQuestUnLock(int _dailyQuestId)

        {

            switch ((DailyQuestType)_dailyQuestId)

@@ -541,9 +538,11 @@
        }





        public void CheckActivityOpenTime(int dailyId)

        public void CheckActivityOpenTime(int dailyId, List<int> quests)

        {

            bool isOpen = GetSwitchStateByIndex(GetSwitchIndexById(dailyId));



            bool isOpen = GetSwitchStateByIndex(GetSwitchIndexById(dailyId, quests));



            if (!isOpen)

                return;




 System/Treasure/DragSelectComponent.cs

@@ -24,7 +24,8 @@
            if (Input.touchCount > 1 || NewBieCenter.Instance.inGuiding

                || WindowCenter.Instance.CheckOpen<TreasureNewStageWin>()

                || WindowCenter.Instance.CheckOpen<PotentialItemUseWin>()

                || WindowCenter.Instance.CheckOpen<TreasureSoulActiveWin>())

                || WindowCenter.Instance.CheckOpen<TreasureSoulActiveWin>()

                || WindowCenter.Instance.CheckOpen<GetItemPathWin>())

            {

                m_StartDrag = false;

                return;


 System/Treasure/PotentialItemBehaviour.cs

@@ -51,9 +51,9 @@
            m_ItemBehaviour.SetItem(potentialBook.itemId, 1);

            m_CostCount.text = StringUtility.Contact(own, "/", need);

            m_CostCount.color = own >= need ? UIHelper.GetUIColor(TextColType.White) : UIHelper.GetUIColor(TextColType.Red);

            m_Click.interactable = own >= need;

            //m_Click.interactable = own >= need;

            m_AddBtnText.color = own >= need ? UIHelper.GetUIColor(TextColType.NavyBrown) : UIHelper.GetUIColor(TextColType.White);

            m_Click.image.material = own >= need ? m_SmoothMask.imageMaterials[0] : m_SmoothMask.imageMaterials[1];

            //m_Click.image.material = own >= need ? m_SmoothMask.imageMaterials[0] : m_SmoothMask.imageMaterials[1];

            var config = Config.Instance.Get<TreasureSkillConfig>(potentialBook.levelUpId);

            var upRate = potentialBook.successRate - config.InitialRate;

            m_SuccessRatio.text = Language.Get("HallowsWin_UpSuccess", StringUtility.Contact((upRate * 0.01f).ToString("f0"), "%"));

@@ -61,15 +61,15 @@


        private void SelectPotentialBook()

        {

            if (own >= need)

            {

            //if (own >= need)

            //{

                model.selectedPotentialBook = potentialBook.itemId;

                WindowCenter.Instance.Close<PotentialItemUseWin>();

            }

            else

            {

                SysNotifyMgr.Instance.ShowTip("SPItemNotEnough");

            }

            //}

            //else

            //{

            //    SysNotifyMgr.Instance.ShowTip("SPItemNotEnough");

            //}

        }



        private void Awake()


 System/Treasure/TreasurePotentialBriefInfo.cs

@@ -80,7 +80,7 @@


        private void SelectPotential()

        {

            if (potential == null || !model.IsPotentialUnlock(model.selectedTreasure, potential.id))

            if (potential == null/* || !model.IsPotentialUnlock(model.selectedTreasure, potential.id)*/)

            {

                return;

            }


 System/Treasure/TreasurePotentialPanel.cs

@@ -84,7 +84,8 @@
                    var level = potential.level;

                    var isMax = level >= config.SkillMaxLV;

                    m_PotentialMaxLevelTip.gameObject.SetActive(isMax);

                    m_ContainerUpgrade.gameObject.SetActive(!isMax && FuncOpen.Instance.IsFuncOpen(82));

                    m_ContainerUpgrade.gameObject.SetActive(!isMax &&

                        FuncOpen.Instance.IsFuncOpen(82) && model.IsPotentialUnlock(m_Treasure.id, selectedPotential));

                    m_ContainerRequirement.gameObject.SetActive(!isMax);



                    if (!isMax)

@@ -93,7 +94,6 @@
                        DisplayUpgradeCost();

                        DisplayGetSkill();

                        DisplaySuccessRatio();

                        m_UpgradeImage.gray = !TestPotentialLevelUp();

                    }

                    else

                    {

@@ -526,13 +526,18 @@
            {

                return;

            }

            if (config.InitialRate >= 100)

            {

                model.selectedPotentialBook = 0;

                return;

            }

            var itemId = config.Meterial2ID.Length > 0 ? config.Meterial2ID[0] : 0;

            if (itemId != 0)

            {

                var own = playerPack.GetItemCountByID(PackType.rptItem, itemId);

                var need = config.MeterialNum2[0];

                //var own = playerPack.GetItemCountByID(PackType.rptItem, itemId);

                //var need = config.MeterialNum2[0];

                var rate = config.Rate[0];

                if (rate >= 60 && own >= need)

                if (rate >= 60)

                {

                    model.selectedPotentialBook = itemId;

                }

@@ -550,7 +555,6 @@
            m_SPOwn.text = UIHelper.ReplaceLargeNum(spOwn);

            m_SPNeed.text = StringUtility.Contact("/", UIHelper.ReplaceLargeNum(spNeed));

            m_SPOwn.color = spOwn >= spNeed ? UIHelper.GetUIColor(TextColType.DarkGreen) : UIHelper.GetUIColor(TextColType.Red);

            m_UpgradeImage.gray = spOwn < spNeed;

        }



        private void DisplayGetSkill(bool _levelUp = false)

@@ -591,9 +595,11 @@
        {

            var levelUpConfig = GetPotentialLevelUpConfig();

            m_SuccessRatio.text = StringUtility.Contact((levelUpConfig.rate * 0.01f).ToString("f0"), "%");

            m_RatioUp.gameObject.SetActive(model.selectedPotentialBook != 0);

            m_SuccessRatio.color = UIHelper.GetUIColor(model.selectedPotentialBook != 0 ? TextColType.DarkGreen : TextColType.LightYellow);

            m_UpgradeImage.gray = !TestPotentialLevelUp();

            m_RatioUp.gameObject.SetActive(model.selectedPotentialBook != 0 && levelUpConfig.rate > 0);

            m_SuccessRatio.color = UIHelper.GetUIColor(model.selectedPotentialBook != 0 && levelUpConfig.rate > 0

                ? TextColType.DarkGreen : TextColType.LightYellow);

            m_UpgradeImage.gray = levelUpConfig.rate == 0 && model.selectedPotentialBook == 0;

            m_Upgrade.interactable = levelUpConfig.rate != 0 || model.selectedPotentialBook != 0;

        }



        private void DisplayAddBookRedpoint()

@@ -644,7 +650,9 @@
                m_PotentialBook.SetItem(_potentialBookId, 1);



                var levelUpConfig = GetPotentialLevelUpConfig();

                m_PotentialCount.text = StringUtility.Contact(levelUpConfig.own, "/", levelUpConfig.need);

                bool satisfy = levelUpConfig.own >= levelUpConfig.need;

                m_PotentialCount.text = StringUtility.Contact(UIHelper.GetTextColorByItemColor(satisfy ?

                    TextColType.LightYellow : TextColType.Red, levelUpConfig.own.ToString()), "/", levelUpConfig.need);

            }



            DisplaySuccessRatio();

@@ -657,10 +665,14 @@
            if (packType == PackType.rptItem && config != null && config.Type == 6)

            {

                var levelUpConfig = GetPotentialLevelUpConfig();

                if (levelUpConfig.own < levelUpConfig.need)

                if (_id == model.selectedPotentialBook)

                {

                    model.selectedPotentialBook = 0;

                    DisplayPotentialBook(model.selectedPotentialBook);

                }

                //if (levelUpConfig.own < levelUpConfig.need)

                //{

                //    model.selectedPotentialBook = 0;

                //}

            }

        }



@@ -687,13 +699,21 @@
                        }

                        break;

                    case 3:

                        MessageWin.Inst.ShowFixedTip(Language.Get("Hallows_SpUnEnough"));

                        ModelCenter.Instance.GetModel<GetItemPathModel>().SetChinItemModel(148);

                        //MessageWin.Inst.ShowFixedTip(Language.Get("Hallows_SpUnEnough"));

                        break;

                    case 4:

                        SysNotifyMgr.Instance.ShowTip("TreasureUnsealed");

                        break;

                    case 6:

                        SysNotifyMgr.Instance.ShowTip("LevelUpZeroRate");

                        if (model.selectedPotentialBook != 0)

                        {

                            ModelCenter.Instance.GetModel<GetItemPathModel>().SetChinItemModel(model.selectedPotentialBook);

                        }

                        else

                        {

                            SysNotifyMgr.Instance.ShowTip("LevelUpZeroRate");

                        }

                        break;

                }



@@ -840,9 +860,10 @@
            }



            var levelUpConfig = GetPotentialLevelUpConfig();

            if (levelUpConfig.own < levelUpConfig.need || !ContainsPotentialBook(model.selectedPotentialBook))

            if (!ContainsPotentialBook(model.selectedPotentialBook))

            {

                model.selectedPotentialBook = 0;

                AutoSelectPotentialBook();

                //model.selectedPotentialBook = 0;

            }



            var curconfig = Config.Instance.Get<SkillConfig>(potential.id);

@@ -924,7 +945,6 @@
                    m_SPOwn.text = UIHelper.ReplaceLargeNum(spOwn);

                    m_SPNeed.text = StringUtility.Contact("/", UIHelper.ReplaceLargeNum(spNeed));

                    m_SPOwn.color = spOwn >= spNeed ? UIHelper.GetUIColor(TextColType.DarkGreen) : UIHelper.GetUIColor(TextColType.Red);

                    m_UpgradeImage.gray = !TestPotentialLevelUp();

                    break;

            }

        }


 System/Voice/SpeechTranslate.cs

@@ -26,7 +26,7 @@
    public void RequestGetToken()

    {

        var url = "https://openapi.baidu.com/oauth/2.0/token?grant_type=client_credentials" + "&client_id=" + apiKey + "&client_secret=" + secretKey;

        HttpRequest.Instance.RequestWWW(url, 2, OnGetToken);

        HttpRequest.Instance.RequestHttpGet(url, HttpRequest.defaultHttpContentType, 2, OnGetToken);

    }



    private void OnGetToken(bool _ok, string _result)


 System/Welfare/OperationTimeHepler.cs

@@ -476,24 +476,24 @@
                    day = int.Parse(dateArray[2].Trim())

                };

            }

            else if (dateArray != null && dateArray.Length == 1)

            {

                var time = TimeUtility.openServerTime;

                if (time.Equals(default(DateTime)))

                {

                    DebugEx.Log("服务期开服时间下发顺序有问题");

                }

                var days = 0;

                int.TryParse(date, out days);

                days = Mathf.Max(1, days);

                time = time.AddDays(days - 1);

                return new OperationDate()

                {

                    year = time.Year,

                    month = time.Month,

                    day = time.Day,

                };

            }

            //else if (dateArray != null && dateArray.Length == 1)

            //{

            //    var time = TimeUtility.openServerTime;

            //    if (time.Equals(default(DateTime)))

            //    {

            //        DebugEx.Log("服务期开服时间下发顺序有问题");

            //    }

            //    var days = 0;

            //    int.TryParse(date, out days);

            //    days = Mathf.Max(1, days);

            //    time = time.AddDays(days - 1);

            //    return new OperationDate()

            //    {

            //        year = time.Year,

            //        month = time.Month,

            //        day = time.Day,

            //    };

            //}

            return default(OperationDate);

        }




 System/WindowBase/WindowCenter.cs

@@ -72,7 +72,7 @@
                }

                else

                {

                    DebugEx.Log(string.Format("{0} 窗口已经打开！", typeof(T)));

                    DebugEx.LogFormat("{0} 窗口已经打开！", typeof(T));

                }

            }

            else

@@ -146,7 +146,7 @@
                }

                else

                {

                    DebugEx.Log(string.Format("{0} 窗口已经打开！", typeof(T)));

                    DebugEx.LogFormat("{0} 窗口已经打开！", typeof(T));

                }



                return (T)win;

@@ -201,13 +201,13 @@
                }

                else

                {

                    DebugEx.Log(string.Format("{0} 窗口已经关闭！", typeof(T)));

                    DebugEx.LogFormat("{0} 窗口已经关闭！", typeof(T));

                }

            }

            else

            {

                asyncLoad.StopTask(typeof(T).Name);

                DebugEx.Log(string.Format("{0} 窗口无法获得！", typeof(T)));

                DebugEx.LogFormat("{0} 窗口无法获得！", typeof(T));

            }



            return win;

@@ -224,13 +224,13 @@
                }

                else

                {

                    DebugEx.Log(string.Format("{0} 窗口已经关闭！", typeof(T)));

                    DebugEx.LogFormat("{0} 窗口已经关闭！", typeof(T));

                }

            }

            else

            {

                asyncLoad.StopTask(typeof(T).Name);

                DebugEx.Log(string.Format("{0} 窗口无法获得！", typeof(T)));

                DebugEx.LogFormat("{0} 窗口无法获得！", typeof(T));

            }



            return win;

@@ -385,7 +385,7 @@
            }

            else

            {

                DebugEx.Log(string.Format("{0} 窗口无法获得！", typeof(T)));

                DebugEx.LogFormat("{0} 窗口无法获得！", typeof(T));

            }

        }



@@ -544,7 +544,7 @@
                }

                else

                {

                    DebugEx.Log(string.Format("{0} 窗口已经打开！", typeof(T)));

                    DebugEx.LogFormat("{0} 窗口已经打开！", typeof(T));

                }



                return (T)win;

@@ -577,7 +577,7 @@
                            }

                            else

                            {

                                DebugEx.Log(string.Format("{0} 窗口已经打开！", typeof(T)));

                                DebugEx.LogFormat("{0} 窗口已经打开！", typeof(T));

                            }

                        }

                    }


 System/WindowJump/WindowJumpMgr.cs

@@ -364,6 +364,7 @@
            case JumpUIType.SkillFunc1:

            case JumpUIType.SkillFunc2:

            case JumpUIType.SkillFunc3:

            case JumpUIType.SkillFunc2Type2:

                SetJumpLogic<SkillPanel>(_tagWinSearchModel.TABID);

                break;

            case JumpUIType.StrengthFunc1:

@@ -558,6 +559,7 @@
                SetJumpLogic<FindPreciousFrameWin>(_tagWinSearchModel.TABID);

                break;

            case JumpUIType.LootPreciousFrameFunc1:

            case JumpUIType.DogzDungeon:

                SetJumpLogic<LootPreciousFrameWin>(_tagWinSearchModel.TABID);

                break;

            case JumpUIType.LootPreciousFrameSpec:

@@ -1108,6 +1110,7 @@
    KnapSackFunc4 = 8,

    SkillFunc1 = 9,

    SkillFunc2 = 10,

    SkillFunc2Type2 = 243, //被动技能界面

    SkillFunc3 = 11,

    StrengthFunc1 = 12,

    StrengthFunc2 = 13,

@@ -1180,6 +1183,7 @@
    WelfareFunc1 = 102, //签到

    WelfareFunc2 = 103,  //祈愿

    LootPreciousFrameFunc1 = 104, //封魔坛

    DogzDungeon = 242, //异兽之地

    SystemSettingFunc1 = 109,//挂机设置



    RebornOpenBag = 113,//死亡复活打开背包


 System/WorldMap/WorldMapWin.cs

@@ -92,7 +92,7 @@


            WorldMapAreaBehaviour playerAtBehaviour = null;

            var currentMapId = PlayerDatas.Instance.baseData.MapID;



            m_ContainerPlayerHead.gameObject.SetActive(false);

            for (int i = 0; i < m_AreaBehaviours.Length; i++)

            {

                var behaviourTable = m_AreaBehaviours[i];

@@ -104,6 +104,7 @@
                    behaviourTable.areaBehaviour.Init(area);

                    if (behaviourTable.id == currentMapId.ToString())

                    {

                        m_ContainerPlayerHead.gameObject.SetActive(true);

                        playerAtBehaviour = behaviourTable.areaBehaviour;

                        m_ContainerPlayerHead.SetParentEx(behaviourTable.areaBehaviour.playerHead, Vector3.zero, Vector3.zero, Vector3.one);

                    }


 Utility/TimeUtility.cs

@@ -4,7 +4,7 @@


public static class TimeUtility

{

    private static DateTime _serverTime = DateTime.Now;

    private static DateTime s_ServerTime = DateTime.Now;



    private static float _checkTime = 0;

    /// <summary>

@@ -15,10 +15,10 @@
        get

        {

            float tick = Time.realtimeSinceStartup - _checkTime;

            DateTime real = _serverTime.AddSeconds(tick);

            DateTime real = s_ServerTime.AddSeconds(tick);

            return real;

        }

        private set { _serverTime = value; }

        private set { s_ServerTime = value; }

    }



    /// <summary>

@@ -95,7 +95,7 @@
        get; private set;

    }



    public static DateTime openServerTime;

    public static DayOfWeek openServerDayOfWeek;



    public static int OpenWeekCnt

    {

@@ -138,10 +138,13 @@
    public static void OnRefreshServerTime(HA004_tagServerDateTime vNetData)

    {

        DateTime n = new DateTime(vNetData.Year, vNetData.Month, vNetData.Day, vNetData.Hour, vNetData.Minute, vNetData.Second);

        _serverTime = n;

        DebugEx.Log("OnRefreshServerTime月份：" + _serverTime.Month);

        s_ServerTime = n;

        DebugEx.Log("OnRefreshServerTime月份：" + s_ServerTime.Month);

        _checkTime = Time.realtimeSinceStartup;

        if (OnServerTimeRefresh != null) OnServerTimeRefresh();

        if (OnServerTimeRefresh != null)

        {

            OnServerTimeRefresh();

        }

        TimeDownMgr.Instance.Begin(TimeDownMgr.CoolTimeType.SyncServerTime, 60, (float tick) =>

        {

            SyncServerTime();

@@ -153,7 +156,18 @@
        OpenDay = package.Day;

        IsMixServer = package.IsMixServer == 1;

        MixOpenDay = package.MixDay;

        DateTime.TryParse(package.OpenServerTime, out openServerTime);

        openServerDayOfWeek = package.OpenWeekday == 7 ? DayOfWeek.Sunday : (DayOfWeek)package.OpenWeekday;

        OnRefreshServerTime(new HA004_tagServerDateTime()

        {

            Year = package.NowYear,

            Month = package.NowMonth,

            Day = package.NowDay,

            Hour = package.NowHour,

            Minute = package.NowMinute,

            Second = package.NowSecond,

            MicSecond = package.NowMicSecond,

        });

        //DateTime.TryParse(package.OpenServerTime, out openServerTime);

        if (OnServerOpenDayRefresh != null)

        {

            OnServerOpenDayRefresh();