public async Task <IActionResult> UpdateCharacter(CharacterUpdateDto updateCharacter)
{
ServiceResponse <CharacterReadDto> serviceResponse = new ServiceResponse <CharacterReadDto>();
var validator = new CharacterUpdateDtoValidator();
var result = validator.Validate(updateCharacter);
if (!result.IsValid)
{
serviceResponse.Success = false;
foreach (var failure in result.Errors)
{
serviceResponse.Message += failure;
}
}
else
{
serviceResponse = await _service.UpdateCharacter(updateCharacter);
}
if (serviceResponse.Success == false)
{
return(NotFound(serviceResponse));
}
return(Ok(serviceResponse));
}
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"));
}
public async Task <ActionResult> BuyItem(Guid?id, Guid?charId, Guid?shopId)
{
if (id == null || charId == null || shopId == null)
{
return(RedirectToAction("Index"));
}
var item = await EquipmentFacade.GetItemAsync(id.GetValueOrDefault());
var character = await CharacterFacade.GetAsync(charId.GetValueOrDefault());
if (await EquipmentFacade.AddToInventoryAsync(character.Inventory, item))
{
var updatedUser = new CharacterUpdateDto()
{
Name = character.Name,
CurrentHp = character.CurrentHp,
Experience = character.Experience,
Gold = character.Gold - (int)(item.Price * 1.5),
Id = character.Id,
SkillPoints = character.SkillPoints,
Sickness = character.Sickness
};
await CharacterFacade.EditAsync(updatedUser);
}
return(RedirectToAction("Detail", new { id = shopId }));
}
public async Task <IActionResult> UpdateCharacter(CharacterUpdateDto updateCharacter)
{
var serviceResponse = await _service.UpdateCharacter(updateCharacter);
if (serviceResponse.Success == false)
{
return(NotFound(serviceResponse));
}
return(Ok(serviceResponse));
}
public async Task <bool> EditAsync(CharacterUpdateDto entityDto)
{
using (var uow = UnitOfWorkProvider.Create())
{
if ((await _characterService.GetAsync(entityDto.Id, false)) == null)
{
return(false);
}
await _characterService.Update(entityDto);
await uow.Commit();
return(true);
}
}
public async Task <Tuple <bool, List <string> > > FightAsync(CharacterDto character, MonsterDto monster, QuestDto quest)
{
var log = new List <string>();
_random = new Random();
if (character.Sickness > DateTime.Now)
{
var diff = Math.Abs(Math.Floor((character.Sickness - DateTime.Now).Value.TotalSeconds));
log.Add($"You can't fight at the moment. You are too tired and will not be able to fight for {diff} seconds.");
return(new Tuple <bool, List <string> >(false, log));
}
if (character.CurrentHp <= 0)
{
log.Add("You can't fight at the moment. You should get some rest, because you are too devasteted.");
return(new Tuple <bool, List <string> >(false, log));
}
var characterAttr = character.CalculateAttributes();
characterAttr.Hp = character.CurrentHp / 10; //setting hp to current value
var combat = Task.Run(() => Combat(characterAttr, monster.Attributes, log));
var result = await combat;
using (var uow = UnitOfWorkProvider.Create())
{
var updatedUser = new CharacterUpdateDto()
{
Name = character.Name,
CurrentHp = result.Item2,
Experience = character.Experience,
Gold = character.Gold,
Id = character.Id,
SkillPoints = character.SkillPoints,
Sickness = DateTime.Now.AddMinutes(10)
};
if (result.Item1)
{
updatedUser.Experience += quest.Experience;
updatedUser.Gold += quest.Gold;
}
await _characterService.Update(updatedUser);
await uow.Commit();
}
return(new Tuple <bool, List <string> >(result.Item1, log));
}
public async Task <ServiceResponse <CharacterReadDto> > UpdateCharacter(CharacterUpdateDto updateCharacter)
{
ServiceResponse <CharacterReadDto> serviceResponse = new ServiceResponse <CharacterReadDto>();
try
{
serviceResponse.Data = await _dataService.Update(updateCharacter);
}
catch (Exception ex)
{
serviceResponse.Success = false;
serviceResponse.Message = ex.Message;
}
return(serviceResponse);
}
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> 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"));
}
public async Task <ServiceResponse <CharacterReadDto> > UpdateCharacter(CharacterUpdateDto dto)
{
ServiceResponse <CharacterReadDto> serviceResponse = new ServiceResponse <CharacterReadDto>();
try
{
Character character = _context.Characters.AsNoTracking().First(c => c.Id == dto.IdForUpdate);
character = _mapper.Map <CharacterUpdateDto, Character>(dto, character);
_context.Update(character);
if (await SaveChanges())
{
serviceResponse.Data = _mapper.Map <CharacterReadDto>(character);
}
}
catch (Exception ex)
{
serviceResponse.Success = false;
serviceResponse.Message = ex.Message;
}
return(serviceResponse);
}
public async Task <ActionResult <Character> > Put([FromBody] CharacterUpdateDto modelUpdateDto, int id)
{
try
{
var character = await _repository.GetCharacterByIdAsync(id);
if (character == null)
{
return(NotFound());
}
if (ModelState.IsValid)
{
var potterApi = new PotterApi();
var accio = await potterApi.AccioHouse(modelUpdateDto.House);
if (accio)
{
_mapper.Map(modelUpdateDto, character);
await _repository.SaveChangesAsync();
return(NoContent());
}
else
{
ModelState.AddModelError("Accio", "Accio House didn't work");
return(BadRequest(ModelState));
}
}
else
{
return(BadRequest(ModelState));
}
}
catch (Exception)
{
return(StatusCode((int)HttpStatusCode.InternalServerError));
}
}
public IActionResult PutCharacter([FromRoute] int id, [FromBody] CharacterUpdateDto characterUpdate)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var existingCharacter = _charactersRepository.get(id, null);
if (characterUpdate == null)
{
return(BadRequest());
}
if (existingCharacter == null)
{
return(NotFound());
}
if (characterUpdate.Name != null)
{
existingCharacter.Name = characterUpdate.Name;
}
_charactersRepository.put(existingCharacter);
var result = _charactersRepository.save();
if (!result)
{
return(new StatusCodeResult(500));
}
return(CreatedAtAction("GetCharacter", new { id = existingCharacter.Id }, existingCharacter));
}
public async Task <CharacterReadDto> Update(CharacterUpdateDto updateCharacter)
{
var dto = new CharacterReadDto();
try
{
Character character = _context.Character.First(c => c.Id == updateCharacter.IdForUpdate);
character = _mapper.Map <CharacterUpdateDto, Character>(updateCharacter, character);
_context.Update(character);
if (await SaveChanges())
{
dto = _mapper.Map <CharacterReadDto>(character);
}
}
catch (Exception ex)
{
return(null);
}
return(dto);
}
public async Task <Tuple <bool, List <string> > > FightAsync(CharacterDto character, CharacterDto character2)
{
var log = new List <string>();
_random = new Random();
if (character.Sickness > DateTime.Now)
{
var diff = Math.Abs(Math.Floor((character.Sickness - DateTime.Now).Value.TotalSeconds));
log.Add($"You can't fight at the moment. You are too tired and will not be able to fight for {diff} seconds.");
return(new Tuple <bool, List <string> >(false, log));
}
if (character.CurrentHp <= 0)
{
log.Add("You can't fight at the moment. You should get some rest, because you are too devasteted.");
return(new Tuple <bool, List <string> >(false, log));
}
if (character2.CurrentHp <= 0)
{
log.Add("It wouldn't be very nice if you attacked your opponent right now. He needs to lick his wounds first.");
return(new Tuple <bool, List <string> >(false, log));
}
var player1 = character.CalculateAttributes();
var player2 = character2.CalculateAttributes();
player1.Hp = character.CurrentHp / 10; //setting hp to current value
player2.Hp = character.CurrentHp / 10; //setting hp to current value
var combat = Task.Run(() => Combat(player1, player2, log));
var result = await combat;
using (var uow = UnitOfWorkProvider.Create())
{
var updatedUser1 = new CharacterUpdateDto()
{
Name = character.Name,
CurrentHp = result.Item2,
Experience = character.Experience,
Gold = character.Gold,
Id = character.Id,
SkillPoints = character.SkillPoints,
Sickness = DateTime.Now.AddMinutes(10)
};
var updatedUser2 = new CharacterUpdateDto()
{
Name = character2.Name,
CurrentHp = result.Item3,
Experience = character2.Experience,
Gold = character2.Gold,
Id = character2.Id,
SkillPoints = character2.SkillPoints,
Sickness = character2.Sickness
};
if (result.Item1)
{
updatedUser2.Gold -= (int)Math.Floor((float)updatedUser2.Gold / 100) * 10;
updatedUser1.Gold += (int)Math.Floor((float)updatedUser2.Gold / 100) * 10;
}
else
{
updatedUser1.Gold -= (int)Math.Floor((float)updatedUser1.Gold / 100) * 10;
updatedUser2.Gold += (int)Math.Floor((float)updatedUser1.Gold / 100) * 10;
}
await _characterService.Update(updatedUser1);
await _characterService.Update(updatedUser2);
await uow.Commit();
}
return(new Tuple <bool, List <string> >(result.Item1, log));
}
