private static async Task DoContinualLight(Player attacker, Room room)
{
_taskRunnning = true;
attacker.Status = Player.PlayerStatus.Busy;
await Task.Delay(500);
if (_target == null)
{
var castingTextAttacker = $"A bright {_color} ball of light is released by your hands and hovers in the air.";
HubContext.SendToClient(castingTextAttacker, attacker.HubGuid);
foreach (var character in room.players)
{
if (character != attacker)
{
var roomMessage = $"{ Helpers.ReturnName(attacker, character, string.Empty)} releases a {_color} bright ball of light which hovers in the air.";
HubContext.SendToClient(roomMessage, character.HubGuid);
}
}
var ballOfLight = Light.BallOfLight();
ballOfLight.description = new Description()
{
exam = $"A bright {_color} ball of light hovers here.",
look = $"A bright {_color} ball of light hovers here.",
room = $"A bright {_color} ball of light hovers here."
};
ballOfLight.name = $"A bright {_color} ball of light";
ballOfLight.location = Item.Item.ItemLocation.Room;
room.items.Add(ballOfLight);
}
else
{
var castingTextAttacker = $"The {_target.name} glows a bright {_color} colour.";
var castingTextRoom = $"The {_target.name} glows a bright {_color} colour.";
HubContext.SendToClient(castingTextAttacker, attacker.HubGuid);
HubContext.broadcastToRoom(castingTextRoom, room.players, attacker.HubGuid, true);
_target.itemFlags.Add(Item.Item.ItemFlags.glow);
}
_target = null;
_taskRunnning = false;
}
public static void ShowPlayerAllSkills(Player player)
{
var getClassSkills = GetSkills(player);
HubContext.SendToClient("You will eventually learn these skills:", player.HubGuid);
var skills = getClassSkills.OrderBy(o => o.LevelObtained).ToList();
foreach (var skill in skills)
{
HubContext.SendToClient("Level " + skill.LevelObtained + ": " + skill.Name + " " + skill.Proficiency + "%", player.HubGuid);
}
}
public static async Task KickIdlePlayers()
{
try
{
foreach (var player in MIMHub._PlayerCache.ToList())
{
if (player.Value != null && player.Value.LastCommandTime.AddMinutes(10) < DateTime.UtcNow)
{
HubContext.SendToClient("You disappear in the void", player.Value.HubGuid);
var room =
MIMHub._AreaCache.FirstOrDefault(
x =>
x.Value.area.Equals(player.Value.Area) && x.Value.areaId.Equals(player.Value.AreaId) &&
x.Value.region.Equals(player.Value.Region));
if (room.Value != null)
{
foreach (var players in room.Value.players.ToList())
{
HubContext.broadcastToRoom(player.Value.Name + " disappears in the void",
room.Value.players,
player.Value.HubGuid, true);
}
}
}
if (player.Value != null && player.Value.LastCommandTime.AddMinutes(20) < DateTime.UtcNow)
{
var room =
MIMHub._AreaCache.FirstOrDefault(
x =>
x.Value.area.Equals(player.Value.Area) && x.Value.areaId.Equals(player.Value.AreaId) &&
x.Value.region.Equals(player.Value.Region));
Command.ParseCommand("quit", player.Value, room.Value);
}
}
}
catch (Exception ex)
{
var log = new Error.Error
{
Date = DateTime.Now,
ErrorMessage = ex.InnerException.ToString(),
MethodName = "KickIdlePlayers"
};
Save.LogError(log);
}
}
public static void buyItems(PlayerSetup.Player player, Room.Room room, string itemName)
{
var mob = room.mobs.FirstOrDefault(x => x.Shop.Equals(true));
if (mob != null)
{
if (mob.Shop)
{
if (string.IsNullOrEmpty(itemName))
{
HubContext.SendToClient("Buy? Buy what?", player.HubGuid);
return;
}
var itemToBuy = mob.itemsToSell.FirstOrDefault(x => x.name.ToLower().Contains(itemName.ToLower()));
if (itemToBuy != null)
{
var result = AvsAnLib.AvsAn.Query(itemToBuy.name);
string article = result.Article;
//Can afford
if (player.Gold >= itemToBuy.Gold)
{
itemToBuy.location = Item.Item.ItemLocation.Inventory;
player.Inventory.Add(itemToBuy);
HubContext.SendToClient(
"You buy " + article + itemToBuy.name + " from " + mob.Name,
player.HubGuid);
HubContext.broadcastToRoom(
player.Name + " buys " + article + " " + itemToBuy.name +
" from " +
mob.Name, room.players, player.HubGuid, true);
Score.UpdateUiInventory(player);
//deduct gold
player.Gold -= itemToBuy.Gold;
}
else
{
HubContext.SendToClient("You can't afford " + article + " " + itemToBuy.name, player.HubGuid);
}
}
}
else
{
HubContext.SendToClient("Sorry I don't sell that", player.HubGuid);
}
}
}
public static void StartTeleport(Player player, Room room)
{
//Check if player has spell
var hasSpell = Skill.CheckPlayerHasSkill(player, TeleporAb().Name);
if (hasSpell == false)
{
HubContext.SendToClient("You don't know that spell.", player.HubGuid);
return;
}
var canDoSkill = Skill.CanDoSkill(player);
if (!canDoSkill)
{
return;
}
if (!_taskRunnning)
{
if (player.ManaPoints < TeleporAb().ManaCost)
{
HubContext.SendToClient("You attempt to draw energy but fail", player.HubGuid);
return;
}
player.ManaPoints -= TeleporAb().ManaCost;
Score.UpdateUiPrompt(player);
HubContext.SendToClient("You utter iter multo ieiunium.", player.HubGuid);
foreach (var character in room.players)
{
if (character != player)
{
var roomMessage = $"{ Helpers.ReturnName(player, character, string.Empty)} utters iter multo ieiunium.";
HubContext.SendToClient(roomMessage, character.HubGuid);
}
}
Task.Run(() => DoTeleport(player, room));
}
}
/// <summary>
/// Starts a fight between two players or mobs
/// The defender can only fight it's original target
/// so cant fight back at multiple targets
/// </summary>
/// <param name="attacker">The attacker</param>
/// <param name="room">The room</param>
/// <param name="defenderName">The defenders Name for now</param>
/// <returns></returns>
public static void PerpareToFight(Player attacker, Room room, string defenderName, bool busy = false)
{
if (attacker == null)
{
return;
}
if (attacker.Target != null)
{
HubContext.SendToClient("You can only concerntrate on one target", attacker.HubGuid);
return;
}
/* player can only attack one target
* if player gets attacked by something else they cannot fight back until
* they have ended the fight they are already in.
* player defence should be divided by the number of people they are being attacked by.
*
*/
//automated Combat rounds for melee attacks
//find defender
Player defender = FindValidTarget(room, defenderName, attacker);
if (defender == null)
{
HubContext.SendToClient("No one here by that name", attacker.HubGuid);
return;
}
defender.Status = Player.PlayerStatus.Fighting;
if (!busy)
{
attacker.Status = Player.PlayerStatus.Fighting;
}
else
{
attacker.Status = Player.PlayerStatus.Busy;
}
AddFightersIdtoRoom(attacker, defender, room);
StartFight(attacker, defender, room);
}
public static void greet(PlayerSetup.Player player, PlayerSetup.Player mob, Room.Room room, string message = "")
{
if (player.Type == PlayerSetup.Player.PlayerTypes.Player && message == string.Empty)
{
if (mob.GreetMessage != null)
{
string greetMessageToRoom = mob.GreetMessage + " " + player.Name;
HubContext.broadcastToRoom(mob.Name + " says " + greetMessageToRoom, room.players, player.HubGuid);
}
}
else
{
}
}
public static void StartCreateSpring(Player player, Room room)
{
//Check if player has spell
var hasSpell = Skill.CheckPlayerHasSkill(player, CreateSpringAb().Name);
if (hasSpell == false)
{
HubContext.SendToClient("You don't know that spell.", player.HubGuid);
return;
}
var canDoSkill = Skill.CanDoSkill(player);
if (!canDoSkill)
{
return;
}
if (!_taskRunnning)
{
if (player.ManaPoints < CreateSpringAb().ManaCost)
{
HubContext.SendToClient("You fail to concentrate due to lack of mana.", player.HubGuid);
return;
}
player.ManaPoints -= CreateSpringAb().ManaCost;
Score.UpdateUiPrompt(player);
HubContext.SendToClient($"You utter aqua fons.", player.HubGuid);
foreach (var character in room.players)
{
if (character != player)
{
var roomMessage = $"{ Helpers.ReturnName(player, character, string.Empty)} utters aqua fons.";
HubContext.SendToClient(roomMessage, character.HubGuid);
}
}
Task.Run(() => DoCreateSpring(player, room));
}
}
/// <summary>
/// Remove worn item.
/// </summary>
/// <param name="player">The Player</param>
/// <param name="itemToRemove">Item to Remove</param>
public static void RemoveItem(Player player, string itemToRemove, bool replaceWithOtherEQ = false, bool unwield = false)
{
var oldPlayer = player;
var foundItem = player.Inventory.Find(i => i.name.ToLower().Contains(itemToRemove.ToLower()) && i.location.Equals("worn"));
if (foundItem == null)
{
if (unwield)
{
HubContext.SendToClient("You do not have that item to unwield.", player.HubGuid);
return;
}
HubContext.SendToClient("You are not wearing that item.", player.HubGuid);
return;
}
foundItem.location = Item.ItemLocation.Inventory;
var value = string.Empty;
var slot = Enum.GetName(typeof(Item.EqSlot), foundItem.slot);
var eqLocation = player.Equipment.GetType().GetProperty(slot);
if (eqLocation == null)
{
return;
} // Log error?
eqLocation.SetValue(player.Equipment, "Nothing");
if (!unwield)
{
HubContext.SendToClient("You Remove." + foundItem.name, player.HubGuid);
}
else
{
HubContext.SendToClient("You Unwield." + foundItem.name, player.HubGuid);
}
if (replaceWithOtherEQ)
{
return; // we don't need to update the cache
}
Cache.updatePlayer(player, oldPlayer);
}
/// <summary>
/// Displays what the player is wearing and what slots are availaible
/// </summary>
/// <param name="player">The player</param>
public static void ShowEquipment(Player player)
{
var eq = player.Equipment;
var displayEquipment = new StringBuilder();
HubContext.SendToClient("You are wearing:", player.HubGuid);
displayEquipment.Append("<ul>")
.Append("<li>Floating: ".PadRight(4)).Append(eq.Floating).Append("</li>")
.Append("<li>Head: ".PadRight(8)).Append(eq.Head).Append("</li>")
.Append("<li>Face: ".PadRight(8)).Append(eq.Face).Append("</li>")
.Append("<li>Eyes: ".PadRight(8)).Append(eq.Eyes).Append("</li>")
.Append("<li>Left Ear: ".PadRight(4)).Append(eq.LeftEar).Append("</li>")
.Append("<li>Right Ear: ".PadRight(4)).Append(eq.RightEar).Append("</li>")
.Append("<li>Neck: ".PadRight(8)).Append(eq.Neck).Append("</li>")
.Append("<li>Neck: ".PadRight(8)).Append(eq.Neck2).Append("</li>")
.Append("<li>Cloak: ".PadRight(8)).Append(eq.Cloak).Append("</li>")
.Append("<li>About Body: ".PadRight(4)).Append(eq.AboutBody).Append("</li>")
.Append("<li>Body: ".PadRight(8)).Append(eq.Body).Append("</li>")
.Append("<li>Waist: ".PadRight(7)).Append(eq.Waist).Append("</li>");
if (eq.LeftSheath != "Nothing")
{
displayEquipment.Append("<li>Left Sheath: ").Append(eq.LeftSheath).Append("</li>");
}
if (eq.RightSheath != "Nothing")
{
displayEquipment.Append("<li>Right Sheath: ").Append(eq.RightSheath).Append("</li>");
}
if (eq.BackSheath != "Nothing")
{
displayEquipment.Append("<li>Back Sheath: ").Append(eq.BackSheath).Append("</li>");
}
displayEquipment.Append("<li>Back: ".PadRight(8)).Append(eq.Back).Append("</li>")
.Append("<li>Left Wrist: ".PadRight(4)).Append(eq.LeftWrist).Append("</li>")
.Append("<li>Right Wrist: ".PadRight(4)).Append(eq.RightWrist).Append("</li>")
.Append("<li>Left Hand: ".PadRight(4)).Append(eq.LeftHand).Append("</li>")
.Append("<li>Right Hand: ".PadRight(4)).Append(eq.RightHand).Append("</li>")
.Append("<li>Left Ring: ".PadRight(4)).Append(eq.LeftRing).Append("</li>")
.Append("<li>Right Ring: ".PadRight(4)).Append(eq.RightRing).Append("</li>")
.Append("<li>Legs: ".PadRight(8)).Append(eq.Legs).Append("</li>")
.Append("<li>Feet: ".PadRight(8)).Append(eq.Feet).Append("</li>")
.Append("</ul>");
HubContext.SendToClient(displayEquipment.ToString(), player.HubGuid);
}
public bool CheckPlayerStatus(PlayerSetup.Player player)
{
if (player.Status == PlayerSetup.Player.PlayerStatus.Sleeping)
{
HubContext.SendToClient("You can't do that while asleep.", player.HubGuid);
}
if (player.Status == PlayerSetup.Player.PlayerStatus.Dead)
{
HubContext.SendToClient("You can't do that as a Ghost.", player.HubGuid);
}
return(false);
}
public static void buyItems(PlayerSetup.Player player, PlayerSetup.Player mob, Item.Item item)
{
if (mob.Shop)
{
player.itemsToSell.Remove(item);
HubContext.SendToClient("You give " + mob.Name + " your " + item.name, player.HubGuid);
mob.itemsToSell.Add(item);
HubContext.SendToClient(mob.Name + " gives you 100 gold", player.HubGuid);
}
else
{
HubContext.SendToClient("Sorry no shops here", player.HubGuid);
}
}
/// <summary>
/// Displays Help text to User
/// </summary>
/// <param name="keyword"></param>
/// <param name="player"></param>
public static void ShowHelp(string keyword, PlayerSetup.Player player)
{
var help = HelpList().FirstOrDefault(x => x.Key.ToLower().Contains(keyword.ToLower()));
if (help.Value == null)
{
HubContext.SendToClient("No help found for '" + keyword + "'. The gods will be notified.", player.HubGuid);
//Logs missing help
return;
}
var helpText = help.Value.Syntax + " " + help.Value.HelpText;
HubContext.SendToClient(helpText, player.HubGuid);
}
/// <summary>
/// Displays Help text to User
/// </summary>
/// <param name="keyword"></param>
/// <param name="player"></param>
public static void ShowHelp(string keyword, PlayerSetup.Player player)
{
var help = HelpList().FirstOrDefault(x => x.Key.StartsWith(keyword, StringComparison.InvariantCultureIgnoreCase));
if (help.Value == null)
{
HubContext.SendToClient("No help found for '" + keyword + "'. The gods will be notified.", player.HubGuid);
//Logs missing help
return;
}
var helpText = help.Value.Syntax + " " + help.Value.HelpText;
HubContext.SendToClient(helpText, player.HubGuid);
}
public static void CheckIfGetItemQuestsComplete(PlayerSetup.Player player)
{
var quests = player.QuestLog.Where(x => x.Type == Quest.QuestType.FindItem && x.Completed == false);
var playerInvQuestItems = player.Inventory.Where(x => x.QuestItem);
var invQuestItems = playerInvQuestItems as IList <Item.Item> ?? playerInvQuestItems.ToList();
foreach (var findQuest in quests)
{
var compelete = false;
var currentItemsForQuest = new List <Item.Item>();
foreach (var questItem in findQuest.QuestItem)
{
compelete = invQuestItems.Any(x => x.name.Equals(questItem.name, StringComparison.CurrentCultureIgnoreCase));
if (compelete)
{
currentItemsForQuest.Add(questItem);
}
}
if (compelete && currentItemsForQuest.Count == findQuest.QuestItem.Count)
{
findQuest.Completed = true;
HubContext.SendToClient(findQuest.RewardDialog.Message, player.HubGuid);
HubContext.SendToClient("You gain " + findQuest.RewardXp + " Experience Points", player.HubGuid);
HubContext.SendToClient("You gain " + findQuest.RewardGold + " gold pieces", player.HubGuid);
var rewardItem = findQuest?.RewardItem;
if (rewardItem != null)
{
rewardItem.location = Item.Item.ItemLocation.Inventory;
player.Inventory.Add(rewardItem);
}
player.Experience += findQuest.RewardXp;
player.Gold = findQuest.RewardGold;
//check if player level
var xp = new Experience();
xp.GainLevel(player);
//update ui
Score.ReturnScoreUI(player);
}
}
}
/// <summary>
/// Wears an item
/// </summary>
/// <param name="player">The Player</param>
/// <param name="itemToWear">Item to wear</param>
public static void WearItem(Player player, string itemToWear, bool wield = false)
{
var oldPlayer = player;
var foundItem = player.Inventory.Find(i => i.name.ToLower().Contains(itemToWear.ToLower()));
if (foundItem == null)
{
if (wield)
{
HubContext.SendToClient("You do not have that item to wield.", player.HubGuid);
return;
}
HubContext.SendToClient("You do not have that item to wear.", player.HubGuid);
return;
}
foundItem.location = Item.ItemLocation.Worn;
var slot = Enum.GetName(typeof(Item.EqSlot), foundItem.slot);
//TODO: WTF is this?
var eqLocation = player.Equipment.GetType().GetProperty(slot);
if (slot == null)
{
return;
} // Log error? What the hell is eqLocation?
var hasValue = eqLocation.GetValue(player.Equipment);
if (hasValue.ToString() != "Nothing")
{
RemoveItem(player, hasValue.ToString(), true);
}
eqLocation.SetValue(player.Equipment, foundItem.name);
if (!wield)
{
HubContext.SendToClient("You wear." + foundItem.name, player.HubGuid);
}
else
{
HubContext.SendToClient("You wield." + foundItem.name, player.HubGuid);
}
Cache.updatePlayer(player, oldPlayer);
}
public static void Annoy(PlayerSetup.Player player, PlayerSetup.Player mob, Room.Room room)
{
var phrase = RandomResponses();
HubContext.SendToClient($"<span class='sayColor'>{mob.Name} says to you \"{phrase}\"</span>", player.HubGuid);
foreach (var character in room.players)
{
if (character != player)
{
HubContext.SendToClient($"<span class='sayColor'>{mob.Name} says to {Helpers.ReturnName(player, character, String.Empty)} \"{phrase}\"</span>", character.HubGuid);
}
}
Follow.MobStalk(mob, player, room);
}
public static void EmoteActionToRoom(string message, Player player)
{
var players = Cache.ReturnPlayers().Where(x => x.AreaId.Equals(player.AreaId) && x.Area.Equals(player.Area) && x.Region.Equals(player.Region));
foreach (var pc in players)
{
if (pc != player)
{
HubContext.SendToClient(Helpers.ReturnName(player, pc, string.Empty) + " " + message, pc.HubGuid);
}
else
{
HubContext.SendToClient("You " + message, pc.HubGuid);
}
}
}
public static void DebugPlayer(Player player)
{
HubContext.SendToClient("Debug:", player.HubGuid);
HubContext.SendToClient("Player Target: " + player.Target?.Name, player.HubGuid);
HubContext.SendToClient("Player is Fighting: " + player.ActiveFighting, player.HubGuid);
HubContext.SendToClient("Player Has active skill: " + player.ActiveSkill?.Name, player.HubGuid);
HubContext.SendToClient("Player status: " + player.Status, player.HubGuid);
HubContext.SendToClient("Player items: ", player.HubGuid);
if (player.Inventory != null)
{
foreach (var item in player.Inventory)
{
HubContext.SendToClient(item.name + " " + item.location + " " + item.type, player.HubGuid);
}
}
}
private string StoreUser(HubContext context, string clientId)
{
var cookie = context.Cookies["username"];
string user;
if (cookie != null)
{
_clients[clientId] = cookie.Value;
user = cookie.Value;
}
else
{
user = clientId;
}
return(user);
}
public static void fleeCombat(PlayerSetup.Player player, Room.Room room)
{
if (player.Status == PlayerSetup.Player.PlayerStatus.Fighting)
{
HubContext.SendToClient("You Flee", player.HubGuid);
//var exit = room.exits.Find(x => x.name.Equals("north", StringComparison.InvariantCultureIgnoreCase));
player.Status = PlayerSetup.Player.PlayerStatus.Standing;
HubContext.SendToClient(player.Name + " Flee's from combat", player.Target.HubGuid);
Room.Movement.Move(player, room, "North");
}
else
{
HubContext.SendToClient("Flee from whom, you're not fighting anyone", player.HubGuid);
}
}
public static void ShowPlayerSkills(Player player, string commandOption)
{
if (commandOption.StartsWith("all"))
{
ShowPlayerAllSkills(player);
}
else
{
HubContext.SendToClient("You currently know these skills:", player.HubGuid);
foreach (var skill in player.Skills)
{
HubContext.SendToClient(
"Level " + skill.LevelObtained + ": " + skill.Name + " " + skill.Proficiency + "%",
player.HubGuid);
}
}
}
private static async Task DoTeleport(Player attacker, Room room)
{
_taskRunnning = true;
attacker.Status = Player.PlayerStatus.Busy;
await Task.Delay(500);
var castingTextAttacker = "You close your eyes and open them to find yourself somewhere else.";
HubContext.SendToClient(castingTextAttacker, attacker.HubGuid);
var goToRoom = Areas.ListOfRooms()[Helpers.diceRoll.Next(Areas.ListOfRooms().Count)];
foreach (var character in room.players)
{
if (character == attacker)
{
continue;
}
if (character != attacker)
{
var hisHer = Helpers.ReturnHisOrHers(attacker, character, false);
var roomMessage =
$"{Helpers.ReturnName(attacker, character, string.Empty)} closes {hisHer} eyes and then vanishes, only wisps of smoke are left behind.";
HubContext.SendToClient(roomMessage, character.HubGuid);
}
}
var randomExitFroMRandomRoom = goToRoom.exits[Helpers.diceRoll.Next(goToRoom.exits.Count)];
Movement.Teleport(attacker, room, randomExitFroMRandomRoom);
Player.SetState(attacker);
_taskRunnning = false;
}
public void recieveFromClient(string message, String playerGuid)
{
Player PlayerData;
Room RoomData;
_PlayerCache.TryGetValue(playerGuid, out PlayerData);
var room = new Tuple <string, string, int>(PlayerData.Region, PlayerData.Area, PlayerData.AreaId);
_AreaCache.TryGetValue(room, out RoomData);
HubContext.SendToClient("<p style='color:#999'>" + message + "<p/>", PlayerData.HubGuid);
Command.ParseCommand(message, PlayerData, RoomData);
}
public static async Task EmoteRoom()
{
//Loop every mob in the rooms in cache.
// only emote if player is in the room
foreach (var room in MIMHub._AreaCache.Values)
{
if (room.players.Count > 0)
{
// check mob emotes
if (room.Emotes.Count > 0)
{
var emoteIndex = Helpers.diceRoll.Next(room.Emotes.Count);
HubContext.broadcastToRoom(room.Emotes[emoteIndex], room.players, String.Empty);
}
}
}
}
public static void Practice(Player player, Room room, string skillToPractice)
{
var foundTrainer = FindItem.Trainer(room.mobs);
if (foundTrainer == null)
{
HubContext.SendToClient("There is no one here that can train you.", player.HubGuid);
return;
}
if (skillToPractice == string.Empty)
{
ShowSkills(player);
}
else
{
PracticeSkill(player, foundTrainer, skillToPractice);
}
}
private static async Task DoPunch(Player attacker, Room room)
{
_taskRunnning = true;
attacker.Status = Player.PlayerStatus.Busy;
await Task.Delay(5000);
//get attacker strength
var die = new PlayerStats();
var dam = die.dice(1, attacker.Strength);
var toHit = Helpers.GetPercentage(attacker.Skills.Find(x => x.Name.Equals("Punch", StringComparison.CurrentCultureIgnoreCase)).Proficiency, 95); // always 5% chance to miss
int chance = die.dice(1, 100);
if (toHit > chance)
{
//HIt, but what about defenders ability to block and dodge?
if (attacker.Target != null && attacker.Target.HitPoints > 0)
{
HubContext.SendToClient("Your punch hits", attacker.HubGuid);
HubContext.SendToClient(attacker.Name + " punch hits you", attacker.HubGuid, attacker.Target.HubGuid, false, true);
HubContext.broadcastToRoom(attacker.Name + " punches " + attacker.Target.Name, room.players, attacker.HubGuid, true);
attacker.Target.HitPoints -= dam;
}
//find target and hurt them, not yourself!!
}
else
{
HubContext.SendToClient("You swing a punch at " + attacker.Target.Name + " but miss", attacker.HubGuid);
HubContext.SendToClient(attacker.Name + " swings a punch at you but misses", attacker.HubGuid, attacker.Target.HubGuid, false, true);
HubContext.broadcastToRoom(attacker.Name + " swings at " + attacker.Target.Name + " but misses", room.players, attacker.HubGuid, true);
}
_taskRunnning = false;
attacker.Status = Player.PlayerStatus.Fighting;
}
/// <summary>
/// Shows attack and damage to player
/// </summary>
/// <param name="attacker">the attacker</param>
/// <param name="defender">the defender</param>
/// <param name="room">The rom</param>
/// <param name="toHit">Target tohit value</param>
/// <param name="chance">Chance to hit value</param>
/// <param name="skillUsed">This is used for skills and spells only</param>
/// <param name="damage">This is used for skills and spells only</param>
public static void ShowAttack(Player attacker, Player defender, Room room, double toHit, int chance, Skill skillUsed, int damage = 0)
{
bool alive = IsAlive(attacker, defender);
int IsCritical = CriticalHit(toHit, chance);
if (alive)
{
if (toHit > chance)
{
var dam = damage > 0 ? damage : Damage(attacker, defender, IsCritical);
var damageText = DamageText(dam);
HubContext.SendToClient("Your " + WeaponAttackName(attacker, skillUsed).Key + " " + damageText.Value + " " + Helpers.ReturnName(defender, attacker, null) + " [" + dam + "]", attacker.HubGuid);
HubContext.SendToClient(Helpers.ReturnName(attacker, defender, null) + "'s " + WeaponAttackName(attacker, skillUsed).Value + " " + damageText.Value + " you [" + dam + "]", defender.HubGuid);
HubContext.SendToAllExcept(Helpers.ReturnName(attacker, defender, null) + "'s " + WeaponAttackName(attacker, skillUsed).Value + " " + damageText.Value + " " + Helpers.ReturnName(defender, attacker, null), room.fighting, room.players);
defender.HitPoints -= dam;
if (defender.HitPoints < 0)
{
defender.HitPoints = 0;
}
if (!IsAlive(attacker, defender))
{
IsDead(attacker, defender, room);
}
}
else
{
HubContext.SendToClient("Your " + WeaponAttackName(attacker, skillUsed).Key + " misses " + Helpers.ReturnName(defender, attacker, null), attacker.HubGuid);
HubContext.SendToClient(Helpers.ReturnName(attacker, defender, null) + "'s " + WeaponAttackName(attacker, skillUsed).Key + " misses you ", defender.HubGuid);
HubContext.SendToAllExcept(Helpers.ReturnName(attacker, defender, null) + "'s " + WeaponAttackName(attacker, skillUsed).Key + " misses " + Helpers.ReturnName(defender, attacker, null), room.fighting, room.players);
}
}
}
public override async Task OnActivateAsync()
{
await base.OnActivateAsync();
_hubContext = GrainFactory.GetHub <IHeroHub>();
// todo: use key data
var keySplit = PrimaryKey.Split('/');
_keyData.Tenant = keySplit[1];
_keyData.HeroKey = keySplit[2];
if (State.Hero == null)
{
var hero = await _heroDataClient.GetByKey(_keyData.HeroKey);
if (hero == null)
{
return;
}
await Set(hero);
}
var hubGroup = _hubContext.Group($"hero:{_keyData.HeroKey}");
var hubAllGroup = _hubContext.Group($"hero:all");
var streamProvider = GetStreamProvider(Constants.STREAM_PROVIDER);
var stream = streamProvider.GetStream <Hero>(StreamConstants.HeroStream, $"hero:{_keyData.HeroKey}");
RegisterTimer(async x =>
{
State.Hero.Health = RandomUtils.GenerateNumber(1, 100);
await Task.WhenAll(
Set(State.Hero),
stream.OnNextAsync(State.Hero),
hubGroup.Send("HeroChanged", State.Hero),
hubAllGroup.Send("HeroChanged", State.Hero)
);
}, State, TimeSpan.FromSeconds(2), TimeSpan.FromSeconds(3));
}
public static void Connected(PlayerSetup.Player playerData)
{
var whoList = new StringBuilder();
whoList.Append(Cache.ReturnPlayers().Count).Append(" Players currently playing <br />");
foreach (var player in Cache.ReturnPlayers())
{
whoList.Append("<p>[")
.Append(player.Level)
.Append(" ")
.Append(player.Race.Truncate(5))
.Append(" ")
.Append(player.SelectedClass.Truncate(3))
.Append("]")
.Append(" ")
.Append(player.Name).Append("</p><br />");
}
HubContext.SendToClient(whoList.ToString(), playerData.HubGuid);
}
public ClockTask(HubContext<AppHub> hubContext)
{
_hubContext = hubContext;
}
public ReportRepository(HubContext context)
{
_context = context;
}
