public byte[] BuyItemFromGuild(byte[] argument)
{
lock (this)
{
ushort guildIDBuying = swap16(BitConverter.ToUInt16(argument, 0));
uint itemIDBuying = swap32(BitConverter.ToUInt32(argument, 2));
ushort quantityOfBuying = swap16(BitConverter.ToUInt16(argument, 6));
uint priceOfEachPiece = swap32(BitConverter.ToUInt32(argument, 8));
Console.WriteLine("Guild ID " + guildIDBuying + "\nItem ID = " + itemIDBuying + "\nitem Quantity " +
quantityOfBuying + "\nprice of each piece " + priceOfEachPiece);
GuildItemShopModel guildItemShopModel =
DBAccess.getInstance().GetSingleGuildItem(guildIDBuying, itemIDBuying);
GuildRepositoryModel guildRepositoryModel = DBAccess.getInstance().GetGuildInfo(guildIDBuying);
guildItemShopModel.Quantity -= quantityOfBuying;
uint totalGPToAdd = priceOfEachPiece * quantityOfBuying;
guildRepositoryModel.Gp += (int)totalGPToAdd;
DBAccess.getInstance().UpdateSingleGuildItem(guildItemShopModel, false);
DBAccess.getInstance().UpdateGuildInfo(guildRepositoryModel);
MemoryStream m = new MemoryStream();
m.Write(BitConverter.GetBytes(swap16(quantityOfBuying)));
return(m.ToArray());
}
}
public ushort CreateGuild(byte[] argument, uint masterPlayerID)
{
lock (this)
{
int pos = 0;
byte[] guildNameBytes = ReadByteString(argument, pos);
pos += guildNameBytes.Length;
byte[] guildCommentBytes = ReadByteString(argument, pos);
pos += guildCommentBytes.Length;
byte[] guildEmblem = ReadByteGuildEmblem(argument, pos);
GuildRepositoryModel model = new GuildRepositoryModel();
model.GuildName = guildNameBytes;
model.GuildComment = guildCommentBytes;
model.GuildEmblem = guildEmblem;
model.GoldCoin = 0;
model.SilverCoin = 0;
model.BronzeCoin = 0;
model.Gp = 0;
model.MasterPlayerID = (int)masterPlayerID;
model.EstablishmentDate = DateTime.Now.ToString("yyyy/MM/dd");
ushort guildID = DBAccess.getInstance().CreateGuild(model);
DBAccess.getInstance().EnrollPlayerInGuild(guildID, masterPlayerID, true);
return(guildID);
}
}
public byte[] DonateCoinsToGuild(byte[] argument)
{
lock (this)
{
ushort guildIDCointToDonate = swap16(BitConverter.ToUInt16(argument, 0));
ushort goldCoinDonate = swap16(BitConverter.ToUInt16(argument, 2));
ushort silverCoinDonate = swap16(BitConverter.ToUInt16(argument, 4));
ushort bronzeCoinDonate = swap16(BitConverter.ToUInt16(argument, 6));
Console.WriteLine("Gold Coin Donation " + goldCoinDonate);
Console.WriteLine("Silver Coin Donation " + silverCoinDonate);
Console.WriteLine("Bronze Coin Donation " + bronzeCoinDonate);
GuildRepositoryModel guildRepositoryModel = DBAccess.getInstance().GetGuildInfo(guildIDCointToDonate);
guildRepositoryModel.GoldCoin += goldCoinDonate;
guildRepositoryModel.SilverCoin += silverCoinDonate;
guildRepositoryModel.BronzeCoin += bronzeCoinDonate;
DBAccess.getInstance().UpdateGuildInfo(guildRepositoryModel);
MemoryStream m = new MemoryStream();
m.Write(BitConverter.GetBytes(swap16(goldCoinDonate)));
m.Write(BitConverter.GetBytes(swap16(silverCoinDonate)));
m.Write(BitConverter.GetBytes(swap16(bronzeCoinDonate)));
return(m.ToArray());
}
}
public void UpdateGuildInfo(GuildRepositoryModel guildRepositoryModel)
{
using ISession session = _sessionFactory.OpenSession();
using ITransaction transaction = session.BeginTransaction();
session.SaveOrUpdate(guildRepositoryModel);
transaction.Commit();
session.Close();
}
public ushort CreateGuild(GuildRepositoryModel guildRepositoryModel)
{
using ISession session = _sessionFactory.OpenSession();
using ITransaction transaction = session.BeginTransaction();
session.Save(guildRepositoryModel);
transaction.Commit();
session.Close();
return((ushort)guildRepositoryModel.GuildID);
}
public byte[] LeaveGuildAndAssignMaster(ushort guildId, uint playerToAssign)
{
lock (this)
{
CharacterRepositoryModel characterRepositoryModel = DBAccess.getInstance().GetCharacterInfo(playerToAssign);
characterRepositoryModel.GuildMaster = 1;
DBAccess.getInstance().updatePlayerInfo(characterRepositoryModel);
GuildRepositoryModel guildInfo = DBAccess.getInstance().GetGuildInfo(guildId);
guildInfo.MasterPlayerID = (int)playerToAssign;
DBAccess.getInstance().UpdateGuildInfo(guildInfo);
return(new byte[] { 0x00, 0x00 });
}
}
public byte[] TakeMoneyFromGuild(ushort guildID, uint amountOfMoney)
{
GuildRepositoryModel guildRepositoryModel = DBAcess.getInstance().GetGuildInfo(guildID);
guildRepositoryModel.Gp -= (int)amountOfMoney;
DBAcess.getInstance().UpdateGuildInfo(guildRepositoryModel);
MemoryStream m = new MemoryStream();
m.Write(BitConverter.GetBytes(swap32(amountOfMoney)));
return(m.ToArray());
}
public GuildRepositoryModel GetGuildInfo(ushort guildID)
{
using ISession session = _sessionFactory.OpenSession();
using ITransaction transaction = session.BeginTransaction();
GuildRepositoryModel guildRepositoryModel = session.Query <GuildRepositoryModel>().SingleOrDefault(
x => x.GuildID == guildID);
transaction.Commit();
session.Close();
return(guildRepositoryModel);
}
public byte[] UpdateGuildEmblemComment(byte[] argument, ushort guildID)
{
int pos = 0;
byte[] guildNameBytes = ReadByteString(argument, pos);
pos += guildNameBytes.Length;
byte[] guildCommentBytes = ReadByteString(argument, pos);
pos += guildCommentBytes.Length;
byte[] guildEmblem = ReadByteGuildEmblem(argument, pos);
GuildRepositoryModel guildRepositoryModel = DBAcess.getInstance().GetGuildInfo(guildID);
guildRepositoryModel.GuildComment = guildCommentBytes;
guildRepositoryModel.GuildEmblem = guildEmblem;
DBAcess.getInstance().UpdateGuildInfo(guildRepositoryModel);
return(new byte[] { 0x00, 0x00 });
}
public async Task SaveGuildMailAsync(byte[] data)
{
var dateNow = DateTime.UtcNow;
var guildIdByteArray = new byte[2]; // 0x00 0x01
var senderAccountIdByteArray = new byte[4]; // 0x02 0x03 0x04 0x05
var sender = new byte[16]; // 0x06 for 16 count
var subject = new byte[32]; // 0x18 = 24 for 32 count
var body = new byte[1200]; // 0x98 = 152 for 1200 count
var face = new byte[25]; // 0x54A = 1354 for 25 count
logger.Debug("Taking data block and breaking it out...");
Buffer.BlockCopy(data, 0, guildIdByteArray, 0, 2);
Buffer.BlockCopy(data, 2, senderAccountIdByteArray, 0, 4);
Buffer.BlockCopy(data, 6, sender, 0, 16);
Buffer.BlockCopy(data, 24, subject, 0, 32);
Buffer.BlockCopy(data, 152, body, 0, 1200);
Buffer.BlockCopy(data, 1354, face, 0, 25);
ushort guildId = BitConverter.ToUInt16(guildIdByteArray).Swap();
GuildRepositoryModel guildRepositoryModel = await Task.Run(() => DBAccess.getInstance().GetGuildInfo(guildId));
int senderAccountId = (int)BitConverter.ToUInt32(senderAccountIdByteArray).Swap();
logger.Debug("...completed; dumping primative information");
logger.Debug("Receiving Guild ID: {0}", guildId);
logger.Debug("Receiver Guild Name: {0} ", encoding.GetString(guildRepositoryModel.GuildName)); // Get guild name from DB
logger.Debug("Sender Account ID: {0}", senderAccountId);
logger.Debug("Sender Name: {0}", encoding.GetString(sender));
logger.Debug("Subject Line: {0}", encoding.GetString(subject));
logger.Debug("Message Body: {0}", encoding.GetString(body));
logger.Debug("Face ID: {0}", encoding.GetString(face));
List <CharacterRepositoryModel> guildMembers = await Task.Run(() => DBAccess.getInstance().GetAllGuildMembers(guildId));
HashSet <int> receiverAccountIdSet = guildMembers.Select(m => m.accountID).ToHashSet(); // get unique accountIDs only
if (receiverAccountIdSet.Contains(senderAccountId))
{
receiverAccountIdSet.Remove(senderAccountId); // just so that we don't send the mail to the sender
}
MailBodyModel bodyModel = new MailBodyModel // this only needed to be created once
{
Mail_Body = body,
Mail_Face_ID = encoding.GetString(face)
};
foreach (int receiverAccountId in receiverAccountIdSet)
{
MailMetaModel metaModel = new MailMetaModel
{
Receiver_Account_ID = receiverAccountId,
Receiver_Name = guildRepositoryModel.GuildName,
Sender_Account_ID = senderAccountId,
Sender_Name = sender,
Mail_Subject = subject,
date = dateNow,
Mail_Delivered = false
};
await Task.Run(() => DBAccess.getInstance().CreateNewMail(metaModel, bodyModel));
}
logger.Information("An email has been sent by {0} to Guild Members of {1}. Saving...", encoding.GetString(sender), encoding.GetString(guildRepositoryModel.GuildName));
logger.Information("The emails has been saved to the database");
}
public byte[] GetGuildInfo(ushort guildID)
{
lock (this)
{
GuildRepositoryModel guildRepositoryModel = DBAccess.getInstance().GetGuildInfo(guildID);
CharacterRepositoryModel guildMaster =
DBAccess.getInstance().GetCharacterInfo((uint)guildRepositoryModel.MasterPlayerID);
List <CharacterRepositoryModel> listOfmembers = DBAccess.getInstance().GetAllGuildMembers(guildID);
MemoryStream m = new MemoryStream();
m.Write(guildRepositoryModel.GuildName);
m.Write(_encoding.GetBytes(guildRepositoryModel.EstablishmentDate)); //date
m.Write(new byte[] { 0x00 });
m.Write(guildMaster.CharacterName);
int memTotal = listOfmembers.Count;
int twinBlade = 0;
int bladeMaster = 0;
int heavyBlade = 0;
int heaveyAxes = 0;
int longArm = 0;
int waveMaster = 0;
int totalLevel = 0;
foreach (var member in listOfmembers)
{
if (member.ClassID == 0)
{
twinBlade++;
}
if (member.ClassID == 1)
{
bladeMaster++;
}
if (member.ClassID == 2)
{
heavyBlade++;
}
if (member.ClassID == 3)
{
heaveyAxes++;
}
if (member.ClassID == 4)
{
longArm++;
}
if (member.ClassID == 5)
{
waveMaster++;
}
totalLevel += member.CharacterLevel;
}
int avgLevel = 0;
if (memTotal != 0)
{
avgLevel = totalLevel / memTotal;
}
m.Write(BitConverter.GetBytes(swap16((ushort)memTotal)), 0, 2);
m.Write(BitConverter.GetBytes(swap16((ushort)twinBlade)), 0, 2);
m.Write(BitConverter.GetBytes(swap16((ushort)bladeMaster)), 0, 2);
m.Write(BitConverter.GetBytes(swap16((ushort)heavyBlade)), 0, 2);
m.Write(BitConverter.GetBytes(swap16((ushort)heaveyAxes)), 0, 2);
m.Write(BitConverter.GetBytes(swap16((ushort)longArm)), 0, 2);
m.Write(BitConverter.GetBytes(swap16((ushort)waveMaster)), 0, 2);
m.Write(BitConverter.GetBytes(swap16((ushort)avgLevel)), 0, 2);
m.Write(BitConverter.GetBytes(swap32((uint)guildRepositoryModel.GoldCoin)), 0, 4);
m.Write(BitConverter.GetBytes(swap32((uint)guildRepositoryModel.SilverCoin)), 0, 4);
m.Write(BitConverter.GetBytes(swap32((uint)guildRepositoryModel.BronzeCoin)), 0, 4);
m.Write(BitConverter.GetBytes(swap32((uint)guildRepositoryModel.Gp)), 0, 4);
m.Write(guildRepositoryModel.GuildComment);
m.Write(guildRepositoryModel.GuildEmblem);
m.Write(new byte[] { 0x00 });
return(m.ToArray());
}
}
public byte[] getRankingPlayerInfo(uint playerID)
{
CharacterRepositoryModel characterRepositoryModel = DBAcess.getInstance().GetCharacterInfo(playerID);
GuildRepositoryModel guildRepositoryModel = null;
bool inGuild = false;
if (characterRepositoryModel.GuildID != 0)
{
guildRepositoryModel = DBAcess.getInstance().GetGuildInfo((ushort)characterRepositoryModel.GuildID);
inGuild = true;
}
MemoryStream m = new MemoryStream();
m.Write(characterRepositoryModel.CharachterName);
if (characterRepositoryModel.ClassID == 0)
{
m.Write(new byte[] { 0x00 });
}
if (characterRepositoryModel.ClassID == 1)
{
m.Write(new byte[] { 0x01 });
}
if (characterRepositoryModel.ClassID == 2)
{
m.Write(new byte[] { 0x02 });
}
if (characterRepositoryModel.ClassID == 3)
{
m.Write(new byte[] { 0x03 });
}
if (characterRepositoryModel.ClassID == 4)
{
m.Write(new byte[] { 0x04 });
}
if (characterRepositoryModel.ClassID == 5)
{
m.Write(new byte[] { 0x05 });
}
m.Write(BitConverter.GetBytes(swap16((ushort)characterRepositoryModel.CharachterLevel)));
m.Write(characterRepositoryModel.Greeting);
if (inGuild && guildRepositoryModel != null)
{
m.Write(guildRepositoryModel.GuildName);
}
else
{
m.Write(new byte[] { 0x00 });
}
m.Write(BitConverter.GetBytes(swap32((uint)characterRepositoryModel.ModelNumber)));
if (characterRepositoryModel.OnlineStatus)
{
m.Write(new byte[] { 0x01 });
}
else
{
m.Write(new byte[] { 0x00 });
}
if (characterRepositoryModel.GuildMaster == 1)
{
m.Write(new byte[] { 0x01 });
}
else if (characterRepositoryModel.GuildMaster == 2)
{
m.Write(new byte[] { 0x02 });
}
else
{
m.Write(new byte[] { 0x03 });
}
return(m.ToArray());
}
