I have been working on a little project and I have run into a design “problem.” I would like to get your opinion on the topic. Should drops from monsters or quests in an RPG game have armor and weapons with random stats and attributes or should they be predefined? Please list pro’s and con’s with your answers.
My thoughts are this:
Armor and weapons with random stats would be cool. It can make almost every item unique. However I think it would be hard to track the number of these items dropped in an online game.
Armor and weapons that are preconfigured with set stats are great because if you need to nerf or buff an items stats it is a lot easier. The number of theseitems dropped can be tracked easier. Tracking of items might let the game limit the amount of time a certain item drops which might be useful for a online RPG.
Random stats are just as easy to nerf as a preconfigured stats, you simply just change the range of how random it is.
How does preconfigured stats make tracking of an item easier…? It’s the same item, the stats are irrelevant to tracking the number of times that item type has dropped.
Again how does the stats of an item have any relevance to how many times that item can drop…?
To me though, I think I’d like random stats better, but it really does depend on the rest of your game mechanics. A little more info about your game would help too. Overall though I think random stats add more suspense.
For the random items, I was thinking the name of the item would be generated based on stats.
My logic for the random items:
Decide type of item (sword, axe, wand etc)
Generate stats based on a tier. The same tier that te monster is in.
Give item a name based on stats. (Sword with a lot of dmg could be Mighy sword of damage)
I can’t think of a reasonable way to track an item like this. If the game is multiplayer and you only want a percentage of an item to drop based on community size, then you would want a way to track an item.
With the logic provides there is no way to nerf or buff already generated items, unless the item generates an id that then can be looked up and changed.
Let me know if you have a better way to do the random generation with better logic.
Regardless of preconfigured or random ‘stats,’ I would raise an eyebrow if I was playing an rpg-style game and suddenly my weapon stats changed from what they were yesterday.
I wrote this up quick, I hope you get a general idea from it.
You can easily manage any items but grabbing their Type and Tier Type, and no matter the stats of it, you still have that same type of item on the same tier.
The most important thing is maintaing the itemID. Once you have the itemID you can grab all stats and info about that item. I hope you’re understanding.
public class Item{
////Item types
public static final int ITEM_TYPE_SWORD = 0;
public static final int ITEM_TYPE_AXE = 1;
///Tier types
public static final int TIER_TYPE_NORMAL = 0;
public static final int TIER_TYPE_RARE = 1;
private int itemID;
private int itemType;
private int tierType;
private String itemName;
private int damageStat;
public Item(int itemID, int itemType, int tierType, String itemName){
this.itemID = itemID;
this.itemType = itemType;
this.tierType = tierType;
this.itemName = itemName;
//obviously this will be a range between 2 numbers but im just giving an example
//stats will be more complex in your code, because you need to generate the stats
//based off of the tier
this.damageStat = random.nextInt(100);
}
}
public class Main{
public ArrayList<Item> trackedItems = new ArrayList<Item>();
public void onMonsterDeath(){
Item itemDrop = new Item(random.nextInt(), Item.ITEM_TYPE_SWORD, Item.TIER_TYPE_NORMAL, "Normal Sword");
trackedItems.Add(itemDrop);
}
// With this list you will have every item of that type and tier in game, and can now manage them by their ID's (Which you would carry over their random itemID to the players inventory).
public ArrayList<Item> getTrackedItems(int itemType, int tierType){
ArrayList<Item> theItems = new ArrayList<Item>();
for (Item i : trackedItems){
if (i.itemType == itemType && i.tierType == tierType){
theItems.add(i);
}
}
return theItems;
}
}
Your response makes me think that it’s less of a game design choice, but rather an issue with how your item system is set up.
Tracking items is easy, assign an ID to them and add them to a list or database of other items. You can group together similar items in this database to save space, for instance:
Instead of creating separate entries in your database for each of these three swords, group together both swords that deal 10 damage (just check your database to see if a sword type with 10 damage already exists, if so then don’t add the duplicate sword). Then, when you want to nerf your items you can just grab the sword type, modify the value, and push these changes in game. Each time a player starts the game check for any item changes and update the corresponding items in the player’s inventory.
Edit:
Just to clarify on what I was talking about.
Your random weapons will have stats which are generated from a predefined range. (Damage = anywhere from 10 to 50) So since there a finite set of whole numbers in that range, it would be easy to just store each type of weapon as they are generated in game. Of course, this requires you to have a dedicated database server running, but in the long run I think it would be a cool idea.
So, for instance.
In game, a weapon is dropped. Turns out to be an Axe with damage of 3.
Query the weapon database for an axe type with damage of 3.
If one already exists, don’t add it to the database.
If not, insert the new axe type.
A week passes, you decide to buff the axe’s damage by 2 points.
So you go into the database, select all axe types, and then up the damage by 2 points.
Now, push an update notification to the client telling it to check the weapon database for these updated values.
Client checks the database, pulls down new values.
Not random attributes: I don’t think the average user will care about that level of detail and it doesn’t make much sense. How much variation is there going to be between two similar swords, presumably rendered with the same model? They are going to do about the same amount of damage, be roughly equally strong etc etc. Maybe one is a plain sword and the other has rubies in the hilt? They have a dramatically different market value in that case, but they still do the same job in a fight.
Don’t bombard your players with unimportant or trivial information - it just dilutes the more unique game content.
Most RPGs use a system where there are a number of common, mundane items, with a random percentage of drops being modified, with increasing rarity depending on modification magnitude. This mechanism keeps players looking for stuff and being interested in playing the game.
