public void IgnoreAccount(DbAccount target, DbAccount acc, bool add)
{
var ignoreList = target.IgnoreList.ToList();
if (ignoreList.Contains(acc.AccountId) && add)
{
return;
}
if (add)
{
ignoreList.Add(acc.AccountId);
}
else
{
ignoreList.Remove(acc.AccountId);
}
target.IgnoreList = ignoreList.ToArray();
target.FlushAsync();
}
public LoginStatus Verify(string uuid, string password, out DbAccount acc)
{
acc = null;
var info = new DbLoginInfo(this, uuid);
if (info.IsNull)
{
return(LoginStatus.AccountNotExists);
}
var userPass = Utils.SHA1(password + info.Salt);
if (Convert.ToBase64String(userPass) != info.HashedPassword)
{
return(LoginStatus.InvalidCredentials);
}
acc = new DbAccount(this, info.AccountId);
return(LoginStatus.OK);
}
public bool CheckPackage(DbAccount acc, int package, int maxpurchases)
{
List <int> packageList = acc.PurchasedPackages.ToList();
int purchases = 0;
foreach (IGrouping <int, int> i in packageList.GroupBy(j => j))
{
if (i.Key == package)
{
purchases = i.Count();
}
}
if (purchases < maxpurchases)
{
return(true);
}
else
{
return(false);
}
}
public bool CheckMysteryBox(DbAccount acc, int box, int total)
{
List <int> boxList = acc.PurchasedBoxes.ToList();
int purchases = 0;
foreach (IGrouping <int, int> i in boxList.GroupBy(j => j))
{
if (i.Key == box)
{
purchases = i.Count();
}
}
if (purchases < total)
{
return(true);
}
else
{
return(false);
}
}
public bool RenameIGN(DbAccount acc, string newName, string lockToken)
{
if (defaultNames.Contains(newName, StringComparer.InvariantCultureIgnoreCase))
{
return(false);
}
using (var trans = CreateTransaction())
{
trans.AddCondition(Condition.KeyEquals(1, NAME_LOCK, lockToken));
Hashes.Remove(0, "names", acc.Name.ToUpperInvariant());
Hashes.Set(0, "names", newName.ToUpperInvariant(), acc.AccountId.ToString());
if (!trans.Execute().Exec())
{
return(false);
}
}
acc.Name = newName;
acc.NameChosen = true;
acc.Flush();
return(true);
}
public void LockAccount(DbAccount target, DbAccount acc, bool add)
{
var lockList = target.LockList.ToList();
if (lockList.Contains(acc.AccountId) && add)
{
return;
}
if (add)
{
lockList.Add(acc.AccountId);
}
else
{
lockList.Remove(acc.AccountId);
}
target.LockList = lockList.ToArray();
target.FlushAsync();
}
private void UpdateAccountCurrency(DbAccount acc, CurrencyType type, int value, bool total = false)
{
switch (type)
{
case CurrencyType.Gold:
if (total)
{
acc.TotalCredits = value;
}
else
{
acc.Credits = value;
}
break;
case CurrencyType.Fame:
if (total)
{
acc.TotalFame = value;
}
else
{
acc.Fame = value;
}
break;
case CurrencyType.Tokens:
if (total)
{
acc.TotalTokens = value;
}
else
{
acc.Tokens = value;
}
break;
}
}
public DbDeath(DbAccount acc, int charId)
{
Account = acc;
CharId = charId;
Init(acc.Database, "death." + acc.AccountId + "." + charId);
}
public DbClassStats(DbAccount acc)
{
Account = acc;
Init(acc.Database, "classStats." + acc.AccountId);
}
public DbVault ReadVault(DbAccount acc)
{
return(new DbVault(acc));
}
private void UpdatePlayerGuildFame(DbAccount acc, int amount)
{
acc.GuildFame = (int)_db.HashIncrement(acc.Key, "guildFame", amount);
}
public RegisterStatus Register(string uuid, string password, bool isGuest, out DbAccount acc)
{
var newAccounts = _resources.Settings.NewAccounts;
acc = null;
if (!_db.HashSet("logins", uuid.ToUpperInvariant(), "{}", When.NotExists))
{
return(RegisterStatus.UsedName);
}
int newAccId = (int)_db.StringIncrement("nextAccId");
acc = new DbAccount(_db, newAccId)
{
UUID = uuid,
Name = GuestNames[(uint)uuid.GetHashCode() % GuestNames.Length],
Admin = false,
NameChosen = false,
FirstDeath = true,
GuildId = 0,
GuildRank = 0,
VaultCount = newAccounts.VaultCount,
MaxCharSlot = newAccounts.MaxCharSlot,
RegTime = DateTime.Now,
Guest = isGuest,
Fame = newAccounts.Fame,
TotalFame = newAccounts.Fame,
Credits = newAccounts.Credits,
TotalCredits = newAccounts.Credits,
PassResetToken = "",
LastSeen = (Int32)(DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1))).TotalSeconds
};
if (newAccounts.SkinsUnlocked)
{
acc.Skins = (from skin in _resources.GameData.Skins.Values
select skin.Type).ToArray();
}
acc.FlushAsync();
DbLoginInfo login = new DbLoginInfo(_db, uuid);
byte[] x = new byte[0x10];
gen.GetNonZeroBytes(x);
string salt = Convert.ToBase64String(x);
string hash = Convert.ToBase64String(Utils.SHA1(password + salt));
login.HashedPassword = hash;
login.Salt = salt;
login.AccountId = acc.AccountId;
login.Flush();
DbClassStats stats = new DbClassStats(acc);
if (newAccounts.ClassesUnlocked)
{
foreach (var @class in _resources.GameData.Classes.Keys)
{
stats.Unlock(@class);
}
}
stats.FlushAsync();
return(RegisterStatus.OK);
}
public IDisposable Lock(DbAccount acc)
{
return(new l(this, acc));
}
public DbVault ReadVault(DbAccount acc) => new DbVault(acc);
public DbClassStats ReadClassStats(DbAccount acc) => new DbClassStats(acc);
public TimeSpan?GetLockTime(DbAccount acc)
{
return(_db.KeyTimeToLive($"lock:{acc.AccountId}"));
}
public l(Database db, DbAccount acc)
{
this.db = db;
this.acc = acc;
lockOk = db.AcquireLock(acc);
}
public void VerifyAge(DbAccount acc)
{
Hashes.Set(0, acc.Key, "isAgeVerified", "1");
acc.Flush();
acc.Reload();
}
public void Guest(DbAccount acc, bool isGuest)
{
acc.Guest = isGuest;
acc.FlushAsync();
}
// Market
public void AddPlayerOffer(DbAccount acc, int id) => AddPlayerOffers(acc, new int[] { id });
public void ReloadAccount(DbAccount acc)
{
acc.FlushAsync();
acc.Reload();
}
public void AddGift(DbAccount acc, ushort item) => AddGifts(acc, new ushort[] { item });
public DbClassStats ReadClassStats(DbAccount acc)
{
return(new DbClassStats(acc));
}
public DbCharInv(DbAccount acc, int charId)
{
Field = "items";
Init(acc.Database, "char." + acc.AccountId + "." + charId, Field);
}
public int CreateGiftChest(DbAccount acc)
{
var id = (int)_db.HashIncrement(acc.Key, "giftCount");
return(id);
}
public DbClassStats(DbAccount acc, ushort?type = null)
{
Account = acc;
Init(acc.Database, "classStats." + acc.AccountId, type?.ToString());
}
internal DbChar(DbAccount acc, int charId)
{
Account = acc;
CharId = charId;
Init(acc.Database, "char." + acc.AccountId + "." + charId);
}
public DbClassAvailability(DbAccount acc)
{
Account = acc;
Init(acc.Database, $"classAvailability.{acc.AccountId}");
}
public DbVault(DbAccount acc)
{
Account = acc;
Init(acc.Database, "vault." + acc.AccountId);
}
public CreateStatus CreateCharacter(DbAccount acc, ushort type, ushort skinType, out DbChar character)
{
if (_db.SetLength("alive." + acc.AccountId) >= acc.MaxCharSlot)
{
character = null;
return(CreateStatus.ReachCharLimit);
}
// check skin requirements
if (skinType != 0)
{
var skinDesc = _resources.GameData.Skins[skinType];
if (!acc.Skins.Contains(skinType) ||
skinDesc.PlayerClassType != type)
{
character = null;
return(CreateStatus.SkinUnavailable);
}
}
var objDesc = _resources.GameData.ObjectDescs[type];
var playerDesc = _resources.GameData.Classes[type];
var classStats = ReadClassStats(acc);
var unlockClass = (playerDesc.Unlock != null)
? playerDesc.Unlock.Type
: null;
// check to see if account has unlocked via gold
if (classStats.AllKeys
.All(x => (ushort)(int)x != type))
{
// check to see if account meets unlock requirements
if ((unlockClass != null && classStats[(ushort)unlockClass].BestLevel < playerDesc.Unlock.Level))
{
character = null;
return(CreateStatus.Locked);
}
}
var newId = (int)_db.HashIncrement(acc.Key, "nextCharId");
var newCharacters = _resources.Settings.NewCharacters;
character = new DbChar(acc, newId)
{
ObjectType = type,
Level = newCharacters.Level,
Experience = 0,
Fame = 0,
Items = InitInventory(playerDesc.Equipment),
Stats = new int[]
{
playerDesc.Stats[0].StartingValue,
playerDesc.Stats[1].StartingValue,
playerDesc.Stats[2].StartingValue,
playerDesc.Stats[3].StartingValue,
playerDesc.Stats[4].StartingValue,
playerDesc.Stats[5].StartingValue,
playerDesc.Stats[6].StartingValue,
playerDesc.Stats[7].StartingValue,
},
HP = playerDesc.Stats[0].StartingValue,
MP = playerDesc.Stats[1].StartingValue,
Tex1 = 0,
Tex2 = 0,
Skin = skinType,
PetId = 0,
FameStats = new byte[0],
CreateTime = DateTime.Now,
LastSeen = DateTime.Now
};
if (newCharacters.Maxed)
{
character.Stats = new int[]
{
playerDesc.Stats[0].MaxValue,
playerDesc.Stats[1].MaxValue,
playerDesc.Stats[2].MaxValue,
playerDesc.Stats[3].MaxValue,
playerDesc.Stats[4].MaxValue,
playerDesc.Stats[5].MaxValue,
playerDesc.Stats[6].MaxValue,
playerDesc.Stats[7].MaxValue,
};
character.HP = character.Stats[0];
character.MP = character.Stats[1];
}
character.FlushAsync();
_db.SetAdd("alive." + acc.AccountId, BitConverter.GetBytes(newId));
return(CreateStatus.OK);
}
