private async Task SeedCharacterRolesAsync(WowGuildManagerDbContext context) { var roleNames = new List <string> { CharacterRoleConstants.Tank, CharacterRoleConstants.Healer, CharacterRoleConstants.Damage }; var characterRoles = new List <CharacterRole>(); foreach (var roleName in roleNames) { var characterRole = new CharacterRole { Name = roleName }; characterRoles.Add(characterRole); } await context.CharacterRoles.AddRangeAsync(characterRoles); await context.SaveChangesAsync(); }
public async Task <CreateEntityResult <CharacterRole> > CreateCharacterRoleAsync ( [NotNull] IRole role, RoleAccess access ) { var getExistingRoleResult = await GetCharacterRoleAsync(role); if (getExistingRoleResult.IsSuccess) { return(CreateEntityResult <CharacterRole> .FromError ( "That role is already registered as a character role." )); } var getServerResult = await _servers.GetOrRegisterServerAsync(role.Guild); if (!getServerResult.IsSuccess) { return(CreateEntityResult <CharacterRole> .FromError(getServerResult)); } var server = getServerResult.Entity; var characterRole = new CharacterRole(server, (long)role.Id, access); _database.CharacterRoles.Update(characterRole); await _database.SaveChangesAsync(); return(CreateEntityResult <CharacterRole> .FromSuccess(characterRole)); }
public override void OnInspectorGUI() { serializedObject.Update(); EditorGUI.BeginChangeCheck(); EditorGUILayout.PropertyField(serializedObject.FindProperty("StepsToPlan")); EditorGUILayout.PropertyField(serializedObject.FindProperty("SequenceString")); EditorGUILayout.PropertyField(serializedObject.FindProperty("MyRole")); EditorGUILayout.PropertyField(serializedObject.FindProperty("AgentNeeds"), true); if (EditorGUI.EndChangeCheck()) { serializedObject.ApplyModifiedProperties(); } EditorUtility.SetDirty(human); if(GUILayout.Button("LoadNeeds")) { human.GetMyNeeds(); } if (role != human.MyRole) { human.GetMyNeeds(); role = human.MyRole; } }
public Need() { Name = "NeedName"; Value = 0f; IncreaseValue = 0f; Importance = 0f; Role = CharacterRole.Human; }
public Need(Need need) { Name = need.Name; Value = need.Value; IncreaseValue = need.IncreaseValue; Importance = need.Importance; Role = need.Role; }
private void Start() { myStats = GetComponent <CharacterStats>(); manaBar_UI = GameManager.instance.manaBar_UI; manaBar_Text = manaBar_UI.GetComponentInChildren <Text>(); charRole = myStats.role; }
public void SetUpCharacter(CharacterRole role) { Ticker.currentBlock = TimelineHolder.Instance.GetCurrentBlock(); int current_frame = Ticker.Instance.GetCurrentTick; Ticker.Instance.Initialize(); Ticker.Instance.Scrum(current_frame - 1); }
public Need(string name, float value = 0f, float increaseValue = 0f, float importance = 0f,CharacterRole role = CharacterRole.Human) { Name = name; Value = value; IncreaseValue = increaseValue; Importance = importance; Role = role; }
public async Task <DeleteEntityResult> DeleteCharacterRoleAsync ( [NotNull] CharacterRole role ) { _database.CharacterRoles.Remove(role); await _database.SaveChangesAsync(); return(DeleteEntityResult.FromSuccess()); }
public override async Task InitializeAsync() { var result = await this.Characters.CreateCharacterRoleAsync ( _discordRole, RoleAccess.Open ); _role = result.Entity; }
/// <summary> /// Sets the custom role of a character. /// </summary> /// <param name="guildID">The ID of the guild the user is on.</param> /// <param name="userID">The ID of the discord user.</param> /// <param name="character">The character.</param> /// <param name="characterRole">The role to set.</param> /// <param name="ct">The cancellation token in use.</param> /// <returns>A modification result which may or may not have succeeded.</returns> public async Task <Result> SetCharacterRoleAsync ( Snowflake guildID, Snowflake userID, Character character, CharacterRole characterRole, CancellationToken ct = default ) { if (character.Role == characterRole) { return(new UserError("The character already has that role.")); } if (character.IsCurrent) { if (character.Role is not null) { var removeRole = await _guildAPI.RemoveGuildMemberRoleAsync ( guildID, userID, character.Role.DiscordID, ct : ct ); if (!removeRole.IsSuccess) { if (removeRole.Error is not RestResultError <RestError> rre) { return(removeRole); } if (rre.Error.Code is not DiscordError.UnknownRole) { return(removeRole); } // It's probably already removed; that's fine } } var addRole = await _guildAPI.AddGuildMemberRoleAsync(guildID, userID, characterRole.DiscordID, ct : ct); if (!addRole.IsSuccess) { return(addRole); } } character.Role = characterRole; await _database.SaveChangesAsync(ct); return(Result.FromSuccess()); }
public bool CanPerformRole(CharacterRole role) { foreach (CharacterRole cRole in Roles) { if (cRole == role) { return(true); } } return(false); }
public CharacterBehavior(CharacterRole role, string ownName) { Role = role; OwnName = ownName; MyAction = Action.Idle; MyDesire = Desire.Nothing; MyAnimation = AnimationStyle.Idle; InebriationLevel = 0; LastDecisionDuration = float.PositiveInfinity; MovementSpeed = 0; }
/// <summary> /// Sets the access conditions for the given character role. /// </summary> /// <param name="role">The character role.</param> /// <param name="access">The access conditions.</param> /// <returns>A modification result which may or may not have succeeded.</returns> public async Task <ModifyEntityResult> SetCharacterRoleAccessAsync(CharacterRole role, RoleAccess access) { if (role.Access == access) { return(ModifyEntityResult.FromError("The role already has those access conditions.")); } role.Access = access; await _database.SaveChangesAsync(); return(ModifyEntityResult.FromSuccess()); }
public override async Task InitializeAsync() { var guild = MockHelper.CreateDiscordGuild(0); var discordRole = MockHelper.CreateDiscordRole(1, guild); var result = await this.Characters.CreateCharacterRoleAsync ( discordRole, RoleAccess.Open ); _role = result.Entity; }
public List <GameplayEffect> GetStartingEffects(CharacterRole Role) { switch (Role) { case CharacterRole.Barbarian: return(Barbarian.StartingEffects); case CharacterRole.Assassin: return(Assassin.StartingEffects); case CharacterRole.Necromancer: return(Necromanacer.StartingEffects); } Debug.Assert(false, "Bad role"); return(new List <GameplayEffect>()); }
public List <AttributeEntry> GetStartingAttributes(CharacterRole Role) { switch (Role) { case CharacterRole.Barbarian: return(Barbarian.StartingAttributeSet); case CharacterRole.Assassin: return(Assassin.StartingAttributeSet); case CharacterRole.Necromancer: return(Necromanacer.StartingAttributeSet); } Debug.Assert(false, "Bad role"); return(new List <AttributeEntry>()); }
/// <summary> /// Deletes the character role for the given Discord role. /// </summary> /// <param name="role">The character role.</param> /// <param name="ct">The cancellation token in use.</param> /// <returns>A deletion result which may or may not have succeeded.</returns> public async Task <DeleteEntityResult> DeleteCharacterRoleAsync ( CharacterRole role, CancellationToken ct = default ) { var currentOwnersWithRole = await _database.Characters.ServerScopedServersideQueryAsync ( role.Server, q => q .Where(c => c.Role == role) .Where(c => c.IsCurrent) .Select(c => c.Owner) .Distinct(), ct ); _database.CharacterRoles.Remove(role); var guild = await _client.GetGuildAsync((ulong)role.Server.DiscordID); if (guild is null) { return(DeleteEntityResult.FromError("Could not retrieve the guild the role was on.")); } foreach (var characterOwner in currentOwnersWithRole) { var owner = await guild.GetUserAsync((ulong)characterOwner.DiscordID); var discordRole = guild.GetRole((ulong)role.DiscordID); if (owner is null || discordRole is null) { return(DeleteEntityResult.FromError("Failed to get the owner or role.")); } var removeRole = await _discord.RemoveUserRoleAsync(owner, discordRole); if (!removeRole.IsSuccess) { return(DeleteEntityResult.FromError(removeRole)); } } await _database.SaveChangesAsync(ct); return(DeleteEntityResult.FromSuccess()); }
/// <summary> /// Sets the custom role of a character. /// </summary> /// <param name="guildUser">The owner of the character.</param> /// <param name="character">The character.</param> /// <param name="characterRole">The role to set.</param> /// <param name="ct">The cancellation token in use.</param> /// <returns>A modification result which may or may not have succeeded.</returns> public async Task <ModifyEntityResult> SetCharacterRoleAsync ( IGuildUser guildUser, Character character, CharacterRole characterRole, CancellationToken ct = default ) { if (character.Role == characterRole) { return(ModifyEntityResult.FromError("The character already has that role.")); } if (character.IsCurrent) { if (!(character.Role is null)) { var oldRole = guildUser.Guild.GetRole((ulong)character.Role.DiscordID); if (!(oldRole is null)) { var removeRole = await _discord.RemoveUserRoleAsync(guildUser, oldRole); if (!removeRole.IsSuccess) { return(removeRole); } } } var newRole = guildUser.Guild.GetRole((ulong)characterRole.DiscordID); if (newRole is null) { return(ModifyEntityResult.FromError("Failed to get the new role.")); } var addRole = await _discord.AddUserRoleAsync(guildUser, newRole); if (!addRole.IsSuccess) { return(addRole); } } character.Role = characterRole; await _database.SaveChangesAsync(ct); return(ModifyEntityResult.FromSuccess()); }
//for the temp object will copy all stats in prefab of that goblin pre set public void AddMember(Entity ent) { this.name = ent.name; this.image = ent.image; this.chanceEncounter = ent.chanceEncounter; this.role = ent.role; this.weakness = ent.weakness; this.invulnerable = ent.invulnerable; this.weakness = ent.weakness; this.level = ent.level; this.hitPoints = ent.hitPoints; this.maxHitPoints = ent.maxHitPoints; this.damage = ent.damage; this.magicDamage = ent.magicDamage; this.specialDamage = ent.specialDamage; }
/// <summary> /// Sets the access conditions for the given character role. /// </summary> /// <param name="role">The character role.</param> /// <param name="access">The access conditions.</param> /// <param name="ct">The cancellation token in use.</param> /// <returns>A modification result which may or may not have succeeded.</returns> public async Task <Result> SetCharacterRoleAccessAsync ( CharacterRole role, RoleAccess access, CancellationToken ct = default ) { if (role.Access == access) { return(new UserError("The role already has those access conditions.")); } role.Access = access; await _database.SaveChangesAsync(ct); return(Result.FromSuccess()); }
public static bool IsFromRole(CharacterType type, CharacterRole role) { if (type == CharacterType.None) { return(false); } if (role == CharacterRole.None) { return(false); } if (type == CharacterType.PendingWillFill || type == CharacterType.FemaleWillFill) { return(true); } return(Roles[role].Contains(type)); }
public static bool IsGoodRole(CharacterRole role) { switch (role) { case CharacterRole.Good: case CharacterRole.Percival: case CharacterRole.Merlin: return(true); case CharacterRole.Evil: case CharacterRole.Assassin: case CharacterRole.Morgana: case CharacterRole.Mordred: case CharacterRole.Oberon: default: return(false); } }
public override async Task InitializeAsync() { var user = (await this.Users.GetOrRegisterUserAsync(_owner)).Entity; _character = new Character((long)_guild.Id, user, CharacterName); this.Database.Characters.Update(_character); var createRoleResult = await this.Characters.CreateCharacterRoleAsync ( MockHelper.CreateDiscordRole(2, _guild), RoleAccess.Open ); _role = createRoleResult.Entity; await this.Database.SaveChangesAsync(); }
// CTOR public tnCharacterData(tnCharacterDataDescriptor i_Descriptor) { if (i_Descriptor != null) { m_FirstName = i_Descriptor.firstName; m_LastName = i_Descriptor.lastName; m_DisplayName = i_Descriptor.displayName; m_Role = i_Descriptor.role; m_Number = i_Descriptor.number; m_HasSpecificPrefab = i_Descriptor.useDifferentPrefab; m_PrefabPath = i_Descriptor.prefabPath; m_AnimatorController = i_Descriptor.animatorController; m_UIIconFacingRight = i_Descriptor.uiIconFacingRight; m_UIIconFacingLeft = i_Descriptor.uiIconFacingLeft; } }
public async Task <ModifyEntityResult> SetCharacterRoleAsync ( [NotNull] Character character, [NotNull] CharacterRole characterRole ) { if (character.Role == characterRole) { return(ModifyEntityResult.FromError ( "The character already has that role." )); } character.Role = characterRole; await _database.SaveChangesAsync(); return(ModifyEntityResult.FromSuccess()); }
/// <summary> /// Deletes the character role for the given Discord role. /// </summary> /// <param name="role">The character role.</param> /// <param name="ct">The cancellation token in use.</param> /// <returns>A deletion result which may or may not have succeeded.</returns> public async Task <Result> DeleteCharacterRoleAsync ( CharacterRole role, CancellationToken ct = default ) { var currentOwnersWithRole = await _database.Characters.ServersideQueryAsync ( q => q .Where(c => c.Server == role.Server) .Where(c => c.Role == role) .Where(c => c.IsCurrent) .Select(c => c.Owner) .Distinct(), ct ); _database.CharacterRoles.Remove(role); foreach (var characterOwner in currentOwnersWithRole) { var removeRole = await _guildAPI.RemoveGuildMemberRoleAsync ( role.Server.DiscordID, characterOwner.DiscordID, role.DiscordID, ct : ct ); if (!removeRole.IsSuccess) { return(removeRole); } } await _database.SaveChangesAsync(ct); return(Result.FromSuccess()); }
/// <summary> /// Deletes the character role for the given Discord role. /// </summary> /// <param name="role">The character role.</param> /// <returns>A deletion result which may or may not have succeeded.</returns> public async Task <DeleteEntityResult> DeleteCharacterRoleAsync(CharacterRole role) { var currentCharactersWithRole = await _characters.GetCharacters(role.Server) .Where(c => c.Role == role) .Where(c => c.IsCurrent) .ToListAsync(); _database.CharacterRoles.Remove(role); await _database.SaveChangesAsync(); var guild = await _client.GetGuildAsync((ulong)role.Server.DiscordID); if (guild is null) { return(DeleteEntityResult.FromError("Could not retrieve the guild the role was on.")); } foreach (var character in currentCharactersWithRole) { var owner = await guild.GetUserAsync((ulong)character.Owner.DiscordID); var discordRole = guild.GetRole((ulong)role.DiscordID); if (owner is null || discordRole is null) { return(DeleteEntityResult.FromError("Failed to get the owner or role.")); } var removeRole = await _discord.RemoveUserRoleAsync(owner, discordRole); if (!removeRole.IsSuccess) { return(DeleteEntityResult.FromError(removeRole)); } } return(DeleteEntityResult.FromSuccess()); }
public void SetCharacter(CharacterRole character) { this.character = character; }
public void Awake() { human = (Human)target; role = human.MyRole; }
public bool Applicable(CharacterRole characterMask) { return((characterMask & applicableMask) != CharacterRole.NA); }
/// <summary> /// The order the results will be returned in. /// </summary> public GraphQueryArgument <CharacterRole> RoleQueryArgument(CharacterRole value) { return(Role.GetQueryArgumentAndSetValue(value)); }
internal VisualNovelMetadata(UInt32 Id, UInt32 ReleaseId, SpoilerLevel spoilerLevel, CharacterRole characterRole) { this.Id = Id; this.ReleaseId = ReleaseId; this.SpoilerLevel = spoilerLevel; this.Role = characterRole; }
public Player(int id, string name) { this.id = id; this.playerName = name; this.character = CharacterRole.Resistance; }
public Character(Tile tile, CharacterRole charRole) { CurrTile = DestTile = nextTile = tile; this.CharRole = charRole; }