xx

internal void CreateStatusAtributes(Client.GameClient client)
           {
               uint oldInner_Strength = Inner_Strength;
               Inner_Strength = 0;
               foreach (var nstage in ArrayStages)
               {
                   if (!nstage.Activate) continue;

                   var atr = nstage.ArrayStars.Where(p => p.UID != 0).ToArray();

                   byte count_doble = 0;

                   Dictionary<uint, List<Stage.Star>> alignementstars = new Dictionary<uint, List<Stage.Star>>();
                   List<Stage.Star> normalstarts = new List<Stage.Star>();
                   ushort counts_alignements = 0;

                   for (byte x = 0; x < atr.Length; x++)
                   {
                       var atribut = atr[x];
                       count_doble = 0;
                       bool wasadd = false;
                       for (byte y = (byte)(x + 1); y < atr.Length; y++)
                       {
                           var atr2nd = atr[y];
                           if (atr2nd.Typ == atribut.Typ)
                           {
                               if (!wasadd)
                               {
                                   if (!alignementstars.ContainsKey(counts_alignements))
                                   {
                                       alignementstars.Add(counts_alignements, new List<Stage.Star>());
                                       alignementstars[counts_alignements].Add(atribut);
                                   }
                               }
                               if (!alignementstars.ContainsKey(counts_alignements))
                               {
                                   alignementstars.Add(counts_alignements, new List<Stage.Star>());
                                   alignementstars[counts_alignements].Add(atr2nd);
                               }
                               else
                                   alignementstars[counts_alignements].Add(atr2nd);
                               wasadd = true;
                               x = y;
                               count_doble++;
                           }
                           else
                           {
                               break;
                           }
                       }
                       uint counts = 1;
                       if (count_doble != 0)
                       {
                           counts = (byte)(count_doble + 1);
                           counts_alignements++;
                       }
                       if (counts == 1)
                           normalstarts.Add(atribut);
                       byte percent = (byte)Database.JianHuTable.AlignmentExtraPoints(count_doble);
                       Database.JianHuTable.Atribut Atri_bas = Database.JianHuTable.Atributes[atribut.UID];
                       if (client != null)
                           ComputeStatus(client, (Stage.AtributesType)Atri_bas.Type, (ushort)((Atri_bas.Power + (Atri_bas.Power * percent) / 100) * counts));
                       count_doble = 0;
                   }

                   foreach (var allignement in alignementstars.Values)
                       CalculateInner_StrengthAlignments(allignement);
                   for (int x = 0; x < normalstarts.Count; x++)
                   {
                       Inner_Strength += Database.JianHuTable.GetStatusPoints(normalstarts[x].Level);
                   }
               }
               if (oldInner_Strength != Inner_Strength)
                   JiangHuRanking.UpdateRank(this);
           }
           internal void CalculateInner_StrengthAlignments(List<Stage.Star> collection)
           {
               ushort points = 0;
               for (int x = 0; x < collection.Count; x++)
               {
                   points += Database.JianHuTable.GetStatusPoints(collection[x].Level);
               }
               if (collection.Count > 0)
                   Inner_Strength += (uint)(points + (points * (GetPercentALignment(collection.Count) * 10) / 100));
           }
           internal byte GetPercentALignment(int count)
           {
               if (count < 8)
                   return (byte)(count - 1);
               if (count == 8)
                   return (byte)count;
               else
                   return (byte)(count + 1);

           }