root/trunk/AE-go_GameServer/src/com/aionemu/gameserver/services/ItemService.java

Show revision log
 
967993
26
import com.aionemu.gameserver.dao.ItemStoneListDAO;
26
import com.aionemu.gameserver.dao.ItemStoneListDAO;
27
import com.aionemu.gameserver.dataholders.DataManager;
27
import com.aionemu.gameserver.dataholders.DataManager;
28
import com.aionemu.gameserver.model.gameobjects.Item;
28
import com.aionemu.gameserver.model.gameobjects.Item;
 
29
import com.aionemu.gameserver.model.gameobjects.player.Inventory;
29
import com.aionemu.gameserver.model.gameobjects.player.Storage;
 
30
import com.aionemu.gameserver.model.gameobjects.player.Player;
30
import com.aionemu.gameserver.model.gameobjects.player.Player;
 
31
import com.aionemu.gameserver.model.gameobjects.player.StorageType;



31
import com.aionemu.gameserver.model.gameobjects.stats.listeners.ItemEquipmentListener;
32
import com.aionemu.gameserver.model.gameobjects.stats.listeners.ItemEquipmentListener;



32
import com.aionemu.gameserver.model.items.ItemId;
33
import com.aionemu.gameserver.model.items.ItemId;



33
import com.aionemu.gameserver.model.items.ItemStone;
34
import com.aionemu.gameserver.model.items.ItemStone;



34
import com.aionemu.gameserver.model.templates.item.ItemTemplate;
35
import com.aionemu.gameserver.model.templates.item.ItemTemplate;



35
import com.aionemu.gameserver.network.aion.serverpackets.SM_DELETE_ITEM;
36
import com.aionemu.gameserver.network.aion.serverpackets.SM_DELETE_ITEM;



37
import com.aionemu.gameserver.network.aion.serverpackets.SM_DELETE_WAREHOUSE_ITEM;



36
import com.aionemu.gameserver.network.aion.serverpackets.SM_INVENTORY_UPDATE;
38
import com.aionemu.gameserver.network.aion.serverpackets.SM_INVENTORY_UPDATE;



37
import com.aionemu.gameserver.network.aion.serverpackets.SM_UPDATE_ITEM;
39
import com.aionemu.gameserver.network.aion.serverpackets.SM_UPDATE_ITEM;



40
import com.aionemu.gameserver.network.aion.serverpackets.SM_UPDATE_WAREHOUSE_ITEM;



41
import com.aionemu.gameserver.network.aion.serverpackets.SM_WAREHOUSE_UPDATE;



38
import com.aionemu.gameserver.utils.PacketSendUtility;
42
import com.aionemu.gameserver.utils.PacketSendUtility;



39
import com.aionemu.gameserver.utils.idfactory.IDFactory;
43
import com.aionemu.gameserver.utils.idfactory.IDFactory;



40
import com.aionemu.gameserver.utils.idfactory.IDFactoryAionObject;
44
import com.aionemu.gameserver.utils.idfactory.IDFactoryAionObject;


...
...
117
	 */
121
	 */



118
	public void loadItemStones(Player player)
122
	public void loadItemStones(Player player)



119
	{
123
	{



120
		List<Item> itemList = player.getInventory().getAllItems();
124
		List<Item> itemList = new ArrayList<Item>();



125
		itemList.addAll(player.getStorage(StorageType.CUBE.getId()).getStorageItems());



126
		itemList.addAll(player.getStorage(StorageType.REGULAR_WAREHOUSE.getId()).getStorageItems());



127
		itemList.addAll(player.getStorage(StorageType.ACCOUNT_WAREHOUSE.getId()).getStorageItems());



128
		itemList.addAll(player.getStorage(StorageType.CUBE.getId()).getEquippedItems());



121
129



122
		for(Item item : itemList)
130
		for(Item item : itemList)



123
		{
131
		{


...
...
143
	 * @param itemObjId
151
	 * @param itemObjId



144
	 * @param splitAmount
152
	 * @param splitAmount



145
	 * @param slotNum
153
	 * @param slotNum



154
	 * @param sourceStorageType



155
	 * @param desetinationStorageType



146
	 */
156
	 */



147
	public void splitItem (Player player, int itemObjId, int splitAmount, int slotNum)
157
	public void splitItem (Player player, int itemObjId, int splitAmount, int slotNum, int sourceStorageType, int destinationStorageType)



148
	{
158
	{



149
		Inventory inventory = player.getInventory();
159
		Storage sourceStorage = player.getStorage(sourceStorageType);



160
		Storage destinationStorage = player.getStorage(destinationStorageType);



150
161



151
		Item itemToSplit = inventory.getItemByObjId(itemObjId);
162
		Item itemToSplit = sourceStorage.getItemByObjId(itemObjId);



152
		if(itemToSplit == null)
163
		if(itemToSplit == null)



153
		{
164
		{



154
			log.warn(String.format("CHECKPOINT: attempt to split null item %d %d %d", itemObjId, splitAmount, slotNum));
165
			itemToSplit = sourceStorage.getKinahItem();



166
			if(itemToSplit.getObjectId() != itemObjId || itemToSplit == null)



167
			{



168
				log.warn(String.format("CHECKPOINT: attempt to split null item %d %d %d", itemObjId, splitAmount, slotNum));



169
				return;



170
			}



171
		}



172



173
		// To move kinah from inventory to warehouse and vise versa client using split item packet



174
		if(itemToSplit.getItemTemplate().isKinah())



175
		{



176
			moveKinah(player, sourceStorage, splitAmount);



155
			return;
177
			return;



156
		}
178
		}



157
179


...
...
162
184



163
185



164
186



165
		Item newItem = this.newItem(itemToSplit.getItemTemplate().getItemId(), splitAmount);
187
		Item newItem = newItem(itemToSplit.getItemTemplate().getItemId(), splitAmount);



166
188



167
		if(inventory.putToBag(newItem) != null)
189
		if(destinationStorage.putToBag(newItem) != null)



168
		{
190
		{



169
			itemToSplit.decreaseItemCount(splitAmount);
191
			itemToSplit.decreaseItemCount(splitAmount);



170
192



171
			List<Item> itemsToUpdate = new ArrayList<Item>();
193
			List<Item> itemsToUpdate = new ArrayList<Item>();



172
			itemsToUpdate.add(newItem);
194
			itemsToUpdate.add(newItem);



173
195



174
			PacketSendUtility.sendPacket(player, new SM_INVENTORY_UPDATE(itemsToUpdate));
196
			sendStorageUpdatePacket(player, destinationStorageType, itemsToUpdate.get(0));



175
			PacketSendUtility.sendPacket(player, new SM_UPDATE_ITEM(itemToSplit));
197



198
			sendUpdateItemPacket(player, sourceStorageType, itemToSplit);



176
		}		
199
		}		



177
		else
200
		else



178
		{
201
		{



179
			releaseItemId(newItem);
202
			releaseItemId(newItem);



180
		}
203
		}



181
	}
204
	}



182
	
205



206



207
	public void moveKinah(Player player, Storage source, int splitAmount)



208
	{



209
		switch(source.getStorageType())



210
		{



211
			case 0:



212
			{



213
				Storage destination = player.getStorage(StorageType.ACCOUNT_WAREHOUSE.getId());



214
				int chksum = (source.getKinahItem().getItemCount() - splitAmount) + (destination.getKinahItem().getItemCount() + splitAmount);



215



216
				if(chksum != source.getKinahItem().getItemCount() + destination.getKinahItem().getItemCount())



217
					return;



218



219
				source.decreaseKinah(splitAmount);



220
				destination.increaseKinah(splitAmount);



221
				break;



222
			}



223



224
			case 2:



225
			{



226
				Storage destination = player.getStorage(StorageType.CUBE.getId());



227
				int chksum = (source.getKinahItem().getItemCount() - splitAmount) + (destination.getKinahItem().getItemCount() + splitAmount);



228



229
				if(chksum != source.getKinahItem().getItemCount() + destination.getKinahItem().getItemCount())



230
					return;



231



232
				source.decreaseKinah(splitAmount);



233
				destination.increaseKinah(splitAmount);



234
				break;



235
			}



236
			default:



237
				break;



238
		}



239
	}



240



183
	/**
241
	/**



184
	 *  Used to merge 2 items in inventory
242
	 *  Used to merge 2 items in inventory



185
	 *  
243
	 *  


...
...
188
	 * @param itemAmount
246
	 * @param itemAmount



189
	 * @param destinationObjId
247
	 * @param destinationObjId



190
	 */
248
	 */



191
	public void mergeItems (Player player, int sourceItemObjId, int itemAmount, int destinationObjId)
249
	public void mergeItems (Player player, int sourceItemObjId, int itemAmount, int destinationObjId, int sourceStorageType, int destinationStorageType)



192
	{
250
	{



193
		if(itemAmount == 0)
251
		if(itemAmount == 0)



194
			return;
252
			return;



195
253



196
		Inventory inventory = player.getInventory();
254
		Storage sourceStorage = player.getStorage(sourceStorageType);



255
		Storage destinationStorage = player.getStorage(destinationStorageType);



197
256



198
		Item sourceItem = inventory.getItemByObjId(sourceItemObjId);
257
		Item sourceItem = sourceStorage.getItemByObjId(sourceItemObjId);



199
		Item destinationItem = inventory.getItemByObjId(destinationObjId);
258
		Item destinationItem = destinationStorage.getItemByObjId(destinationObjId);



200
		
259



201
		if(sourceItem == null || destinationItem == null)
260
		if(sourceItem == null || destinationItem == null)



202
			return; //Invalid object id provided
261
			return; //Invalid object id provided



203
		
262



204
		if(sourceItem.getItemTemplate().getItemId() != destinationItem.getItemTemplate().getItemId())
263
		if(sourceItem.getItemTemplate().getItemId() != destinationItem.getItemTemplate().getItemId())



205
			return; //Invalid item type
264
			return; //Invalid item type



206
		
265



207
		if(sourceItem.getItemCount() < itemAmount)
266
		if(sourceItem.getItemCount() < itemAmount)



208
			return; //Invalid item amount
267
			return; //Invalid item amount



209
268



210
		if(sourceItem.getItemCount() == itemAmount)
269
		if(sourceItem.getItemCount() == itemAmount)



211
		{
270
		{



212
			destinationItem.increaseItemCount(itemAmount);
271
			destinationItem.increaseItemCount(itemAmount);



213
			inventory.removeFromBag(sourceItem);
272
			sourceStorage.removeFromBag(sourceItem, true);



214
273



215
			PacketSendUtility.sendPacket(player, new SM_DELETE_ITEM(sourceItem.getObjectId()));
274
			sendDeleteItemPacket(player, sourceStorageType, sourceItem.getObjectId());



216
			PacketSendUtility.sendPacket(player, new SM_UPDATE_ITEM(destinationItem));
275



276
			sendUpdateItemPacket(player, destinationStorageType, destinationItem);



277



217
		}
278
		}



218
		else if(sourceItem.getItemCount() > itemAmount)
279
		else if(sourceItem.getItemCount() > itemAmount)



219
		{
280
		{



220
			sourceItem.decreaseItemCount(itemAmount);
281
			sourceItem.decreaseItemCount(itemAmount);



221
			destinationItem.increaseItemCount(itemAmount);
282
			destinationItem.increaseItemCount(itemAmount);



222
283



223
			PacketSendUtility.sendPacket(player, new SM_UPDATE_ITEM(sourceItem));
284
			sendUpdateItemPacket(player, sourceStorageType, sourceItem);



224
			PacketSendUtility.sendPacket(player, new SM_UPDATE_ITEM(destinationItem));
285



286
			sendUpdateItemPacket(player, destinationStorageType, destinationItem);



225
		}
287
		}



226
		else return; // cant happen in theory, but...
288
		else return; // cant happen in theory, but...



227
	}
289
	}


...
...
239
	 */
301
	 */



240
	public int addItem(Player player, int itemId, int count, boolean isQuestItem)
302
	public int addItem(Player player, int itemId, int count, boolean isQuestItem)



241
	{
303
	{



242
		Inventory inventory = player.getInventory();
304
		Storage inventory = player.getInventory();



243
305



244
		ItemTemplate itemTemplate =  DataManager.ITEM_DATA.getItemTemplate(itemId);
306
		ItemTemplate itemTemplate =  DataManager.ITEM_DATA.getItemTemplate(itemId);



245
		if(itemTemplate == null)
307
		if(itemTemplate == null)


...
...
262
			{
324
			{



263
				if(count == 0)
325
				if(count == 0)



264
					break;
326
					break;



265
				
327



266
				int freeCount = maxStackCount - existingItem.getItemCount();
328
				int freeCount = maxStackCount - existingItem.getItemCount();



267
				if(count <= freeCount)
329
				if(count <= freeCount)



268
				{
330
				{


...
...
274
					existingItem.increaseItemCount(freeCount);
336
					existingItem.increaseItemCount(freeCount);



275
					count -= freeCount;
337
					count -= freeCount;



276
				}
338
				}



277
				
339



278
				udpateItem(player, existingItem, false);
340
				udpateItem(player, existingItem, false);



279
			}
341
			}



280
342


...
...
306
			return count;
368
			return count;



307
		}
369
		}



308
	}
370
	}



309
	
371



372
	public void moveItem(Player player, int itemObjId, int sourceStorageType, int destinationStorageType)



373
	{



374
		Storage sourceStorage = player.getStorage(sourceStorageType);



375
		Storage destinationStorage = player.getStorage(destinationStorageType);



376



377
		Item item = player.getStorage(sourceStorageType).getItemByObjId(itemObjId);



378



379
		if(item == null)



380
			return;



381



382
		List<Item> existingItems = destinationStorage.getItemsByItemId(item.getItemTemplate().getItemId());



383



384
		int count = item.getItemCount();



385
		int maxStackCount = item.getItemTemplate().getMaxStackCount();



386



387
		for(Item existingItem : existingItems)



388
		{



389
			if(count == 0)



390
				break;



391



392
			int freeCount = maxStackCount - existingItem.getItemCount();



393
			if(count <= freeCount)



394
			{



395
				existingItem.increaseItemCount(count);



396
				count = 0;



397
				sendDeleteItemPacket(player, sourceStorageType, item.getObjectId());



398
				sourceStorage.removeFromBag(item, true);



399



400
			}



401
			else



402
			{



403
				existingItem.increaseItemCount(freeCount);



404
				count -= freeCount;



405
			}



406
			sendStorageUpdatePacket(player, destinationStorageType, existingItem);



407



408
		}



409



410
		while(!destinationStorage.isFull() && count > 0)



411
		{



412
			// item count still more than maxStack value



413
			if(count > maxStackCount)



414
			{



415
				count -= maxStackCount;



416
				Item newitem = newItem(item.getItemTemplate().getItemId(), maxStackCount);



417
				newitem = destinationStorage.putToBag(newitem);



418
				sendStorageUpdatePacket(player, destinationStorageType, newitem);



419



420
			}



421
			else



422
			{



423
				item.setItemCount(count);



424
				sourceStorage.removeFromBag(item, true);



425
				sendDeleteItemPacket(player, sourceStorageType, item.getObjectId());



426



427
				Item newitem = destinationStorage.putToBag(item);



428
				sendStorageUpdatePacket(player, destinationStorageType, newitem);



429



430
				count = 0;



431
			}



432
		}



433



434
	}



435



436



310
	public void udpateItem(Player player, Item item, boolean isNew)
437
	public void udpateItem(Player player, Item item, boolean isNew)



311
	{
438
	{



312
		if(isNew)
439
		if(isNew)



313
		{



314
			PacketSendUtility.sendPacket(player, new SM_INVENTORY_UPDATE(Collections.singletonList(item)));
440
			PacketSendUtility.sendPacket(player, new SM_INVENTORY_UPDATE(Collections.singletonList(item)));



315
		}



316
		else
441
		else



317
		{



318
			PacketSendUtility.sendPacket(player, new SM_UPDATE_ITEM(item));
442
			PacketSendUtility.sendPacket(player, new SM_UPDATE_ITEM(item));



319
		}



320
	}
443
	}



321
444



445
	public void sendDeleteItemPacket(Player player, int storageType, int itemObjId)



446
	{



447
		if(storageType == StorageType.CUBE.getId())



448
			PacketSendUtility.sendPacket(player, new SM_DELETE_ITEM(itemObjId));



449
		else



450
			PacketSendUtility.sendPacket(player, new SM_DELETE_WAREHOUSE_ITEM(storageType, itemObjId));



451
	}



452



453
	public void sendStorageUpdatePacket(Player player, int storageType, Item item)



454
	{



455
		if(storageType == StorageType.CUBE.getId())



456
			PacketSendUtility.sendPacket(player, new SM_INVENTORY_UPDATE(Collections.singletonList(item)));



457
		else



458
			PacketSendUtility.sendPacket(player, new SM_WAREHOUSE_UPDATE(item, storageType));



459
	}



460



461
	public void sendUpdateItemPacket(Player player, int storageType, Item item)



462
	{



463
		if(storageType == StorageType.CUBE.getId())



464
			PacketSendUtility.sendPacket(player, new SM_UPDATE_ITEM(item));



465
		else



466
			PacketSendUtility.sendPacket(player, new SM_UPDATE_WAREHOUSE_ITEM(item, storageType));



467
	}



468



322
	/**
469
	/**



323
	 *  Releases item id if item was not used by caller
470
	 *  Releases item id if item was not used by caller



324
	 *  
471
	 *  



325
	 * @param item
472
	 * @param item



326
	 */
473
	 */



327
	public void releaseItemId(Item item)
474
	 public void releaseItemId(Item item)



328
	{
475
	{



329
		aionObjectsIDFactory.releaseId(item.getObjectId());
476
		 aionObjectsIDFactory.releaseId(item.getObjectId());



330
	}
477
	}



331
}
478
}