public ListAddFailureEnum?CanAddFriend(WorldAccount friendAccount)
{
ListAddFailureEnum?result;
if (friendAccount.Id == this.Owner.Client.WorldAccount.Id)
{
result = new ListAddFailureEnum?(ListAddFailureEnum.LIST_ADD_FAILURE_EGOCENTRIC);
}
else
{
if (this.m_friends.ContainsKey(friendAccount.Id))
{
result = new ListAddFailureEnum?(ListAddFailureEnum.LIST_ADD_FAILURE_IS_DOUBLE);
}
else
{
if (this.m_friends.Count >= FriendsBook.MaxFriendsNumber)
{
result = new ListAddFailureEnum?(ListAddFailureEnum.LIST_ADD_FAILURE_OVER_QUOTA);
}
else
{
result = null;
}
}
}
return(result);
}
public Ignored(AccountRelation relation, WorldAccount account, bool session, Character character)
{
Relation = relation;
Session = session;
Account = account;
Character = character;
}
/// <summary>
/// Called after LoadSEconomy, or on PostInitialize, this binds the current SEconomy instance
/// to the currently running terraria world.
/// </summary>
public async Task BindToWorldAsync()
{
IBankAccount account = null;
if ((WorldAccount = RunningJournal.GetWorldAccount()) == null)
{
TShock.Log.ConsoleError("[SEconomy Bind] The journal system did not return a world account. This is an internal error.");
return;
}
await WorldAccount.SyncBalanceAsync();
TShock.Log.ConsoleInfo(string.Format(SEconomyPlugin.Locale.StringOrDefault(1, "[SEconomy World Account] Paid {0} to players."), WorldAccount.Balance.ToLongString()));
await Task.Delay(5000);
foreach (var player in TShockAPI.TShock.Players)
{
if (player == null ||
string.IsNullOrWhiteSpace(player.Name) == true
//|| string.IsNullOrWhiteSpace(player.User.Name) == true
|| (account = GetBankAccount(player)) == null)
{
continue;
}
await account.SyncBalanceAsync();
}
}
/// <summary>
/// Occurs when a player online payment needs to occur.
/// </summary>
void PayRunTimer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
{
lock (__accountSafeLock) {
if (Configuration.PayIntervalMinutes > 0 && !string.IsNullOrEmpty(Configuration.IntervalPayAmount))
{
Money payAmount;
if (Money.TryParse(Configuration.IntervalPayAmount, out payAmount))
{
if (payAmount > 0)
{
foreach (Economy.EconomyPlayer ep in economyPlayers)
{
//if the time since the player was idle is less than or equal to the configuration idle threshold
//then the player is considered not AFK.
if (ep.TimeSinceIdle.TotalMinutes <= Configuration.IdleThresholdMinutes && ep.BankAccount != null)
{
//Pay them from the world account
WorldAccount.TransferToAsync(ep.BankAccount, payAmount, Journal.BankAccountTransferOptions.AnnounceToReceiver);
}
}
}
}
}
}
}
public Ignored(AccountRelation relation, WorldAccount account, bool session, Character character)
{
this.Relation = relation;
this.Session = session;
this.Account = account;
this.Character = character;
}
public static void HandleIgnoredAddRequestMessage(WorldClient client, IgnoredAddRequestMessage message)
{
Character character = Singleton <World> .Instance.GetCharacter(message.name);
if (character != null)
{
if (character.UserGroup.Role == RoleEnum.Player)
{
client.Character.FriendsBook.AddIgnored(character.Client.WorldAccount, message.session);
}
else
{
FriendHandler.SendFriendAddFailureMessage(client, ListAddFailureEnum.LIST_ADD_FAILURE_NOT_FOUND);
}
}
else
{
ServerBase <WorldServer> .Instance.IOTaskPool.AddMessage(delegate
{
WorldAccount record = Singleton <AccountManager> .Instance.FindByNickname(message.name);
if (record != null && client.Character.Context != null)
{
client.Character.Context.ExecuteInContext(delegate
{
client.Character.FriendsBook.AddIgnored(record, message.session);
});
}
else
{
FriendHandler.SendIgnoredAddFailureMessage(client, ListAddFailureEnum.LIST_ADD_FAILURE_NOT_FOUND);
}
});
}
}
public IEnumerable <Merchant> UnActiveMerchantFromAccount(WorldAccount account)
{
var merchants = m_activeMerchants.Where(x => x.IsMerchantOwner(account)).ToArray();
foreach (var merchant in merchants)
{
UnActiveMerchant(merchant);
yield return(merchant);
}
}
public WorldAccount CreateWorldAccount(WorldClient client)
{
WorldAccount worldAccount = new WorldAccount
{
Id = client.Account.Id,
Nickname = client.Account.Nickname
};
base.Database.Insert(worldAccount);
return(worldAccount);
}
public bool AddFriend(WorldAccount friendAccount)
{
var result = CanAddFriend(friendAccount);
if (result != null)
{
FriendHandler.SendFriendAddFailureMessage(Owner.Client, result.Value);
return(false);
}
var relation = new AccountRelation
{
AccountId = Owner.Client.Account.Id,
TargetId = friendAccount.Id,
Type = AccountRelationType.Friend
};
m_relations.AddOrUpdate(relation.TargetId, relation, (key, value) =>
{
value.Type = AccountRelationType.Friend;
return(value);
});
Friend friend;
var isConnected = friendAccount.ConnectedCharacter.HasValue;
if (isConnected)
{
var character = World.Instance.GetCharacter(friendAccount.ConnectedCharacter.Value);
friend = new Friend(relation, friendAccount, character);
}
else
{
friend = new Friend(relation, friendAccount);
}
var success = m_friends.TryAdd(friendAccount.Id, friend);
if (success && isConnected)
{
OnFriendOnline(friend);
}
else
{
friend.SetOffline();
}
FriendHandler.SendFriendAddedMessage(Owner.Client, friend);
return(success);
}
private static void OnAccountReceived(AccountAnswerMessage message, WorldClient client)
{
lock (ApproachHandler.ConnectionQueue.SyncRoot)
{
ApproachHandler.ConnectionQueue.Remove(client);
}
if (client.QueueShowed)
{
ApproachHandler.SendQueueStatusMessage(client, 0, 0);
}
AccountData account = message.Account;
if (account == null)
{
client.Send(new AuthenticationTicketRefusedMessage());
client.DisconnectLater(1000);
}
else
{
WorldAccount worldAccount = Singleton <AccountManager> .Instance.FindById(account.Id);
if (worldAccount != null)
{
client.WorldAccount = worldAccount;
if (client.WorldAccount.ConnectedCharacter.HasValue)
{
Character character = Singleton <World> .Instance.GetCharacter(client.WorldAccount.ConnectedCharacter.Value);
if (character != null)
{
character.LogOut();
}
}
}
client.SetCurrentAccount(account);
client.Send(new AuthenticationTicketAcceptedMessage());
BasicHandler.SendBasicTimeMessage(client);
ApproachHandler.SendServerOptionalFeaturesMessage(client, new sbyte[1] {
7
});
ApproachHandler.SendAccountCapabilitiesMessage(client);
client.Send(new TrustStatusMessage(true, false));
if (client.UserGroup.Role >= RoleEnum.Moderator)
{
ApproachHandler.SendConsoleCommandsListMessage(client);
}
}
}
public WorldAccount CreateWorldAccount(WorldClient client)
{
/* Create WorldAccount */
var worldAccount = new WorldAccount
{
Id = client.Account.Id,
Nickname = client.Account.Nickname,
Tokens = 0,
NewTokens = 0
};
Database.Insert(worldAccount);
return(worldAccount);
}
public void Load()
{
this.m_relations = new ConcurrentDictionary <int, AccountRelation>(ServerBase <WorldServer> .Instance.DBAccessor.Database.Query <AccountRelation>(string.Format(AccountRelationRelator.FetchByAccount, this.Owner.Account.Id), new object[0]).ToDictionary((AccountRelation x) => x.AccountId, (AccountRelation x) => x));
foreach (AccountRelation current in this.m_relations.Values)
{
WorldAccount worldAccount = Singleton <World> .Instance.GetConnectedAccount(current.TargetId) ?? Singleton <AccountManager> .Instance.FindById(current.TargetId);
if (worldAccount == null)
{
ServerBase <WorldServer> .Instance.DBAccessor.Database.Delete(current);
}
else
{
switch (current.Type)
{
case AccountRelationType.Friend:
if (worldAccount.ConnectedCharacter.HasValue)
{
Character character = Singleton <World> .Instance.GetCharacter(worldAccount.ConnectedCharacter.Value);
this.m_friends.TryAdd(worldAccount.Id, new Friend(current, worldAccount, character));
}
else
{
this.m_friends.TryAdd(worldAccount.Id, new Friend(current, worldAccount));
}
break;
case AccountRelationType.Ignored:
if (worldAccount.ConnectedCharacter.HasValue)
{
Character character = Singleton <World> .Instance.GetCharacter(worldAccount.ConnectedCharacter.Value);
this.m_ignoreds.TryAdd(worldAccount.Id, new Ignored(current, worldAccount, false, character));
}
else
{
this.m_ignoreds.TryAdd(worldAccount.Id, new Ignored(current, worldAccount, false));
}
break;
}
}
}
Singleton <World> .Instance.CharacterJoined += new System.Action <Character>(this.OnCharacterLogIn);
}
public bool AddIgnored(WorldAccount ignoredAccount, bool session = false)
{
var result = CanAddIgnored(ignoredAccount);
if (result != null)
{
FriendHandler.SendIgnoredAddFailureMessage(Owner.Client, result.Value);
return(false);
}
var relation = new AccountRelation
{
AccountId = Owner.Client.Account.Id,
TargetId = ignoredAccount.Id,
Type = AccountRelationType.Ignored
};
if (!session)
{
m_relations.AddOrUpdate(relation.TargetId, relation, (key, value) =>
{
value.Type = AccountRelationType.Ignored;
return(value);
});
}
Ignored ignored;
if (ignoredAccount.ConnectedCharacter.HasValue)
{
var character = World.Instance.GetCharacter(ignoredAccount.ConnectedCharacter.Value);
ignored = new Ignored(relation, ignoredAccount, session, character);
}
else
{
ignored = new Ignored(relation, ignoredAccount, session);
}
var success = m_ignoreds.TryAdd(ignoredAccount.Id, ignored);
FriendHandler.SendIgnoredAddedMessage(Owner.Client, ignored, session);
return(success);
}
public bool AddFriend(WorldAccount friendAccount)
{
ListAddFailureEnum?listAddFailureEnum = this.CanAddFriend(friendAccount);
bool result;
if (listAddFailureEnum.HasValue)
{
FriendHandler.SendFriendAddFailureMessage(this.Owner.Client, listAddFailureEnum.Value);
result = false;
}
else
{
AccountRelation accountRelation = new AccountRelation
{
AccountId = this.Owner.Client.Account.Id,
TargetId = friendAccount.Id,
Type = AccountRelationType.Friend
};
this.m_relations.AddOrUpdate(accountRelation.TargetId, accountRelation, delegate(int key, AccountRelation value)
{
value.Type = AccountRelationType.Friend;
return(value);
});
bool flag;
if (friendAccount.ConnectedCharacter.HasValue)
{
Character character = Singleton <World> .Instance.GetCharacter(friendAccount.ConnectedCharacter.Value);
Friend friend = new Friend(accountRelation, friendAccount, character);
if (flag = this.m_friends.TryAdd(friendAccount.Id, friend))
{
this.OnFriendOnline(friend);
}
}
else
{
flag = this.m_friends.TryAdd(friendAccount.Id, new Friend(accountRelation, friendAccount));
}
FriendHandler.SendFriendsListMessage(this.Owner.Client, this.Friends);
result = flag;
}
return(result);
}
ListAddFailureEnum?CanAddFriend(WorldAccount friendAccount)
{
if (friendAccount.Id == Owner.Client.WorldAccount.Id)
{
return(ListAddFailureEnum.LIST_ADD_FAILURE_EGOCENTRIC);
}
if (IsIgnored(friendAccount.Id) || IsFriend(friendAccount.Id))
{
return(ListAddFailureEnum.LIST_ADD_FAILURE_IS_DOUBLE);
}
if (m_friends.Count >= MaxFriendsNumber)
{
return(ListAddFailureEnum.LIST_ADD_FAILURE_OVER_QUOTA);
}
return(null);
}
public bool AddIgnored(WorldAccount ignoredAccount, bool session = false)
{
ListAddFailureEnum?listAddFailureEnum = this.CanAddIgnored(ignoredAccount);
bool result;
if (listAddFailureEnum.HasValue)
{
FriendHandler.SendIgnoredAddFailureMessage(this.Owner.Client, listAddFailureEnum.Value);
result = false;
}
else
{
AccountRelation accountRelation = new AccountRelation
{
AccountId = this.Owner.Client.Account.Id,
TargetId = ignoredAccount.Id,
Type = AccountRelationType.Ignored
};
if (!session)
{
this.m_relations.AddOrUpdate(accountRelation.TargetId, accountRelation, delegate(int key, AccountRelation value)
{
value.Type = AccountRelationType.Ignored;
return(value);
});
}
bool flag;
if (ignoredAccount.ConnectedCharacter.HasValue)
{
Character character = Singleton <World> .Instance.GetCharacter(ignoredAccount.ConnectedCharacter.Value);
flag = this.m_ignoreds.TryAdd(ignoredAccount.Id, new Ignored(accountRelation, ignoredAccount, session, character));
}
else
{
flag = this.m_ignoreds.TryAdd(ignoredAccount.Id, new Ignored(accountRelation, ignoredAccount, session));
}
FriendHandler.SendIgnoredListMessage(this.Owner.Client, this.Ignoreds);
result = flag;
}
return(result);
}
public bool IsMerchantOwner(WorldAccount account)
{
return(account.Id == this.m_record.AccountId);
}
public System.Collections.Generic.IEnumerable <Merchant> UnActiveMerchantFromAccount(WorldAccount account)
{
var merchants = m_activeMerchants.Where(entry => entry.IsMerchantOwner(account)).ToArray();
foreach (Merchant merchant in merchants)
{
this.UnActiveMerchant(merchant);
yield return(merchant);
}
}
public Ignored(AccountRelation relation, WorldAccount account, bool session)
{
Relation = relation;
Session = session;
Account = account;
}
public void UnBlockAccount(WorldAccount account)
{
Tuple <Character, DateTime> dummy;
m_blockedAccount.TryRemove(account.Id, out dummy);
}
// block this account
public void BlockAccount(WorldAccount account, Character character)
{
m_blockedAccount.TryAdd(account.Id, Tuple.Create(character, DateTime.Now));
}
public bool IsMerchantOwner(WorldAccount account) => account.Id == m_record.AccountId;
public Friend(AccountRelation relation, WorldAccount account)
{
this.Relation = relation;
this.Account = account;
}
public Friend(AccountRelation relation, WorldAccount account)
{
Relation = relation;
Account = account;
}
public Friend(AccountRelation relation, WorldAccount account, Character character)
{
Relation = relation;
Account = account;
Character = character;
}
public Friend(AccountRelation relation, WorldAccount account, Character character)
{
this.Relation = relation;
this.Account = account;
this.Character = character;
}
public Ignored(AccountRelation relation, WorldAccount account, bool session)
{
this.Relation = relation;
this.Session = session;
this.Account = account;
}
