public async Task InsertPlayerAsync(StoredPlayer player, int profileId)
{
await this.cache.InsertIfMissingAsync(
player,
this.GetFromDatabase(player.Name, player.RealmId, player.ProfileId),
this.Store(),
this.GetKey(player.Name, player.Realm.Name, player.ProfileId));
}
public static OnlinePlayer FullLoginSequence(this MockedClient client, StoredPlayer player)
{
AccountService.RegisterAccount(player.Login, player.Password, player.Email, player);
client.Login(player.Login, player.Password);
client.SendToServer(new AssetsReadyPacket()
{
UserId = player.UserId
});
return(Server.GetPlayer(player.UserId));
}
public void FromStored(StoredPlayer player)
{
this.Name = player.Login;
this.MoveSpeed = player.MoveSpeed;
this.Position = new Position(player.X, player.Y);
this.UID = player.UserId;
this.BodySprite.SpriteRowIndex = player.BodySpriteIndex;
this.LegSprite.SpriteRowIndex = player.LegsSpriteIndex;
this.ChestSprite.SpriteRowIndex = player.ChestSpriteIndex;
this.HeadSprite.SpriteRowIndex = player.ChestSpriteIndex;
}
static void AddPlayerToQueue(QueueInteractionPacket packet)
{
StoredPlayer playerToAdd = new StoredPlayer();
{
playerToAdd.name = packet.name;
playerToAdd.playerIP = packet.IPAddress;
playerToAdd.mmrTolerance = 25;
playerToAdd.mmr = packet.mmr;
playerToAdd.searchedThisIteration = false;
playerToAdd.TimeAddedtoQueue = 0;
}
mmQueue.Enqueue(playerToAdd, packet.mmr);
}
public void Start()
{
Redis redis = new Redis();
redis.Start();
TestDb.Create();
_server = new Server(new ServerStartConfig()
{
Port = 123
});
_server.StartGameThread();
_player = TestDb.TEST_PLAYER;
_player.Login = "******";
}
public void TestPlayerDaoSaveRead()
{
var player = new StoredPlayer();
player.UserId = "123";
player.Login = "******";
player.Password = "******";
RedisHash <StoredPlayer> .Set(player);
var user = RedisHash <StoredPlayer> .Get("123");
Assert.AreEqual(user.Login, player.Login);
Assert.AreEqual(user.Password, player.Password);
}
public void TestSimpleDeSerialization()
{
var player = new StoredPlayer();
player.Email = "wololo";
player.Login = "******";
player.MoveSpeed = 15;
var serializedPlayer = DataSerializer.ToRedisHash(player);
var player2 = DataSerializer.FromRedisHash <StoredPlayer>(serializedPlayer);
Assert.AreEqual(player.Login, player2.Login);
Assert.AreEqual(player.Email, player2.Email);
Assert.AreEqual(player.MoveSpeed, player2.MoveSpeed);
}
public void Start()
{
Redis redis = new Redis();
redis.Start();
TestDb.Create();
_server = new Server(1234);
_server.StartGameThread();
_player = new StoredPlayer()
{
UserId = "wololo",
Login = "******",
Password = "******"
};
}
public Player GetPlayer(int id)
{
//Get player,player skills and player stats
var player = new StoredPlayer().GetPlayerByPlayerID(id);
player.Skills = new StoredSkill().GetSkillsByPlayerID(id);
player.Feats = new StoredFeat().GetFeatsByPlayerID(id);
player.Stats = new StoredStat().GetStatsByPlayerID(id);
player.Race = new StoredRaces().GetPlayerRace(id);
player.Class = new StoredClass().GetPlayerClass(id);
player.Alignment = new StoredAlignment().GetPlayerAlignment(id);
player.Gender = new StoredGender().GetPlayerGender(id);
player.Inventory = new StoredInventory().GetPlayerInventory(id);
return(player);
}
private void FullLoginSequence(ConnectedClientTcpHandler client)
{
var loginpass = Guid.NewGuid().ToString();
var player = new StoredPlayer()
{
UserId = Guid.NewGuid().ToString(),
Login = loginpass,
Password = loginpass
};
AccountService.RegisterAccount(loginpass, loginpass, "", player);
client.Send(new LoginPacket()
{
Login = loginpass,
Password = loginpass
});
}
public void Start()
{
Redis redis = new Redis();
redis.Start();
TestDb.Create();
_player = new StoredPlayer()
{
UserId = "wololo",
Login = "******",
Password = "******",
MoveSpeed = 1,
X = 5,
Y = 5
};
}
public static async Task <bool> AddPlayerAsync(string username, string password)
{
using (ModuleContext DB = new ModuleContext())
{
if (DB.Players.Where(x => x.Username == username).Count() > 0)
{
return(false);
}
StoredPlayer player = new StoredPlayer()
{
Username = username, Password = password
};
DB.Players.Add(player);
await DB.SaveChangesAsync();
return(true);
}
}
public void UpdateStoredPlayer(APIUser player)
{
if (string.IsNullOrEmpty(player.id) || string.IsNullOrEmpty(player.displayName))
{
return;
}
var storedPlayer = new StoredPlayer
{
PlayerId = player.id,
Name = player.displayName,
ThumbnailUrl = player.profilePicThumbnailImageUrl // already includes override/avatar check
};
myUpdateThreadQueue.Enqueue(() =>
{
myStoredPlayers.Upsert(storedPlayer);
});
}
public void UpdateStoredPlayer(APIUser player)
{
if (string.IsNullOrEmpty(player.id) || string.IsNullOrEmpty(player.displayName))
{
return;
}
var storedPlayer = new StoredPlayer
{
PlayerId = player.id,
Name = player.displayName,
ThumbnailUrl = player.currentAvatarThumbnailImageUrl
};
myUpdateThreadQueue.Enqueue(() =>
{
myStoredPlayers.Upsert(storedPlayer);
});
}
public void TestUpdatingPosition()
{
var player = new StoredPlayer();
player.UserId = "123";
player.Login = "******";
player.Password = "******";
player.X = 1;
player.Y = 2;
RedisHash <StoredPlayer> .Set(player);
PlayerService.UpdatePlayerPosition(player.UserId, 3, 4);
var obtainedPlayer = RedisHash <StoredPlayer> .Get("123");
Assert.AreEqual(obtainedPlayer.X, 3);
Assert.AreEqual(obtainedPlayer.Y, 4);
}
public void Start()
{
Redis redis = new Redis();
redis.Start();
TestDb.Create();
_server = new Server(new ServerStartConfig()
{
Port = 123
});
_server.StartGameThread();
_player = new StoredPlayer()
{
UserId = "wololo",
Login = "******",
Password = "******",
MoveSpeed = 1,
X = 0,
Y = 0
};
}
public void TestSimpleSerialization()
{
var player = new StoredPlayer();
player.Email = "wololo";
player.Login = "******";
player.MoveSpeed = 15;
var serializedPlayer = DataSerializer.ToRedisHash(player);
var emailEntry = FindEntry("e", serializedPlayer);
var loginEntry = FindEntry("l", serializedPlayer);
var speedEntry = FindEntry("s", serializedPlayer);
Assert.That(emailEntry.HasValue);
Assert.That(loginEntry.HasValue);
Assert.That(speedEntry.HasValue);
Assert.That(emailEntry.Value.Value == player.Email);
Assert.That(loginEntry.Value.Value == player.Login);
Assert.That(speedEntry.Value.Value == player.MoveSpeed);
}
public void Start()
{
Redis redis = new Redis();
redis.Start();
TestDb.Create();
_server = new Server(new Server.ServerStartConfig()
{
Port = 123, DisableSpawners = true
});
// _server.StartGameThread();
GameThread.TIME_MS_NOW = DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond;
_player = new StoredPlayer()
{
UserId = "wololo",
Login = "******",
Password = "******",
MoveSpeed = 1,
X = 0,
Y = 0
};
_client = ServerMocker.GetClient();
_client.FullLoginSequence(_player);
_monster = new Skeleton()
{
HP = 10,
Position = new Position(1, 0)
};
Server.Events.Call(new EntitySpawnEvent()
{
Entity = _monster,
Position = _monster.Position
});
// So we can send move events w/o worryng about cooldown check
Server.GetPlayer(_player.UserId).MoveSpeed = int.MaxValue;
}
public static void Create()
{
Console.WriteLine("Creating admin account");
try
{
var testPlayerTemplate = new StoredPlayer()
{
MoveSpeed = 10,
BodySpriteIndex = 2,
HeadSpriteIndex = 2,
ChestSpriteIndex = 2,
LegsSpriteIndex = 2
};
Redis.Server.FlushAllDatabases();
AccountService.RegisterAccount("a", "a", "*****@*****.**", testPlayerTemplate);
AccountService.RegisterAccount("b", "b", "*****@*****.**", testPlayerTemplate);
} catch (AccountError err)
{
Console.WriteLine("Admin account was already created");
}
Console.WriteLine("Admin account ready");
}
public static StoredPlayer RegisterAccount(string login, string password, string email, StoredPlayer playerTemplate)
{
var account = LoginDao.GetUserId(login);
if (account != null)
{
throw new AccountError(AccountErrorCode.ACCOUNT_ALREADY_EXISTS, "Login already registered");
}
playerTemplate.Login = login;
playerTemplate.Password = password;
playerTemplate.Email = email;
playerTemplate.UserId = Guid.NewGuid().ToString();
LoginDao.SetUserId(login, playerTemplate.UserId);
RedisHash <StoredPlayer> .Set(playerTemplate);
return(playerTemplate);
}
private StoredPlayer[] Merge(StoredPlayer[] players, int left, int middle, int right)
{
//find the lengths of the two halves
int lengthLeft = middle - left;
int lengthRight = right - middle;
//set the final element of both arrays to infinity
StoredPlayer[] leftArray = new StoredPlayer[lengthLeft + 2];
StoredPlayer temp = new StoredPlayer();
{
temp.mmr = 10000;
}
leftArray[lengthLeft + 1] = temp;
StoredPlayer[] rightArray = new StoredPlayer[lengthRight + 1];
rightArray[lengthRight] = temp;
//create the two arrays that will be used to
for (int i = 0; i <= lengthLeft; i++)
{
leftArray[i] = players[left + i];
}
for (int j = 0; j < lengthRight; j++)
{
rightArray[j] = players[middle + j + 1];
}
int iIndex = 0;
int jIndex = 0;
//take the lower element of the two arrays and add it to the new sorted array
for (int k = left; k <= right; k++)
{
if (leftArray[iIndex].mmr <= rightArray[jIndex].mmr)
{
players[k] = leftArray[iIndex];
iIndex++;
}
else
{
players[k] = rightArray[jIndex];
jIndex++;
}
}
return players;
}
public StoredPlayer[] SortMerge(StoredPlayer[] players, int left, int right)
{
//Mergesort is the "serious" sorting algorithm
int mid;
if (right > left)
{
//find a midpoint
mid = (right + left) / 2;
//recursively call this function for each half of the current array
players = SortMerge(players, left, mid);
players = SortMerge(players, mid + 1, right);
//once that is done, merge it
players = Merge(players, left, mid, right);
}
return players;
}
public List <Player> GetUserPlayers(string username)
{
var PlayerList = new StoredPlayer().GetUserPlayers(username);
return(PlayerList);
}
