public MapperData(string productId, string catEntryId, string productUrl, InventoryData inventory)
{
ProductId = productId;
CatEntryId = catEntryId;
ProductUrl = productUrl;
Inventory = inventory;
}
void Awake()
{
inventoryData = this.gameObject.GetComponent<InventoryData>();
inventoryLogic = this.gameObject.GetComponent<InventoryLogic>();
playerData = GameObject.Find("Player").GetComponent<PlayerData>();
playerLogic = GameObject.Find("Player").GetComponent<PlayerLogic>();
}
protected override void Awake()
{
base.Awake();
_data = GetComponentInChildren <InventoryData>();
_characterData = GetComponentInChildren <CharacterData>();
}
/// <summary>
/// Creates a connection using token.
/// </summary>
/// <param name="companyId">Company context</param>
/// <param name="token">The predefined token from Visma.net</param>
/// <param name="branchId">Branch ID to work with in the Visma.net Company (optional)</param>
public VismaNet(int companyId, string token, int branchId = 0)
{
if (string.IsNullOrEmpty(token))
{
throw new InvalidArgumentsException("Token is missing");
}
Auth = new VismaNetAuthorization
{
Token = token,
CompanyId = companyId,
BranchId = branchId
};
Customers = new CustomerData(Auth);
CustomerInvoices = new CustomerInvoiceData(Auth);
Suppliers = new SupplierData(Auth);
SupplierInvoices = new SupplierInvoiceData(Auth);
CashSales = new CashSaleData(Auth);
CustomerDocuments = new CustomerDocumentData(Auth);
Dimensions = new DimensionData(Auth);
Inventory = new InventoryData(Auth);
JournalTransactions = new JournalTransactionData(Auth);
Accounts = new FinAccountData(Auth);
Employee = new EmployeeData(Auth);
CreditNote = new CreditNoteData(Auth);
Shipments = new ShipmentData(Auth);
Contacts = new ContactData(Auth);
Projects = new ProjectData(Auth);
SalesOrder = new SalesOrderData(Auth);
}
public void LoadSerialization(InventoryData loadedInventory)
{
itemsEquipInInv = loadedInventory.itemsEquipInInv;
itemsConsumeInInv = loadedInventory.itemsConsumeInInv;
itemsOtherInInv = loadedInventory.itemsOtherInInv;
SyncItemsInInventory();
}
public void ReadFile(string jsonFile = "")
{
List <InventoryData> objList = new List <InventoryData> ();
//inventory = new QI_Inventory();
if (jsonFile == "")
{
jsonFile = jsonFileName;
}
// Debug.Log("Loading -> " + jsonFile);
string path = Application.persistentDataPath + "/" + jsonFile;
//Read the text from directly from the test.txt file
StreamReader reader = new StreamReader(path);
string line = "";
bool done = false;
//reader
while ((line = reader.ReadLine()) != null)
{
//Debug.Log("Read -> " + line);
InventoryData data = CreateFromJSON(line);
inventory.AddItem(itemDatabase.GetItem(data.name), data.amount);
//objList.Add(CreateFromJSON(line));
}
//.ReadToEnd());
reader.Close();
//return objList;
}
// 删除物品
private void OnDeleteItem(UserToken token, SocketModel model)
{
ReqDeleteItem req = SerializeUtil.Deserialize <ReqDeleteItem>(model.message);
// 应答
RespDeleteItem resp = new RespDeleteItem();
if (req.deleteType == DeleteType.Equip)
{
EquipData equipData = CacheManager.instance.GetEquipData(token.characterid, req.slot);
equipData.itemid = -1;
resp.dto = EquipData.GetInvDTO(equipData);
resp.deleteType = DeleteType.Equip;
equipData = CacheManager.instance.GetEquipData(token.characterid, req.slot);
}
else
{
// 获取背包栏位物品数据
InventoryData invData = CacheManager.instance.GetInvData(token.characterid, req.slot);
invData.itemid = -1;
invData.num = 0;
resp.dto = InventoryData.GetInvDTO(invData);
resp.deleteType = DeleteType.Inv;
}
NetworkManager.Send(token, (int)MsgID.INV_Delete_Item_SRES, resp);
}
public ReportData(InventoryData inventoryData)
{
foreach (InventoryProduct item in inventoryData.inventoryProducts)
{
switch (item.name.ToUpper())
{
case "SOAP":
reportProducts.Add(new productSoap(name: item.name, sellIn: item.sellIn, quality: item.quality));
break;
case "CHRISTMAS CRACKERS":
reportProducts.Add(new productXmasCrackers(name: item.name, sellIn: item.sellIn, quality: item.quality));
break;
case "AGED BRIE":
reportProducts.Add(new productAgedBrie(name: item.name, sellIn: item.sellIn, quality: item.quality));
break;
case "FRESH ITEM":
reportProducts.Add(new productFreshItem(name: item.name, sellIn: item.sellIn, quality: item.quality));
break;
case "FROZEN ITEM":
reportProducts.Add(new productFrozenItem(name: item.name, sellIn: item.sellIn, quality: item.quality));
break;
default:
reportProducts.Add(new UnknownProduct(name: item.name, sellIn: item.sellIn, quality: item.quality));
break;
}
}
}
public void Load()
{
if (File.Exists(Application.persistentDataPath + "/inventoryInfo.dat"))
{
BinaryFormatter bf = new BinaryFormatter();
FileStream file = File.Open(Application.persistentDataPath + "/inventoryInfo.dat", FileMode.Open);
InventoryData data = (InventoryData)bf.Deserialize(file);
file.Close();
currency = data.currency;
heldItems = new List <string>(data.heldItems.Count);
for (int i = 0; i < data.heldItems.Count; i++)
{
heldItems.Add(data.heldItems[i]);
}
curInvSize = data.curInvSize;
}
else
{
currency = 0;
heldItems = new List <string>();
curInvSize = 0;
}
}
//save current inventory
public void SaveCurrentInventory()
{
//create slot array
InventoryData.SlotData[] currentInventoryItems = new InventoryData.SlotData[UIManager.instance.inventorySlots.Count];
//search all slots
for (int i = 0; i < UIManager.instance.inventorySlots.Count; i++)
{
SlotManager slot = UIManager.instance.inventorySlots[i];
if (slot.isSlotEmpty)//if slot empty create null item
{
currentInventoryItems[i] = new InventoryData.SlotData(null, true);
continue;
}
//if not, copy item
Item slotItem = new Item(slot.slotItem);
currentInventoryItems[i] = new InventoryData.SlotData(slotItem, false);
}
//add to saved inventory lists
InventoryData currentInventoryData = new InventoryData(inventoryName.text, currentInventoryItems);
savedInventorys.Add(currentInventoryData);
UpdateSavedList();
}
static public void SaveGameplay(ShapeData[] t_shapes, InventoryData t_inventory)
{
LevelData levelData = new LevelData();
foreach (ShapeData shape in t_shapes)
{
SaveShapeData shapeData = new SaveShapeData();
shapeData.name = shape.name;
shapeData.objectPosition = shape.m_position;
levelData.m_saveShapeDatas.Add(shapeData);
}
SaveInventoryData inventoryData = new SaveInventoryData();
inventoryData.itemTypes = t_inventory.m_inventoryItems;
levelData.m_saveInventoryData = inventoryData;
string jsonData = JsonUtility.ToJson(levelData, true);
string fullPath = s_jsonPath + s_currentLevel + ".txt";
System.IO.File.WriteAllText(fullPath, jsonData);
}
void GetNewShop()
{
time_created = DateTime.Today;
if (DateTime.Now.Hour >= 12)
{
time_created = time_created.AddHours(12);
}
InventoryData new_inventory = new InventoryData(UnityEngine.Random.Range(1000, 2001));
new_inventory.base_inventory_data.base_pieces = new int[Database.GetMaxID(ItemType.BasePiece)];
for (int i = 1; i < Database.GetMaxID(ItemType.BasePiece); i++)
{
if (i != Database.base_pieces.entrance_id && i != Database.base_pieces.exit_id)
{
new_inventory.base_inventory_data.base_pieces[i] = UnityEngine.Random.Range(0, 11);
}
}
new_inventory.base_inventory_data.enemy_groups = new int[Database.GetMaxID(ItemType.EnemyGroup)];
for (int i = 1; i < Database.GetMaxID(ItemType.EnemyGroup); i++)
{
new_inventory.base_inventory_data.enemy_groups[i] = UnityEngine.Random.Range(0, 11);
}
inventory.LoadInventory(new_inventory);
}
public string removeItemName(params string[] args)
{
string name;
int num;
try {
name = args[0].Replace("_", " ");
} catch (Exception e) {
return("Missing Item Name");
}
try {
num = int.Parse(args[1]);
} catch (Exception e) {
return("Missing Quantity");
}
bool used = InventoryData.RemoveItem(name, num);
if (used)
{
return("Item removed from inventory");
}
else
{
return("Item could not be removed");
}
}
public string additem(params string[] args)
{
string name;
int num;
try{
name = args[0];
} catch (Exception e) {
return("Missing Item Name");
}
try{
num = int.Parse(args[1]);
} catch (Exception e) {
return("Missing Quantity");
}
InventoryData.AddItem(ItemDictionary.itemDict.GetItem(name), num);
if (ItemDictionary.itemDict.Contains(name))
{
return("Item added to inventory");
}
else
{
return("Item does not exist");
}
}
public DroneSaveData(Position _curPosition, Position _targePosition,
bool _isTravelling, bool _isBusy, bool _isLaser,
Position _currentTaskPosition, List <InventoryItemSlot> _currentTaskMaterials,
List <InventoryItemSlot> _myInv,
int _droneState,
Position _targetStorage,
Position _constructionInventory)
{
curPosition = _curPosition;
targetPosition = _targePosition;
isTravelling = _isTravelling;
isBusy = _isBusy;
isLaser = _isLaser;
currentTaskPosition = _currentTaskPosition;
currentTaskMaterials = InventoryData.ConvertToSaveData(_currentTaskMaterials);
myInv = InventoryData.ConvertToSaveData(_myInv);
droneState = _droneState;
targetStorage = _targetStorage;
constructionInventory = _constructionInventory;
}
public BeltSaveData(Position _start, Position _end, int _direction, List <InventoryItemSlot> slots)
{
start = _start;
end = _end;
direction = _direction;
myInv = InventoryData.ConvertToSaveData(slots);
}
public async Task <IActionResult> UpdateInventory(InventoryData InvenData)
{
User user = await _auth.GetUser(this.User.Identity.Name);
Permissions permissions = await _auth.GetPermissions(user.Id);
if (permissions.UpdateInventory == false)
{
return(Unauthorized());
}
Inventory inventory;
inventory = await _repo.GetInventory(InvenData.Id);
//probably a much better way to do this
//possibly something like:
//PropertyInfo[] properties = inventory.GetType().GetProperties();
//foreach (PropertyInfo pi in properties)
inventory.Name = InvenData.Name;
inventory.UPC = InvenData.UPC;
inventory.Price = InvenData.Price;
inventory.Description = InvenData.Description;
inventory.Quantity = InvenData.Quantity;
//inventory.AlertBit = InvenData.AlertBit;
var updatedInventory = await _repo.UpdateInventory(inventory);
//Check if this changes the alert status
await _alert.CheckAlert(updatedInventory.Id, updatedInventory.Quantity);
//created at root status code
return(StatusCode(201));
}
public void AddItem(int source, string Id, int Count, dynamic MetaData)
{
Player player = Players[source];
InventoryData data = GetInventoryData(player, "player");
if (data.Inventory.Values.Any(value => value.Id == Id))
{
KeyValuePair <int, InventorySlot> slot = data.Inventory.First(value => value.Value.Id == Id);
slot.Value.Count += Count;
Inventory.UpdateSlot(slot.Key, data, slot.Value);
}
else
{
var slot = new InventorySlot
{
Id = Id,
Count = Count,
MetaData = MetaData
};
int slotPos = FindFreeSlot(data.Inventory);
data.Inventory.Add(slotPos, slot);
Inventory.CreateSlot(slotPos, data, slot);
}
player.TriggerEvent(Events.UpdateInventory, data);
}
public async Task <IActionResult> AddInventory(InventoryData iData)
{
User user = await _auth.GetUser(this.User.Identity.Name);
Permissions permissions = await _auth.GetPermissions(user.Id);
if (permissions.AddIventory == false)
{
return(Unauthorized());
}
if (ModelState.IsValid)
{
var itemToCreate = new Inventory
{
UPC = iData.UPC,
Name = iData.Name,
Price = iData.Price,
Description = iData.Description,
Quantity = iData.Quantity,
//InventoryLocationID = iData.InventoryLocationID,
//InventoryAlertID = iData.InventoryAlertID,
QB_Id = -1
};
var createdInventory = await _repo.AddInventory(itemToCreate);
//created at root status code
return(StatusCode(201));
}
else
{
return(BadRequest(ModelState));
}
}
// 装备物品
private void OnInvEquip(UserToken token, SocketModel model)
{
ReqEquipItem req = SerializeUtil.Deserialize <ReqEquipItem>(model.message);
// 获取背包栏位物品数据
InventoryData invData = CacheManager.instance.GetInvData(token.characterid, req.slot);
// 获取装备栏位物品数据
ItemCfg itemCfg = ConfigManager.instance.GetItemCfg(req.itemid);
EquipData equipData = CacheManager.instance.GetEquipData(token.characterid, (int)itemCfg.EquipType);
int itemid = invData.itemid;
invData.itemid = equipData.itemid;
equipData.itemid = itemid;
if (invData.itemid == -1)
{
invData.num = 0;
}
RespEquipItem resp = new RespEquipItem();
resp.equip = EquipData.GetInvDTO(equipData);
resp.inv = InventoryData.GetInvDTO(invData);
NetworkManager.Send(token, (int)MsgID.INV_Equip_SRES, resp);
}
public Inventory NewInventory(Vector3 worldPosition, InventoryData data, bool isPermanent = false, InventoryType type = null)
{
if (!type)
{
type = defaultType;
}
if (!data)
{
data = ScriptableObject.CreateInstance <InventoryData>();
data.name = "New";
data.height = 1;
data.width = 1;
}
GameObject obj = Instantiate(inventoryPrefab, transform);
obj.transform.position = new Vector3(worldPosition.x - data.width / 2, worldPosition.y - data.height / 2);
Inventory inventory = obj.GetComponent <Inventory>();
inventory.Initialize(type, data, isPermanent);
AddInventory(inventory);
return(inventory);
}
public void SaveInventoryData()
{
InventoryData inventoryData = new InventoryData();
inventoryData.ItemTypes = new ItemTypeForInventorySave[DataManager.Instance.PlayerData.Inventory.MaxItemCount];
for (int i = 0; i < inventoryData.ItemTypes.Length; i++)
{
if (DataManager.Instance.PlayerData.Inventory.ItemSlots[i] == null)
{
inventoryData.ItemTypes[i] = ItemTypeForInventorySave.Empty;
}
else
{
inventoryData.ItemTypes[i] = (ItemTypeForInventorySave)DataManager.Instance.PlayerData.Inventory.ItemSlots[i].Type;
}
}
inventoryData.Gold = DataManager.Instance.PlayerData.Inventory.Gold;
if (File.Exists(characterInventoryDataPath))
{
File.Delete(characterInventoryDataPath);
}
string data = JsonUtility.ToJson(inventoryData);
FileStream fileStream = new FileStream(characterInventoryDataPath, FileMode.OpenOrCreate, FileAccess.Write);
byte[] bytes = Encoding.UTF8.GetBytes(data);
fileStream.Write(bytes, 0, bytes.Length);
fileStream.Close();
}
public InventoryRepositorySpec()
{
InventoryData.Clients.Add(_clientId);
_data = InventoryData.Cache();
_testObject = new InventoryRepository(_data, InventoryData.Clients);
}
// SAVING & LOADING
public void Save()
{
// Save inventory data
var inventoryData = new InventoryData();
inventoryData.hasInventory = hasInventory;
inventoryData.numberOfFilledSlots = numberOfFilledSlots;
GameManager.Instance.gameData.inventory = inventoryData;
// Save item data
GameManager.Instance.gameData.items = new ItemData[numberOfFilledSlots];
for (int i = 0; i < numberOfFilledSlots; i++)
{
var data = new ItemData();
if (inventorySlots[i].item)
{
data.itemName = inventorySlots[i].item.itemName;
data.currentCount = inventorySlots[i].item.currentCount;
data.durability = inventorySlots[i].item.durability;
GameManager.Instance.gameData.items[i] = data;
}
else
{
GameManager.Instance.gameData.items[i] = null;
}
}
}
private bool onInventoryRetrieved(InventoryServiceEvents.InventoryLoaded evt)
{
Service.Get <EventDispatcher>().RemoveListener <InventoryServiceEvents.InventoryLoaded>(onInventoryRetrieved);
DataEntityHandle localPlayerHandle = Service.Get <CPDataEntityCollection>().LocalPlayerHandle;
if (!localPlayerHandle.IsNull)
{
InventoryData inventoryData = Service.Get <CPDataEntityCollection>().AddComponent <InventoryData>(localPlayerHandle);
inventoryData.Inventory = new Dictionary <long, InventoryIconModel <DCustomEquipment> >();
inventoryData.CurrentAvatarEquipment = new List <long>();
for (int i = 0; i < evt.Inventory.Count; i++)
{
try
{
DCustomEquipment data = CustomEquipmentResponseAdaptor.ConvertResponseToCustomEquipment(evt.Inventory[i]);
InventoryIconModel <DCustomEquipment> value = new InventoryIconModel <DCustomEquipment>(data.Id, data, isEquipped: false, isMemberItem: true);
inventoryData.Inventory.Add(data.Id, value);
}
catch (KeyNotFoundException)
{
}
}
}
else
{
Log.LogError(this, "Unable to find the LocalPlayerHandle.");
}
if (callback != null)
{
callback();
callback = null;
}
return(false);
}
public void WriteFile(string jsonFile = "") //Objective objective)
{
List <InventoryData> objList = new List <InventoryData> ();
foreach (QI_ItemData entry in itemDatabase.Items)
{
if (inventory.GetStock(entry.Name) > 0)
{
InventoryData data = new InventoryData(entry.Name, inventory.GetStock(entry.Name));
objList.Add(data);
}
}
if (jsonFile == "")
{
jsonFile = jsonFileName;
}
//Debug.Log("Saving -> " + jsonFile);
//if (objList == null) objList = masterObjectiveList;
string path = Application.persistentDataPath + "/" + jsonFile;
//Write some text to the test.txt file
StreamWriter writer = new StreamWriter(path, false);
writer.Close();
writer = new StreamWriter(path, true);
foreach (InventoryData obj in objList)
{
//WriteFile(obj);
//Debug.Log("Write -> " + CreateJSON(obj));
writer.WriteLine(CreateJSON(obj));
}
writer.Close();
}
private void OnEnable()
{
inventoryData = (InventoryData)target;
listLenth = inventoryData.items.Count;
selectedItem = -1;
hoveredItem = -1;
}
//load selected inventory
public void LoadInventory()
{
//get selected inventory
Dropdown.OptionData optionData = inventoryList.options[inventoryList.value];
InventoryData loadInventoryData = savedInventorys.Find(i => i.inventoryName == optionData.text);
//create selected inventory items
for (int i = 0; i < UIManager.instance.inventorySlots.Count; i++)
{
if (loadInventoryData.itemList[i].isEmpty)
{
UIManager.instance.inventorySlots[i].CreateItemOnSlot(null);
continue;
}
Item slotItem = new Item(loadInventoryData.itemList[i].slotItem);
UIManager.instance.inventorySlots[i].CreateItemOnSlot(slotItem);
}
//update InventoryManager
InventoryManager.instance.itemList.Clear();
foreach (var slot in UIManager.instance.inventorySlots)
{
if (slot.isSlotEmpty)
{
continue;
}
InventoryManager.instance.itemList.Add(slot.slotItem);
}
//reset text,trigger event
inventoryName.text = "";
InventoryLoaded();
}
private World CreateFreshWorld()
{
PersistedWorldData pWorldData = new PersistedWorldData
{
BaseData = BaseData.From(new List <BasePiece>(), new List <BasePiece>()),
EntityData = EntityData.From(new List <Entity>()),
PlayerData = PlayerData.From(new List <Player>()),
WorldData = new WorldData()
{
EscapePodData = EscapePodData.From(new List <EscapePodModel>()),
GameData = new GameData
{
PDAState = new PDAStateData(),
StoryGoals = new StoryGoalData(),
StoryTiming = new StoryTimingData()
},
InventoryData = InventoryData.From(new List <ItemData>(), new List <ItemData>(), new List <EquippedItemData>()),
VehicleData = VehicleData.From(new List <VehicleModel>()),
ParsedBatchCells = new List <NitroxInt3>(),
ServerStartTime = DateTime.Now
#if DEBUG
,
Seed = "TCCBIBZXAB"
#endif
}
};
return(CreateWorld(pWorldData, config.GameMode));
}
private World CreateWorld(DateTime serverStartTime,
EntityData entityData,
BaseData baseData,
VehicleData vehicleData,
InventoryData inventoryData,
PlayerData playerData,
GameData gameData,
List <Int3> ParsedBatchCells)
{
World world = new World();
world.TimeKeeper = new TimeKeeper();
world.TimeKeeper.ServerStartTime = serverStartTime;
world.SimulationOwnership = new SimulationOwnership();
world.PlayerManager = new PlayerManager(playerData);
world.EntityData = entityData;
world.EventTriggerer = new EventTriggerer(world.PlayerManager);
world.BaseData = baseData;
world.VehicleData = vehicleData;
world.InventoryData = inventoryData;
world.PlayerData = playerData;
world.GameData = gameData;
ResourceAssets resourceAssets = ResourceAssetsParser.Parse();
world.BatchEntitySpawner = new BatchEntitySpawner(resourceAssets, ParsedBatchCells);
return(world);
}
public void UnequipSelected()
{
ItemData item = InventoryData.EquipmentData.GetEquipmentSlot(selectedSlotId.equipmentSlotType).Item;
InventoryData.Unequip(selectedSlotId.equipmentSlotType);
Select(new ItemSlotID(InventoryData.InventorySlotIdOf(item)));
}
/// <summary>
/// 序列化存入数据
/// </summary>
/// <param name="Data"></param>
public static void SaveData(List<ItemData> Data, string DataPath)
{
InventoryData inventorydata = new InventoryData();
inventorydata.Items = Data;
XmlSerializer Xml = new XmlSerializer(typeof(InventoryData));
FileStream Stream = new FileStream(DataPath, FileMode.Create);
Xml.Serialize(Stream, inventorydata);
Stream.Close();
}
void Start ()
{
instance = this;
Toggle = false;
m_MaxItemSlots = m_MaxItems;
m_Items = new GameObject[m_MaxItems];
m_Player = GameObject.Find(m_PlayerName);
gameObject.transform.localPosition = new Vector3 (-0.7f, -20f, 0f);
}
/// <summary>
/// 反序列载入数据
/// </summary>
/// <returns></returns>
public static List<ItemData> LoadData(string DataPath)
{
if (File.Exists(DataPath))
{
InventoryData inventorydata = new InventoryData();
XmlSerializer Xml = new XmlSerializer(typeof(InventoryData));
FileStream Stream = new FileStream(DataPath, FileMode.Open);
inventorydata = Xml.Deserialize(Stream) as InventoryData;
Stream.Close();
return inventorydata.Items;
}
else
return new List<ItemData>();
}
public void SaveInventory()
{
BinaryFormatter bf = new BinaryFormatter ();
FileStream file = File.Create(Application.persistentDataPath + "/InventoryData.dat");
InventoryData data = new InventoryData ();
data._Items = Inventory._Items;
data._Recipes = Inventory._Recipes;
data._Armors = Inventory._Armors;
data._Weapons = Inventory._Weapons;
data.currentWeapon = Inventory.currentWeapon;
data.currentArmor = Inventory.currentArmor;
bf.Serialize (file, data);
file.Close ();
}
/// <summary>
/// 读取物品列表中的道具信息
/// </summary>
/// <param name="Name">道具名字</param>
/// <returns></returns>
public static ItemData LoadItemData(string Name)
{
InventoryData allitemsdata = new InventoryData();
XmlSerializer Xml = new XmlSerializer(typeof(InventoryData));
FileStream Stream = new FileStream(AllItemsDataPath, FileMode.Open);
allitemsdata = Xml.Deserialize(Stream) as InventoryData;
Stream.Close();
ItemData Data = new ItemData();
foreach (ItemData item in allitemsdata.Items)
{
if (item.Name == Name)
{
Data = item;
break;
}
}
return Data;
}
public void Process_Inventory(long entryId)
{
if (!chk_disableInv.Checked)
{
InventoryApi inventoryApi = new InventoryApi();
InventoryData inventoryData = new InventoryData();
inventoryData.EntryId = entryId;
inventoryData.UnitsInStock = EkFunctions.ReadIntegerValue(txt_instock.Text, 0);
inventoryData.UnitsOnOrder = EkFunctions.ReadIntegerValue(txt_onorder.Text, 0);
inventoryData.ReorderLevel = EkFunctions.ReadIntegerValue(txt_reorder.Text, 0);
inventoryApi.SaveInventory(inventoryData);
}
}
private void CalculatePlayerDataResponse(WalletData receivedWallet, InventoryData receivedInventory)
{
bool updated = false;
PlayerDataUpdatedData updatedData = new PlayerDataUpdatedData ();
if (receivedWallet != null) {
for (int i = 0; i < Wallet.currencies.Count; i++) {
Wallet.currencies[i].delta = 0;
}
if (Wallet.offset < receivedWallet.offset && receivedWallet.currencies.Count > 0) {
for (int i = 0; i < receivedWallet.currencies.Count; i++) {
for (int j = 0; j < Wallet.currencies.Count; j++) {
if (receivedWallet.logic.Equals ("CLIENT")) {
if (Wallet.currencies [j].id == receivedWallet.currencies [i].id && receivedWallet.currencies [i].delta != 0) {
int updatedBalance = 0;
if (Wallet.offset == 0 && receivedWallet.offset != 0) {
updatedBalance = receivedWallet.currencies [i].currentBalance;
} else {
updatedBalance = Wallet.currencies [j].currentBalance + receivedWallet.currencies [i].delta;
if (updatedBalance < 0) {
updatedBalance = 0;
}
}
Wallet.currencies [j].currentBalance = updatedBalance;
updated = true;
updatedData.currencies.Add (Wallet.currencies [j]);
}
} else if (receivedWallet.logic.Equals ("SERVER")) {
}
}
}
}
Wallet.offset = receivedWallet.offset;
Wallet.logic = receivedWallet.logic;
}
if (receivedInventory != null) {
for (int i = 0; i < Inventory.items.Count; i++) {
Inventory.items[i].delta = 0;
}
if(Inventory.offset < receivedInventory.offset && receivedInventory.items.Count > 0){
List<PlayerItemData> itemsToBeAdded = new List<PlayerItemData>();
for(int i = 0; i < receivedInventory.items.Count; i++){
for(int j = 0; j < Inventory.items.Count; j++){
if(receivedInventory.logic.Equals("CLIENT")){
if(Inventory.items[j].id == receivedInventory.items[i].id && receivedInventory.items[i].delta != 0){
int updatedAmount = Inventory.items[j].amount + receivedInventory.items[i].delta;
Inventory.items[j].amount = updatedAmount;
} else {
itemsToBeAdded.Add(receivedInventory.items[i]);
}
updated = true;
} else if(receivedInventory.logic.Equals("SERVER")){
}
}
updatedData.items.Add(receivedInventory.items[i]);
}
for(int i = 0; i < itemsToBeAdded.Count; i++){
SpilItemData item = GetItemFromObjects(itemsToBeAdded[i].id);
if(item != null && itemsToBeAdded[i].amount > 0){
PlayerItemData playerItem = new PlayerItemData();
playerItem.id = item.id;
playerItem.name = item.name;
playerItem.type = item.type;
playerItem.amount = itemsToBeAdded[i].amount;
playerItem.value = itemsToBeAdded[i].value;
playerItem.delta = 0;
Inventory.items.Add(playerItem);
updated = true;
}
}
}
Inventory.offset = receivedInventory.offset;
Inventory.logic = receivedInventory.logic;
}
if (updated) {
updatedData.reason = PlayerDataUpdateReasons.ServerUpdate;
SpilUnityImplementationBase.firePlayerDataUpdated (JsonHelper.getJSONFromObject (updatedData));
}
}
public void ProcessPlayerDataResponse(ResponseEvent response)
{
WalletData receivedWallet = null;
InventoryData receivedInventory = null;
if (response.data.HasField ("wallet")) {
JSONObject walletJSON = response.data.GetField ("wallet");
receivedWallet = new WalletData ();
if (walletJSON.HasField ("currencies")) {
receivedWallet.currencies = new List<PlayerCurrencyData> ();
JSONObject currenciesJSON = walletJSON.GetField ("currencies");
for (int i = 0; i < currenciesJSON.Count; i++) {
PlayerCurrencyData currency = new PlayerCurrencyData ();
currency.id = (int)currenciesJSON.list [i].GetField ("id").n;
currency.currentBalance = (int)currenciesJSON.list [i].GetField ("currentBalance").n;
currency.delta = (int)currenciesJSON.list [i].GetField ("delta").n;
receivedWallet.currencies.Add (currency);
}
}
receivedWallet.offset = (int)walletJSON.GetField ("offset").n;
receivedWallet.logic = walletJSON.GetField ("logic").str;
}
if (response.data.HasField ("inventory")) {
JSONObject inventoryJSON = response.data.GetField ("inventory");
receivedInventory = new InventoryData ();
if (inventoryJSON.HasField ("items")) {
receivedInventory.items = new List<PlayerItemData> ();
JSONObject itemsJSON = inventoryJSON.GetField ("items");
for (int i = 0; i < itemsJSON.Count; i++) {
PlayerItemData item = new PlayerItemData ();
item.id = (int)itemsJSON.list [i].GetField ("id").n;
item.amount = (int)itemsJSON.list [i].GetField ("amount").n;
item.delta = (int)itemsJSON.list [i].GetField ("delta").n;
receivedInventory.items.Add (item);
}
}
receivedInventory.offset = (int)inventoryJSON.GetField ("offset").n;
receivedInventory.logic = inventoryJSON.GetField ("logic").str;
}
CalculatePlayerDataResponse (receivedWallet, receivedInventory);
}
