public async Task <ActionResult> FightForCredits()
{
var user = await UserFacade.GetUserAccordingToUsernameAsync(User.Identity.Name);
if (user.Credits < 10)
{
return(Json(new { CanFight = false }, JsonRequestBehavior.AllowGet));
}
var charUpdate = new CharacterUpdateDto()
{
Id = user.Character.Id,
Name = user.Character.Name,
Experience = user.Character.Experience,
Gold = user.Character.Gold,
CurrentHp = user.Character.CurrentHp,
SkillPoints = user.Character.SkillPoints,
Sickness = null
};
await CharacterFacade.EditAsync(charUpdate);
var userUpdate = new UserEditDto()
{
Credits = user.Credits - 10, CharacterId = user.CharacterId, Id = user.Id, Score = user.Score
};
await UserFacade.EditAsync(userUpdate);
return(Json(new { CanFight = true }, JsonRequestBehavior.AllowGet));
}
public async Task <ActionResult> EatItem(Guid?itemId, Guid charId)
{
var model = await CharacterFacade.GetAsync(charId);
if (model.CurrentHp == model.CalculateAttributes().Hp * 10)
{
return(RedirectToAction("Detail"));
}
var toHeal = model.CalculateAttributes().Hp * 10 - model.CurrentHp;
DateTime?sickness = DateTime.Now.AddHours(1);
if (itemId != null)
{
sickness = model.Sickness;
var item = await EquipmentFacade.GetItemAsync(itemId.GetValueOrDefault());
toHeal = (item.Attributes.Hp * 10) >= toHeal ? toHeal : (item.Attributes.Hp * 10);
await EquipmentFacade.DeleteFromInventoryAsync(model.Inventory, item);
}
var charUpdate = new CharacterUpdateDto()
{
Id = model.Id,
Name = model.Name,
Experience = model.Experience,
Gold = model.Gold,
CurrentHp = model.CurrentHp + toHeal,
Sickness = sickness,
SkillPoints = model.SkillPoints
};
await CharacterFacade.EditAsync(charUpdate);
return(RedirectToAction("Detail"));
}
private void OnUnset(CharacterFacade facade)
{
facade.Inventory.OnItemAdded -= RaiseReassigned;
facade.Inventory.OnItemRemoved -= RaiseRemoved;
facade.Inventory.OnRefresh -= ScanItems;
OnPlayerUnset?.Invoke();
}
public PlayerRegistryTracker(IRespawnable <CharacterSpawnParameters> respawnable, PlayerRegistry registry, CharacterFacade facade)
{
_respawnable = respawnable;
_registry = registry;
_facade = facade;
PreInitialize();
}
private void OnSet(CharacterFacade facade)
{
facade.Inventory.OnItemAdded += RaiseReassigned;
facade.Inventory.OnItemRemoved += RaiseRemoved;
facade.Inventory.OnRefresh += ScanItems;
ScanItems();
}
public EquipmentMessageSender(
UnityClient client,
CharacterFacade characterFacade
)
{
_networkManager = client;
_characterFacade = characterFacade;
}
private void Remove(CharacterFacade facade)
{
LivingPlayers.Remove(facade);
if (LivingPlayersCount == 0)
{
AllPlayersDead?.Invoke();
}
}
public WeaponChangedMessageSender(
IWeapon weapon,
UnityClient unityClient,
CharacterFacade characterFacade)
{
_weapon = weapon;
_unityClient = unityClient;
_characterFacade = characterFacade;
}
public async Task <ActionResult> Detail(Guid id)
{
var character = await CharacterFacade.GetCharacterById(id);
if (character == null)
{
return(RedirectToAction("Index", "Error", "Postava neexistuje"));
}
return(View(character));
}
public async Task <ActionResult> Index()
{
var character = await CharacterFacade.GetCharacterById(Guid.Parse(User.Identity.Name));
if (character == null)
{
return(RedirectToAction("Create"));
}
return(View(character));
}
public NetworkedCharacterWeapon(
NetworkRelay networkRelay,
CharacterFacade characterFacade,
WeaponCreator weaponCreator,
IWeapon weapon)
{
_weapon = weapon;
_networkRelay = networkRelay;
_characterFacade = characterFacade;
_weaponCreator = weaponCreator;
}
public async Task <ActionResult> List(int page = 1)
{
var characters = await CharacterFacade.GetCharactersByFilterAsync(new CharacterFilterDto { PageSize = PageSize, RequestedPageNumber = page, SortCriteria = nameof(CharacterDto.Score) });
// Paging
ViewBag.RequestedPageNumber = characters.RequestedPageNumber;
ViewBag.PageCount = (int)Math.Ceiling((double)characters.TotalItemsCount / (double)PageSize);
// Paging END
return(View(characters.Items));
}
public void UseItem(CharacterFacade facade)
{
if (Module.IsAttached == false)
{
facade.Weapon.AttachModule(Module);
}
else
{
facade.Weapon.DetachModule(Module);
}
}
private void SendAssignItemMessage(CharacterFacade facade)
{
using (var writer = DarkRiftWriter.Create())
{
writer.Write(facade.Id);
writer.Write(_facade.Item.itemId);
using (var message = Message.Create(Tags.AssignItem, writer))
{
_info.Client.SendMessage(message, SendMode.Reliable);
}
}
}
public NetworkedCharacterInput(
ControlState controlState,
CharacterFacade characterFacade,
NetworkRelay relay,
Settings settings,
CharacterMovement movement)
{
_controlState = controlState;
_characterFacade = characterFacade;
_networkRelay = relay;
_settings = settings;
_movement = movement;
}
public InputMessageSender(
UnityClient client,
ControlState controlState,
CharacterFacade characterFacade,
Settings settings)
{
_client = client;
_characterFacade = characterFacade;
_controlState = controlState;
_settings = settings;
UpdatePreviousStates();
}
/// <summary>
/// Spawns enemies on the host side.
/// </summary>
/// <param name="data"> Data on which to spawn enemies. </param>
/// <returns> Wheter any </returns>
private void LocalSpawn(List <AISpawnParameters> data)
{
data.ForEach(enemy =>
{
CharacterFacade facade = _aiSpawner.Spawn(enemy.SpawnParameters);
if (facade == null)
{
throw new Exception("Encountered error while spawning enemies. Character facade is null.");
}
_aliveEnemies.Add(facade);
facade.OnDeath += OnAIDeath;
});
}
public async Task <ActionResult> Create(CharacterCreateDto model)
{
model.Id = Guid.Empty;
var u = new UserDto {
Id = model.UserId
};
model.Id = await CharacterFacade.CreateAsync(model);
await UserFacade.AssignAsync(u, model);
return(RedirectToAction("Index", "Home"));
}
public async Task <ActionResult> Remove(CharacterDto characterDto)
{
var c = await CharacterFacade.RemoveCharacter(Guid.Parse(User.Identity.Name));
var cookie = FormsAuthentication.GetAuthCookie(User.Identity.Name, true);
var ticket = FormsAuthentication.Decrypt(cookie.Value);
var newTicket = new FormsAuthenticationTicket(ticket.Version, ticket.Name, ticket.IssueDate, ticket.Expiration, false, ticket.UserData.Replace(",HasCharacter", ""));
cookie.Value = FormsAuthentication.Encrypt(newTicket);
cookie.Expires = newTicket.Expiration.AddMinutes(30);
HttpContext.Response.Cookies.Set(cookie);
return(RedirectToAction("Create"));
}
/// <summary>
/// Remove local enemies and
/// </summary>
/// <param name="deathParameters"></param>
private void OnAIDeath(DeathParameters deathParameters)
{
CharacterFacade facade = _aliveEnemies.Find(enemy => enemy.Id == deathParameters.characterInfo.Id);
//Unsubsribe event
if (facade == null)
{
Debug.Log("Facade is null");
}
facade.OnDeath -= OnAIDeath;
_aliveEnemies.Remove(facade);
//AllEnemiesDead?.Invoke();
CheckWaveEnded();
}
public async Task <ActionResult> Edit(CharacterDto characterDto)
{
try
{
var character = await CharacterFacade.GetCharacterById(Guid.Parse(User.Identity.Name));
character.Name = characterDto.Name;
var res = await CharacterFacade.EditCharacter(character);
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
public async Task <ActionResult> Detail(Guid?id)
{
if (id == null)
{
return(RedirectToAction("Index"));
}
var model = await CharacterFacade.GetAsync(id.GetValueOrDefault());
if (model == null)
{
return(RedirectToAction("Index"));
}
var u = await UserFacade.GetUserAccordingToUsernameAsync(User.Identity.Name);
ViewBag.isMine = u.Character.Equals(model);
return(View(model));
}
public async Task <ActionResult> SellItem(Guid itemId, Guid charId)
{
var item = await EquipmentFacade.GetItemAsync(itemId);
var model = await CharacterFacade.GetAsync(charId);
var charUpdate = new CharacterUpdateDto()
{
Id = model.Id, Name = model.Name, Experience = model.Experience,
Gold = model.Gold + item.Price, CurrentHp = model.CurrentHp, Sickness = model.Sickness, SkillPoints = model.SkillPoints
};
await EquipmentFacade.DeleteFromInventoryAsync(model.Inventory, item);
await CharacterFacade.EditAsync(charUpdate);
return(RedirectToAction("Detail"));
}
public async Task <ActionResult> Create(CharacterDto characterDto)
{
try
{
var character = await CharacterFacade.CreateCharacter(Guid.Parse(User.Identity.Name), characterDto);
var cookie = FormsAuthentication.GetAuthCookie(User.Identity.Name, true);
var ticket = FormsAuthentication.Decrypt(cookie.Value);
var newTicket = new FormsAuthenticationTicket(ticket.Version, ticket.Name, ticket.IssueDate, ticket.Expiration, false, ticket.UserData + ",HasCharacter");
cookie.Value = FormsAuthentication.Encrypt(newTicket);
cookie.Expires = newTicket.Expiration.AddMinutes(30);
HttpContext.Response.Cookies.Set(cookie);
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
/// <summary>
/// Spawns a character with given parameters.
/// </summary>
/// <param name="spawnParameters">Parameters to spawn a character.</param>
public CharacterFacade Spawn(CharacterSpawnParameters spawnParameters)
{
ushort ID = spawnParameters.Id;
if (_AIplayers.ContainsKey(ID) == false)
{
CharacterFacade characterFacade = _AIfactory.Create(spawnParameters);
characterFacade.Id = ID;
characterFacade.CharacterType = CharacterType.AICharacter;
// Put the character on spawn position
Transform transform = characterFacade.transform;
transform.SetPositionAndRotation(new Vector3(spawnParameters.X, spawnParameters.Y, transform.position.z), transform.rotation);
_AIplayers.Add(ID, characterFacade);
return(characterFacade);
}
else
{
return(null);
}
}
/// <summary>
/// Spawns a character with given parameters.
/// </summary>
/// <param name="spawnParameters">Parameters to spawn a character.</param>
public void Spawn(CharacterSpawnParameters spawnParameters)
{
ushort playerId = spawnParameters.Id;
bool isLocal = spawnParameters.IsLocal;
if (_characters.ContainsKey(playerId) == false)
{
CharacterFacade characterFacade = null;
if (isLocal)
{
// Player character
characterFacade = _playerFactory.Create(spawnParameters);
characterFacade.Id = _unityClient.ID;
_cameraManager.SetCameraToPlayerCharacter(characterFacade);
}
else
{
// Networked character
characterFacade = _networkFactory.Create(spawnParameters);
characterFacade.Id = playerId;
var animator = characterFacade.GetComponentInChildren <Animator>();
if (characterFacade.CharacterType == CharacterType.AICharacter)
{
animator.runtimeAnimatorController = (RuntimeAnimatorController)_controllers.Wasp;
}
else
{
animator.runtimeAnimatorController = (RuntimeAnimatorController)_controllers.Human;
}
}
// Put the character on spawn position
Transform transform = characterFacade.transform;
transform.SetPositionAndRotation(new Vector3(spawnParameters.X, spawnParameters.Y, transform.position.z), transform.rotation);
_characters.Add(playerId, characterFacade);
CharacterSpawned?.Invoke(characterFacade);
}
}
public async Task <ActionResult> EquipItem(Guid itemId, Guid charId)
{
var item = await EquipmentFacade.GetItemAsync(itemId);
var model = await CharacterFacade.GetAsync(charId);
var charUpdate = new CharacterUpdateDto()
{
Id = model.Id,
Name = model.Name,
Experience = model.Experience,
Gold = model.Gold,
CurrentHp = model.CurrentHp + (item.Attributes.Hp * 10),
Sickness = model.Sickness,
SkillPoints = model.SkillPoints
};
ItemDto equipped = null;
foreach (var itemDto in model.Equipment.ListItems())
{
if (itemDto != null && itemDto.ArmorClass == item.ArmorClass)
{
equipped = itemDto;
}
}
await EquipmentFacade.DeleteFromInventoryAsync(model.Inventory, item);
if (equipped != null)
{
charUpdate.CurrentHp -= equipped.Attributes.Hp * 10;
await EquipmentFacade.AddToInventoryAsync(model.Inventory, equipped);
}
await EquipmentFacade.EquipItemAsync(model.Equipment, item);
await CharacterFacade.EditAsync(charUpdate);
return(RedirectToAction("Detail"));
}
private void CharacterSpawned(CharacterFacade spawnedCharacter)
{
spawnedCharacter.OnDeath += RemoveDeadCharacter;
LivingPlayers.Add(spawnedCharacter);
}
private void CharacterDespawned(CharacterFacade despawnedCharacter)
{
Remove(despawnedCharacter);
}
private void OnUnset(CharacterFacade obj)
{
obj.OnDamageTaken -= OnDamageTaken;
}
