0

作为一个学习实验，我一直致力于使用 LibGDX 创建一个 2d java 游戏。我对硬编码有一个非常大的问题，但我从来没有对此做任何事情。直到最近，当我（终于）弄清楚如何有效地使用 sax/dom 时，才找到了 JDOM。我开始明白，使用像 JDOM 这样的优秀 API，很有可能在每个使用的类中实现用户制作的“对象”（命名为...“GameObject”）。该对象将具有可以构造程序中包含的任何对象的方法。以及一个 ArrayList 将保存所有创建的对象......我遇到的问题是我无法从多个类扩展，所以我无法从 scene2d 中获取“Actor”类并扩展它以便它可以解析 JDOM 文档，并填充它的数组列表......

我的问题是：有没有办法通过在 xml 文件中定义对象结构来完全删除对象结构的硬编码，这样可以在运行时更改将被硬编码的对象数据）

这是一些示例代码......它可能并不完美，但它有望让这个想法得到传达

GameObject ...这是我希望每个对象都继承的类

包装rastek.thegame；

import java.util.ArrayList;
import java.util.List;
import org.jdom2.Element;

public class GameObject
{
    Element node;
    ArrayList<GameObject> gameObjects;

    public GameObject(Element node)
    {
        this.setNode(node);
        this.parseJDOM();
    }

    public void parseJDOM()
    {
        List objectList = this.getNode().getChildren();
        for (int i = 0; i < objectList.size(); i++)
        {
            Element node = (Element) objectList.get(i);

            // ONE list of EVERY object used,
            if (node.getName() == "GameScreen")
            {
            //the idea being that since every onject extends gameobject, 
            //they would all take an element as an argument and automatically 
            //create its array structure with it
                this.getGameObjects().add(new GameScreen(node));
            }

//          if (node.getName() == "GameActor")
//          {
//              this.getGameObjects().add(new GameActor(node));
//          }


        }
    }

    public Element getNode()
    {
        return node;
    }

    public void setNode(Element node)
    {
        this.node = node;
    }

    public ArrayList<GameObject> getGameObjects()
    {
        return gameObjects;
    }

    public void setGameObjects(ArrayList<GameObject> gameObjects)
    {
        this.gameObjects = gameObjects;
    }
}

GameCore ... libgdx 抽象层的入口点——这个想法在这里有效

package rastek.thegame;

import org.jdom2.Document;
import org.jdom2.Element;
import org.jdom2.input.SAXBuilder;
import com.badlogic.gdx.ApplicationListener;
import com.badlogic.gdx.Gdx;



public class GameCore extends GameObject implements ApplicationListener
{
    public GameCore(Element node)
    {
        //call the super cunstructor, thus parsing the JDOM and creating 
        //(as per the linked xml), one GameScreen and adding it to the 
        //super's array named gameObjects

        //unlike the other objects constructors, this is passed a local method, which 
        //is simply a temporary solution to obtain the xml file, 

        //as i dont want platform
        //dependancy to come into play yet, i dont want to pass the element to GameCore
        //which comes from the application entry point, which can be android, 
        //ios, or desktop dependant
        super(createJDOM());
    }



    // currently a local static and (UGH) hardcoded method, may find another
    // place and implementation for this for this
    private static Element createJDOM()
    {
        Object object = null;
        Document document;
        try
        {
            SAXBuilder saxBuilder = new SAXBuilder();
            object = saxBuilder.build(Gdx.files.internal("data/xml/GameCore.xml").reader());
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        if (object != null)
        {
            document = (Document) object;
            return document.getRootElement();
        }
        else
        {
            return null;
        }
    }
    @Override
    public void create()
    {
    }
    @Override
    public void resize(int width, int height)
    {
        // TODO Auto-generated method stub
    }

    @Override
    public void render()
    {
        // TODO Auto-generated method stub
    }

    @Override
    public void pause()
    {
        // TODO Auto-generated method stub
    }

    @Override
    public void resume()
    {
        // TODO Auto-generated method stub
    }

    @Override
    public void dispose()
    {
        // TODO Auto-generated method stub
    }
}

GameScreen ...我打算使用的对象之一-这个想法在这里有效...如您所见...这个对象不需要任何努力，超级构造函数是自动生成的，并且它的arraylist的传播会自动开始

package rastek.thegame;

import org.jdom2.Element;
import com.badlogic.gdx.Screen;

public class GameScreen extends GameObject implements Screen
{

    public GameScreen(Element node)
    {
        super(node);
    }

    @Override
    public void render(float delta)
    {
    }

    @Override
    public void resize(int width, int height)
    {
    }

    @Override
    public void show()
    {
    }

    @Override
    public void hide()
    {
    }

    @Override
    public void pause()
    {
    }

    @Override
    public void resume()
    {
    }

    @Override
    public void dispose()
    {
    }
}

你好

package rastek.thegame;
import com.badlogic.gdx.scenes.scene2d.Actor;

public class GameActor extends Actor // ,GameObject
{
    ///i cant extend GameObject on this class, and thus cant add things 
    //like texture objects, and wrappers for complex character data
}

和 xml 即时通讯使用...简单的测试器

<?xml version="1.0" encoding="UTF-8"?>
<GameCore>

    <GameScreen>
        <Actor>
            <foo>
                <bar etc="123" >
                </bar>
            </foo>
        </Actor>
    </GameScreen>

</GameCore>
4

1 回答 1

0

使用组合而不是继承 - 让所有对象包含相同的游戏变量作为成员变量。也许为 getter 指定一个接口，所以：

public interface GameObjectHolder {
    GameObject getGameObject();
}

public class ExampleGO implements GameObjectHolder {

    GameObject go = new GameObject();

    @override
    GameObject getGameObject() {
        return go;
    }
}

现在你可以做 getGameObject.act()、getGameObject.draw() 等

如果你需要对 GameObject 进行回调钩子，让它抽象，然后包含它的对象可以使用匿名内部类实现抽象类：

    GameObject go = new GameObject() {
         void doStuff() {
         }
    }
于 2013-12-14T21:20:55.093 回答