public Quests(Character @char, CharacterDto characterDto)
{
QuestStates = new byte[20];
_quests = new List <Quest>();
Array.Fill <byte>(QuestStates, 0xff);
Player = @char.Player;
foreach (var q in characterDto.Quests)
{
var nq = new Quest
{
Manager = this,
Index = q.Quest,
State = (QuestState)q.State,
_dbId = q.QuestId,
};
nq._needSave = false;
_quests.Add(nq);
var details = q.Details
.Split(";")
.Where(x => !string.IsNullOrEmpty(x))
.Select(x => x.Split("="))
.ToDictionary(x => uint.Parse(x[0]), y => byte.Parse(y[1]));
_logger
.ForAccount(Player.Session)
.Information("Quest Found:{0} State:{1}", nq.Details.Name, nq.State);
foreach (var d in details)
{
_questMonsterKillCount.Add(d.Key, d.Value);
}
}
}
public void Setup()
{
PacketFactory.Initialize <NoS0575Packet>();
var contextBuilder =
new DbContextOptionsBuilder <NosCoreContext>().UseInMemoryDatabase(
databaseName: Guid.NewGuid().ToString());
DataAccessHelper.Instance.InitializeForTest(contextBuilder.Options);
var logRepository = LogManager.GetRepository(Assembly.GetEntryAssembly());
XmlConfigurator.Configure(logRepository, new FileInfo(ConfigurationPath + "/log4net.config"));
Logger.InitializeLogger(LogManager.GetLogger(typeof(CharacterScreenControllerTests)));
var map = new MapDto {
MapId = 1
};
DaoFactory.MapDao.InsertOrUpdate(ref map);
_acc = new AccountDto {
Name = "AccountTest", Password = EncryptionHelper.Sha512("test")
};
DaoFactory.AccountDao.InsertOrUpdate(ref _acc);
_chara = new CharacterDto
{
Name = "TestExistingCharacter",
Slot = 1,
AccountId = _acc.AccountId,
MapId = 1,
State = CharacterState.Active
};
DaoFactory.CharacterDao.InsertOrUpdate(ref _chara);
_session.InitializeAccount(_acc);
_handler = new CharacterScreenPacketController(new CharacterBuilderService(null), null, null);
_handler.RegisterSession(_session);
}
public void checkDtoUtils()
{
// try to cast a House into HouseDto type
House h = new House("DTOtest", 4000);
HouseDto hdto = DtoUtils.ToDto <HouseDto>(h);
Assert.AreEqual(h.Name, hdto.Name);
Assert.AreEqual(h.ID, hdto.ID);
Assert.AreEqual(h.NumberOfUnits, hdto.NumberOfUnits);
// try to cast a Character into CharacterDto type
Character c = new Character();
CharacterDto ctdo = DtoUtils.ToDto <CharacterDto>(c);
Assert.AreEqual(c.Bravoury, ctdo.Bravoury);
// try to cast a house into CharacterDto type
House house = new House("Casting", 10);
house.ID = 122;
CharacterDto mutated_bastard_house_into_character = DtoUtils.ToDto <CharacterDto>(house);
// this should be the only matching property
Assert.AreEqual(house.ID, mutated_bastard_house_into_character.ID);
// the others CharacterDto properties should be default or null depending on type
Assert.IsNull(mutated_bastard_house_into_character.LastName);
Assert.AreEqual(0, mutated_bastard_house_into_character.Bravoury);
}
public async Task <bool> EditAsync(CharacterDto character)
{
var existingCharacter = await Context.Characters.FindAsync(character.Id);
if (existingCharacter != null)
{
existingCharacter.Name = character.Name;
existingCharacter.Status = character.Status;
existingCharacter.LastModified = DateTime.UtcNow;
if (existingCharacter.IconImage != null)
{
existingCharacter.IconImage.File = character.IconImage?.File;
existingCharacter.IconImage.LastModified = character.IconImage?.LastModified ?? existingCharacter.IconImage.LastModified;
}
else
{
if (character.IconImage != null && character.IconImage.File != null)
{
existingCharacter.IconImage = new Image {
File = character.IconImage.File
}
}
;
}
Context.Update(existingCharacter);
await Context.SaveChangesAsync();
return(true);
}
return(false);
}
public async Task AddAsync_AddsCharacter_WhenCharacterAddedWithoutIcon()
{
//ARRANGE
var game = new Game {
Name = "Test"
};
var specificCharacterName = Guid.NewGuid().ToString();
fixture.Context.Add(game);
fixture.Context.SaveChanges();
var currentCount = await fixture.Context.Characters.CountAsync();
var character = new CharacterDto
{
Name = specificCharacterName,
GameId = game.Id
};
//ACT
var result = await service.AddAsync(character);
//ASSERT
var existingCharacter = await fixture.Context.Characters.SingleOrDefaultAsync(g => g.Name == specificCharacterName);
Assert.NotNull(existingCharacter);
Assert.Equal(existingCharacter.Id, result);
Assert.Equal(currentCount + 1, await fixture.Context.Characters.CountAsync());
}
protected override async Task Handle(CharacterDeletePacketBase packet, ISession session)
{
AccountDto account = await _accountService.GetByIdAsync(session.Account.Id);
if (account == null)
{
return;
}
if (!string.Equals(account.Password, packet.Password.ToSha512(), StringComparison.CurrentCultureIgnoreCase))
{
await session.SendPacketAsync(new InfoPacket
{
Message = "bad_password"
});
return;
}
CharacterDto character = await _characterService.GetByAccountIdAndSlotAsync(session.Account.Id, packet.Slot);
if (character == null)
{
return;
}
character.State = CharacterState.Inactive;
await _characterService.DeleteByIdAsync(character.Id);
await _screenLoader.Handle(session);
}
public void Setup()
{
PacketFactory.Initialize <NoS0575Packet>();
var contextBuilder =
new DbContextOptionsBuilder <NosCoreContext>().UseInMemoryDatabase(
databaseName: Guid.NewGuid().ToString());
DataAccessHelper.Instance.InitializeForTest(contextBuilder.Options);
var map = new MapDto {
MapId = 1
};
DaoFactory.MapDao.InsertOrUpdate(ref map);
var _acc = new AccountDto {
Name = "AccountTest", Password = "******".ToSha512()
};
DaoFactory.AccountDao.InsertOrUpdate(ref _acc);
_chara = new Character(null, null, null)
{
Name = "TestExistingCharacter",
Slot = 1,
AccountId = _acc.AccountId,
MapId = 1,
State = CharacterState.Active
};
CharacterDto character = _chara;
DaoFactory.CharacterDao.InsertOrUpdate(ref character);
_session.InitializeAccount(_acc);
_handler = new CharacterScreenPacketController(null, null, new Adapter());
_handler.RegisterSession(_session);
}
protected override async ValueTask HandleRequirementAsync(AuthorizationHandlerContext context, CharacterOwnerRequirement requirement, DiscordMember member)
{
if (requirement.AllowAdmin && DiscordClientProvider.HasAdminRole(member))
{
context.Succeed(requirement);
return;
}
long?characterId = context.Resource switch
{
long id => id,
CharacterDto character => character.Id,
_ => null
};
if (characterId.HasValue)
{
var discordId = (long)member.Id;
var characterIdString = characterId.Value.ToString();
if (context.User.HasClaim(AppClaimTypes.Character, characterIdString) ||
await _context.UserClaims.AsNoTracking().CountAsync(claim => claim.UserId == discordId && claim.ClaimType == AppClaimTypes.Character && claim.ClaimValue == characterIdString) > 0)
{
context.Succeed(requirement);
}
}
}
}
public void Should_Create_New_Character_UsingDto()
{
// Arrange
using (var db = new RickAndMortyContext(dbOptions))
{
var existing = db.Characters.Find(1);
existing.Should().BeNull();
// Act
var character = new CharacterDto
{
Id = 1,
Name = "Steve",
Location = new CharacterLocationDto {
Name = "Earth"
},
Origin = new CharacterOriginDto {
Name = "Moon"
},
Episode = Array.Empty <string>()
};
var entity = mapper.Map <Character>(character);
db.Characters.Add(entity);
db.SaveChanges();
}
// Assert
using (var db = new RickAndMortyContext(dbOptions))
{
var found = db.Characters.Find(1);
found.Should().NotBeNull();
found.Name.Should().Be("Steve");
}
}
public async Task <IActionResult> Edit(CharacterEditViewModel vm)
{
if (!ModelState.IsValid)
{
return(View(vm));
}
var game = await _gameService.GetByIdAsync(vm.GameId);
if (game == null)
{
return(StatusCode((int)HttpStatusCode.NotFound));
}
if (vm.Id.HasValue)
{
var character = await _characterService.GetByIdAsync(vm.Id.Value);
if (character == null)
{
return(StatusCode((int)HttpStatusCode.NotFound));
}
character.Name = vm.Name;
character.Status = vm.Status;
if (vm.IconImage != null)
{
if (character.IconImage != null)
{
character.IconImage.File = vm.IconImage.Getbytes();
character.IconImage.LastModified = DateTime.UtcNow;
}
else
{
character.IconImage = new ImageDto {
File = vm.IconImage.Getbytes()
};
}
}
await _characterService.EditAsync(character);
}
else
{
var character = new CharacterDto()
{
Name = vm.Name,
IconImage = vm.IconImage != null ? new ImageDto {
File = vm.IconImage.Getbytes()
} : null,
Status = vm.Status,
GameId = game.Id
};
await _characterService.AddAsync(character);
}
return(RedirectToAction("ListByGame", "Character", new { id = vm.GameId }));
}
public async Task <IEnumerable <CharacterDto> > GetCharactersToFight(CharacterDto character, int count)
{
using (UnitOfWorkProvider.Create())
{
var characters = await _characterService.ListCharactersAsync(new CharacterFilterDto { SortCriteria = nameof(character.Score) });
var lessScore = characters.Items.TakeWhile(x => x.Name != character.Name);
var moreScore = characters.Items.SkipWhile(x => x.Name != character.Name);
moreScore = moreScore.Skip(1);
var possibleCharacters = new List <CharacterDto>();
if (lessScore.Count() < count / 2)
{
possibleCharacters.AddRange(lessScore);
}
else
{
possibleCharacters.AddRange(lessScore.Skip(lessScore.Count() - count / 2));
}
if (moreScore.Count() < count - possibleCharacters.Count())
{
var i = possibleCharacters.Count();
possibleCharacters.AddRange(moreScore);
}
else
{
possibleCharacters.AddRange(moreScore.Take(count - possibleCharacters.Count()));
}
return(possibleCharacters);
}
}
public async Task <IHttpActionResult> Mutate(
Guid userId, [FromBody] CharacterDto c)
{
await putService.Mutate(userId, c);
return(Ok());
}
public Inventory(Character @char, CharacterDto characterDto)
{
Character = @char;
Storages = new Dictionary <StorageID, object>();
_equipament = new Dictionary <Equipament, Item>();
_inventory = new Storage(Storage.InventorySize, StorageID.Inventory);
_personalShop = new Storage(Storage.TradeSize, StorageID.PersonalShop);
if (@char != null)
{
_chaosBox = new Storage(Storage.ChaosBoxSize);
_tradeBox = new Storage(Storage.TradeSize);
}
_forDelete = new List <Item>();
Storages.Add(StorageID.Equipament, _equipament);
Storages.Add(StorageID.Inventory, _inventory);
Storages.Add(StorageID.PersonalShop, _personalShop);
foreach (var item in characterDto.Items.Where(x => x.VaultId == 0))
{
var it = new Item(item);
try
{
Add((byte)item.SlotId, it, false);
}catch (Exception)
{
if (Add(it) == 0xff)
{
_forDelete.Add(it);
}
}
}
}
public Spells(Character @char, CharacterDto character)
{
_spellList = new Dictionary <Spell, SpellInfo>();
Player = @char.Player;
Character = @char;
_buffs = new List <Buff>();
var spells = ResourceCache.Instance.GetSkills();
foreach (var skill in Character.BaseInfo.Spells)
{
var spell = spells[skill];
_spellList.Add(skill, spell);
Logger
.ForAccount(Player.Session)
.Information("Class Skill Added: {0}", spell.Name);
}
foreach (var skill in character.Spells.Select(x => (Spell)x.Magic))
{
var spell = spells[skill];
_spellList.Add(skill, spell);
Logger
.ForAccount(Player.Session)
.Information("Learned {0} Skill Added", spell.Name);
}
}
public void SeralizationTest()
{
CharacterDto dto = new CharacterDto
{
Level = 10,
ResourcePoints = 3,
Agility = 3,
Endurance = 3,
HealthPoints = 3,
ExpNextLevel = 100,
Intelligence = 3,
Strength = 3,
Id = Guid.NewGuid()
};
var intelligenceCharacter = new IntelligenceCharacter(dto);
var maxResourcePointsBefore = intelligenceCharacter.MaxResourcePoints;
var intJson = intelligenceCharacter.ToJson();
dynamic deserializedObject = intJson.ToGameObject();
var maxResourcePointsAfter = deserializedObject.MaxResourcePoints;
Assert.AreEqual(maxResourcePointsAfter, maxResourcePointsBefore);
}
public Character LoadCharacter(CharacterDto characterDto)
{
Character character = characterDto.Adapt <Character>();
character.Inventory = _inventory;
return(character);
}
public Quests(Character @char, CharacterDto characterDto)
{
_quests = new List <Quest>();
Player = @char.Player;
QuestStates = new byte[20];
Array.Fill <byte>(QuestStates, 0xff);
}
public void InstantiationTest()
{
CharacterDto dto = new CharacterDto
{
Level = 10,
ResourcePoints = 1,
Agility = 1,
Endurance = 1,
HealthPoints = 1,
ExpNextLevel = 100,
Intelligence = 1,
Strength = 1,
Id = Guid.NewGuid()
};
var intelligenceCharacter = new IntelligenceCharacter(dto);
var strengthCharacter = new StrengthCharacter(dto);
var agilityCharacter = new AgilityCharacter(dto);
Assert.AreEqual(intelligenceCharacter.MaxHealthPoint, strengthCharacter.MaxHealthPoint);
Assert.Greater(intelligenceCharacter.MaxResourcePoints, agilityCharacter.MaxResourcePoints);
Assert.Greater(agilityCharacter.MaxResourcePoints, strengthCharacter.MaxResourcePoints);
}
public async Task <Character> AddCharacter(CharacterDto character)
{
AppUserCharacter appUserChar;
var user = await _userManager.FindByEmailAsync(User.FindFirstValue(ClaimTypes.Email));
var characterInDb = _dbContext.Characters.FirstOrDefault(c => c.CharacterId == character.Id);
if (characterInDb is null)
{
appUserChar = new AppUserCharacter
{
AppUserId = user.Id,
Character = new Character
{
CharacterId = character.Id,
}
};
}
else
{
appUserChar = new AppUserCharacter
{
AppUserId = user.Id,
Character = characterInDb
};
}
await _dbContext.AppUserCharacters.AddAsync(appUserChar);
await _dbContext.SaveChangesAsync();
return(appUserChar.Character);
}
/// <summary>
/// Create a character by CharacterDto with it's Abilities (f.e. RLR character).
/// </summary>
public PlayerManager Create(CharacterDto character)
{
var playerManager = InstantiateCharacter(character.Name);
playerManager?.CharacterController.Initialize(playerManager, character);
return(playerManager);
}
protected override async Task Handle(CharNewPacketBase packet, ISession session)
{
long accountId = session.Account.Id;
byte slot = packet.Slot;
string characterName = packet.Name;
if (slot > 3)
{
return;
}
if (await _characterService.GetByAccountIdAndSlotAsync(session.Account.Id, slot) != null)
{
Log.Warn($"[CREATE_CHARACTER] SLOT_ALREADY_TAKEN {slot}");
return;
}
var rg = new Regex(@"^[\u0021-\u007E\u00A1-\u00AC\u00AE-\u00FF\u4E00-\u9FA5\u0E01-\u0E3A\u0E3F-\u0E5B\u002E]*$");
if (rg.Matches(characterName).Count != 1)
{
await session.SendPacketAsync(new InfoPacket
{
Message = _gameLanguageService.GetLanguage(PlayerMessages.CHARACTER_NAME_INVALID, session.Language)
});
Log.Warn($"[CREATE_CHARACTER] INVALID_NAME {characterName}");
return;
}
CharacterDto character = await _characterService.GetActiveByNameAsync(characterName);
if (character != null)
{
await session.SendPacketAsync(new InfoPacket
{
Message = _gameLanguageService.GetLanguage(PlayerMessages.CHARACTER_NAME_ALREADY_TAKEN, session.Language)
});
Log.Warn($"[CREATE_CHARACTER] INVALID_NAME {characterName}");
return;
}
CharacterDto newCharacter = _characterService.GetCreationCharacter();
newCharacter.Class = CharacterClassType.Adventurer;
newCharacter.Gender = packet.Gender;
newCharacter.HairColor = packet.HairColor;
newCharacter.HairStyle = packet.HairStyle;
newCharacter.Name = characterName;
newCharacter.Slot = slot;
newCharacter.AccountId = accountId;
newCharacter.MinilandMessage = "Welcome";
newCharacter.State = CharacterState.Active;
await _characterService.SaveAsync(newCharacter);
Log.Info($"[CHARACTER_CREATE] {newCharacter.Name} | Account : {session.Account.Name}");
await _screenLoader.Handle(session);
}
public BattleComponent(IEntity entity, CharacterDto dto) : this(entity)
{
var algo = Container.Instance.Resolve <IAlgorithmService>();
HpMax = algo.GetHpMax(dto.Class, dto.Level);
Hp = HpMax;
MpMax = algo.GetMpMax(dto.Class, dto.Level);
Mp = MpMax;
}
public Character LoadCharacter(CharacterDto characterDto)
{
Character character = characterDto.Adapt <Character>();
character.Inventory = _inventory;
character.ItemBuilderService = _itemBuilderService;
return(character);
}
public async Task <IActionResult> CreateCharacter([FromBody] CharacterCreateDto dto)
{
var character = await _characterService.CreateAsync(dto);
var characterDto = new CharacterDto(character);
return(Ok(characterDto));
}
public CharacterModel ToCharacterModel(CharacterDto characterDto)
{
return(new CharacterModel
{
Name = characterDto.Name,
Planet = characterDto.Planet
});
}
public string CreateCharacter(IList <string> arguments)
{
var characterName = arguments[0];
try
{
Console.WriteLine($"Please enter character's label:");
var label = Console.ReadLine();
Console.WriteLine($"Please enter character's description(at least 15characters):");
var description = Console.ReadLine();
Console.WriteLine($"Do you want to enter manually character's health and armour or use the default values?");
Console.WriteLine($"M => Manually ; D => Default values (In case of other input the default values would be choosen");
var decision = Console.ReadLine();
var hp = 0;
var armour = 0;
bool manual = false;
if (decision == "M")
{
Console.WriteLine($"Health:");
hp = int.Parse(Console.ReadLine());
Console.WriteLine($"Armour:");
armour = int.Parse(Console.ReadLine());
manual = true;
}
var characterDto = new CharacterDto
{
Name = characterName,
Label = label,
Description = description
};
var dbCharacter = new Character
{
Name = characterDto.Name,
Label = characterDto.Label,
Description = characterDto.Description
};
if (manual)
{
characterDto.Health = hp;
characterDto.Armour = armour;
dbCharacter.Hp = characterDto.Health;
dbCharacter.Armour = characterDto.Armour;
}
context.Characters.Add(dbCharacter);
context.SaveChanges();
return("Character created");
}
catch (ArgumentException ex)
{
return(ex.Message);
}
}
public override CharList AddChar(byte id, CharacterDto @char, byte[] charSet, GuildStatus gStatus)
{
var l = CharacterList.ToList();
l.Add(new CharacterPreviewS12Dto(id, @char.Name, @char.Level, (ControlCode)@char.CtlCode, charSet, gStatus, 3));
CharacterList = l.ToArray();
Count = (byte)CharacterList.Length;
return(this);
}
public async Task <IActionResult> PostAsync([FromBody] CharacterDto characterDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
return(Created("", await _characterService.CreateAsync(characterDto)));
}
public async Task <CharacterDto> UpdateAsync(int id, CharacterDto dto)
{
dto.Account = null;
CharacterModel model = await _unitOfWork.CharactersRepository.GetAsync(id);
_mapper.Map(dto, model);
await _unitOfWork.SaveAsync();
return(dto);
}
// Start is called before the first frame update
private void Start()
{
_combatService = new CombatService();
CurrentCharacter = new CharacterDto() // Devrait être choppé dans un autre service, ou dans un autre controller
{
Attack = 20,
Defense = 20,
Hp = 100
};
}
public IHttpActionResult PutCharacter(int id, CharacterDto dto)
{
if (id != dto.Id)
{
return BadRequest();
}
_metadataService.Update<Character, CharacterDto>(id, dto);
return StatusCode(HttpStatusCode.NoContent);
}
public CharacterDto Character()
{
var character = new CharacterDto
{
ColorTheme = "#323423",
Description = "desc",
Id = _characterCounter,
MainImageUrl = "http://img.com/i.png",
Name = "falco",
Style = "prefers the air",
ThumbnailUrl = "http://img.net/ii.png"
};
_characterCounter++;
return character;
}
public IHttpActionResult PostCharacter(CharacterDto dto)
{
var newDto = _metadataService.Add<Character, CharacterDto>(dto);
return CreatedAtRoute("DefaultApi", new { controller = CharactersRouteKey + "", id = newDto.Id }, newDto);
}
