libgdx
एशले एंटिटी सिस्टम

टिप्पणियों

एक घटक बनाना

घटक केवल उदाहरण हैं जो एशले घटक वर्ग को लागू करते हैं।

import com.badlogic.ashley.core.Component;
import com.badlogic.ashley.core.ComponentMapper;

public class Position implements Component {
    public static final ComponentMapper<Position> Map = 
                                 ComponentMapper.getFor(Position.class);

    public float x = 0f, 
                 y = 0f;
}

घटक नक्शे संस्थाओं पर घटकों का उपयोग करने का एक तेज़ तरीका प्रदान करते हैं। अपने घटक मानचित्रों को प्रबंधित करने के दो सामान्य तरीके हैं या तो अपने घटक के वर्ग के भीतर एक स्थिर उदाहरण रखना, या एक कक्षा / ईनम रखना जिसमें आपके सभी घटकों के लिए सभी मैपर्स शामिल हों।

आपके एप्लिकेशन में एक से अधिक बार एक घटक प्रकार के लिए मैपर घोषित करने की आवश्यकता नहीं है।

एक इकाई प्रणाली बनाना

एंटिटी सिस्टम हैं कि आप संस्थाओं के सेट पर कार्यात्मक संचालन कैसे करते हैं। घटकों में आम तौर पर उनके साथ जुड़े तर्क नहीं होने चाहिए जिसमें डेटा या अन्य घटक उदाहरणों की स्थिति के बारे में जागरूकता शामिल हो, क्योंकि यह एक इकाई प्रणाली का काम है। एक इकाई प्रणाली को एक बार में एक से अधिक इंजन में पंजीकृत नहीं किया जा सकता है।

इकाई प्रणालियों को एक से अधिक प्रकार के कार्य नहीं करने चाहिए। एक मूवमेंटसिस्टम को केवल पोजिशनिंग और पसंद को संभालना चाहिए, जबकि रेंडरसिस्टम जैसी किसी चीज को संस्थाओं की ड्राइंग को संभालना चाहिए।

import com.badlogic.ashley.core.Entity;
import com.badlogic.ashley.core.EntitySystem;
import com.badlogic.ashley.core.Family;

public class MovementSystem extends EntitySystem {
    //the type of components necessary for entities to have to be operated on
    private static final Family FAMILY = Family.all(Position.class).get();

    public MovementSystem () {
        super();
    }

    /**
     * The update method called every tick.
     * @param deltaTime The time passed since last frame in seconds.
     */
    public void update (float deltaTime) {
        for (Entity e : this.getEngine().getEntitiesFor(FAMILY)) {
            Position pos = Position.Map.get(e);
            
            // do entity movement logic on component
            ...
        }
    }

कभी-कभी यह आपके एंटिटी सिस्टम को अतिरिक्त कार्यक्षमता के साथ विस्तारित करने के लिए सहायक होता है, जैसे कि एंटिटी लिस्ट्रेन में पाया जाता है ताकि आप केवल प्रत्येक प्रकार की संस्थाओं पर नज़र रखें, बजाय इसके कि आप हर चक्र में सभी संस्थाओं पर ध्यान दें। EntityListeners को ट्रिगर किया जाता है जब भी किसी इकाई को उसी इंजन में जोड़ा जाता है जिसे सिस्टम पंजीकृत है।

import com.badlogic.ashley.core.EntityListener;
import com.badlogic.gdx.utils.Array;

public class MovementSystem extends EntitySystem implements EntityListener {
    Array<Entity> moveables = new Array<>();
    ...

    @Override
    public void entityAdded(Entity entity) {
        if (FAMILY.matches(entity)) {
            moveables.add(entity);
        }
    }

    @Override
    public void entityRemoved(Entity entity) {
        if (FAMILY.matches(entity)) {
            moveables.removeValue(entity, true);
        }
    }

    public void update (float deltaTime) {
        for (Entity e : this.moveables) {
            Position pos = Position.Map.get(e);
            
            // do entity movement logic on component
            ...
        }
    }
}

संस्थाओं के एक सबसेट को ध्यान में रखते हुए कि हर समय सिस्टम प्रक्रियाएं भी इष्टतम हो सकती हैं, क्योंकि आप किसी विशेष इकाई को उस सिस्टम के प्रसंस्करण से संबद्ध घटक को हटाए बिना या पूरी तरह से इंजन से निकालने के बिना उस सिस्टम के प्रसंस्करण से निकाल सकते हैं।

एक सॉर्टेड एंटिटी सिस्टम बनाना

एक साधारण EntitySystem जो किसी दिए गए परिवार की प्रत्येक इकाई को एक comparator द्वारा निर्दिष्ट क्रम में संसाधित करता है और प्रत्येक इकाई EntitySystem के अद्यतन होने पर हर इकाई के लिए EntitySystem processEntity() EntitySystem है। यह वास्तव में सिर्फ एक सुविधा वर्ग है क्योंकि रेंडरिंग सिस्टम एक क्रमबद्ध तरीके से संस्थाओं की सूची पर पुनरावृति करते हैं। संस्थाओं को जोड़ने से इकाई सूची का सहारा लिया जाएगा। यदि आप अपने छँटाई मानदंडों को बदलते हैं तो forceSort() कॉल करें। अधिक जानकारी के लिए, कृपया SortedIteratingSystem देखें

नीचे दिए गए कोड उदाहरण में, इसके लिए सबसे अच्छा उपयोग ज़िन्डेक्स द्वारा क्रमबद्ध क्रम में अपने स्प्राइट्स का प्रतिपादन है।

public class SpriteComponent implements Component {
     public TextureRegion region;
     public int z = 0;
}

public class Mapper {
     public static ComponentMapper<SpriteComponent> sprite = ComponentMapper.getFor(SpriteComponent.class);
}

public class RenderingSystem extends SortedIteratingSystem {

    public RenderingSystem () {
         super(Familly.all(SpriteComponent.class).get(), new ZComparator())
    }

    public void processEntity(Entity entity, float deltaTime) {
         if(checkZIndexHasChangeValue()) {
              forceSort();
         }
    }

    private static class ZComparator implements Comparator<Entity> {
        @Override
        public int compare(Entity entityA, Entity entityB) {
            return (int)Math.signum(Mapper.sprite.get(entityA).z - Mapper.sprite.get(entityB).z);
        }
    }

}

इंटरवल इरेटिंग सिस्टम बनाना

एक साधारण EntitySystem जो एक बार नहीं बल्कि एक निश्चित अंतराल के बाद संस्थाओं के एक परिवार को संसाधित करता है। Entity प्रोसेसिंग लॉजिक को processEntity(Entity) में रखा जाना चाहिए। अधिक जानकारी के लिए, कृपया IntervalIteratingSystem देखें

नीचे दिए गए कोड उदाहरण में, इसके लिए सबसे अच्छा उपयोग भौतिकी दुनिया कदम है।

public class Constants {
     public final static float TIME_STEP = 1 / 60.0f; // 60 fps
     public final static int VELOCITY_ITERATIONS = 6;
     public final static int POSITION_ITERATIONS = 2;
}

public class PhysicsSystem extends IntervalIteratingSystem {
    public PhysicsSystem () {
         super(Family.all(PhysicsComponent.class), Constants.TIME_STEP);
    }

    @Override
    protected void processEntity(Entity entity) {
         // process the physics component here with an interval of 60fps
    }

    @Override
    protected void updateInterval() {
        WorldManager.world.step(Constants.TIME_STEP, Constants.VELOCITY_ITERATIONS, Constants.POSITION_ITERATIONS);
        super.updateInterval();
    }

}