Libgdx存储游戏项目

Question

I understand the basics of JSON, but what I more curious about is how I would use it to go about achieving what I need to get done.

Let me explain, I want to store all my game ITEMS in a JSON file so it would hold the item name "WEAPON OF WHATEVER" then have its stats such as buyPrice , sellPrice , minDamage , maxDamage , etc...

How would one go about doing something like this in JSON?

Answer 1

I've used JSON files to store reference data for my game, and the good news is that libGDX comes with a JSON parser that you can use in a few lines of code as shown below. First, you want to define a class that can be serialized:

public class Item {
    private String name;
    private String description;
    private String image;
    private float baseValue;
    private int baseQuantity;
    private float rarityIndex;
    private Array<String> tags = new Array<>();

    public Item() { }
    // More Constructors/Getters/Setters/Helper Methods, etc.
}

Then you need to create a Json object to read a file (or write to a file):

Json json = new Json();
types = json.fromJson(Array.class, Item.class, Gdx.files.internal(FILE_NAME) );

This is actual, working code from my game. A few things to point out:

• types is of type Array<Item> using libGDX's Array class. This means we're really telling libGDX to interpret it as an Array object instead of a proper array, but I really like libGDX's data structures, so this wasn't an issue for me.
• Not all Java data structures are supported when using GWT (in particular, when using Maps you want to use a libGDX implementation under com.badlogic.gdx.utils ). This is because the nature of GWT puts certain restrictions on reflection.
• Note that when we call Json#fromJson() we have to pass Array.class and Item.class so that it knows to return an Array<Item> object.

Now how do we structure the JSON? The easiest way to figure this out is to create a small test program that generates a few objects and then writes them to a file or to stdout:

System.out.println(json.prettyPrint(types));

This will work for simple structures (and is probably all you need, but it might be helpful to look at the JSON and understand how it's structured. Going back to my example earlier, the JSON file looks like the following:

[
  {
    "class": "tech.otter.merchant.data.Item",
    "name": "Bindookian Spices",
    "description": "Sweet, yet spicy.",
    "image": "goods0",
    "baseValue": 150,
    "baseQuantity": 1000,
    "rarityIndex": 0.25,
    "tags": [
      "category-food",
      "category-luxury"
    ]
  },
  {
    "class": "tech.otter.merchant.data.Item",
    "name": "Italiluminum Rods",
    "description": "Shiny.",
    "image": "goods1",
    "baseValue": 400,
    "baseQuantity": 1000,
    "rarityIndex": 0.25,
    "tags": [
      "category-valuable",
      "category-material"
    ]
  }
  // More items in the real file
]

You'll see that this is a pretty straightforward mapping from the JSON to our class. A few things of note:

• Note how the file begins with the square brackets []- this tells us that the data is being stored as a JSON array, even though we're translating it into an Array class in our code.
• I based this off of the libGDX output, so inside each Item structure there is a "class" tag. I don't believe that this is strictly necessary, but it doesn't hurt when you have nested data structures like this.
• Notice how "tags" got stored as an array, and libGDX doesn't need to know that it is an Array object.

In summary, the libGDX library comes with its own JSON parser (which can be further customized if you have special serialization needs), but the tradeoff is that you have to use the libGDX data structures in certain cases (particularly when using GWT).

Answer 2

I use Gson to achieve something similar.

first add this to your core (of project of your chosing) build.gradle

compile group: 'com.google.code.gson', name: 'gson', version: '2.6.2'

Get or allocate preferences (libgdx's cross plaform way to save user data):

//It is advised to use you app package name + some name for these specific prefs to avoid collision with other apps using the same name. Since some plaform uses this name for a flat file name.
Preferences preferences = Gdx.app.getPreferences("nl.example.whatever");

Load/save your values:

Gson gson = new Gson();

Item getItem(String id)
{
    String data = preferences.getString(id,null);
    if(data == null)
        return null;

    Item item = gson.fromJson(preferences.getString(id),Item.class);
}

void saveItems(List<Item> items)
{
    for(Item item : items)
    {
        preferences.putString(item.getId(),gson.toJson(item));
    }
    //save from cache to file. Try to minimize flush calls.
    preferences.flush();
}

LibGDX wiki on preferences

This is asuming your data is dynamic and not just descriptions and the like. In that case I recommend the following (I created it for achievements once):

add to build.gradle:

compile 'org.json:json:20151123'

Achievement.ID is an enumeration

void loadAchievements()
{
    JSONArray array;
    try
    {
        String json = Globals.loadResourceToString("achievements.json");
        array = new JSONArray(json);
    }
    catch (Exception ex)
    {
        throw new RuntimeException("could not load achievements");
    }

    int nr_of_achievements = array.length();
    for (int i = 0; i < nr_of_achievements; i++)
    {
        JSONObject obj = array.getJSONObject(i);
        if (obj.getString("id") == null)
            throw new RuntimeException("achievement does not exist");
        Achievement.ID id = Achievement.ID.valueOf(obj.getString("id"));
        achievementList.put(id, new Achievement(id, obj));
    }
}


public static String loadResourceToString(String resourceName) throws Exception
{
    ClassLoader loader = Thread.currentThread().getContextClassLoader();
    InputStream resourceStream = loader.getResourceAsStream(resourceName);
    StringBuilder sb = new StringBuilder();
    BufferedReader br = new BufferedReader(new InputStreamReader(resourceStream, "UTF-8"));
    for (int c = br.read(); c != -1; c = br.read()) sb.append((char) c);
    return sb.toString();
}