private void RandomSpawnMobs(int mobId, int count, Point maxPos, Point minPos)
{
WzMob mobInfo = DataBuffer.GetMobById(mobId);
for (int i = 0; i < count; i++)
{
MapleMap spawnMap = null;
if (RecreatedMap)
{
spawnMap = EventMap;
}
else if (Starter.Map != null)
{
spawnMap = Starter.Map;
}
if (spawnMap == null)
{
return;
}
WzMap.FootHold randomFh = spawnMap.GetRandomFoothold(maxPos, minPos);
spawnMap.SpawnMobOnGroundBelow(new MapleMonster(mobInfo, spawnMap), randomFh.Point1);
}
}
public MapleMonster SpawnMonster(MapleMap mapleMap)
{
var mob = new MapleMonster(m_monster)
{
Position = Pos
};
m_spawnedMonsters.Increment();
mob.Listeners.Add((kak, args) =>
{
m_nextPossibleSpawn = DateTime.Now.GetTimeMilliseconds();
if (m_mobTime > 0)
{
m_nextPossibleSpawn += m_mobTime * 1000;
}
else
{
m_nextPossibleSpawn += args.Monster.Stats.GetAnimationTime("die1");
}
m_spawnedMonsters.Decrement();
});
mapleMap.SpawnMonster(mob);
if (m_mobTime == 0)
{
m_nextPossibleSpawn = DateTime.Now.GetTimeMilliseconds() + 5000;
}
return(mob);
}
public static void Warp(string[] split, MapleClient c)
{
int mapId;
if (int.TryParse(split[1], out mapId))
{
MapleMap map = Program.GetChannelServer(c.Channel).GetMap(mapId);
if (map != null)
{
c.Account.Character.ChangeMap(map);
}
}
else
{
MapleCharacter victim = Program.GetCharacterByName(split[1]);
if (victim != null)
{
if (victim.Client.Channel != c.Channel)
{
c.Account.Character.SendBlueMessage("You are not on the same channel, please move to channel " + victim.Client.Channel);
}
else
{
c.Account.Character.ChangeMap(victim.Map, victim.Map.GetClosestSpawnPoint(victim.Position).Name);
}
}
else
{
c.Account.Character.SendBlueMessage("Player " + split[1] + " not found");
}
}
}
public SpecialPortal(int skillId, MapleCharacter owner, Point position, MapleMap fromMap, MapleMap toMap, WzMap.Portal toMapSpawnPortal, int durationMS, bool partyObject)
: base(0, owner, position, durationMS, partyObject)
{
SkillId = skillId;
FromMap = fromMap;
ToMap = toMap;
ToMapPortal = toMapSpawnPortal;
}
public void KilledMob(MapleMap map, int baseExp, bool mostDamage)
{
var chr = m_cserv.Characters.FirstOrDefault(x => x.Id == m_chrid);
if (chr != null && chr.Map.MapId == map.MapId)
{
m_monster.GiveExpToCharacter(chr, baseExp, mostDamage, 1);
}
}
public static void Handle(MapleClient c, PacketReader pr)
{
//[00 00 00 00] [F2 07 00 00] 00 00 00 00 00 00 64 11 A0 D8 00 00 00 00 B8 54 00 00 38 9A FE 92 98 EB F3 B2
pr.Skip(4); //v143
int characterId = pr.ReadInt();
pr.Skip(18);
long ConnectionAuth = pr.ReadLong();
MigrationData migration = Program.TryDequeueMigration(characterId, ConnectionAuth, c.Channel);
if (migration != null || migration.Character == null)
{
MapleClient oldClient = Program.GetClientByCharacterId(migration.CharacterId);
if (oldClient != null)
{
oldClient.SClient.Dispose();
}
MapleAccount account = MapleAccount.GetAccountFromDatabase(migration.AccountName);
MapleCharacter chr = migration.Character;
account.Character = chr;
c.Account = account;
chr.Bind(c);
account.MigrationData = migration;
account.Character = chr;
if (!migration.ToCashShop)
{
MapleMap map = Program.GetChannelServer(c.Channel).GetMap(chr.MapId);
if (map != null)
{
chr.Map = map;
MapleCharacter.EnterChannel(c);
c.Account.Character.LoggedIn();
chr.Stats.Recalculate(chr);
chr.Position = map.GetStartpoint(0).Position;
map.AddCharacter(chr);
}
}
else
{
CashShop.StartShowing(c);
}
}
else
{
c.Disconnect("No migration data found.");
}
}
public MapleMonster(WzMob Info, MapleMap map)
{
WzInfo = Info;
Controller = new WeakReference <MapleCharacter>(null);
ControllerHasAggro = false;
HP = WzInfo.HP;
Stance = 2;
Alive = true;
Map = map;
foreach (MobSkill skill in Info.Skills)
{
SkillTimes[skill] = DateTime.MinValue;
}
}
public List <MapleCharacter> GetCharactersOnMap(MapleMap map, int sourceCharacterId = 0)
{
List <MapleCharacter> ret = new List <MapleCharacter>();
foreach (int i in Characters)
{
MapleCharacter chr;
if (i != sourceCharacterId && (chr = map.GetCharacter(i)) != null)
{
ret.Add(chr);
}
}
return(ret);
}
public static void HandleReturnScroll(MapleClient c, PacketReader pr)
{
MapleCharacter chr = c.Account.Character;
if (!chr.DisableActions())
{
return;
}
int tickCount = pr.ReadInt();
pr.Skip(2); //Unk
int itemId = pr.ReadInt();
if (!chr.Inventory.HasItem(itemId))
{
return;
}
WzConsume item = DataBuffer.GetItemById(itemId) as WzConsume;
if (item == null)
{
return;
}
if (item.MoveTo > 0)
{
int toMap = 0;
toMap = item.MoveTo == 999999999 ? chr.Map.ReturnMap : item.MoveTo;
if (toMap != 0)
{
MapleMap map = Program.GetChannelServer(c.Channel).GetMap(toMap);
if (map == null || map.PortalScrollLimit)
{
return;
}
if (chr.Inventory.RemoveItemsById(itemId, 1))
{
chr.ChangeMap(toMap);
}
}
}
else
{
string msg = "Unhandled return scroll: " + itemId;
ServerConsole.Warning(msg);
FileLogging.Log("Unhandled items", msg);
chr.EnableActions();
}
}
public ChannelServer(byte channelId)
: base()
{
ChannelId = channelId;
Maps = new Dictionary <int, MapleMap>();
foreach (KeyValuePair <int, WzMap> kvp in DataBuffer.MapBuffer)
{
MapleMap map = new MapleMap(kvp.Key, kvp.Value);
Maps.Add(kvp.Key, map);
}
ICollection <MapleMap> mapsList = Maps.Values;
MapRespawnTimer.Elapsed += (sender, e) => CheckMapRespawns(mapsList);
MapUpdateTimer.Elapsed += (sender, e) => UpdateMaps(mapsList);
MapUpdateTimer.Enabled = true;
MapRespawnTimer.Enabled = true;
}
public static void Handle(MapleClient c, PacketReader pr)
{
pr.Skip(1); //dont know, == 1 in spawn map and becomes 3 after changing map
pr.Skip(4); //CRC ?
int tickCount = pr.ReadInt();
pr.Skip(1);
pr.Skip(4); //new v137
Point originalPosition = pr.ReadPoint();
pr.Skip(4); //wobble?
List <MapleMovementFragment> movementList = ParseMovement.Parse(pr);
updatePosition(movementList, c.Account.Character, 0);
MapleMap Map = c.Account.Character.Map;
if (movementList != null && pr.Available > 10 && Map.CharacterCount > 1)
{
PacketWriter packet = CharacterMovePacket(c.Account.Character.Id, movementList, originalPosition);
Map.BroadcastPacket(packet, c.Account.Character);
}
}
private void SpawnMobs(int mobId, int count, int x, int y)
{
WzMob mobInfo = DataBuffer.GetMobById(mobId);
for (int i = 0; i < count; i++)
{
MapleMap spawnMap = null;
if (RecreatedMap)
{
spawnMap = EventMap;
}
else if (Starter.Map != null)
{
spawnMap = Starter.Map;
}
if (spawnMap == null)
{
return;
}
spawnMap.SpawnMobOnGroundBelow(new MapleMonster(mobInfo, spawnMap), new Point(x, y));
}
}
public MysticDoor(int skillId, MapleCharacter owner, Point position, MapleMap fromMap, MapleMap toMap, WzMap.Portal toMapSpawnPortal, int durationMS, bool partyObject)
: base(skillId, owner, position, fromMap, toMap, toMapSpawnPortal, durationMS, partyObject)
{
}
public void loadMap(Client c)
{
FMap = Database.loadMap(FmapID, c);
}
public MapleMap GetMap(int mapid)
{
var omapid = mapid;
MapleMap map;
if (!Maps.TryGetValue(omapid, out map))
{
lock (this)
{
// check if someone else who was also synchronized has loaded the map already
if (Maps.ContainsKey(omapid))
{
return(Maps[omapid]);
}
var mapName = GetMapName(mapid);
var mapData = m_mSource.GetData(mapName);
var link = MapleDataTool.GetString(mapData.GetChildByPath("info/link"), "");
if (!link.Equals(""))
{
mapName = GetMapName(int.Parse(link));
mapData = m_mSource.GetData(mapName);
}
float monsterRate = 0;
var mobRate = mapData.GetChildByPath("info/mobRate");
if (mobRate != null)
{
monsterRate = (float)mobRate.Data;
}
map = new MapleMap(mapid, ChannelId, MapleDataTool.GetInt("info/returnMap", mapData), monsterRate)
{
OnFirstUserEnter = MapleDataTool.GetString(mapData.GetChildByPath("info/onFirstUserEnter"),
mapid.ToString()),
OnUserEnter = MapleDataTool.GetString(mapData.GetChildByPath("info/onUserEnter"),
mapid.ToString()),
TimeMobId = MapleDataTool.GetInt(mapData.GetChildByPath("info/timeMob/id"), -1),
TimeMobMessage = MapleDataTool.GetString(mapData.GetChildByPath("info/timeMob/message"), "")
};
var portalFactory = new PortalFactory();
foreach (var portal in mapData.GetChildByPath("portal"))
{
var portalresult =
portalFactory.MakePortal((PortalType)MapleDataTool.GetInt(portal.GetChildByPath("pt")),
portal);
map.Portals.Add(portalresult.PortalId, portalresult);
}
var allFootholds = new List <MapleFoothold>();
var lBound = new Point();
var uBound = new Point();
foreach (var footRoot in mapData.GetChildByPath("foothold"))
{
foreach (var footCat in footRoot)
{
foreach (var footHold in footCat)
{
var x1 = MapleDataTool.GetInt(footHold.GetChildByPath("x1"));
var y1 = MapleDataTool.GetInt(footHold.GetChildByPath("y1"));
var x2 = MapleDataTool.GetInt(footHold.GetChildByPath("x2"));
var y2 = MapleDataTool.GetInt(footHold.GetChildByPath("y2"));
var fh = new MapleFoothold(new Point(x1, y1), new Point(x2, y2),
int.Parse(footHold.Name));
fh.PrevFootholdId = MapleDataTool.GetInt(footHold.GetChildByPath("prev"));
fh.NextFootholdId = MapleDataTool.GetInt(footHold.GetChildByPath("next"));
if (fh.Point1.X < lBound.X)
{
lBound.X = fh.Point1.X;
}
if (fh.Point2.X > uBound.X)
{
uBound.X = fh.Point2.X;
}
if (fh.Point1.Y < lBound.Y)
{
lBound.Y = fh.Point1.Y;
}
if (fh.Point2.Y > uBound.Y)
{
uBound.Y = fh.Point2.Y;
}
allFootholds.Add(fh);
}
}
}
var fTree = new MapleFootholdTree(lBound, uBound);
foreach (var fh in allFootholds)
{
fTree.Insert(fh);
}
map.Footholds = fTree;
// load areas (EG PQ platforms)
if (mapData.GetChildByPath("area") != null)
{
foreach (var area in mapData.GetChildByPath("area"))
{
var x1 = MapleDataTool.GetInt(area.GetChildByPath("x1"));
var y1 = MapleDataTool.GetInt(area.GetChildByPath("y1"));
var x2 = MapleDataTool.GetInt(area.GetChildByPath("x2"));
var y2 = MapleDataTool.GetInt(area.GetChildByPath("y2"));
var mapArea = new Rectangle(x1, y1, x2 - x1, y2 - y1);
map.Areas.Add(mapArea);
}
}
// load life data (npc, monsters)
foreach (var life in mapData.GetChildByPath("life"))
{
var id = MapleDataTool.GetString(life.GetChildByPath("id"));
var type = MapleDataTool.GetString(life.GetChildByPath("type"));
var myLife = LoadLife(life, id, type);
var mapleMonster = myLife as MapleMonster;
if (mapleMonster != null)
{
var monster = mapleMonster;
var mobTime = MapleDataTool.GetInt("mobTime", life, 0);
if (mobTime == -1)
{
//does not respawn, force spawn once
map.SpawnMonster(monster);
}
else
{
map.AddMonsterSpawn(monster, mobTime);
}
}
else
{
map.AddMapObject(myLife);
}
}
//load reactor data
if (mapData.GetChildByPath("reactor") != null)
{
foreach (var reactor in mapData.GetChildByPath("reactor"))
{
var id = MapleDataTool.GetString(reactor.GetChildByPath("id"));
if (id != null)
{
var newReactor = LoadReactor(reactor, id);
map.SpawnReactor(newReactor);
}
}
}
//try
//{
map.MapName = MapleDataTool.GetString("mapName", m_mNameData.GetChildByPath(GetMapStringName(omapid)),
"");
map.StreetName = MapleDataTool.GetString("streetName",
m_mNameData.GetChildByPath(GetMapStringName(omapid)), "");
//}
//catch
//{
//map.MapName = "";
//map.StreetName = "";
//}
map.Clock = mapData.GetChildByPath("clock") != null;
map.Everlast = mapData.GetChildByPath("everlast") != null;
map.Town = mapData.GetChildByPath("town") != null;
map.AllowShops = MapleDataTool.GetInt(mapData.GetChildByPath("info/personalShop"), 0) == 1;
map.DecHp = MapleDataTool.ConvertToInt("decHP", mapData, 0);
map.ProtectItem = MapleDataTool.ConvertToInt("protectItem", mapData, 0);
map.ForcedReturnMapId = MapleDataTool.GetInt(mapData.GetChildByPath("info/forcedReturn"), 999999999);
map.OnFirstUserEnter = MapleDataTool.GetString(mapData.GetChildByPath("info/onFirstUserEnter"), "");
map.OnUserEnter = MapleDataTool.GetString(mapData.GetChildByPath("info/onUserEnter"), "");
map.HasBoat = mapData.GetChildByPath("shipObj") != null;
map.FieldLimit = MapleDataTool.GetInt(mapData.GetChildByPath("info/fieldLimit"), 0);
map.TimeLimit = MapleDataTool.ConvertToInt("timeLimit", mapData.GetChildByPath("info"), -1);
map.FieldType = MapleDataTool.ConvertToInt("info/fieldType", mapData, 0);
Maps.Add(omapid, map);
//try
//{
// PreparedStatement ps = DatabaseConnection.getConnection().prepareStatement("SELECT * FROM spawns WHERE mid = ?");
// ps.setInt(1, omapid);
// ResultSet rs = ps.executeQuery();
// while (rs.next())
// {
// int id = rs.getInt("idd");
// int f = rs.getInt("f");
// bool hide = false;
// string type = rs.getString("type");
// int fh = rs.getInt("fh");
// int cy = rs.getInt("cy");
// int rx0 = rs.getInt("rx0");
// int rx1 = rs.getInt("rx1");
// int x = rs.getInt("x");
// int y = rs.getInt("y");
// int mobTime = rs.getInt("mobtime");
// AbstractLoadedMapleLife myLife = loadLife(id, f, hide, fh, cy, rx0, rx1, x, y, type);
// if (type.equals("n"))
// {
// map.addMapObject(myLife);
// }
// else if (type.equals("m"))
// {
// MapleMonster monster = (MapleMonster)myLife;
// map.addMonsterSpawn(monster, mobTime);
// }
// }
//}
//catch (SQLException e)
//{
// log.info(e.toString());
//}
}
}
return(map);
}
public static void RemoveMapItems(string[] split, MapleClient c)
{
MapleMap map = c.Account.Character.Map;
map.RemoveAllMapItems();
}
public void KilledMob(MapleMap map, int baseExp, bool mostDamage)
{
Dictionary <MapleCharacter, OnePartyAttacker> attackers = ResolveAttackers();
MapleCharacter highest = null;
int highestDamage = 0;
Dictionary <MapleCharacter, int> expMap = new Dictionary <MapleCharacter, int>(6);
foreach (var attacker in attackers)
{
MapleParty party = attacker.Value.LastKnownParty;
double averagePartyLevel = 0;
List <MapleCharacter> expApplicable = new List <MapleCharacter>();
foreach (var partychar in party.GetMembers())
{
if (attacker.Key.Level - partychar.Level <= 5 || m_monster.Stats.Level - partychar.Level <= 5)
{
MapleCharacter pchr = m_cserv.Characters.FirstOrDefault(x => x.Name == partychar.CharacterName);
if (pchr == null)
{
continue;
}
if (!pchr.IsAlive || pchr.Map != map)
{
continue;
}
expApplicable.Add(pchr);
averagePartyLevel += pchr.Level;
}
}
double expBonus = 1.0;
if (expApplicable.Count > 1)
{
expBonus = 1.10 + 0.05 * expApplicable.Count;
averagePartyLevel /= expApplicable.Count;
}
int iDamage = attacker.Value.Damage;
if (iDamage > highestDamage)
{
highest = attacker.Key;
highestDamage = iDamage;
}
double innerBaseExp = baseExp * ((double)iDamage / m_totDamage);
double expFraction = innerBaseExp * expBonus / (expApplicable.Count + 1);
foreach (var expReceiver in expApplicable)
{
int oexp;
int iexp = !expMap.TryGetValue(expReceiver, out oexp) ? 0 : oexp;
double expWeight = expReceiver == attacker.Key ? 2.0 : 1.0;
double levelMod = expReceiver.Level / averagePartyLevel;
if (levelMod > 1.0 || m_attackers.ContainsKey(expReceiver.Id))
{
levelMod = 1.0;
}
iexp += (int)Math.Round(expFraction * expWeight * levelMod);
if (expMap.ContainsKey(expReceiver))
{
expMap[expReceiver] = iexp;
}
else
{
expMap.Add(expReceiver, iexp);
}
}
}
// F**K we are done -.-
foreach (var expReceiver in expMap)
{
bool white = mostDamage && expReceiver.Key == highest;
m_monster.GiveExpToCharacter(expReceiver.Key, expReceiver.Value, white, expMap.Count);
}
}
public void ApplyEffect(MapleCharacter source, MapleCharacter target)
{
int value;
if (SkillConstants.IsHealSkill(Parent.SkillId) && Info.TryGetValue(CharacterSkillStat.hp, out value))
{
int healHp = (int)((value / 100.0) * source.Stats.GetDamage());
target.AddHP(healHp);
}
#region Mist
if (SkillConstants.IsMistSkill(Parent.SkillId))
{
Point sourcePos = source.Position;
BoundingBox boundingBox = CalculateBoundingBox(sourcePos, source.IsFacingLeft);
source.Map.SpawnMist(Parent.SkillId, Level, source, boundingBox, sourcePos, Info[CharacterSkillStat.time] * 1000, false);
}
else if (Parent.SkillId == Priest.MYSTIC_DOOR)
{
MapleMap fromMap = source.Map;
if (fromMap.MysticDoorLimit)
{
return;
}
source.CancelDoor(Priest.MYSTIC_DOOR);
int partyId = source.Party?.Id ?? -1;
Point fromMapPosition = source.Map.GetDropPositionBelow(source.Position, source.Position);
int time = Info[CharacterSkillStat.time] * 1000;
MapleMap toMap = Program.GetChannelServer(source.Client.Channel).GetMap(source.Map.ReturnMap);
if (toMap != null)
{
WzMap.Portal toPortal = toMap.TownPortal;
if (toPortal != null)
{
Point toMapPosition = toMap.GetDropPositionBelow(toPortal.Position, toPortal.Position);
MysticDoor sourceDoor = new MysticDoor(Parent.SkillId, source, fromMapPosition, fromMap, toMap, toPortal, time, true);
fromMap.SpawnStaticObject(sourceDoor);
source.AddDoor(sourceDoor);
}
}
}
#endregion
#region Summons
if (Parent.HasSummon)
{
source.RemoveSummon(Parent.SkillId); //Remove old one if exists
WzCharacterSkill.SummonAttackInfo info = Parent.SummonInfo;
MapleSummon summon = new MapleSummon(source.Map.GetNewObjectId(), Parent.SkillId, source.Position, info.Type, info.MovementType, source, Level, (uint)Info[CharacterSkillStat.time] * 1000);
source.AddSummon(summon);
}
#endregion
//Custom handling:
switch (Parent.SkillId)
{
case Hunter.QUIVER_CARTRIDGE:
QuiverCartridgeSystem qcs = source.Resource as QuiverCartridgeSystem;
if (qcs != null)
{
qcs.SwitchCurrentArrow(source.Client);
}
break;
case Priest.HOLY_MAGIC_SHELL:
case SuperGameMaster.HEAL_DISPEL:
target.AddHP(target.Stats.MaxHp);
break;
case Bishop.RESURRECTION:
case SuperGameMaster.RESURRECTION:
if (target.IsDead)
{
target.Revive(false, false, true);
}
break;
}
}
