Return to Answer

Why not go for a polymorphic approach where your logic is separated into objects with an update function?

You then add these objects to a list and simply loop over this list to update all. You can give each number a priority so that when you add an object to your list you can sort them easily so that you're sure each object is updated in the right order/

If you wan't to take out a system you simply take it out of the list.

public abstract class LogicObject{
  int priority = 0;
  abstract  void update(float dt);
  void setPriority(int value){priority = value}
  int getPriority(){return priority;
 }

public Collision extends LogicObjects{
 
  //Add more properties

  @Override 
  public void update(float dt){
     //updatecollision here
  }

}

 Collision collision = new Collision();
 collision.setPriority(3);
  

 
 private static List<LogicObjects> gameLogicList = new ArrayList<LogicObjects>();
 gameLogicList.add(collision);     
 
 //sort your list on priority

 //somewhere in your main loop
 for(int i;  i < gameLogicList.size(); i++)
 {
    gameLogicList[i].update();
 }

Like sean said, working with events to trigger when something should or should not be used is an elegant way of doing it.

Why not go for a polymorphic approach where your logic is separated into objects with an update function?

You then add these objects to a list and simply loop over this list to update all. You can give each number a priority so that when you add an object to your list you can sort them easily so that you're sure each object is updated in the right order/

If you wan't to take out a system you simply take it out of the list.

public abstract class LogicObject{
  int priority = 0;
  abstract  void update(float dt);
  void setPriority(int value){priority = value}
  int getPriority(){return priority;
 }

public Collision extends LogicObjects{
 
  //Add more properties

  @Override 
  public void update(float dt){
     //updatecollision here
  }

}

 Collision collision = new Collision();
 collision.setPriority(3);
  

 
 private List<LogicObjects> gameLogicList = new ArrayList<LogicObjects>();
 gameLogicList.add(collision);     
 
 //sort your list on priority

 //somewhere in your main loop
 for(int i;  i < gameLogicList.size(); i++)
 {
    gameLogicList[i].update();
 }

Like sean said, working with events to trigger when something should or should not be used is an elegant way of doing it.

Why not go for a polymorphic approach where your logic is separated into objects with an update function?

You then add these objects to a list and simply loop over this list to update all. You can give each number a priority so that when you add an object to your list you can sort them easily so that you're sure each object is updated in the right order/

If you wan't to take out a system you simply take it out of the list.

public abstract class LogicObject{
  int priority = 0;
  abstract  void update(float dt);
  void setPriority(int value){priority = value}
  int getPriority(){return priority;
 }

public Collision extends LogicObjects{
 
  //Add more properties

  @Override 
  public void update(float dt){
     //updatecollision here
  }

}

 Collision collision = new Collision();
 collision.setPriority = 3;
  

 
 private static List<LogicObjects> gameLogicList = new ArrayList<LogicObjects>();
 gameLogicList.add(collision);     
 
 //sort your list on priority

 //somewhere in your main loop
 for(int i;  i < gameLogicList.size(); i++)
 {
    gameLogicList[i].update();
 }

Why not go for a polymorphic approach where your logic is separated into objects with an update function?

You then add these objects to a list and simply loop over this list to update all. You can give each number a priority so that when you add an object to your list you can sort them easily so that you're sure each object is updated in the right order/

If you wan't to take out a system you simply take it out of the list.

public abstract class LogicObject{
  int priority = 0;
  abstract  void update(float dt);
  void setPriority(int value){priority = value}
  int getPriority(){return priority;
 }

public Collision extends LogicObjects{
 
  //Add more properties

  @Override 
  public void update(float dt){
     //updatecollision here
  }

}

 Collision collision = new Collision();
 collision.setPriority(3);
  

 
 private static List<LogicObjects> gameLogicList = new ArrayList<LogicObjects>();
 gameLogicList.add(collision);     
 
 //sort your list on priority

 //somewhere in your main loop
 for(int i;  i < gameLogicList.size(); i++)
 {
    gameLogicList[i].update();
 }

Like sean said, working with events to trigger when something should or should not be used is an elegant way of doing it.

Why not go for a polymorphic approach where your logic is separated into objects with an update function?

You then add these objects to a list and simply loop over this list to update all. You can give each number a priority so that when you add an object to your list you can sort them easily so that you're sure each object is updated in the right order/

If you wan't to take out a system you simply take it out of the list.

Why not go for a polymorphic approach where your logic is separated into objects with an update function?

You then add these objects to a list and simply loop over this list to update all. You can give each number a priority so that when you add an object to your list you can sort them easily so that you're sure each object is updated in the right order/

If you wan't to take out a system you simply take it out of the list.

public abstract class LogicObject{
  int priority = 0;
  abstract  void update(float dt);
  void setPriority(int value){priority = value}
  int getPriority(){return priority;
 }

public Collision extends LogicObjects{
 
  //Add more properties

  @Override 
  public void update(float dt){
     //updatecollision here
  }

}

 Collision collision = new Collision();
 collision.setPriority = 3;
  

 
 private static List<LogicObjects> gameLogicList = new ArrayList<LogicObjects>();
 gameLogicList.add(collision);     
 
 //sort your list on priority

 //somewhere in your main loop
 for(int i;  i < gameLogicList.size(); i++)
 {
    gameLogicList[i].update();
 }