public void SyncMonsters()
 {
     lock (this)
     {
         if (MonstersGroups.Count > 0 || Record.HaveZaap || !MapNoSpawnRecord.CanSpawn(Record.Id))
         {
             return;
         }
         AsyncRandom random = new AsyncRandom();
         if (this.Record.DugeonMap)
         {
             if (this.MonstersGroups.Count == 0)
             {
                 List <MonsterSpawnMapRecord> monsters = DungeonRecord.GetDungeonMapMonsters(this.Record.Id).ConvertAll <MonsterSpawnMapRecord>(x => new MonsterSpawnMapRecord(-1, x, this.Record.Id, 100));
                 monsters.ForEach(x => x.ActualGrade = (sbyte)random.Next(1, 6));
                 MonstersGroups.Add(new MonsterGroup(MonsterGroup.START_ID, monsters, (ushort)Record.RandomWalkableCell()));
             }
             return;
         }
         var spawns = MonsterSpawnSubRecord.GetSpawns(Record.Id);
         if (spawns.Count() == 0)
         {
             return;
         }
         for (sbyte groupId = 0; groupId < random.Next(1, MAX_MONSTER_PER_GROUP + 1); groupId++)
         {
             List <MonsterSpawnMapRecord> monsters = new List <MonsterSpawnMapRecord>();
             for (int w = 0; w < random.Next(1, MAX_MONSTER_PER_GROUP + 1); w++)
             {
                 int max  = spawns.Sum((MonsterSpawnMapRecord entry) => entry.Probability);
                 int num  = random.Next(0, max);
                 int num2 = 0;
                 foreach (var monster in spawns)
                 {
                     num2 += monster.Probability;
                     if (num <= num2)
                     {
                         monster.ActualGrade = (sbyte)random.Next(1, 6);
                         monsters.Add(monster);
                         break;
                     }
                 }
             }
             MonstersGroups.Add(new MonsterGroup(groupId + MonsterGroup.START_ID, monsters, (ushort)Record.RandomWalkableCell()));
         }
     }
 }
Exemple #2
0
        public static void NoSpawnCommand(string value, WorldClient client)
        {
            // Already no spawn, re enable spawn
            if (MapNoSpawnRecord.MapsNoSpawns.Exists(r => r.MapId == client.Character.Map.Id))
            {
                MapNoSpawnRecord record = MapNoSpawnRecord.MapsNoSpawns.Find(r => r.MapId == client.Character.Map.Id);
                record.RemoveInstantElement();

                client.Character.Map.Instance.Reload();
                client.Character.Reply("Monster spawn has be re-enabled on this map.");
            }
            // Otherwise, disable spawn
            else
            {
                new MapNoSpawnRecord(client.Character.Map.Id).AddInstantElement();
                foreach (MonsterGroup entity in client.Character.Map.Instance.GetEntities <MonsterGroup>())
                {
                    client.Character.Map.Instance.RemoveEntity(entity);
                }

                client.Character.Reply("Monster spawn has be disabled on this map.");
            }
        }
        public static bool SpawnMonster(Character character, EffectDice effect)
        {
            MonsterRecord template = MonsterRecord.GetMonster(effect.Const);

            if (template != null && template.GradeExist((sbyte)effect.Min))
            {
                if (character.Map.Instance.MonsterGroupCount < MonsterSpawnManager.MaxMonsterGroupPerMap && MapNoSpawnRecord.AbleToSpawn(character.Map.Id))
                {
                    MonsterSpawnManager.Instance.AddFixedMonsterGroup(character.Map.Instance,
                                                                      new MonsterRecord[] { template },
                                                                      new sbyte[] { (sbyte)effect.Min },
                                                                      false);

                    return(true);
                }
                else
                {
                    character.ReplyError("Impossible de spawn le monstre ici...");

                    return(false);
                }
            }
            else
            {
                return(false);
            }
        }