[Release] Monster spawn void

Ok so be warned, this is messy as I haven't cleaned up most of it. Also note: as far as I'm aware, all mesh sizeadds are controlled by the client so I wasn't able to add that into this (the whole reason I started messing around with this was to easily change mob names/custom quest mobs without having to edit client)

Anyways, I have no use for it and I have no reason to clean up the code at all so I'm gonna go ahead and post what I have done.

Current version works perfectly to spawn mobs. I added some very poorly written code to save monster names when you go offscreen (if you just spawn them with the name it will default back to the old name/display info when you leave screen and come back)

Also added some basic code to control monster spread, number of mobs and some other simple stuff.

NOTE: COEMU 5095! I WILL NOT CONVERT IT FOR LOTF!

First off, for simplicity create a new .cs file under handlers (mine is Handlers.SpawnVoid.cs. Add this into it

Spoiler

Code:

using System;
using System.Collections;
using System.Collections.Generic;
using CoEmu_v2_GameServer;
using CoEmu_v2_GameServer.Connections;
using CoEmu_v2_GameServer.Entities;
using CoEmu_v2_GameServer.Structs;
using CoEmu_v2_GameServer.Packets;
using CoEmu_v2_GameServer.Calculations;
using CoEmu_v2_GameServer.Database;
using System.Threading;

namespace CoEmu_v2_GameServer.Handlers
{
    public partial class Handler
    {
        public class SpawnVoid
        {


            public static void SpawnMonster(int MobId, string MobName, int Map1, int X1, int Y1, int Spread)
            {
                {

                    MonsterInfo MobInfo = Nano.BaseMonsters[MobId];//mobid
                   
                    MonsterInfo CustomInfo = new MonsterInfo();
                    CustomInfo.AggroRange = MobInfo.AggroRange;                    
                    CustomInfo.AttackRange = MobInfo.AttackRange;
                    CustomInfo.AttackSpeed = MobInfo.AttackSpeed;
                    CustomInfo.Defense = MobInfo.Defense;
                    CustomInfo.Dodge = MobInfo.Dodge;
                    CustomInfo.ID = MobInfo.ID;
                    CustomInfo.Level = MobInfo.Level;
                    CustomInfo.MagicID = MobInfo.MagicID;
                    CustomInfo.MaxAttack = MobInfo.MaxAttack;
                    CustomInfo.MaxHP = MobInfo.MaxHP;
                    CustomInfo.MDefense = MobInfo.MDefense;
                    CustomInfo.Mesh = MobInfo.Mesh;
                    CustomInfo.MinAttack = MobInfo.MinAttack;
                    CustomInfo.Name = MobName;
                    CustomInfo.Speed = MobInfo.Speed;
                while (Nano.BaseMonsters.ContainsKey(CustomInfo.ID))
                {
                    CustomInfo.ID = Nano.Rand.Next(1000, 100000);
                    
                }
                Nano.BaseMonsters.Add(CustomInfo.ID, CustomInfo);


                    Monster Mon = new Monster();                   
                    
                    Mon.X = X1;
                    Mon.Y = Y1;
                    Mon.Map = Map1;                   
                    int UID = 0;
                   
                    Mon.X = Nano.Rand.Next((X1 - Spread), (X1 + Spread));
                    Mon.Y = Nano.Rand.Next((Y1 - Spread), (Y1 + Spread));
                    if (Nano.Maps.ContainsKey(Mon.Map))
                    {
                        Structs.Struct.DmapData Mapping = Nano.Maps[Mon.Map];
                        while (!Mapping.CheckLoc((ushort)Mon.X, (ushort)Mon.Y))
                        {
                            Mon.X = Nano.Rand.Next((X1 - Spread), (X1 + Spread));
                             Mon.Y = Nano.Rand.Next((Y1 - Spread), (Y1 + Spread));
                        }
                    }
                    UID = Nano.Rand.Next(200000, 600000);
                    while (Nano.Monsters.ContainsKey(UID))
                    {
                        UID = Nano.Rand.Next(200000, 600000);
                    }
                    Mon.CurrentHP = MobInfo.MaxHP;                    
                    Mon.MaxHP = MobInfo.MaxHP;
                    Mon.UID = UID;
                    Mon.Direction = 0;
                    Mon.ID = MobInfo.ID;
                    Mon.Info = CustomInfo;
                    Mon.Level = MobInfo.Level;                    
                    Mon.SpawnX = Mon.X;
                    Mon.SpawnY = Mon.Y;
                    int SpawnID = Nano.Rand.Next(1, 1000);
                    Mon.SpawnID = SpawnID;
                    if (!Nano.Monsters.ContainsKey(Mon.UID))
                    {
                        //lock(Nano.Monsters)
                        //{
                        try
                        {
                            Monitor.Enter(Nano.Monsters);
                            Nano.Monsters.Add(Mon.UID, Mon);
                        }
                        catch (Exception e)
                        {
                            Console.WriteLine(e.ToString());
                        }
                        finally
                        {
                            Monitor.Exit(Nano.Monsters);
                        }
                        //}
                    }
                    else
                    {
                        while (Nano.Monsters.ContainsKey(Mon.UID))
                        {
                            Mon.UID = Nano.Rand.Next(200000, 600000);
                        }
                        //lock(Nano.Monsters)
                        //{
                        try
                        {
                            Monitor.Enter(Nano.Monsters);
                            Nano.Monsters.Add(Mon.UID, Mon);
                        }
                        catch (Exception e)
                        {
                            Console.WriteLine(e.ToString());
                        }
                        finally
                        {
                            Monitor.Exit(Nano.Monsters);
                        }
                        //}
                    }
                    int SpawnNumber = 1;
                    ConquerPacket.ToLocal(ConquerPacket.SpawnMonster(Mon.UID, MobInfo.Mesh, Mon.X, Mon.Y, CustomInfo.Name /*MobInfo.Name*/, Mon.CurrentHP, Mon.Level, Mon.Direction), Mon.X, Mon.Y, Mon.Map, 0, 0);
                    ConquerPacket.ToLocal(ConquerPacket.MobSpawnEffect(Mon.UID, Mon.X, Mon.Y, Mon.Direction, 131), Mon.X, Mon.Y, Mon.Map, 0, 0);
                    Interlocked.Add(ref SpawnNumber, 1);
                }
            }
        }
    }
}

Now to spawn monsters via a command (you can add this into quests/conditionals, random events and all sorts of other good stuff.) open Handlers>Chat.cs and add this command

Code:

case "mobtest":
                            {
                              
                                int Amount = Convert.ToInt32(Command[7]);

                                while (Amount > 0)
                                {
                                Handler.SpawnVoid.SpawnMonster(Convert.ToInt32(Command[1]), Command[2], Convert.ToInt32(Command[3]), Convert.ToInt32(Command[4]), Convert.ToInt32(Command[5]), Convert.ToInt32(Command[6]));
                                    Amount -= 1;
                                }                            
                                break;
                            }

I didn't implement changing monster max hp/level (useful for exp monsters! All you have to do for that is edit the first code.

CustomInfo.MaxHP = MobInfo.MaxHP;
CustomInfo.Level = MobInfo.Level;

To be whatever you want (I'd simply change the void so that you can edit the monster hp/level easily as they are the most common things you will wanna change)

Anyways, I know it's not pretty but it works just fine. As far as I know, no such thing has been released and it can be used for alot of interesting stuff (eg: spawning boss monster at a certain spot for quests such as dis city or 2nd reborn quest)

To use the command

/mobtest MobId(mesh) mobname map x y spread amount

Eg: /mobtest 3311 Epvp 1002 500 501 10 2

would spawn 2 bunnies named "Epvp" at 500, 501 twin city (with 10 spread, meaning randomness of where they actually spawn. useful for spawning more than 1 so they aren't all stacked up)

Screenshot of it: [Only registered and activated users can see links. Click Here To Register...]

Enjoy,
P4N

... it lets you spawn any monster while the server is running wherever you want it with any name you want.

I included a command with it (summon a monster by command) but it makes it simple to spawn a monster under any server conditions (such as time, quest conditions, etc)

So lets say you have a quest that you want a boss monster to spawn at a specific point under certain conditions (such as player has 100 kills on that map) you could use it for that.

Or lets say you have an item you want to summon a monster. Code it into the item use code and you can have it summon a monster at your current position.

It has a ton of applications, you just have to use some imagination. Basically, if you need/want a monster to spawn for any reason, you can use this by using Handler.SpawnVoid.SpawnMonster(mobmesh, mob name, mob mab, mob x, mob y, spread);

Hope that clears up some of your questions.