/// <summary> /// Updates the specified item in a thread-safe manner. /// </summary> /// <param name="oldItem"></param> /// <param name="newItem"></param> public void AppendUpdateItem(Item itemToUpdate) { lock (lockThis) { //Add new attributes to the item w/ the ID Item.CreateItem(itemToUpdate.ItemID).Clone(itemToUpdate); if (itemToUpdate.CarryingInventory != null) { Player player = itemToUpdate.CarryingInventory; byte index = player.GetInventoryIndex(itemToUpdate); player.RemoveInventoryItem(index); player.AddInventoryItem(index, itemToUpdate); } else if (itemToUpdate.CurrentPosition != null) { ThingSet tSet = gameMap.GetThingsInVicinity(itemToUpdate.CurrentPosition); byte stackpos = gameMap.GetStackPosition(itemToUpdate, itemToUpdate.CurrentPosition); foreach (Thing thing in tSet.GetThings()) { thing.UpdateItem(itemToUpdate.CurrentPosition, itemToUpdate, stackpos); } } else if (itemToUpdate.CurrentPosition == null) //In container { Container container = itemToUpdate.Parent; container.UpdateItem(itemToUpdate); } } }
/// <summary> /// Remove the specified item in a thread-safe manner. /// </summary> /// <param name="itemToRemove"></param> public void AppendRemoveItem(Item itemToRemove) { lock (lockThis) { if (itemToRemove.CarryingInventory != null) { Player player = itemToRemove.CarryingInventory; byte index = player.GetInventoryIndex(itemToRemove); player.RemoveInventoryItem(index); } else if (itemToRemove.CurrentPosition != null) { Position pos = itemToRemove.CurrentPosition; Tile mapTile = gameMap.GetTile(pos); byte stackpos = mapTile.GetStackPosition(itemToRemove); mapTile.RemoveThing(itemToRemove); ThingSet tSet = gameMap.GetThingsInVicinity(pos); foreach (Thing thing in tSet.GetThings()) { thing.RemoveThing(pos, stackpos); } } else if (itemToRemove.CurrentPosition == null) //In container { Container container = itemToRemove.Parent; container.RemoveItem(itemToRemove); } } }
/// <summary> /// A quantified message is a message that starts with a special character. For example, /// in tibia 6.4, # is a quantifier, so #y is used to yell, #w is used to whisper etc. /// </summary> /// <param name="sender">Sender of the quantified message.</param> /// <param name="msg">The message itself.</param> private void HandleQuantifiedMessage(Creature sender, string msg, ThingSet tSet) { if (!msg.StartsWith(MSG_QUANTIFIER)) { throw new Exception("Invalid call to HandleQuantifiedMessage()"); } msg = msg.Substring(1); //Remove first quanitifer char quantifierType = char.ToLower(msg[0]); switch (quantifierType) { case BROADCAST_TYPE: HandleBroadcast(sender, msg); break; case WHISPER_TYPE: gameMap.GetThingsInWhisperVicinity(sender.CurrentPosition, tSet); //msg.Substring(2) is called in order to remove quantifier type and a space HandleLocalChat(ChatLocal.WHISPER, tSet, msg.Substring(2), sender); break; case YELL_TYPE: gameMap.GetThingsInYellVacinity(sender.CurrentPosition, tSet); //msg.Substring(2) is called in order to remove quantifier type and a space HandleLocalChat(ChatLocal.YELLS, tSet, msg.Substring(2).ToUpper(), sender); break; default: #if DEBUG Log.WriteDebug("Invalid quantifier type"); #endif break; } }
/// <summary> /// Move a specified thing from the ground. /// </summary> private void MoveItemFromGround() { bool stackable = itemToMove.IsOfType(Constants.TYPE_STACKABLE) && itemToMove.Count != count; Item oldItem = null; if (!stackable) { map.RemoveThing(itemToMove, posFrom); } else { oldItem = itemToMove; oldItem.Count -= count; itemToMove = Item.CreateItem(itemToMove.ItemID); itemToMove.Count = count; } ThingSet tSet = map.GetThingsInVicinity(posFrom); foreach (Thing thing in tSet.GetThings()) { if (!stackable) { thing.RemoveThing(posFrom, stackpos); } else { thing.UpdateItem(posFrom, oldItem, stackpos); } } }
/// <summary> /// Gets all the things in the vicinity (as specified in the parameters) /// and adds them to the ThingSet specified in the parameters. /// Note: general vicinity is specified as an 18x14 box w/ the Position /// in the center at x == 6 && y == 7. /// </summary> /// <param name="position">The position for which to get the things /// in Vicinity.</param> /// <param name="tSet">The ThingSet to add all the things gotten in /// the vacanity.</param> /// <param name="leftXOffset">The left offset from the general Vicinity.</param> /// <param name="rightXOffset">The right offset from the general Vicinity.</param> /// <param name="leftYOffset">The left offset from the general Vicinity.</param> /// <param name="rightYOffset">The right offset from the gernal Vicinity</param> /// <param name="noZChange">True if only get things on the same z level or false /// in order to get things on all z levels defined in the general Vicinity.</param> public void GetThingsInVicinity(Position position, ThingSet tSet, int leftXOffset, int rightXOffset, int leftYOffset, int rightYOffset, bool noZChange) { short startZ = 0; short endZ = 0; short zStep = 1; if (noZChange) { startZ = endZ = position.z; } else { GetZIter(ref startZ, ref endZ, ref zStep, position.z); } //Original x: -9, +8, y: -7, +6 for (int x = position.x - 9 - leftXOffset; x <= position.x + 9 + rightXOffset; x++) { for (int y = position.y - 7 - leftYOffset; y <= position.y + 6 + rightYOffset; y++) { for (short z = startZ; z != endZ + zStep; z += zStep) { short offset = (short)(position.z - z); Tile mapTile = GetTile((ushort)(x + offset), (ushort)(y + offset), (byte)(z)); if (mapTile == null) { continue; } mapTile.GetThings(tSet); } } } }
/// <summary> /// Gets things in the vicinity. /// </summary> /// <param name="position">The position of the vicinity.</param> /// <param name="noZChange">True if only to get things on the same z level or false /// in order to get things on all z levels defined in the general Vicinity.</param> /// <returns>All the things in the Vicinity.</returns> public ThingSet GetThingsInVicinity(Position position, bool noZChange) { ThingSet tSet = new ThingSet(); GetThingsInVicinity(position, tSet, 0, 0, 0, 0, noZChange); return(tSet); }
public void GetThings(ThingSet tSet) { foreach (Thing thing in tileThings) { tSet.AddThing(thing); } }
/// <summary> /// Handles sending a chat message in a player's local vicinity. /// </summary> /// <param name="type">The type of chat to send.</param> /// <param name="set">The set of things in the player's local vicinity.</param> /// <param name="msg">The message to send.</param> /// <param name="sender">The sender of the message.</param> private void HandleLocalChat(ChatLocal type, ThingSet set, string msg, Creature sender) { foreach (Thing thing in set.GetThings()) { thing.AddLocalChat(type, msg, sender.CurrentPosition, sender); } }
public virtual void SendRemovePlayer(Player player, bool reset) { lock (lockThis) { ThingSet tSet = gameMap.GetThingsInVicinity(player.CurrentPosition); AppendRemovePlayer(player, reset); SendProtocolMessages(); } }
/// <summary> /// Adds a magic effect at the given position. /// </summary> /// <param name="effect">The effect to add.</param> /// <param name="position">Add effect at this position.</param> public void AddMagicEffect(MagicEffect effect, Position position) { ThingSet tSet = gameMap.GetThingsInVicinity(position); foreach (Thing thing in tSet.GetThings()) { thing.AddEffect(effect, position); } }
/// <summary> /// Updates the health status of a creature to all creatures /// in vicinity. /// </summary> /// <param name="creature">Creature whose health status to update.</param> /// <param name="tSet">The things to update for.</param> private void UpdateHealthStatus(Creature creature, Position position) { ThingSet tSet = gameMap.GetThingsInVicinity(position); foreach (Thing thing in tSet.GetThings()) { thing.UpdateHealthStatus(creature); } }
private void AddShootEffect(DistanceType type, Position origin, Position destination, ThingSet tSet) { gameMap.GetThingsInVicinity(origin, tSet); gameMap.GetThingsInVicinity(destination, tSet); foreach (Thing thing in tSet.GetThings()) { thing.AddShootEffect((byte)type, origin, destination); } }
public void AppendUpdateOutfit(Creature creature) { lock (lockThis) { ThingSet tSet = gameMap.GetThingsInVicinity(creature.CurrentPosition); foreach (Thing thing in tSet.GetThings()) { thing.UpdateOutfit(creature); } } }
public void HandleSpellCheck(Creature caster) { lock (lockThis) { Spell spell = caster.GetSpell(); if (spell != null) { ThingSet tSet = new ThingSet(); spellSystem.CastSpell(spell.Name, caster, spell, this); SendProtocolMessages(); } } }
public void AppendAddItem(Item item, Position position) { lock (lockThis) { gameMap.AddThing(item, position); byte stackpos = gameMap.GetStackPosition(item, position); ThingSet tSet = gameMap.GetThingsInVicinity(position); foreach (Thing thing in tSet.GetThings()) { thing.AddItem(item, position, stackpos); } } }
/// <summary> /// Handle a message from a creature. /// </summary> /// <param name="creature">The creature sending the message.</param> /// <param name="msg">The message sent.</param> public void HandleChat(Creature creature, string msg) { ThingSet tSet = new ThingSet(); if (msg.StartsWith(PRIVATE_MSG_INDICATOR)) { HandlePrivateMessage(creature, msg); } else if (msg.StartsWith(MSG_QUANTIFIER)) { HandleQuantifiedMessage(creature, msg, tSet); } else { tSet = gameMap.GetThingsInVicinity(creature.CurrentPosition, true); HandleLocalChat(creature.GetChatType(), tSet, msg, creature); } }
/// <summary> /// Move the specified thing to the ground. /// </summary> /// <param name="thingToMove">Thing to move.</param> /// <param name="posTo">Position to move to.</param> /// <param name="thingsPrepared">A reference to the things /// already prepared.</param> private void MoveToGround() { Thing topThing = map.GetTopThing(posTo); Item topItem = null; if (topThing.IsOfType(Constants.TYPE_STACKABLE)) { topItem = (Item)topThing; } bool stackable = false; bool addItem = true; if (topItem != null && itemToMove != null && topItem.ItemID == itemToMove.ItemID) //Both stackable items of same type { stackable = true; if (topItem.Count + itemToMove.Count > MAX_STACK_COUNT) { byte countRemainder = (byte)(MAX_STACK_COUNT - topItem.Count); topItem.Count += countRemainder; itemToMove.Count -= countRemainder; } else { topItem.Count += itemToMove.Count; addItem = false; } } ThingSet tSet = map.GetThingsInVicinity(posTo); byte stackpos = map.GetStackPosition(itemToMove, posTo); if (stackable) { foreach (Thing thing in tSet.GetThings()) { thing.UpdateItem(posTo, topItem, map.GetStackPosition(topItem, posTo)); } } if (addItem) { map.AddThing(itemToMove, posTo); foreach (Thing thing in tSet.GetThings()) { thing.AddThingToGround(itemToMove, posTo, map.GetStackPosition(itemToMove, posTo)); } } }
private void AppendAddCreature(Creature creature, Position position) { position = gameMap.GetFreePosition(position, creature); ThingSet tSet = gameMap.GetThingsInVicinity(position); AddCachedCreature(creature, position); creature.InitCreatureCheck(this); byte stackpos = gameMap.GetStackPosition(creature, position); foreach (Thing thing in tSet.GetThings()) { thing.AddScreenCreature(creature, position, stackpos); } }
//TODO: Completely rework this method... it currently sucks //A LOT... i mean it! public void CheckForRespawn() { Position pos = new Position(CenterX, CenterY, CenterZ); Monster monster = Monster.CreateMonster(MonsterName); if (monster != null && world.GetGameMap().GetTile(pos) != null) { world.AppendAddMonster(monster, pos); } return; Map map = world.GetGameMap(); ThingSet tSet = map.GetThingsInVicinity(pos); //Monster monster = Monster.CreateMonster(MonsterName); if (monster == null) { return; } if (map.GetTile(pos) != null && !map.TileContainsType(pos, Constants.TYPE_BLOCKS_AUTO_WALK)) { bool canRespawn = true; foreach (Thing thing in tSet.GetThings()) { if (thing is Player) //TODO: FIX this crap { canRespawn = false; } } if (canRespawn) { world.SendAddMonster(monster, pos); } } else { return; } // if (map.GetTile(pos) != null && // !map.TileContainsType(pos, Constants.TYPE_BLOCKS_AUTO_WALK)) { // Console.WriteLine("x: " + x++); //world.SendAddMonster(monster, pos); // } world.AddEventInCS(SpawnTime, CheckForRespawn); }
public virtual void HandleChangeDirection(Creature creature, Direction direction) { lock (lockThis) { creature.CurrentDirection = direction; ThingSet tSet = gameMap.GetThingsInVicinity(creature.CurrentPosition); byte stackpos = gameMap.GetStackPosition(creature, creature.CurrentPosition); foreach (Thing thing in tSet.GetThings()) { thing.UpdateDirection(direction, creature, stackpos); } SendProtocolMessages(); } }
/// <summary> /// Removes the creature from the game world and only /// appends the data to the ThingSet without reseting or sending it. /// </summary> /// <param name="creature">The creature to remove.</param> /// <param name="tSet">A reference for which things to notify of the /// creature's removal.</param> private void AppendRemoveCreature(Creature creature) { creaturesOnline.Remove(creature.GetID()); creature.LogedIn = false; byte stackpos = gameMap.GetStackPosition(creature, creature.CurrentPosition); ThingSet tSet = gameMap.GetThingsInVicinity(creature.CurrentPosition); foreach (Monster summon in creature.GetSummons()) { summon.SetMaster(null); } foreach (Thing thing in tSet.GetThings()) { thing.RemoveThing(creature.CurrentPosition, stackpos); } gameMap.RemoveThing(creature, creature.CurrentPosition); }
/// <summary> /// Handle a message from a creature. /// </summary> /// <param name="creature">The creature sending the message.</param> /// <param name="msg">The message sent.</param> public void HandleChat(Creature creature, string msg) { ThingSet tSet = new ThingSet(); if (msg.StartsWith(PRIVATE_MSG_INDICATOR)) { HandlePrivateMessage(creature, msg); } else if (msg.StartsWith(MSG_QUANTIFIER)) { HandleQuantifiedMessage(creature, msg, tSet); } else { tSet = gameMap.GetThingsInVicinity(creature.CurrentPosition, true); HandleLocalChat(creature.GetChatType(), tSet, msg, creature); } }
/// <summary> /// Gets things in the vicinity. /// </summary> /// <param name="position">The position of the vicinity.</param> /// <param name="tSet">The ThingSet to add to.</param> public void GetThingsInVicinity(Position position, ThingSet tSet) { GetThingsInVicinity(position, tSet, 0, 0, 0, 0, false); }
/// <summary> /// Gets a set of things are are in the vacinity of a yell. /// </summary> /// <param name="center">The center of the vacinity.</param> /// <returns>A set of things in the yell vacinity.</returns> public void GetThingsInYellVacinity(Position center, ThingSet tSet) { GetThingsInVicinity(center, tSet, 8, 7, 6, 5, false); }
/// <summary> /// Gets a set of things are are in the vacinity of a yell. /// </summary> /// <param name="center">The center of the vacinity.</param> /// <returns>A set of things in the yell vacinity.</returns> public void GetThingsInYellVacinity(Position center, ThingSet tSet) { GetThingsInVicinity(center, tSet, 8, 7, 6, 5, false); }
/// <summary> /// Gets things in the vicinity. /// </summary> /// <param name="position">The position of the vicinity.</param> /// <param name="tSet">The ThingSet to add to.</param> public void GetThingsInVicinity(Position position, ThingSet tSet) { GetThingsInVicinity(position, tSet, 0, 0, 0, 0, false); }
/// <summary> /// Gets a set of things that are in the vacinity of a whipser. /// </summary> /// <param name="center">The center of the vacinity.</param> public void GetThingsInWhisperVicinity(Position center, ThingSet tSet) { GetThingsInVicinity(center, tSet, -8, -7, -6, -5, true); }
/// <summary> /// Gets a set of things that are in the vacinity of a whipser. /// </summary> /// <param name="center">The center of the vacinity.</param> public void GetThingsInWhisperVicinity(Position center, ThingSet tSet) { GetThingsInVicinity(center, tSet, -8, -7, -6, -5, true); }
/// <summary> /// A quantified message is a message that starts with a special character. For example, /// in tibia 6.4, # is a quantifier, so #y is used to yell, #w is used to whisper etc. /// </summary> /// <param name="sender">Sender of the quantified message.</param> /// <param name="msg">The message itself.</param> private void HandleQuantifiedMessage(Creature sender, string msg, ThingSet tSet) { if (!msg.StartsWith(MSG_QUANTIFIER)) { throw new Exception("Invalid call to HandleQuantifiedMessage()"); } msg = msg.Substring(1); //Remove first quanitifer char quantifierType = char.ToLower(msg[0]); switch (quantifierType) { case BROADCAST_TYPE: HandleBroadcast(sender, msg); break; case WHISPER_TYPE: gameMap.GetThingsInWhisperVicinity(sender.CurrentPosition, tSet); //msg.Substring(2) is called in order to remove quantifier type and a space HandleLocalChat(ChatLocal.WHISPER, tSet, msg.Substring(2), sender); break; case YELL_TYPE: gameMap.GetThingsInYellVacinity(sender.CurrentPosition, tSet); //msg.Substring(2) is called in order to remove quantifier type and a space HandleLocalChat(ChatLocal.YELLS, tSet, msg.Substring(2).ToUpper(), sender); break; default: #if DEBUG Log.WriteDebug("Invalid quantifier type"); #endif break; } }
public void GetThings(ThingSet tSet) { foreach (Thing thing in tileThings) { tSet.AddThing(thing); } }
/// <summary> /// Gets things in the vicinity. /// </summary> /// <param name="position">The position of the vicinity.</param> /// <param name="noZChange">True if only to get things on the same z level or false /// in order to get things on all z levels defined in the general Vicinity.</param> /// <returns>All the things in the Vicinity.</returns> public ThingSet GetThingsInVicinity(Position position, bool noZChange) { ThingSet tSet = new ThingSet(); GetThingsInVicinity(position, tSet, 0, 0, 0, 0, noZChange); return tSet; }
/// <summary> /// Handles sending a chat message in a player's local vicinity. /// </summary> /// <param name="type">The type of chat to send.</param> /// <param name="set">The set of things in the player's local vicinity.</param> /// <param name="msg">The message to send.</param> /// <param name="sender">The sender of the message.</param> private void HandleLocalChat(ChatLocal type, ThingSet set, string msg, Creature sender) { foreach (Thing thing in set.GetThings()) { thing.AddLocalChat(type, msg, sender.CurrentPosition, sender); } }
public void AppendHandleMove(Creature creature, Position newPos, Direction direction, bool validateMove) { lock (lockThis) { Position oldPos = creature.CurrentPosition; Tile oldTile = gameMap.GetTile(oldPos); Tile newTile = gameMap.GetTile(newPos); if (validateMove) { if (newTile == null || newTile.ContainsType(Constants.TYPE_BLOCKING)) { return; } } foreach (Thing thing in oldTile.GetThings()) { bool proceed = thing.HandleWalkAction(creature, this, WalkType.WALK_OFF); if (!proceed) { return; } } foreach (Thing thing in newTile.GetThings()) { bool proceed = thing.HandleWalkAction(creature, this, WalkType.WALK_ON); if (!proceed) { return; } } if (creature.IsNextTo(newPos)) { //TODO: Finish coding speed int speed = GetGroundSpeed(creature.CurrentPosition); int duration = (100 * 90 /*speed*/) / (creature.GetSpeed()); creature.LastWalk.SetTimeInCS((uint)duration); if (!creature.LastWalk.Elapsed()) { return; } Position oldPosClone = oldPos.Clone(); if (oldPos.y > newPos.y) { direction = Direction.NORTH; oldPosClone.y--; creature.AddScreenMoveByOne(direction, oldPos, oldPosClone, gameMap); } else if (oldPos.y < newPos.y) { direction = Direction.SOUTH; oldPosClone.y++; creature.AddScreenMoveByOne(direction, oldPos, oldPosClone, gameMap); } if (oldPos.x < newPos.x) { direction = Direction.EAST; oldPosClone.x++; creature.AddScreenMoveByOne(direction, oldPos, oldPosClone, gameMap); } else if (oldPos.x > newPos.x) { direction = Direction.WEST; oldPosClone.x--; creature.AddScreenMoveByOne(direction, oldPos, oldPosClone, gameMap); } } ThingSet tSet = gameMap.GetThingsInVicinity(creature.CurrentPosition); byte oldStackPos = gameMap.GetStackPosition(creature, oldPos); gameMap.MoveThing(creature, oldPos, newPos); creature.CurrentDirection = direction; byte newStackPos = gameMap.GetStackPosition(creature, newPos); gameMap.GetThingsInVicinity(newPos, tSet); creature.HandleMove(); foreach (Thing thing in tSet.GetThings()) { thing.AddCreatureMove(direction, creature, oldPos, newPos, oldStackPos, newStackPos); } if (!creature.IsNextTo(oldPos)) { creature.AddTeleport(gameMap); } } }
public virtual void HandleChat(Creature creature, string msg) { lock (lockThis) { if (Command.IsCommand(msg, creature)) { Command.ExecuteCommand(this, gameMap, msg, creature); return; } chatSystem.HandleChat(creature, msg); if (msg == "test") //TODO: REMOVE PLX { HandleCreatureTarget(creature, creature); } else if (msg == "magic") { ((Player)creature).AppendAddManaSpent(10000); } else if (msg == "combat") { for (int i = 0; i < 1000; i++) { ((Player)creature).NotifyOfAttack(); creature.AddDamage(0, creature, false); } } else if (msg == "distance") { ((Player)creature).buggabugga(); } else if (msg == "shooteffect") { Position orig = creature.CurrentPosition; Position dest = orig.Clone(); dest.x += 4; dest.y += 2; creature.AddShootEffect((byte)DistanceType.EFFECT_ENERGY, orig, dest); SendProtocolMessages(); } else if (msg == "a") { ((Player)creature).add(); } else if (msg == "b") { ((Player)creature).remove(); } else if (msg == "!dragon") { } else if (msg == "monster") { List <Monster> monsterList = new List <Monster>(); // m.SetMaster(creature); //SendAddCreature(m, gameMap.GetFreePosition(creature.CurrentPosition, m)); //SendProtocolMessages(); return; //return; } else if (msg == "dead") { ThingSet ttSet = gameMap.GetThingsInVicinity(creature.CurrentPosition); AppendAddDamage(creature, creature, creature.CurrentHP, ImmunityType.IMMUNE_PHYSICAL, true); } else if (msg == "!up") { Position newPos = creature.CurrentPosition.Clone(); newPos.z--; //Z goes down as player goes up :D HandleMove(creature, newPos, creature.CurrentDirection); return; } else if (msg == "!down") { Position newPos = creature.CurrentPosition.Clone(); newPos.z++; HandleMove(creature, newPos, creature.CurrentDirection); return; } else if (msg == "!lighthack") { creature.SpellLightLevel = 10; creature.UpdateCreatureLight(creature); } else if (msg == "burn") { creature.Burning = new int[] { 10, 10, 10 }; creature.BurningCheck = new BurningCheck(); creature.BurningCheck.TimeInCS = 200; creature.BurningCheck.World = this; creature.BurningCheck.CurrentCreature = creature; AddEventInCS(creature.BurningCheck.TimeInCS, creature.BurningCheck.PerformCheck); } else if (msg == "position") { creature.AddAnonymousChat(ChatAnonymous.WHITE, "Your position: " + creature.CurrentPosition); } else if (msg == "knight") { ((Player)creature).CurrentVocation = Vocation.KNIGHT; } else if (msg == "sorcerer") { ((Player)creature).CurrentVocation = Vocation.SORCERER; } else if (msg == "druid") { ((Player)creature).CurrentVocation = Vocation.DRUID; } else if (msg == "paladin") { ((Player)creature).CurrentVocation = Vocation.PALADIN; } else if (msg == "hudini") { creature.CharType++; SendUpdateOutfit(creature); return; } else if (msg == "resetoutfit") { creature.CharType = 1; SendUpdateOutfit(creature); } else if (msg == "resetoutfit") { creature.CharType = 0; SendUpdateOutfit(creature); } else if (msg == "level") { ((Player)creature).AddExperienceGain(1000000); } else if (msg.ToLower().StartsWith("item")) { msg = Regex.Split(msg, "\\s+")[1]; Item item = Item.CreateItem("sword"); item.ItemID = ushort.Parse(msg); AppendAddItem(item, creature.CurrentPosition.Clone()); } else if (msg == "sd") { Item item = Item.CreateItem(2127); item.Charges = 2; AppendAddItem(item, creature.CurrentPosition.Clone()); } else if (msg == "vial") { Item item = Item.CreateItem("vial"); item.FluidType = Fluids.FLUID_MILK; AppendAddItem(item, creature.CurrentPosition.Clone()); } else if (msg == "speed") { creature.AddAnonymousChat(ChatAnonymous.WHITE, "Your speed is: " + creature.GetSpeed() + "."); } if (Spell.IsSpell(msg, SpellType.PLAYER_SAY)) { Spell spell = Spell.CreateSpell(msg, (Player)creature); spellSystem.CastSpell(msg, creature, spell, this); } SendProtocolMessages(); } }
//One huge ugly method. TODO: Split it up. public virtual void HandleAttackCheck(Creature attacker, Creature attacked) { lock (lockThis) { if (attacker == attacked) { //throw new Exception("Attacker == attacked in HandleAttackCheck()"); return; } if (attacked == null || !attacked.LogedIn) { attacker.SetCreatureAttacking(null); return; } if (attacked.CurrentPosition == null) { throw new Exception("Invalid condition in HandleAttackCheck()"); } if (attacked.CurrentHP == 0) { throw new Exception("Attacked is already dead in HandleAttack()"); } bool usingDistance = attacker.UsingDistance(); DistanceType shootEffect = DistanceType.EFFECT_NONE; if (usingDistance) { if (attacker.GetAmmo() == 0) { return; } else { shootEffect = attacker.GetDistanceType(); } } else if (!usingDistance && !attacker.IsNextTo(attacked.CurrentPosition)) { return; } ThingSet tSet = gameMap.GetThingsInVicinity(attacker.CurrentPosition); gameMap.GetThingsInVicinity(attacked.CurrentPosition, tSet); if (shootEffect != DistanceType.EFFECT_NONE) { AddShootEffect(shootEffect, attacker.CurrentPosition, attacked.CurrentPosition, tSet); } int dmg = attacked.GetDamageAmt(attacker); if (dmg == Constants.PUFF) { AddMagicEffect(MagicEffect.PUFF, attacked.CurrentPosition); dmg = 0; } else if (dmg == Constants.SPARK) { AddMagicEffect(MagicEffect.BLOCKHIT, attacked.CurrentPosition); dmg = 0; } else { AddMagicEffect(MagicEffect.DRAW_BLOOD, attacked.CurrentPosition); } AppendAddDamage(attacker, attacked, dmg, ImmunityType.IMMUNE_PHYSICAL, false); SendProtocolMessages(); } }
private void AddShootEffect(DistanceType type, Position origin, Position destination, ThingSet tSet) { gameMap.GetThingsInVicinity(origin, tSet); gameMap.GetThingsInVicinity(destination, tSet); foreach (Thing thing in tSet.GetThings()) { thing.AddShootEffect((byte)type, origin, destination); } }
public void HandleSpellCheck(Creature caster) { lock (lockThis) { Spell spell = caster.GetSpell(); if (spell != null) { ThingSet tSet = new ThingSet(); spellSystem.CastSpell(spell.Name, caster, spell, this); SendProtocolMessages(); } } }
/// <summary> /// Use this method cast the specified spell. Note: This method only /// appends and does not send protocol data. /// </summary> /// <param name="caster">The creature casting the spell</param> /// <param name="spell">The spell to cast</param> /// <param name="tSet">The set of affected things</param> public void CastSpell(string msg, Creature caster, Spell spell, GameWorld world) { /*string error = caster.CanCastSpell(spell); * if (error != null) { * caster.AddAnonymousChat(ChatAnonymous.WHITE, error); * return; * }*///TODO: Uncomment if (spell.IsSpellValid != null && !spell.IsSpellValid(world, msg)) { world.AddMagicEffect(MagicEffect.PUFF, caster.CurrentPosition); return; } if (spell.RequiresTarget) { Tile tile = map.GetTile(spell.SpellCenter); if (tile == null || !tile.ContainsType(Constants.TYPE_CREATURE)) { world.AddMagicEffect(MagicEffect.PUFF, caster.CurrentPosition); caster.AddAnonymousChat(ChatAnonymous.WHITE, "No target selected."); return; } } //Constants. //Not the most efficient method but it is simple and works. int length = spell.SpellArea.GetLength(0); int width = spell.SpellArea.GetLength(1); Position startPos = new Position(); startPos.x = (ushort)(spell.SpellCenter.x - (width / 2)); startPos.y = (ushort)(spell.SpellCenter.y - (length / 2)); startPos.z = spell.SpellCenter.z; Position local = new Position(); List <Thing> things = new List <Thing>(); for (int i = 0; i < length; i++) { for (int j = 0; j < width; j++) { local.x = (ushort)(startPos.x + j); local.y = (ushort)(startPos.y + i); local.z = startPos.z; if (map.GetTile(local) == null /*|| !map.GetTile(local).CanMoveTo(caster) * TODO: Finish*/) { continue; } if (spell.SpellArea[i, j] && !map.GetTile(local).ContainsType(Constants.TYPE_BLOCKS_MAGIC)) { ThingSet tSet = map.GetThingsInVicinity(local); foreach (Thing thing in tSet.GetThings()) { thing.AddEffect(spell.SpellEffect, local); if (spell.HasDistanceType()) { thing.AddShootEffect((byte)spell.DistanceEffect, caster.CurrentPosition, spell.SpellCenter); } } List <Thing> localThings = map.GetTile(local).GetThings(); if (spell.Action != null) { spell.Action.Invoke(world, local, localThings); } foreach (Thing thing in map.GetTile(local).GetThings()) { things.Add(thing); } } } } foreach (Thing thing in things) { thing.AppendHandleDamage(spell.GetDamage(), caster, spell.Immunity, world, true); } //caster.NotifyOfSuccessfulCast(spell); TODO: Uncomment }
/// <summary> /// Gets all the things in the vicinity (as specified in the parameters) /// and adds them to the ThingSet specified in the parameters. /// Note: general vicinity is specified as an 18x14 box w/ the Position /// in the center at x == 6 && y == 7. /// </summary> /// <param name="position">The position for which to get the things /// in Vicinity.</param> /// <param name="tSet">The ThingSet to add all the things gotten in /// the vacanity.</param> /// <param name="leftXOffset">The left offset from the general Vicinity.</param> /// <param name="rightXOffset">The right offset from the general Vicinity.</param> /// <param name="leftYOffset">The left offset from the general Vicinity.</param> /// <param name="rightYOffset">The right offset from the gernal Vicinity</param> /// <param name="noZChange">True if only get things on the same z level or false /// in order to get things on all z levels defined in the general Vicinity.</param> public void GetThingsInVicinity(Position position, ThingSet tSet, int leftXOffset, int rightXOffset, int leftYOffset, int rightYOffset, bool noZChange) { short startZ = 0; short endZ = 0; short zStep = 1; if (noZChange) { startZ = endZ = position.z; } else { GetZIter(ref startZ, ref endZ, ref zStep, position.z); } //Original x: -9, +8, y: -7, +6 for (int x = position.x - 9 - leftXOffset; x <= position.x + 9 + rightXOffset; x++) { for (int y = position.y - 7 - leftYOffset; y <= position.y + 6 + rightYOffset; y++) { for (short z = startZ; z != endZ + zStep; z += zStep) { short offset = (short)(position.z - z); Tile mapTile = GetTile((ushort)(x + offset), (ushort)(y + offset), (byte)(z)); if (mapTile == null) continue; mapTile.GetThings(tSet); } } } }