public async Task Add(ItemsModel item)
{
await Item.AddItem(item);
}
public ItemsModel Get(int id)
{
ItemsModel ret = db.QueryFirst(modelType, "SELECT * FROM Items where Id = @Id;", new { Id = id });
return(ret);
}
public PROTOCOL_INVENTORY_ITEM_CREATE_ACK(byte type, Account player, ItemsModel item)
{
this.type = type;
this.player = player;
AddItems(item);
}
//------------------------------------------------------------------------------------------------------
#endregion
#region /*--------- PopulateModelFromIDataReader ---------*\
//------------------------------------------------------------------------------------------------------
/// <summary>
/// Populates model from IDataReader .
/// </summary>
/// <param name="reader"></param>
/// <returns>Model object.</returns>
//--------------------------------------------------------------------
private ItemsModel PopulateModelFromIDataReader(IDataReader reader)
{
//Create a new object
ItemsModel ItemsObj = new ItemsModel();
//Fill the object with data
//------------------------------------------------
//ItemID
//------------------------------------------------
if (reader["ItemID"] != DBNull.Value)
ItemsObj.ItemID = (int)reader["ItemID"];
//------------------------------------------------
//------------------------------------------------
//[CategoryID]
//------------------------------------------------
if (reader["CategoryID"] != DBNull.Value)
ItemsObj.CategoryID = (int)reader["CategoryID"];
//------------------------------------------------
//------------------------------------------------
//[PhotoFile]
//------------------------------------------------
if (reader["PhotoFile"] != DBNull.Value)
ItemsObj.PhotoFile = (string)reader["PhotoFile"];
//------------------------------------------------
//------------------------------------------------
//[Url]
//------------------------------------------------
if (reader["Url"] != DBNull.Value)
ItemsObj.Url = (string)reader["Url"];
//------------------------------------------------
//------------------------------------------------
//[Type]
//------------------------------------------------
if (reader["Type"] != DBNull.Value)
ItemsObj.Type = (int)reader["Type"];
//------------------------------------------------
//------------------------------------------------
//[IsMain]
//------------------------------------------------
if (reader["IsMain"] != DBNull.Value)
ItemsObj.IsMain = (bool)reader["IsMain"];
//------------------------------------------------
//------------------------------------------------
//[YoutubeCode]
//------------------------------------------------
if (reader["YoutubeCode"] != DBNull.Value)
ItemsObj.YoutubeCode = (string)reader["YoutubeCode"];
//------------------------------------------------
//------------------------------------------------
//[Title]
//------------------------------------------------
if (reader["Title"] != DBNull.Value)
ItemsObj.Title = (string)reader["Title"];
//------------------------------------------------
//------------------------------------------------
//[Description]
//------------------------------------------------
if (reader["Description"] != DBNull.Value)
ItemsObj.Description = (string)reader["Description"];
//------------------------------------------------
//------------------------------------------------
//[DateInserted]
//------------------------------------------------
if (reader["DateInserted"] != DBNull.Value)
ItemsObj.DateInserted = (DateTime)reader["DateInserted"];
//------------------------------------------------
//Return the populated object
return ItemsObj;
}
private async void Start()
{
var aggregator = new MessageAggregator();
_relay = aggregator;
IConfigStore configStore = new AppDataConfigStore();
IPreviewImageStore previewStore = new AppDataPreviewImageStore();
_library = new Library(configStore, _previewBuilder, previewStore, _relay);
var factory = new ImportFolderFactory(_library);
// Misc
var checker = new UpdateChecker(_relay);
var appVersionModel = new AppVersionDisplayModel(_relay);
// Main View
var progressModel = new ProgressModel();
var applicationModel = new ApplicationModel(_relay);
var searchViewModel = new SearchModel(_library, _relay);
var itemsViewModel = new ItemsModel(_library, _relay);
// Main Menu
var importFoldersViewModel = new ImportFoldersModel(configStore, factory, _relay);
var savedSearchesViewModel = new SavedSearchesModel(configStore, _relay);
var collectionsViewModel = new CollectionsModel(configStore, _relay);
// Detail Menu
var detailMenuModel = new DetailMenuModel(_library, _relay);
// Dialogs
var addSavedSearchViewModel = new AddSavedSearchModel(_relay);
var addImportFolderViewModel = new AddImportFolderModel(_relay);
var applicationSettingsModel = new ApplicationSettingsModel(configStore);
var userFeedbackModel = new UserFeedbackModel();
var updateNotificationModel = new UpdateNotificationModel(configStore);
var exitingModel = new ExitingModel(_library, OnShutdownComplete);
var editScreenModel = new EditScreenModel(_library);
BindViewModels();
BindSettings();
// Wire up misc items
_disposables.Add(importFoldersViewModel);
_editScreen.MainView = _mainGroup;
// Also restores app settings for import etc.
await applicationSettingsModel.InitializeAsync();
await _library.InitializeAsync();
InitializeViewModelsAsync();
aggregator.Subscribe(
// Main View
progressModel,
searchViewModel,
itemsViewModel,
// Main Menu
importFoldersViewModel,
savedSearchesViewModel,
collectionsViewModel,
// DetailMenu
detailMenuModel,
// Misc
appVersionModel,
// Dialogs
addSavedSearchViewModel,
addImportFolderViewModel,
applicationSettingsModel,
userFeedbackModel,
updateNotificationModel,
exitingModel,
editScreenModel);
void BindViewModels()
{
// Main View
_progressView.BindTo(progressModel);
_applicationView.BindTo(applicationModel);
_searchView.BindTo(searchViewModel);
_libraryView.BindTo(itemsViewModel);
// Main Menu
_importFoldersView.BindTo(importFoldersViewModel);
_savedSearchesView.BindTo(savedSearchesViewModel);
_collectionsView.BindTo(collectionsViewModel);
// Detail Menu
_detailMenu.BindTo(detailMenuModel);
// Misc
_versionButton.BindTo(appVersionModel);
// Dialogs
_addImportFolderDialog.BindTo(addImportFolderViewModel);
_addSavedSearchDialog.BindTo(addSavedSearchViewModel);
_applicationSettingsDialog.BindTo(applicationSettingsModel);
_userFeedbackDialog.BindTo(userFeedbackModel);
_updateNotificationDialog.BindTo(updateNotificationModel);
_exitingDialog.BindTo(exitingModel);
_editScreen.BindTo(editScreenModel);
}
void BindSettings()
{
var rt = applicationSettingsModel.RuntimeSettings;
rt.ImportParallelism.ValueChanged += factor => _library.Parallelism = factor;
rt.LogLevel.ValueChanged += logLevel => UnityLogger.LogLevel = logLevel;
rt.UiScalePercent.ValueChanged += factor =>
{
foreach (var canvas in FindObjectsOfTypeAll <CanvasScaler>())
{
canvas.scaleFactor = applicationSettingsModel.UiScalePercent / 125f;
}
};
rt.ScrollSensitivity.ValueChanged += sensitivity =>
{
foreach (var area in FindObjectsOfType <ScrollRect>())
{
area.scrollSensitivity = sensitivity;
}
};
rt.PreviewResolution.ValueChanged += res => _previewBuilder.PreviewResolution.Value = Mathf.RoundToInt(Mathf.Pow(2f, res));
rt.PreviewJpegQuality.ValueChanged += quality => _previewBuilder.Quality = quality;
}
async void InitializeViewModelsAsync()
{
await savedSearchesViewModel.InitializeAsync();
await importFoldersViewModel.InitializeAsync();
await collectionsViewModel.InitializeAsync();
await updateNotificationModel.InitializeAsync();
// run update checks
await checker.CheckForUpdatesAsync();
}
}
// Menu commands
private void SaveClick(object sender, EventArgs e)
{
ItemsModel m = PlotModel.ItemsModel.Separate(this);
m.Save();
}
public PlotForm(ItemsModel Items, Plot.Type Type) : this(Items, new PlotModel(Items, Type))
{
}
private void InitializeItems()
{
ItemsModel = new ItemsModel();
}
public void DiscountPlayerItems()
{
bool flag = false;
uint num1 = uint.Parse(DateTime.Now.ToString("yyMMddHHmm"));
List <object> objectList = new List <object>();
int num2 = this._bonus != null ? this._bonus.bonuses : 0;
int num3 = this._bonus != null ? this._bonus.freepass : 0;
lock (this._inventory._items)
{
for (int index = 0; index < this._inventory._items.Count; ++index)
{
ItemsModel itemsModel = this._inventory._items[index];
if (itemsModel._count <= num1 & itemsModel._equip == 2)
{
if (itemsModel._category == 3)
{
if (this._bonus != null)
{
if (!this._bonus.RemoveBonuses(itemsModel._id))
{
if (itemsModel._id == 1200014000)
{
ComDiv.updateDB("player_bonus", "sightcolor", (object)4, "player_id", (object)this.player_id);
this._bonus.sightColor = 4;
}
else if (itemsModel._id == 1200006000)
{
ComDiv.updateDB("accounts", "name_color", (object)0, "player_id", (object)this.player_id);
this.name_color = 0;
}
else if (itemsModel._id == 1200009000)
{
ComDiv.updateDB("player_bonus", "fakerank", (object)55, "player_id", (object)this.player_id);
this._bonus.fakeRank = 55;
}
else if (itemsModel._id == 1200010000 && this._bonus.fakeNick.Length > 0)
{
ComDiv.updateDB("player_bonus", "fakenick", (object)"", "player_id", (object)this.player_id);
ComDiv.updateDB("accounts", "player_name", (object)this._bonus.fakeNick, "player_id", (object)this.player_id);
this.player_name = this._bonus.fakeNick;
this._bonus.fakeNick = "";
}
}
CupomFlag cupomEffect = CupomEffectManager.getCupomEffect(itemsModel._id);
if (cupomEffect != null && cupomEffect.EffectFlag > (CupomEffects)0 && this.effects.HasFlag((Enum)cupomEffect.EffectFlag))
{
this.effects -= cupomEffect.EffectFlag;
flag = true;
}
}
else
{
continue;
}
}
objectList.Add((object)itemsModel._objId);
this._inventory._items.RemoveAt(index--);
}
else if (itemsModel._count == 0U)
{
objectList.Add((object)itemsModel._objId);
this._inventory._items.RemoveAt(index--);
}
}
ComDiv.deleteDB("player_items", "object_id", objectList.ToArray(), "owner_id", (object)this.player_id);
}
if (this._bonus != null && (this._bonus.bonuses != num2 || this._bonus.freepass != num3))
{
PlayerManager.updatePlayerBonus(this.player_id, this._bonus.bonuses, this._bonus.freepass);
}
if (this.effects < (CupomEffects)0)
{
this.effects = (CupomEffects)0;
}
if (flag)
{
PlayerManager.updateCupomEffects(this.player_id, this.effects);
}
this._inventory.LoadBasicItems();
int num4 = PlayerManager.CheckEquipedItems(this._equip, this._inventory._items, false);
if (num4 <= 0)
{
return;
}
DBQuery query = new DBQuery();
if ((num4 & 2) == 2)
{
PlayerManager.updateWeapons(this._equip, query);
}
if ((num4 & 1) == 1)
{
PlayerManager.updateChars(this._equip, query);
}
ComDiv.updateDB("accounts", "player_id", (object)this.player_id, query.GetTables(), query.GetValues());
}
public override void RunImplement()
{
try
{
Account player = client.SessionPlayer;
if (player == null)
{
return;
}
ItemsModel item = player.inventory.GetItem(objectId);
if (item == null)
{
client.SendCompletePacket(PackageDataManager.INVENTORY_ITEM_EXCLUDE_0x80000000_PAK);
return;
}
else if (Utilities.GetIdStatics(item.id, 1) == 12)
{
PlayerBonus bonus = player.bonus;
if (bonus == null)
{
client.SendCompletePacket(PackageDataManager.INVENTORY_ITEM_EXCLUDE_0x80000000_PAK);
return;
}
bool changed = bonus.RemoveBonuses(item.id);
if (!changed)
{
if (item.id == 1200014000)
{
if (player.ExecuteQuery($"UPDATE player_bonus SET sightcolor='4' WHERE player_id='{player.playerId}'"))
{
bonus.sightColor = 4;
client.SendPacket(new PROTOCOL_BASE_USER_EFFECTS_ACK(0, bonus));
}
else
{
client.SendCompletePacket(PackageDataManager.INVENTORY_ITEM_EXCLUDE_0x80000000_PAK);
return;
}
}
else if (item.id == 1200010000)
{
if (bonus.fakeNick.Length == 0)
{
client.SendCompletePacket(PackageDataManager.INVENTORY_ITEM_EXCLUDE_0x80000000_PAK);
return;
}
if (player.ExecuteQuery($"UPDATE accounts SET nickname='{bonus.fakeNick}' WHERE id='{player.playerId}'") &&
player.ExecuteQuery($"UPDATE player_bonus SET fakenick='{""}' WHERE player_id='{player.playerId}'"))
{
player.nickname = bonus.fakeNick;
bonus.fakeNick = "";
client.SendPacket(new PROTOCOL_BASE_USER_EFFECTS_ACK(0, bonus));
client.SendPacket(new PROTOCOL_AUTH_CHANGE_NICKNAME_ACK(player.nickname));
}
else
{
client.SendCompletePacket(PackageDataManager.INVENTORY_ITEM_EXCLUDE_0x80000000_PAK);
return;
}
}
else if (item.id == 1200009000)
{
if (player.ExecuteQuery($"UPDATE player_bonus SET fakerank='55' WHERE player_id='{player.playerId}'"))
{
bonus.fakeRank = 55;
client.SendPacket(new PROTOCOL_BASE_USER_EFFECTS_ACK(0, bonus));
}
else
{
client.SendCompletePacket(PackageDataManager.INVENTORY_ITEM_EXCLUDE_0x80000000_PAK);
return;
}
}
else if (item.id == 1200006000)
{
if (player.ExecuteQuery($"UPDATE accounts SET nickcolor='0' WHERE id='{player.playerId}'"))
{
player.nickcolor = 0;
client.SendPacket(new BASE_2612_PAK(player));
Room room = player.room;
if (room != null)
{
using (PROTOCOL_ROOM_GET_NICKNAME_ACK packet = new PROTOCOL_ROOM_GET_NICKNAME_ACK(player.slotId, player.nickname, player.nickcolor))
{
room.SendPacketToPlayers(packet);
}
}
}
else
{
client.SendCompletePacket(PackageDataManager.INVENTORY_ITEM_EXCLUDE_0x80000000_PAK);
return;
}
}
}
else
{
player.UpdatePlayerBonus();
}
}
if (item != null)
{
if (player.DeleteItem(item.objectId))
{
player.inventory.RemoveItem(item);
}
else
{
client.SendCompletePacket(PackageDataManager.INVENTORY_ITEM_EXCLUDE_0x80000000_PAK);
return;
}
}
client.SendPacket(new INVENTORY_ITEM_EXCLUDE_PAK(1, objectId));
}
catch (Exception ex)
{
PacketLog(ex);
}
}
public BaseModel <object> Detail(long id)
{
BaseModel <object> _baseModel = new BaseModel <object>();
PageModel _pageModel = new PageModel();
ErrorModel _error = new ErrorModel();
string Token = _account.GetHeader(Request);
try
{
Func <ItemsModel, object> _orderByExpression = x => x.IdItem;
Dictionary <string, Func <ItemsModel, object> > _sortableFields = new Dictionary <string, Func <ItemsModel, object> >
{
{ "IdItem", x => x.IdItem }
};
ItemsModel _data = (from item in _context.DBItems
where item.IdItem == id
select new ItemsModel
{
IdItem = item.IdItem,
IdType = item.IdType,
Name = item.Name,
Money = item.Money,
Sales = item.Sales,
RateAvg = _context.DBReview.Where(x => x.IdItem == item.IdItem.Value).Count() <= 0 ? 0 : Decimal.Divide(Decimal.Divide(_context.DBReview.Where(x => x.IdItem == item.IdItem.Value).Select(s => s.Rate).Sum(), _context.DBReview.Where(x => x.IdItem == item.IdItem.Value).Count()), 5) * 100,
RateNumber = _context.DBReview.Where(x => x.IdItem == item.IdItem.Value).Count(),
LinkImage = item.LinkImage,
}).ToList().FirstOrDefault();
_data.UserReview = _context.DBReview.Where(x => x.IdItem == id)
.Join(_context.DBAccount,
re => re.IdAccount,
acc => acc.IdAccount,
(re, acc) => new { re = re, acc = acc })
.Join(_context.DBUser,
acc => acc.acc.IdUser,
user => user.IdUser,
(acc, user) => new { acc = acc, user = user })
.Select(s => new UserReview
{
AccountName = s.user.Fullname,
Time = s.acc.re.Time,
Rate = Decimal.Divide(s.acc.re.Rate, 5) * 100,
Text = s.acc.re.Text
}).ToList();
_baseModel.status = 1;
_baseModel.error = null;
_baseModel.data = _data;
_baseModel.page = _pageModel;
return(_baseModel);
}
catch (Exception ex)
{
_error = new ErrorModel();
_error.message = "Lỗi dữ liệu hoặc bạn phải truyền Token!";
_error.code = Constant.ERRORCODE;
return(new BaseModel <object>
{
status = 0,
error = _error,
data = null,
page = null
});
}
}
//------------------------------------------------------------------------------------------------------
#endregion
#region --------------Updat--------------
//------------------------------------------------------------------------------------------------------
/// <summary>
/// Updates model object by calling sql data provider update method.
/// </summary>
/// <param name="ItemsObj">The model object.</param>
/// <returns>The result of update operation.</returns>
//--------------------------------------------------------------------
public static bool Updat(ItemsModel ItemsObj)
{
return(ItemsSqlDataPrvider.Instance.Updat(ItemsObj));
}
//------------------------------------------------------------------------------------------------------
/// <summary>
/// Creates model object by calling News data provider create method.
/// </summary>
/// <param name="ItemsObj">The model object.</param>
/// <returns>The result of create operation.</returns>
//--------------------------------------------------------------------
public static bool Create(ItemsModel ItemsObj)
{
return(ItemsSqlDataPrvider.Instance.Create(ItemsObj));
}
public void Update(ItemsModel item)
{
Item.UpdateItem(item);
}
public override void Write()
{
WriteH(2566);
WriteD(error);
if (error != 0)
{
return;
}
EventVisitModel eventVisit = EventVisitSyncer.GetRunningEvent();
WriteC(player.age);
WriteS(player.nickname, 33);
WriteD(player.exp);
WriteD(player.rankId);
WriteD(player.rankId);
WriteD(player.gold);
WriteD(player.cash);
WriteD(clan.id);
WriteD((int)player.clanAuthority);
WriteD(player.nickname == "" ? 1 : 0);
WriteD(0);
WriteC(player.pccafe);
WriteC(player.tourneyLevel);
WriteC(player.nickcolor);
WriteS(clan.name, 17);
WriteC(clan.rank);
WriteC(clan.GetClanUnit());
WriteD(clan.logo);
WriteC(clan.nameColor);
WriteD(10000);
WriteC(0);
WriteD(0);
WriteD(player.lastRankUpDate); //109 BYTES
WriteD(player.statistics.fights);
WriteD(player.statistics.fightsWin);
WriteD(player.statistics.fightsLost);
WriteD(player.statistics.fightsDraw);
WriteD(player.statistics.kills);
WriteD(player.statistics.headshots);
WriteD(player.statistics.deaths);
WriteD(player.statistics.totalfights);
WriteD(player.statistics.totalkills);
WriteD(player.statistics.escapes);
WriteD(player.statistics.fights);
WriteD(player.statistics.fightsWin);
WriteD(player.statistics.fightsLost);
WriteD(player.statistics.fightsDraw);
WriteD(player.statistics.kills);
WriteD(player.statistics.headshots);
WriteD(player.statistics.deaths);
WriteD(player.statistics.totalfights);
WriteD(player.statistics.totalkills);
WriteD(player.statistics.escapes);
WriteD(player.equipments.red);
WriteD(player.equipments.blue);
WriteD(player.equipments.helmet);
WriteD(player.equipments.beret);
WriteD(player.equipments.dino);
WriteD(player.equipments.primary);
WriteD(player.equipments.secondary);
WriteD(player.equipments.melee);
WriteD(player.equipments.grenade);
WriteD(player.equipments.special);
WriteH(0); //Auxiliar de cor da mira
WriteD(player.bonus.fakeRank);
WriteD(player.bonus.fakeRank);
WriteS(player.bonus.fakeNick, 33);
WriteH(player.bonus.sightColor);
WriteC(player.country);
CheckGameEvents(eventVisit);
if (Settings.ClientVersion == "1.15.23" || Settings.ClientVersion == "1.15.37")
{
GetInventoryInfo();
WriteC(Settings.InventoryActive);
WriteD(charas.Count);
WriteD(weapons.Count);
WriteD(cupons.Count);
WriteD(0);
for (int i = 0; i < charas.Count; i++)
{
ItemsModel item = charas[i];
WriteQ(item.objectId);
WriteD(item.id);
WriteC(item.equip);
WriteD(item.count);
}
for (int i = 0; i < weapons.Count; i++)
{
ItemsModel item = weapons[i];
WriteQ(item.objectId);
WriteD(item.id);
WriteC(item.equip);
WriteD(item.count);
}
for (int i = 0; i < cupons.Count; i++)
{
ItemsModel item = cupons[i];
WriteQ(item.objectId);
WriteD(item.id);
WriteC(item.equip);
WriteD(item.count);
}
}
WriteC(Settings.OutpostActive);
WriteD(player.brooch);
WriteD(player.insignia);
WriteD(player.medal);
WriteD(player.blueorder);
WriteC(player.missions.actualMission);
WriteC(player.missions.card1);
WriteC(player.missions.card2);
WriteC(player.missions.card3);
WriteC(player.missions.card4);
WriteB(player.GetCardFlags(player.missions.mission1, player.missions.list1));
WriteB(player.GetCardFlags(player.missions.mission2, player.missions.list2));
WriteB(player.GetCardFlags(player.missions.mission3, player.missions.list3));
WriteB(player.GetCardFlags(player.missions.mission4, player.missions.list4));
WriteC(player.missions.mission1);
WriteC(player.missions.mission2);
WriteC(player.missions.mission3);
WriteC(player.missions.mission4);
WriteB(player.missions.list1);
WriteB(player.missions.list2);
WriteB(player.missions.list3);
WriteB(player.missions.list4);
WriteQ(player.titles.Flags);
WriteC(player.titles.Equiped1);
WriteC(player.titles.Equiped2);
WriteC(player.titles.Equiped3);
WriteD(player.titles.Slots);
WriteD(44); //Tutorial
WriteD(1); //Deathmatch
WriteD(25); //Destruction
WriteD(35); //Sabotage
WriteD(11); //Supression
WriteD(39); //Defense
WriteD(1); //Challenge
WriteD(40); //Dinosaur
WriteD(1); //Sniper
WriteD(1); //Shotgun
WriteD(0); //HeadHunter
WriteD(0); //Knuckle
WriteD(54); //CrossCounter
WriteD(1); //Chaos
if (Settings.ClientVersion == "1.15.38" || Settings.ClientVersion == "1.15.39" || Settings.ClientVersion == "1.15.41" || Settings.ClientVersion == "1.15.42")
{
WriteD(1); //TheifMode
}
WriteC((byte)MapsXML.ModeList.Count); //124 maps ver 42
WriteC(4); //(Flag pages | 4 bytes)
WriteD(MapsXML.maps1);
WriteD(MapsXML.maps2);
WriteD(MapsXML.maps3);
WriteD(MapsXML.maps4);
WriteB(MapsXML.ModeBytes);
WriteB(MapsXML.TagBytes);
WriteC(Settings.MissionActive); //Pages Count
WriteD(MissionsXML.missionPage1);
WriteD(0); //Multiplicado por 100?
WriteD(0); //Multiplicado por 100?
WriteC(0);
WriteH(20); //length de algo.
//WriteB(new byte[20] { 0x70, 0x0C, 0x94, 0x2D, 0x48, 0x08, 0xDD, 0x1E, 0xB0, 0xAB, 0x1A, 0x00, 0x99, 0x7B, 0x42, 0x00, 0x70, 0x0C, 0x94, 0x2D });
WriteB(new byte[20]);
WriteD(player.IsGM() || player.HaveAcessLevel());
WriteD(xmas);
WriteC(1); //Repair?
WriteVisitEvent(eventVisit);
//WriteD(int.Parse(DateTime.Now.ToString("yyMMddHHmm"))); //DataNow By Server
//WriteS("10.120.1.44", 256);
//WriteH(0); //8085
//WriteH(0);
//WriteC(0); //Presentes
//WriteH(1); //1
//WriteC(0);
//WriteC(1);
//WriteC(7); //6
//WriteC(4); //Vip
//WriteC(1); //Posição do item VIP na loja
//WriteC(1);
//WriteC(2);
//WriteC(5);
//WriteC(3);
//WriteC(6);
WriteD(uint.Parse(DateTime.Now.ToString("yyMMddHHmm"))); //DataNow By Server
//writeB(new byte[256]);
WriteS("10.120.1.44", 256); //?
WriteH(8085); //8085
WriteC(1); //gift system
WriteH(0);
WriteH(1);
WriteC(0);
WriteH(1);
WriteC(1);
WriteC(6);
WriteH(4);
WriteC(2);
WriteC(1);
WriteC(5);
WriteC(3);
charas = null;
weapons = null;
cupons = null;
}
public void DiscountPlayerItems()
{
bool updEffect = false;
uint data_atual = uint.Parse(DateTime.Now.ToString("yyMMddHHmm"));
List <object> removedItems = new List <object>();
int bonuses = _bonus != null ? _bonus.bonuses : 0, freepass = _bonus != null ? _bonus.freepass : 0;
lock (_inventory._items)
{
for (int i = 0; i < _inventory._items.Count; i++)
{
ItemsModel item = _inventory._items[i];
if (item._count <= data_atual & item._equip == 2)
{
if (item._category == 3)
{
if (_bonus == null)
{
continue;
}
bool changed = _bonus.RemoveBonuses(item._id);
if (!changed)
{
if (item._id == 1200014000)
{
ComDiv.updateDB("player_bonus", "sightcolor", 4, "player_id", player_id);
_bonus.sightColor = 4;
}
else if (item._id == 1200006000)
{
ComDiv.updateDB("contas", "name_color", 0, "player_id", player_id);
name_color = 0;
}
else if (item._id == 1200009000)
{
ComDiv.updateDB("player_bonus", "fakerank", 55, "player_id", player_id);
_bonus.fakeRank = 55;
}
else if (item._id == 1200010000)
{
if (_bonus.fakeNick.Length > 0)
{
ComDiv.updateDB("player_bonus", "fakenick", "", "player_id", player_id);
ComDiv.updateDB("contas", "player_name", _bonus.fakeNick, "player_id", player_id);
player_name = _bonus.fakeNick;
_bonus.fakeNick = "";
}
}
}
CupomFlag cupom = CupomEffectManager.getCupomEffect(item._id);
if (cupom != null && cupom.EffectFlag > 0 && effects.HasFlag(cupom.EffectFlag))
{
effects -= cupom.EffectFlag;
updEffect = true;
}
}
removedItems.Add(item._objId);
_inventory._items.RemoveAt(i--);
}
else if (item._count == 0)
{
removedItems.Add(item._objId);
_inventory._items.RemoveAt(i--);
}
}
ComDiv.deleteDB("player_items", "id", removedItems.ToArray(), "owner_id", player_id);
}
removedItems = null;
if (_bonus != null && (_bonus.bonuses != bonuses || _bonus.freepass != freepass))
{
PlayerManager.updatePlayerBonus(player_id, _bonus.bonuses, _bonus.freepass);
}
if (effects < 0)
{
effects = 0;
}
if (updEffect)
{
PlayerManager.updateCupomEffects(player_id, effects);
}
_inventory.LoadBasicItems();
int type = PlayerManager.CheckEquipedItems(_equip, _inventory._items);
if (type > 0)
{
DBQuery query = new DBQuery();
if ((type & 2) == 2)
{
PlayerManager.updateWeapons(_equip, query);
}
if ((type & 1) == 1)
{
PlayerManager.updateChars(_equip, query);
}
ComDiv.updateDB("contas", "player_id", player_id, query.GetTables(), query.GetValues());
query = null;
}
}
private void CheckGameEvents(EventVisitModel eventVisit)
{
PlayerEvent playerEvent = player.events;
if (playerEvent != null)
{
QuestModel eventQuest = EventQuestSyncer.GetRunningEvent();
if (eventQuest != null)
{
long lastDate = playerEvent.LastQuestDate;
int finish = playerEvent.LastQuestFinish;
if (playerEvent.LastQuestDate < eventQuest.startDate)
{
playerEvent.LastQuestDate = 0;
playerEvent.LastQuestFinish = 0;
player.SendCompletePacket(PackageDataManager.SERVER_MESSAGE_EVENT_QUEST_PAK);
}
if (playerEvent.LastQuestFinish == 0)
{
player.missions.mission4 = 13; //13 = MissionId Event
if (playerEvent.LastQuestDate == 0)
{
playerEvent.LastQuestDate = date;
}
}
if (playerEvent.LastQuestDate != lastDate || playerEvent.LastQuestFinish != finish)
{
player.ExecuteQuery($"UPDATE player_events SET last_quest_date='{playerEvent.LastQuestDate}', last_quest_finish='{playerEvent.LastQuestFinish}' WHERE player_id='{player.playerId}'");
}
}
EventLoginModel eventLogin = EventLoginSyncer.GetRunningEvent();
if (eventLogin != null && !(eventLogin.startDate < playerEvent.LastLoginDate && playerEvent.LastLoginDate < eventLogin.endDate))
{
ItemsModel item = new ItemsModel(eventLogin.rewardId, eventLogin.category, "Login event", 1, eventLogin.count);
player.TryCreateItem(item);
player.SendCompletePacket(PackageDataManager.AUTH_SERVER_MESSAGE_ITEM_RECEIVE_PAK);
if (item.category == 1)
{
weapons.Add(item);
}
else if (item.category == 2)
{
charas.Add(item);
}
else if (item.category == 3)
{
cupons.Add(item);
}
long dateNow = long.Parse(DateTime.Now.ToString("yyMMddHHmm"));
player.ExecuteQuery($"UPDATE player_events SET last_login_date='{dateNow}' WHERE player_id='{player.playerId}'");
}
if (eventVisit != null && playerEvent.LastVisitEventId != eventVisit.id)
{
playerEvent.LastVisitEventId = eventVisit.id;
playerEvent.LastVisitSequence1 = 0;
playerEvent.LastVisitSequence2 = 0;
playerEvent.NextVisitDate = 0;
player.ExecuteQuery($"UPDATE player_events SET last_visit_event_id='{eventVisit.id}', last_visit_sequence1='0', last_visit_sequence2='0', next_visit_date='0' WHERE player_id='{player.playerId}'");
}
EventXmasModel eventXMAS = EventXmasSyncer.GetRunningEvent();
if (eventXMAS != null)
{
if (playerEvent.LastXmasRewardDate < eventXMAS.startDate)
{
playerEvent.LastXmasRewardDate = 0;
player.ExecuteQuery($"UPDATE player_events SET last_xmas_reward_date='0' WHERE player_id='{player.playerId}'");
}
if (!(playerEvent.LastXmasRewardDate > eventXMAS.startDate && playerEvent.LastXmasRewardDate <= eventXMAS.endDate))
{
xmas = true;
}
}
}
}
private static void parse(string path, int cupomId)
{
XmlDocument xmlDocument = new XmlDocument();
using (FileStream fileStream = new FileStream(path, FileMode.Open))
{
if (fileStream.Length == 0)
{
Printf.warning("[RandomBoxXML] O arquivo está vazio: " + path);
}
else
{
try
{
xmlDocument.Load(fileStream);
for (XmlNode xmlNode1 = xmlDocument.FirstChild; xmlNode1 != null; xmlNode1 = xmlNode1.NextSibling)
{
if ("list".Equals(xmlNode1.Name))
{
XmlNamedNodeMap xml2 = xmlNode1.Attributes;
RandomBoxModel box = new RandomBoxModel
{
itemsCount = int.Parse(xml2.GetNamedItem("count").Value)
};
for (XmlNode xmlNode2 = xmlNode1.FirstChild; xmlNode2 != null; xmlNode2 = xmlNode2.NextSibling)
{
if ("item".Equals(xmlNode2.Name))
{
XmlNamedNodeMap xml = xmlNode2.Attributes;
ItemsModel item = null;
int itemId = int.Parse(xml.GetNamedItem("id").Value);
uint count = uint.Parse(xml.GetNamedItem("count").Value);
if (itemId > 0)
{
item = new ItemsModel(itemId)
{
_name = "Randombox",
_equip = int.Parse(xml.GetNamedItem("equip").Value),
_count = count
};
}
box.items.Add(new RandomBoxItem
{
index = int.Parse(xml.GetNamedItem("index").Value),
percent = int.Parse(xml.GetNamedItem("percent").Value),
special = bool.Parse(xml.GetNamedItem("special").Value),
count = count,
item = item
});
}
}
box.SetTopPercent();
boxes.Add(cupomId, box);
}
}
}
catch (Exception ex)
{
SaveLog.fatal(ex.ToString());
Printf.b_danger("[RandomBoxXML] Erro fatal!");
}
}
fileStream.Dispose();
fileStream.Close();
}
}
public PlotForm(ItemsModel Items, PlotModel Model) : this(Items, Model, new Rectangle(0, 0, 0, 0))
{
}
public override void run()
{
try
{
Account p = _client._player;
if (p == null)
{
return;
}
ItemsModel item = p._inventory.getItem(objId);
PlayerBonus bonus = p._bonus;
if (item == null)
{
erro = 0x80000000;
}
else if (ComDiv.getIdStatics(item._id, 1) == 12)
{
if (bonus == null)
{
_client.SendPacket(new INVENTORY_ITEM_EXCLUDE_PAK(0x80000000));
return;
}
bool changed = bonus.RemoveBonuses(item._id);
if (!changed)
{
if (item._id == 1200014000)
{
if (ComDiv.updateDB("player_bonus", "sightcolor", 4, "player_id", p.player_id))
{
bonus.sightColor = 4;
_client.SendPacket(new BASE_USER_EFFECTS_PAK(0, bonus));
}
else
{
erro = 0x80000000;
}
}
else if (item._id == 1200010000)
{
if (bonus.fakeNick.Length == 0)
{
erro = 0x80000000;
}
else
{
if (ComDiv.updateDB("contas", "player_name", bonus.fakeNick, "player_id", p.player_id) &&
ComDiv.updateDB("player_bonus", "fakenick", "", "player_id", p.player_id))
{
p.player_name = bonus.fakeNick;
bonus.fakeNick = "";
_client.SendPacket(new BASE_USER_EFFECTS_PAK(0, bonus));
_client.SendPacket(new AUTH_CHANGE_NICKNAME_PAK(p.player_name));
}
else
{
erro = 0x80000000;
}
}
}
else if (item._id == 1200009000)
{
if (ComDiv.updateDB("player_bonus", "fakerank", 55, "player_id", p.player_id))
{
bonus.fakeRank = 55;
_client.SendPacket(new BASE_USER_EFFECTS_PAK(0, bonus));
}
else
{
erro = 0x80000000;
}
}
else if (item._id == 1200006000)
{
if (ComDiv.updateDB("contas", "name_color", 0, "player_id", p.player_id))
{
p.name_color = 0;
_client.SendPacket(new BASE_2612_PAK(p));
Room room = p._room;
if (room != null)
{
using (ROOM_GET_NICKNAME_PAK packet = new ROOM_GET_NICKNAME_PAK(p._slotId, p.player_name, p.name_color))
room.SendPacketToPlayers(packet);
}
}
else
{
erro = 0x80000000;
}
}
}
else
{
PlayerManager.updatePlayerBonus(p.player_id, bonus.bonuses, bonus.freepass);
}
CupomFlag cupom = CupomEffectManager.getCupomEffect(item._id);
if (cupom != null && cupom.EffectFlag > 0 && p.effects.HasFlag(cupom.EffectFlag))
{
p.effects -= cupom.EffectFlag;
PlayerManager.updateCupomEffects(p.player_id, p.effects);
}
}
if (erro == 1 && item != null)
{
if (PlayerManager.DeleteItem(item._objId, p.player_id))
{
p._inventory.RemoveItem(item);
}
else
{
erro = 0x80000000;
}
}
_client.SendPacket(new INVENTORY_ITEM_EXCLUDE_PAK(erro, objId));
}
catch (Exception ex)
{
SaveLog.fatal(ex.ToString());
Printf.b_danger("[INVENTORY_ITEM_EXCLUDE_REC.INVENTORY_ITEM_EXCLUDE_REC] Erro fatal!");
_client.SendPacket(new INVENTORY_ITEM_EXCLUDE_PAK(0x80000000));
}
}
public static void OpenPlots(ItemsModel Items)
{
Items.OpenPlots(OpenPlot);
}
//add record
public void addItems(ItemsModel item)
{
ItemDAL.addItems(item);
}
public override void RunImplement()
{
try
{
Account player = client.SessionPlayer;
ItemsModel itemObj = player != null?player.inventory.GetItem(objectId) : null;
if (itemObj != null)
{
itemId = itemObj.id;
oldCOUNT = itemObj.count;
if (itemObj.category == 3 && player.inventory.items.Count >= 500)
{
client.SendPacket(new INVENTORY_ITEM_EQUIP_PAK(0x80001029));
Logger.Warning($" [GAME] [PROTOCOL_INVENTORY_ITEM_EQUIP_REQ] Foi atingido o limite de 500 items no inventário. Nick: {player.nickname} Login: {player.login} PlayerId: {player.playerId}");
return;
}
if (itemId == 1301049000)
{
if (player.UpdateKDReset())
{
player.statistics.kills = 0;
player.statistics.deaths = 0;
client.SendPacket(new BASE_USER_CHANGE_STATS_PAK(player.statistics));
}
else
{
client.SendCompletePacket(PackageDataManager.INVENTORY_ITEM_EQUIP_0x80000000_PAK);
return;
}
}
else if (itemId == 1301048000)
{
if (player.UpdateTotalFights())
{
player.statistics.fights = 0;
player.statistics.fightsWin = 0;
player.statistics.fightsLost = 0;
player.statistics.fightsDraw = 0;
client.SendPacket(new BASE_USER_CHANGE_STATS_PAK(player.statistics));
}
else
{
client.SendCompletePacket(PackageDataManager.INVENTORY_ITEM_EQUIP_0x80000000_PAK);
return;
}
}
else if (itemId == 1301050000)
{
if (player.ExecuteQuery($"UPDATE accounts SET fights_escapes='0' WHERE id='{player.playerId}'"))
{
player.statistics.escapes = 0;
client.SendPacket(new BASE_USER_CHANGE_STATS_PAK(player.statistics));
}
else
{
client.SendCompletePacket(PackageDataManager.INVENTORY_ITEM_EQUIP_0x80000000_PAK);
return;
}
}
else if (itemId == 1301053000)
{
Clan clan = ClanManager.GetClan(player.clanId);
if (clan.id > 0 && clan.ownerId == player.playerId && clan.UpdateBattlesReset())
{
clan.partidas = 0;
clan.vitorias = 0;
clan.derrotas = 0;
client.SendPacket(new CLAN_CHANGE_FIGHTS_PAK());
}
else
{
client.SendCompletePacket(PackageDataManager.INVENTORY_ITEM_EQUIP_0x80000000_PAK);
return;
}
}
else if (itemId == 1301055000)
{
Clan clan = ClanManager.GetClan(player.clanId);
if (clan.id > 0 && clan.ownerId == player.playerId)
{
if ((clan.maxPlayers + 50) <= 250 && player.ExecuteQuery($"UPDATE clan_data SET max_players='{clan.maxPlayers + 50}' WHERE clan_id='{player.clanId}'"))
{
clan.maxPlayers += 50;
client.SendPacket(new CLAN_CHANGE_MAX_PLAYERS_PAK(clan.maxPlayers));
}
else
{
erro = 0x80001056;
}
}
else
{
erro = 0x80001056;
}
}
else if (itemId == 1301056000)
{
Clan clan = ClanManager.GetClan(player.clanId);
if (clan.id > 0 && clan.pontos != 1000)
{
if (player.ExecuteQuery($"UPDATE clan_data SET pontos='{1000.0f}' WHERE clan_id='{player.clanId}'"))
{
clan.pontos = 1000;
client.SendPacket(new CLAN_CHANGE_POINTS_PAK());
}
else
{
erro = 0x80001056;
}
}
else
{
erro = 0x80001056;
}
}
else if (itemId > 1301113000 && itemId < 1301119000)
{
int goldReceive = itemId == 1301114000 ? 500 : (itemId == 1301115000 ? 1000 : (itemId == 1301116000 ? 5000 : (itemId == 1301117000 ? 10000 : 30000)));
if ((player.gold + goldReceive) <= 999999999 && player.ExecuteQuery($"UPDATE accounts SET gold='{player.gold + goldReceive}' WHERE id='{player.playerId}'"))
{
player.gold += goldReceive;
client.SendPacket(new AUTH_GOLD_REWARD_PAK(goldReceive, player.gold, 0));
}
else
{
client.SendCompletePacket(PackageDataManager.INVENTORY_ITEM_EQUIP_0x80000000_PAK);
return;
}
}
else if (itemId == 1301999000)
{
if ((player.exp + 515999) <= 999999999 && player.ExecuteQuery($"UPDATE accounts SET exp='{player.exp + 515999}' WHERE id='{player.playerId}'"))
{
player.exp += 515999;
client.SendPacket(new A_3096_PAK(515999, 0));
}
else
{
client.SendCompletePacket(PackageDataManager.INVENTORY_ITEM_EQUIP_0x80000000_PAK);
return;
}
}
else if (itemObj.category == 3 && RandomBoxXML.ContainsBox(itemId))
{
RandomBoxModel box = RandomBoxXML.GetBox(itemId);
if (box != null)
{
List <RandomBoxItem> sortedList = box.GetSortedList(GetRandomNumber(1, 100));
List <RandomBoxItem> rewardList = box.GetRewardList(sortedList, GetRandomNumber(0, sortedList.Count));
if (rewardList.Count > 0)
{
byte itemIdx = (byte)rewardList[0].index;
client.SendPacket(new AUTH_RANDOM_BOX_REWARD_PAK(itemId, itemIdx));
List <ItemsModel> rewards = new List <ItemsModel>();
for (int i = 0; i < rewardList.Count; i++)
{
RandomBoxItem cupom = rewardList[i];
if (cupom.item != null)
{
rewards.Add(cupom.item);
}
else if (player.UpdateAccountGold(player.gold + cupom.count))
{
player.gold += cupom.count;
client.SendPacket(new AUTH_GOLD_REWARD_PAK(cupom.count, player.gold, 0));
}
else
{
client.SendCompletePacket(PackageDataManager.INVENTORY_ITEM_EQUIP_0x80000000_PAK);
break;
}
if (cupom.special)
{
using (AUTH_JACKPOT_NOTICE_PAK packet = new AUTH_JACKPOT_NOTICE_PAK(player.nickname, itemId, itemIdx))
{
GameManager.SendPacketToAllClients(packet);
}
}
}
if (rewards.Count > 0)
{
client.SendPacket(new PROTOCOL_INVENTORY_ITEM_CREATE_ACK(1, player, rewards));
}
rewards = null;
}
else
{
client.SendCompletePacket(PackageDataManager.INVENTORY_ITEM_EQUIP_0x80000000_PAK);
return;
}
sortedList = null;
rewardList = null;
}
else
{
client.SendCompletePacket(PackageDataManager.INVENTORY_ITEM_EQUIP_0x80000000_PAK);
return;
}
}
else if (player.rankId < 31 && (itemId == 1103003001 || itemId == 1103003002 || itemId == 1103003003 || itemId == 1103003004 || itemId == 1103003005))
{
client.SendPacket(new SERVER_MESSAGE_ANNOUNCE_PAK("Você não tem rank suficiente para equipar esta boina."));
return;
}
else
{
int wclass = GetIdStatics(itemObj.id, 1);
if (wclass <= 11)
{
if (itemObj.equip == 1)
{
itemObj.equip = 2;
itemObj.count = int.Parse(DateTime.Now.AddSeconds(itemObj.count).ToString("yyMMddHHmm"));
player.ExecuteQuery($"UPDATE player_items SET count='{itemObj.count}', equip='{(int)itemObj.equip}' WHERE object_id='{objectId}' AND owner_id='{player.playerId}'");
}
else
{
client.SendCompletePacket(PackageDataManager.INVENTORY_ITEM_EQUIP_0x80000000_PAK);
return;
}
}
else if (wclass == 13)
{
CupomIncreaseDays(player, itemObj.name);
}
else if (wclass == 15)
{
CupomIncreaseGold(player, itemObj.id);
}
else
{
client.SendCompletePacket(PackageDataManager.INVENTORY_ITEM_EQUIP_0x80000000_PAK);
return;
}
}
}
else
{
client.SendCompletePacket(PackageDataManager.INVENTORY_ITEM_EQUIP_0x80000000_PAK);
return;
}
client.SendPacket(new INVENTORY_ITEM_EQUIP_PAK(erro, itemObj, player));
}
catch (OverflowException ex)
{
Logger.Error($" [PROTOCOL_INVENTORY_ITEM_EQUIP_REQ] [OverflowException] ObjectId: {objectId} ItemId: {itemId} Count na DB: {oldCOUNT} Nick: {client.SessionPlayer.nickname}\r\n" + ex.ToString());
client.SendCompletePacket(PackageDataManager.INVENTORY_ITEM_EQUIP_0x80000000_PAK);
}
catch (Exception ex)
{
client.SendCompletePacket(PackageDataManager.INVENTORY_ITEM_EQUIP_0x80000000_PAK);
PacketLog(ex);
}
}
//UpdateItem
public void UpdateItem(ItemsModel item)
{
ItemDAL.UpdateItem(item);
}
public async Task <bool> UpdateCatalogItem(ItemsModel item)
{
var response = await _client.GetAsync($"/Items");
return(await response.ReadContentAs <bool>());
}
public IActionResult UpdateItems(ItemsModel itemid)
{
return(Ok(_manager.UpdateItemsManager(itemid)));
throw new Exception("Exception while retrieving the items from the storage.");
}
public async Task <HttpClientServiceResult <string> > PlaceOrderAsync(string url, string username, ItemsModel itemsModes)
{
await TokenProvider.AttachAccessTokenToHeader(HttpClient, HttpContextAccessor);
HttpResponseMessage response;
try
{
var items = new TempDataHolder(username, itemsModes.Items, DateTimeOffset.UtcNow);
var json = JsonSerializer.Serialize(items);
//Needed to setup the body of the request
var data = new StringContent(json, Encoding.UTF8, "application/json");
response = await HttpClient.PostAsync(url, data);
response.EnsureSuccessStatusCode();
}
catch (HttpRequestException e)
{
return(new HttpClientServiceResult <string>
{
Content = null !,
StatusCode = 500, // Server Error!
Error = e.Message
});
//var model = Items.Find(i => i.Id == Id);
//return View(model);
public IActionResult Add()
{
var item = new ItemsModel();
return(View(item));
}
Task <int> IRepository <ItemsModel> .InsertAsync(ItemsModel model)
{
EntityExtension.FlagForCreate(model, _identityProvider.Username, USER_AGENT);
_ItemsDbSet.Add(model);
return(_dbContext.SaveChangesAsync());
}
public async Task <IActionResult> GetAll(int offset = 0, int limit = 100)
{
long totalCount = 0;
var totalPages = 0;
var pagedList = await itemApp.GetAllAsync(offset, limit);
if (pagedList.IsNotNull() && pagedList.Items.IsNotNull() && pagedList.Items.Count > 0)
{
totalCount = pagedList.Total;
totalPages = (int)Math.Ceiling((double)totalCount / limit);
}
var urlHelper = urlHelperFactory.GetUrlHelper(ControllerContext);
var prevLink = offset > 0 ? urlHelper.Link("GetAllItems", new { offset = limit > offset ? 0 : offset - limit, limit = limit }) : string.Empty;
var nextLink = offset < totalCount - limit ? urlHelper.Link("GetAllItems", new { offset = offset + limit, limit = limit }) : string.Empty;
var firstLink = offset > 0 ? urlHelper.Link("GetAllItems", new { offset = 0, limit = limit }) : string.Empty;
var lastLink = offset < totalCount - limit ? urlHelper.Link("GetAllItems", new { offset = totalCount - limit, limit = limit }) : string.Empty;
var links = new List <Link>();
if (prevLink.HasValue())
{
links.Add(new Link {
Href = prevLink, Method = Method.GET, Relations = "previous"
});
}
if (nextLink.HasValue())
{
links.Add(new Link {
Href = nextLink, Method = Method.GET, Relations = "next"
});
}
if (firstLink.HasValue())
{
links.Add(new Link {
Href = firstLink, Method = Method.GET, Relations = "first"
});
}
if (lastLink.HasValue())
{
links.Add(new Link {
Href = lastLink, Method = Method.GET, Relations = "last"
});
}
var result = new ItemsModel
{
TotalCount = pagedList.Total,
TotalPages = totalPages,
Links = links,
Items = pagedList.Items.Select(e => ItemModel.ToModel(e)).ToList()
};
return(Ok(result));
}
