public void renderShopStock(Graphics g, int[] inventory) {
int x = 240, y = 464;
g.setColor(Color.black);
int inventoryCounter = 0;
for (Items item : this.itemList) {
if (!item.isEquipped()) {
if (inventoryCounter <= 20) {
g.setColor(item.getItemRarityColor());
g.fillRect(x, y, 32, 32);
item.drawImageItem(x, y);
inventory[inventoryCounter++] = item.getID();
}
x += 64;
if (x > 496) {
x = 112;
y += 64;
}
}
}
}
@Override
public void onClick(View v) {
// TODO Auto-generated method stub
Log.d(TAG, "add......");
mDate = mEdtDate.getText().toString();
mItem = mEdtItem.getText().toString();
try {
mDateStamp = toDateStamp(mDate);
} catch (ParseException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
String costS = mEdtCost.getText().toString();
if (!costS.matches("")) {
mCost = Integer.parseInt(costS);
Items it = new Items();
it.setDate(mDate);
it.setItem(mItem);
it.setCost(mCost);
it.setDateStamp(mDateStamp);
ItemsHelper.addItems(getContentResolver(), it);
// money_items.add(0, it); //********************************************
money_items = ItemsHelper.listItems(MainActivity.this);
itemadapter = new ItemAdapter2(MainActivity.this, money_items);
money_list.setAdapter(itemadapter);
itemadapter.notifyDataSetChanged();
resetForm();
} else {
Toast.makeText(getApplicationContext(), "Cost 為必填欄位", Toast.LENGTH_SHORT).show();
}
}
/**
* Add a new message to the beginning i.e. send it as soon as possible (e.g. if we tried to send
* it and failed); it is assumed to already be urgent.
*/
public void addFirst(MessageItem item) {
long id = item.getID();
Items list;
if (itemsByID == null) {
itemsByID = new HashMap<Long, Items>();
if (nonEmptyItemsWithID == null) nonEmptyItemsWithID = new DoublyLinkedListImpl<Items>();
list = new Items(id);
nonEmptyItemsWithID.push(list);
itemsByID.put(id, list);
} else {
list = itemsByID.get(id);
if (list == null) {
list = new Items(id);
if (nonEmptyItemsWithID == null) nonEmptyItemsWithID = new DoublyLinkedListImpl<Items>();
nonEmptyItemsWithID.unshift(list);
itemsByID.put(id, list);
} else {
if (list.items.isEmpty()) {
assert (list.getParent() == emptyItemsWithID);
// It already exists, so it has a valid time.
// Which is probably in the past, so use Forward.
moveFromEmptyToNonEmptyForward(list);
} else assert (list.getParent() == nonEmptyItemsWithID);
}
}
list.addFirst(item);
}
// Returns null if not found
public Items getItemByID(int ID) {
for (Items item : this.itemList) {
if (item.getID() == ID) {
return item;
}
}
return null;
}
@Override
public void onBindViewHolder(CusineItemAdapter.ViewHolder viewHolder, int i) {
Items fp = dataSet.get(i);
viewHolder.tvName.setText(fp.getTitle());
viewHolder.iconView.setImageResource(fp.getThumbnail());
viewHolder.feed = fp;
}
private void drawDungeon(Graphics g) {
// System.out.println("At draw Dungeon");
Location current = hero.main.getLocation();
// System.out.println("current is "+current);
int row = current.getRow();
int col = current.getCol();
// System.out.println(current);
int counterr = 0;
int counterc = 0;
for (int r = row - 4; r < row + 5; r++) { // gets 4 above and 4 below
// hero
for (int c = col - 4; c < col + 5; c++) {
// System.out.println("counter r is "
// +counterr+" counter c is "+counterc);
if (land[r][c].equals("C") || land[r][c].equals("R")) {
// System.out.println("Looking at " + r + " " + c);
g.drawImage(floor, counterc * 60, counterr * 60, 60, 60, null);
// g.draw3DRect(r * 10, c * 10, 10, 10, true);
} else if (land[r][c].equals("W")) {
// System.out.println("Looking at " + r + " " + c);
g.drawImage(wall, counterc * 60, counterr * 60, 60, 60, null);
// g.draw3DRect(r * 10, c * 10, 10, 10, true);
} else if (land[r][c].equals("S")) {
// System.out.println("got here");
// System.out.println("Location of stairs is " + r + " " +
// c);
g.drawImage(stairs, counterc * 60, counterr * 60, 60, 60, null);
} else {
g.drawImage(error, counterc * 60, counterr * 60, 60, 60, null);
}
if (grid.get(new Location(r, c)) instanceof Pokemon) {
// System.out.println("Pokemon here");
Pokemon p = (Pokemon) grid.get(new Location(r, c));
// g.drawImage(floor, counterc * 60, counterr * 60, 60, 60,
// null);
p.draw(g, counterc * 60, counterr * 60);
// g.draw3DRect(r * 60, c * 60, 60, 60, true);
} else if (grid.get(new Location(r, c)) instanceof Items) {
// System.out.println("Found an item at " + r + " " + c);
Items i = (Items) grid.get(new Location(r, c));
// g.drawImage(floor, counterc * 60, counterr * 60, 60, 60,
// null);
i.draw(g, counterc * 60, counterr * 60);
// System.out.println("Drawimg at "+counterr+" "+counterc);
}
counterc++;
}
counterr++;
counterc = 0;
// System.out.println();
}
}
public void addEnemyNPCArmor(int level) {
if (this.itemList.isEmpty()) {
Items[] basic = new Items[6];
Random rand = new Random();
// Assigning basic Items
basic[0] = new Items(2, this.classID, -1, level);
basic[1] = new Items(3, this.classID, -1, level);
basic[2] = new Items(4, this.classID, -1, level);
basic[3] = new Items(5, this.classID, -1, level);
basic[4] = new Items(6, this.classID, -1, level);
// Check class to give correct weapon
if (this.classID == 0) {
basic[5] = new Items(10, this.classID, -1, level);
} else if (this.classID == 1) {
basic[5] = new Items(9, this.classID, -1, level);
} else if (this.classID == 2) {
basic[5] = new Items(12, this.classID, -1, level);
} else if (this.classID == 3) {
basic[5] = new Items(11, this.classID, -1, level);
}
for (int x = 0; x < basic.length; x++) {
addItem(basic[x]);
equipItem(basic[x].getID());
}
// Necklaces
int willHaveItem = rand.nextInt(80);
if (willHaveItem > 40 && willHaveItem < 60) {
Items necklace = new Items(8, this.classID, -1, level);
addItem(necklace);
equipItem(necklace.getID());
}
// Ring
willHaveItem = rand.nextInt(100);
if (willHaveItem > 20 && willHaveItem < 40) {
Items ring = new Items(7, this.classID, -1, level);
addItem(ring);
equipItem(ring.getID());
}
// Adds monies
this.money = ((rand.nextInt(level + 3) + 1) * (rand.nextInt(3) + 1));
// Extra inventory items
Items[] extra = new Items[3];
int itemCount = rand.nextInt(4);
for (int x = 0; x < itemCount; x++) {
extra[x] = new Items(rand.nextInt(level) + 1);
this.addItem(extra[x]);
}
}
}
public void removeUIDs(Long[] list) {
if (itemsByID == null) return;
for (Long l : list) {
Items items = itemsByID.get(l);
if (items == null) continue;
if (items.items.isEmpty()) {
itemsByID.remove(l);
assert (emptyItemsWithID != null);
assert (items.getParent() == emptyItemsWithID);
emptyItemsWithID.remove(items);
}
}
}
private void moveToUrgent(long now) {
if (itemsNonUrgent == null) return;
ListIterator<MessageItem> it = itemsNonUrgent.listIterator();
int moved = 0;
while (it.hasNext()) {
MessageItem item = it.next();
if (item.submitted + PacketSender.MAX_COALESCING_DELAY <= now) {
// Move to urgent list
long id = item.getID();
Items list;
if (itemsByID == null) {
itemsByID = new HashMap<Long, Items>();
if (nonEmptyItemsWithID == null)
nonEmptyItemsWithID = new DoublyLinkedListImpl<Items>();
list = new Items(id);
nonEmptyItemsWithID.push(list);
itemsByID.put(id, list);
} else {
list = itemsByID.get(id);
if (list == null) {
list = new Items(id);
if (nonEmptyItemsWithID == null)
nonEmptyItemsWithID = new DoublyLinkedListImpl<Items>();
// In order to ensure fairness, we add it at the beginning.
// addLast() is typically called by sendAsync().
// If there are later items they are probably block transfers that are
// already in progress; it is fairer to send the new item first.
nonEmptyItemsWithID.unshift(list);
itemsByID.put(id, list);
} else {
if (list.items.isEmpty()) {
assert (list.getParent() == emptyItemsWithID);
// It already exists, so it has a valid time.
// Which is probably in the past, so use Forward.
moveFromEmptyToNonEmptyForward(list);
} else {
assert (list.getParent() == nonEmptyItemsWithID);
}
}
}
list.addLast(item);
it.remove();
moved++;
} else {
if (logDEBUG && moved > 0)
Logger.debug(this, "Moved " + moved + " items to urgent round-robin");
return;
}
}
}
@POST
@Produces(MediaType.APPLICATION_JSON)
public Response createItem(Item item) {
Item newItem =
items.createItem(item.getTitle(), item.getCoorX(), item.getCoorY(), item.getDirection());
return Response.status(Response.Status.CREATED).entity(newItem).build();
}
@GET
@Produces(MediaType.APPLICATION_JSON)
public Response getAllItems() {
Collection<Item> allItems = items.findAllItems();
GenericEntity<Collection<Item>> list = new GenericEntity<Collection<Item>>(allItems) {};
return Response.ok(list).build();
}
@GET
@Path("/{itemId}")
@Produces(MediaType.APPLICATION_JSON)
public Response getItem(@PathParam("itemId") String itemId) {
Item item = items.findItem(itemId);
return Response.ok(item).build();
}
@Override
public boolean equals(Object obj) {
// TODO Auto-generated method stub
if (this == obj) {
return true;
}
if (obj instanceof Items) {
Items i = (Items) obj;
if (this.getId() == i.getId() && this.getName().equals(i.getName())) {
return true;
} else {
return false;
}
} else {
return false;
}
}
public static void main(String[] args) {
EPServiceProvider esProvider = EPServiceProviderManager.getDefaultProvider();
EPAdministrator admin = esProvider.getEPAdministrator();
EPRuntime er = esProvider.getEPRuntime();
Review r1 = new Review();
r1.setReviewId(1);
r1.setComment("r1");
Book b1 = new Book();
b1.setAuthor("b1");
b1.setBookId(1);
b1.setReview(r1);
Book b2 = new Book();
b2.setAuthor("b2");
b2.setBookId(2);
Item i1 = new Item();
i1.setItemId(1);
i1.setProductId(1);
i1.setPrice(1.11);
i1.setAmount(2);
// 添加Bean对象
MediaOrder mo1 = new MediaOrder();
Books bs = new Books();
Items is = new Items();
List<Item> items = new ArrayList<Item>();
List<Book> books = new ArrayList<Book>();
items.add(i1);
books.add(b1);
books.add(b2);
mo1.setOrderId(1);
bs.setBook(books);
is.setItem(items);
mo1.setItems(is);
mo1.setBooks(bs);
String mediaOrder = MediaOrder.class.getName();
String epl = "select * from " + mediaOrder + "[books.book]";
EPStatement stat1 = admin.createEPL(epl);
stat1.addListener(new SelectContainedListener());
er.sendEvent(mo1);
}
public boolean removeMessage(MessageItem item) {
long id = item.getID();
Items list;
if (itemsByID != null) {
list = itemsByID.get(id);
if (list != null) {
if (list.remove(item)) {
if (list.items.isEmpty()) {
nonEmptyItemsWithID.remove(list);
addToEmptyBackward(list);
}
return true;
}
}
}
if (itemsNonUrgent != null) return itemsNonUrgent.remove(item);
else return false;
}
public void createSampleTodoItems(@Observes StartupEvent startupEvent) {
/*int i = 20;
for (int j = 1; j <= i; j++) {
String title = "Item #" + j;
items.createItem(title);
}*/
// items.createItem(title)
items.createItem("prvi", 0, 0, direction.up);
items.createItem("drugi", 4, -2, direction.up);
items.createItem("tretji", 3, 7, direction.down);
boolean a = items.CheckFreeLocation(0, 0, direction.up);
boolean b = items.CheckFreeLocation(0, 0, direction.down);
System.out.println("REZ: " + a + " " + b);
}
// Returns True if added, false if not
public boolean addItem(Items item) {
// Potions don't actually get added, they just increment the counter
if (item.getItemID() == 0) {
this.healthPotions++;
return true;
} else if (item.getItemID() == 1) {
this.staminaPotions++;
return true;
}
// Checks for space in inventory
if (getInventoryCount() < MAX_ITEMS_IN_INVENTORY) {
this.itemList.addElement(item);
this.currentInventoryCount++;
return true;
} else {
return false;
}
}
private void moveFromEmptyToNonEmptyForward(Items list) {
// Presumably is in emptyItemsWithID
assert (list.items.isEmpty());
if (logMINOR) {
if (list.getParent() == nonEmptyItemsWithID) {
Logger.error(this, "Already in non-empty yet empty?!");
return;
}
}
if (emptyItemsWithID != null) emptyItemsWithID.remove(list);
addToNonEmptyForward(list);
}
private void showItemDialog(Items item, final int adpPos) {
final int iId = item.getId();
AlertDialog.Builder itemDialog = new AlertDialog.Builder(MainActivity.this);
LayoutInflater inflater = getLayoutInflater();
itemDialog.setTitle(R.string.idlg_title);
final View itemDlg = inflater.inflate(R.layout.item_dialog, null);
itemDialog.setView(itemDlg);
final EditText idEdtDate = (EditText) itemDlg.findViewById(R.id.edt_DlgDate);
idEdtDate.setText(item.getDate());
String[] date = item.getDate().split("/");
final int iY = Integer.parseInt(date[0]);
final int iM = Integer.parseInt(date[1]) - 1;
final int iD = Integer.parseInt(date[2]);
idEdtDate.setOnClickListener(
new OnClickListener() {
@Override
public void onClick(View v) {
// TODO Auto-generated method stub
DatePickerDialog dpd =
new DatePickerDialog(
MainActivity.this,
new DatePickerDialog.OnDateSetListener() {
@Override
public void onDateSet(
DatePicker view, int year, int monthOfYear, int dayOfMonth) {
// TODO Auto-generated method stub
mCalendar.set(Calendar.YEAR, year);
mCalendar.set(Calendar.MONTH, monthOfYear);
mCalendar.set(Calendar.DAY_OF_MONTH, dayOfMonth);
idEdtDate.setText(sdf.format(mCalendar.getTime()));
}
},
iY,
iM,
iD);
dpd.setTitle("Choose Date");
dpd.setMessage("");
dpd.setCancelable(false);
dpd.show();
}
});
final EditText idEdtItem = (EditText) itemDlg.findViewById(R.id.edt_DlgItem);
idEdtItem.setText(item.getItem());
final EditText idEdtCost = (EditText) itemDlg.findViewById(R.id.edt_DlgCost);
idEdtCost.setText(Integer.toString(item.getCost()));
itemDialog.setPositiveButton(
R.string.idlg_btn_update,
new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
// TODO Auto-generated method stub
Log.d(TAG, "update ...");
Items upit = new Items();
upit.setId(iId);
upit.setDate(idEdtDate.getText().toString());
upit.setItem(idEdtItem.getText().toString());
upit.setCost(Integer.parseInt(idEdtCost.getText().toString()));
try {
upit.setDateStamp(toDateStamp(idEdtDate.getText().toString()));
} catch (ParseException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
ItemsHelper.updateItems(getContentResolver(), upit);
// money_items.set(adpPos, upit);
money_items = ItemsHelper.listItems(MainActivity.this);
itemadapter = new ItemAdapter2(MainActivity.this, money_items);
money_list.setAdapter(itemadapter);
}
});
itemDialog.setNeutralButton(
R.string.idlg_btn_delete,
new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
// TODO Auto-generated method stub
Log.d(TAG, "delete ...");
ItemsHelper.deleteItems(getContentResolver(), iId);
// money_items.remove(adpPos);
money_items = ItemsHelper.listItems(MainActivity.this);
itemadapter = new ItemAdapter2(MainActivity.this, money_items);
money_list.setAdapter(itemadapter);
}
});
itemDialog.setNegativeButton(
R.string.idlg_btn_cancel,
new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
// TODO Auto-generated method stub
}
});
itemDialog.show();
}
private void calculateAttackAndDefence() {
// Setting to base
this.playerOverallAttack = this.baseAttack;
this.playerOverallDefence = this.baseDefence;
for (Items item : this.itemList) {
if (item.getID() == this.playerHelmet) {
this.playerOverallAttack += item.getAttackPower();
this.playerOverallDefence += item.getDefencePower();
} else if (item.getID() == this.playerBody) {
this.playerOverallAttack += item.getAttackPower();
this.playerOverallDefence += item.getDefencePower();
} else if (item.getID() == this.playerPants) {
this.playerOverallAttack += item.getAttackPower();
this.playerOverallDefence += item.getDefencePower();
} else if (item.getID() == this.playerGloves) {
this.playerOverallAttack += item.getAttackPower();
this.playerOverallDefence += item.getDefencePower();
} else if (item.getID() == this.playerWeapon) {
this.playerOverallAttack += item.getAttackPower();
this.playerOverallDefence += item.getDefencePower();
} else if (item.getID() == this.playerBoots) {
this.playerOverallAttack += item.getAttackPower();
this.playerOverallDefence += item.getDefencePower();
} else if (item.getID() == this.playerRing) {
this.playerOverallAttack += item.getAttackPower();
this.playerOverallDefence += item.getDefencePower();
} else if (item.getID() == this.playerNecklaces) {
this.playerOverallAttack += item.getAttackPower();
this.playerOverallDefence += item.getDefencePower();
}
}
}
/**
* Add messages to <code>messages</code> until there are no more messages to add or <code>size
* </code> would exceed <code>maxSize</code>. If <code>size == maxSize</code>, a message in the
* queue will be added even if it makes <code>size</code> exceed <code>maxSize</code>. If <code>
* isUrgent</code> is set, only messages that are considered urgent are added.
*
* @param size the current size of <code>messages</code>
* @param minSize the size when <code>messages</code> is empty
* @param maxSize the maximum size of <code>messages</code>
* @param now the current time
* @param messages the list that messages will be added to
* @param isUrgent <code>true</code> if only urgent messages should be added
* @return the size of <code>messages</code>, multiplied by -1 if there were messages that
* didn't fit
*/
private int addUrgentMessages(
int size, int minSize, int maxSize, long now, ArrayList<MessageItem> messages) {
assert (size >= 0);
assert (minSize >= 0);
assert (maxSize >= minSize);
if (size < 0) size = -size; // FIXME remove extra paranoia
int added = 0;
while (true) {
boolean addedNone = true;
int lists = 0;
if (nonEmptyItemsWithID == null) return size;
lists += nonEmptyItemsWithID.size();
Items list = nonEmptyItemsWithID.head();
for (int i = 0; i < lists && list != null; i++) {
if (list.items.isEmpty()) {
// Should not happen, but check for it anyway since it keeps happening. :(
Logger.error(this, "List is in nonEmptyItemsWithID yet it is empty?!: " + list);
nonEmptyItemsWithID.remove(list);
addToEmptyBackward(list);
if (nonEmptyItemsWithID.isEmpty()) return size;
list = nonEmptyItemsWithID.head();
continue;
}
MessageItem item = list.items.getFirst();
int thisSize = item.getLength();
boolean oversize = false;
if (size + 2 + thisSize > maxSize) {
if (size == minSize) {
// Won't fit regardless, send it on its own.
oversize = true;
} else {
// Send what we have so far.
if (logDEBUG && added != 0)
Logger.debug(
this,
"Added "
+ added
+ " urgent messages, could add more but out of space at "
+ size);
return -size;
}
}
size += 2 + thisSize;
list.items.removeFirst();
// Move to end of list.
Items prev = list.getPrev();
nonEmptyItemsWithID.remove(list);
list.timeLastSent = now;
if (!list.items.isEmpty()) {
addToNonEmptyBackward(list);
} else {
addToEmptyBackward(list);
}
if (prev == null) list = nonEmptyItemsWithID.head();
else list = prev.getNext();
messages.add(item);
added++;
addedNone = false;
if (oversize) {
if (logDEBUG) Logger.debug(this, "Returning with oversize urgent message");
return size;
}
}
if (addedNone) {
if (logDEBUG && added != 0)
Logger.debug(
this,
"Added "
+ added
+ " urgent messages, size now "
+ size
+ " no more queued at this priority");
return size;
}
}
}
private int addNonUrgentMessages(
int size, int minSize, int maxSize, long now, ArrayList<MessageItem> messages) {
assert (size >= 0);
assert (minSize >= 0);
assert (maxSize >= minSize);
if (size < 0) size = -size; // FIXME remove extra paranoia
if (itemsNonUrgent == null) return size;
int added = 0;
for (ListIterator<MessageItem> items = itemsNonUrgent.listIterator(); items.hasNext(); ) {
MessageItem item = items.next();
int thisSize = item.getLength();
boolean oversize = false;
if (size + 2 + thisSize > maxSize) {
if (size == minSize) {
// Won't fit regardless, send it on its own.
oversize = true;
} else {
// Send what we have so far.
if (logDEBUG && added != 0)
Logger.debug(
this,
"Returning with "
+ added
+ " non-urgent messages (have more but they don't fit)");
return -size;
}
}
size += 2 + thisSize;
items.remove();
messages.add(item);
if (itemsByID != null) {
long id = item.getID();
Items tracker = itemsByID.get(id);
if (tracker != null) {
tracker.timeLastSent = now;
DoublyLinkedList<? super Items> parent = tracker.getParent();
// Demote the corresponding tracker to maintain round-robin.
if (tracker.items.isEmpty()) {
if (emptyItemsWithID == null) emptyItemsWithID = new DoublyLinkedListImpl<Items>();
if (parent == null) {
Logger.error(this, "Tracker is in itemsByID but not in either list! (empty)");
} else if (parent == emptyItemsWithID) {
// Normal. Remove it so we can re-add it in the right place.
emptyItemsWithID.remove(tracker);
} else if (parent == nonEmptyItemsWithID) {
Logger.error(this, "Tracker is in non empty items list when is empty");
nonEmptyItemsWithID.remove(tracker);
} else assert (false);
addToEmptyBackward(tracker);
} else {
if (nonEmptyItemsWithID == null)
nonEmptyItemsWithID = new DoublyLinkedListImpl<Items>();
if (parent == null) {
Logger.error(this, "Tracker is in itemsByID but not in either list! (non-empty)");
} else if (parent == nonEmptyItemsWithID) {
// Normal. Remove it so we can re-add it in the right place.
nonEmptyItemsWithID.remove(tracker);
} else if (parent == emptyItemsWithID) {
Logger.error(this, "Tracker is in empty items list when is non-empty");
emptyItemsWithID.remove(tracker);
} else assert (false);
addToNonEmptyBackward(tracker);
}
}
}
added++;
if (oversize) {
if (logDEBUG) Logger.debug(this, "Returning with non-urgent oversize message");
return size;
}
}
if (logDEBUG && added != 0)
Logger.debug(this, "Returning with " + added + " non-urgent messages (all gone)");
return size;
}
public void renderInventory(Graphics g, int[] equipped, int[] inventory) {
int x = 112, y = 464;
g.setColor(Color.black);
int inventoryCounter = 0;
for (Items item : this.itemList) {
if (item.getID() == this.playerHelmet) {
g.setColor(item.getItemRarityColor());
g.fillRect(112, 80, 32, 32);
item.drawImageItem(112, 80);
equipped[0] = this.playerHelmet;
} else if (item.getID() == this.playerBody) {
g.setColor(item.getItemRarityColor());
g.fillRect(112, 144, 32, 32);
item.drawImageItem(112, 144);
equipped[1] = this.playerBody;
} else if (item.getID() == this.playerPants) {
g.setColor(item.getItemRarityColor());
g.fillRect(112, 208, 32, 32);
item.drawImageItem(112, 208);
equipped[2] = this.playerPants;
} else if (item.getID() == this.playerGloves) {
g.setColor(item.getItemRarityColor());
g.fillRect(48, 144, 32, 32);
item.drawImageItem(48, 144);
equipped[4] = this.playerGloves;
} else if (item.getID() == this.playerWeapon) {
g.setColor(item.getItemRarityColor());
g.fillRect(176, 144, 32, 32);
item.drawImageItem(176, 144);
equipped[5] = this.playerWeapon;
} else if (item.getID() == this.playerBoots) {
g.setColor(item.getItemRarityColor());
g.fillRect(112, 272, 32, 32);
item.drawImageItem(112, 272);
equipped[3] = this.playerBoots;
} else if (item.getID() == this.playerRing) {
g.setColor(item.getItemRarityColor());
g.fillRect(208, 48, 32, 32);
item.drawImageItem(208, 48);
equipped[6] = this.playerRing;
} else if (item.getID() == this.playerNecklaces) {
g.setColor(item.getItemRarityColor());
g.fillRect(272, 48, 32, 32);
item.drawImageItem(272, 48);
equipped[7] = this.playerNecklaces;
} else if (item.getItemID() == 0 || item.getItemID() == 1) {
} else {
g.setColor(item.getItemRarityColor());
g.fillRect(x, y, 32, 32);
item.drawImageItem(x, y);
inventory[inventoryCounter++] = item.getID();
x += 64;
if (x > 496) {
x = 112;
y += 64;
}
}
}
try {
g.setColor(Color.black);
Image healthPotion = new Image("NewEra-Beta/res/items/health.png");
healthPotion.draw(431, 368);
g.drawString("" + this.healthPotions, 460, 360);
Image staminaPotion = new Image("NewEra-Beta/res/items/stamina.png");
staminaPotion.draw(496, 368);
g.drawString("" + this.staminaPotions, 525, 360);
} catch (SlickException e) {
e.printStackTrace();
}
}
@Override
@SideOnly(Side.CLIENT)
public void registerIcons(IconRegister register) {
System.out.println("registering icon for " + enumEntry.name());
itemIcon = register.registerIcon(Config.TEXTURE_PATH + ":" + enumEntry.name());
}
public int compare(Items i1, Items i2) {
return i2.getNumberDownloads() - i1.getNumberDownloads();
}
