Adding spell view (Designer app)

design/src/design/designers/SpellDesigner.java

@@ -0,0 +1,87 @@
+package design.designers;
+
+import com.badlogic.gdx.Gdx;
+import com.badlogic.gdx.files.FileHandle;
+import com.badlogic.gdx.scenes.scene2d.Stage;
+import shared.model.Spell;
+import shared.util.AOJson;
+import shared.util.SharedResources;
+import shared.util.SpellJson;
+
+import java.util.*;
+
+import static design.designers.SpellDesigner.SpellParameter;
+
+public class SpellDesigner implements IDesigner<Spell, SpellParameter> {
+
+    private HashMap<Integer, Spell> spells = new HashMap<>();
+    ;
+
+    public SpellDesigner() {
+        load(new SpellParameter());
+    }
+
+    @Override
+    public void load(SpellParameter params) {
+        SpellJson.load(spells, Gdx.files.internal(SharedResources.SPELLS_JSON_FILE));
+        spells.forEach((k, v) -> v.setId(k));
+    }
+
+    @Override
+    public void reload() {
+
+    }
+
+    @Override
+    public void save() {
+        ArrayList<Spell> spells = new ArrayList<>(this.spells.values());
+        FileHandle output = Gdx.files.local("output/" + SharedResources.SPELLS_FOLDER);
+        new AOJson().toJson(spells, ArrayList.class, Spell.class, output);
+    }
+
+    @Override
+    public Map<Integer, Spell> get() {
+        return spells;
+    }
+
+    @Override
+    public Optional<Spell> get(int id) {
+        return Optional.ofNullable(spells.get(id));
+    }
+
+    @Override
+    public Optional<Spell> create() {
+        return Optional.of(new Spell(getFreeId()));
+    }
+
+    private int getFreeId() {
+        return spells.keySet().stream().max(Integer::compareTo).get() + 1;
+    }
+
+    @Override
+    public void modify(Spell element, Stage stage) {
+
+    }
+
+    @Override
+    public void delete(Spell element) {
+        spells.remove(element.getId());
+    }
+
+    @Override
+    public void add(Spell spell) {
+        spells.put(spell.getId(), spell);
+    }
+
+    @Override
+    public boolean contains(int id) {
+        return spells.containsKey(id);
+    }
+
+    @Override
+    public void markUsedImages() {
+    }
+
+    static class SpellParameter implements Parameters<Spell> {
+    }
+}

design/src/design/editors/GenericEditor.java

@@ -0,0 +1,133 @@
+package design.editors;
+
+import com.badlogic.gdx.scenes.scene2d.ui.Dialog;
+import com.badlogic.gdx.scenes.scene2d.ui.ScrollPane;
+import com.badlogic.gdx.scenes.scene2d.ui.Table;
+import com.esotericsoftware.minlog.Log;
+import design.editors.fields.*;
+import org.jetbrains.annotations.NotNull;
+import shared.objects.types.Obj;
+
+import java.lang.reflect.Field;
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.List;
+
+import static launcher.DesignCenter.SKIN;
+
+public class GenericEditor extends Dialog {
+
+    Object obj;
+
+    public GenericEditor(Obj obj) {
+        super("Object Editor", SKIN);
+        this.obj = obj;
+        addTable();
+        button("Cancel", false);
+        button("OK", obj);
+    }
+
+    public static Table getTable(Object obj, FieldEditor.FieldListener listener) {
+        Table table = new Table(SKIN);
+        table.defaults().growX().uniform();
+
+        List<Field> allFields = getAllFields(new LinkedList<>(), obj.getClass());
+        allFields.forEach(field -> {
+            Class<?> type = field.getType();
+            field.setAccessible(true);
+            if (type.equals(int.class) || type.equals(Integer.class)) {
+                table.add(IntegerEditor.create(field.getName(), getFieldProvider(field.getName()), (v) -> {
+                    try {
+                        field.set(obj, v);
+                    } catch (Exception e) {
+                        Log.error("Failed to set field value", e);
+                    }
+                }, () -> {
+                    try {
+                        return (Integer) field.get(obj);
+                    } catch (Exception e) {
+                        Log.error("Failed to get field value", e);
+                    }
+                    return 0;
+                }, listener)).row();
+            } else if (type.equals(String.class)) {
+                table.add(StringEditor.simple(field.getName(), (v) -> {
+                    try {
+                        field.set(obj, v);
+                    } catch (Exception e) {
+                        Log.error("Failed to set field value", e);
+                    }
+                }, () -> {
+                    try {
+                        return (String) field.get(obj);
+                    } catch (Exception e) {
+                        Log.error("Failed to get field value", e);
+                    }
+                    return "";
+                }, listener)).row();
+            } else if (type.equals(boolean.class) || type.equals(Boolean.class)) {
+                table.add(BooleanEditor.simple(field.getName(), (v) -> {
+                    try {
+                        field.set(obj, v);
+                    } catch (Exception e) {
+                        Log.error("Failed to set field value", e);
+                    }
+                }, () -> {
+                    try {
+                        return (Boolean) field.get(obj);
+                    } catch (Exception e) {
+                        Log.error("Failed to get field value", e);
+                    }
+                    return false;
+                }, listener)).row();
+            } else if (type.equals(float.class) || type.equals(Float.class)) {
+                table.add(FloatEditor.simple(field.getName(), (v) -> {
+                    try {
+                        field.set(obj, v);
+                    } catch (Exception e) {
+                        Log.error("Failed to set field value", e);
+                    }
+                }, () -> {
+                    try {
+                        return (Float) field.get(obj);
+                    } catch (Exception e) {
+                        Log.error("Failed to get field value", e);
+                    }
+                    return 0f;
+                }, listener)).row();
+            }
+        });
+
+        return table;
+    }
+
+    private static List<Field> getAllFields(List<Field> fields, Class<?> type) {
+        fields.addAll(Arrays.asList(type.getDeclaredFields()));
+
+        if (type.getSuperclass() != null) {
+            getAllFields(fields, type.getSuperclass());
+        }
+
+        return fields;
+    }
+
+    @NotNull
+    public static FieldProvider getFieldProvider(String field) {
+        switch (field) {
+            case "grhIndex":
+            case "iconGrh":
+                return FieldProvider.IMAGE;
+            case "bodyNumber":
+            case "animationId":
+            case "dwarfAnimationId":
+            case "fxGrh":
+                return FieldProvider.ANIMATION;
+        }
+        return FieldProvider.NONE;
+    }
+
+    private void addTable() {
+        getContentTable().add(new ScrollPane(getTable(obj, () -> {
+        }))).prefHeight(300).prefWidth(300);
+    }
+}

design/src/design/screens/ScreenEnum.java

@@ -17,6 +17,7 @@ public enum ScreenEnum {
     WEAPONS_VIEW("Weapons", WeaponsView.class),
     HELMETS_VIEW("Helmets", HelmetsView.class),
     FXS_VIEW("FXs", FXsView.class),
+    SPELL_VIEW("Spells", SpellView.class),
     TILE_SET_VIEW("Tile Set", TileSetView.class);
 
     private String title;

design/src/design/screens/views/SpellView.java

@@ -0,0 +1,92 @@
+package design.screens.views;
+
+import com.badlogic.gdx.scenes.scene2d.ui.Table;
+import com.badlogic.gdx.utils.Array;
+import design.designers.SpellDesigner;
+import design.editors.GenericEditor;
+import design.editors.fields.FieldEditor;
+import design.screens.ScreenEnum;
+import graphics.AOAnimationActor;
+import graphics.Effect;
+import model.descriptors.FXDescriptor;
+import model.textures.AOAnimation;
+import model.textures.BundledAnimation;
+import org.jetbrains.annotations.NotNull;
+import shared.model.Spell;
+
+import static launcher.DesignCenter.SKIN;
+
+public class SpellView extends View<Spell, SpellDesigner> {
+
+    public SpellView() {
+        super(new SpellDesigner());
+    }
+
+    @Override
+    Preview<Spell> createPreview() {
+        return new SpellPreview();
+    }
+
+    @Override
+    Editor<Spell> createItemView() {
+        return new SpellItemView();
+    }
+
+    @Override
+    protected void sort(Array<Spell> items) {
+    }
+
+    @Override
+    protected void keyPressed(int keyCode) {
+    }
+
+    class SpellItemView extends Editor<Spell> {
+
+        public SpellItemView() {
+            super(SKIN);
+        }
+
+        @NotNull
+        @Override
+        protected Table getTable(FieldEditor.FieldListener listener) {
+            return GenericEditor.getTable(get(), listener);
+        }
+
+        @Override
+        protected Spell getCopy(Spell to) {
+            return to;
+        }
+    }
+
+    class SpellPreview extends Preview<Spell> {
+
+        private Spell spell;
+
+        public SpellPreview() {
+            super(SKIN);
+        }
+
+        @Override
+        void show(Spell spell) {
+            clear();
+            this.spell = spell;
+
+            int fxGrh = spell.getFxGrh();
+            ScreenEnum.FXS_VIEW.getScreen()
+                    .getDesigner()
+                    .get(fxGrh)
+                    .filter(FXDescriptor.class::isInstance)
+                    .ifPresent(fx -> {
+                        FXDescriptor descriptor = (FXDescriptor) fx;
+                        BundledAnimation anim = getAnimationHandler().getFX(new Effect.EffectBuilder().withFX(descriptor.id).build());
+                        AOAnimationActor animation = new AOAnimationActor(anim);
+                        add(animation);
+                    });
+        }
+
+        @Override
+        Spell get() {
+            return spell;
+        }
+    }
+}

design/src/graphics/AOAnimationActor.java

@@ -27,11 +27,13 @@
 import com.badlogic.gdx.graphics.g2d.Batch;
 import com.badlogic.gdx.math.MathUtils;
 import com.esotericsoftware.minlog.Log;
+import design.screens.ScreenEnum;
 import design.screens.views.DescriptorActor;
 import entity.character.states.Heading;
 import game.handlers.AnimationHandler;
 import model.descriptors.Descriptor;
 import model.descriptors.FXDescriptor;
+import model.textures.AOAnimation;
 import model.textures.BundledAnimation;
 
 public class AOAnimationActor extends DescriptorActor {
@@ -46,6 +48,15 @@ public AOAnimationActor(AnimationHandler animationHandler) {
         this.animationHandler = animationHandler;
     }
 
+    public AOAnimationActor(AOAnimation animation) {
+        this(new BundledAnimation(animation));
+    }
+
+    public AOAnimationActor(BundledAnimation animation) {
+        super();
+        this.animation = animation;
+    }
+
     @Override
     public void act(float delta) {
         super.act(delta);
@@ -80,9 +91,16 @@ public void setDescriptor(Descriptor descriptor) {
 
     public void setAnimation(Descriptor descriptor) {
         int graphic = descriptor instanceof FXDescriptor ? descriptor.getGraphic(0) : descriptor.getGraphic(heading);
+        setAnimationID(graphic);
+    }
+
+    public void setAnimationID(int graphic) {
         if (graphic > 0) {
-            Effect effect = new Effect.EffectBuilder().withFX(graphic).withLoops(1).build();
-            this.animation = animationHandler.getFX(effect);
+            ScreenEnum.ANIMATION_VIEW
+                    .getScreen()
+                    .getDesigner()
+                    .get(graphic)
+                    .ifPresent(anim -> this.animation = new BundledAnimation((AOAnimation) anim));
         } else {
             Log.info("Failed to preview descriptor: " + descriptor);
         }

server/src/server/core/Finisterra.java

@@ -94,14 +94,12 @@ public void startGame(Room room) {
         });
         room.getPlayers().stream().mapToInt(player -> getNetworkManager().getConnectionByPlayer(player)).forEach(connectionId -> {
             try {
-                final String ip = IpChecker.getIp();
-                InetAddress inetAddress = InetAddress.getLocalHost();
-
                 if (shouldUseLocalHost) {
                     System.out.println("Using localhost...");
                 }
-
-                getNetworkManager().sendTo(connectionId, new StartGameResponse(shouldUseLocalHost ? inetAddress.getHostAddress() : ip, roomServer.getTcpPort(), roomServer.getUdpPort()));
+                getNetworkManager().sendTo(connectionId, new StartGameResponse(
+                                shouldUseLocalHost ? InetAddress.getLocalHost().getHostAddress() : IpChecker.getIp(),
+                                roomServer.getTcpPort(), roomServer.getUdpPort()));
             } catch (Exception e) {
                 e.printStackTrace();
             }