Merge branch '4326-sdk-add-a-force-commit-option' into 'master'

[FIX][sdk] Changing the behaviour of the commit and optimization

See merge request codingame/game-engine!126

Author: Builder

engine/core/src/main/java/com/codingame/gameengine/core/GameManager.java

@@ -240,7 +240,7 @@ private void dumpView() {
         if (totalViewDataBytesSent > VIEW_DATA_HARD_QUOTA) {
             throw new RuntimeException("The amount of data sent to the viewer is too big!");
         } else if (totalViewDataBytesSent > VIEW_DATA_SOFT_QUOTA) {
-            log.warn("Warning: the amount of data sent to the viewer is too big. Please try to optimize your code to send less data.");
+            log.warn("Warning: the amount of data sent to the viewer is too big.\nPlease try to optimize your code to send less data (try replacing some commitEntityStates by a commitWorldState).");
         }
 
         log.info(viewData);

engine/modules/entities/src/main/java/com/codingame/gameengine/module/entities/GraphicEntityModule.java

@@ -5,6 +5,7 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
+import java.util.Optional;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
@@ -107,9 +108,7 @@ public SpriteSheetLoader createSpriteSheetLoader() {
      * <p>
      * Only the most recent commits are kept for a given t.
      * </p>
-     * <p>
-     * If an entity hasn't changed since its previous commit, its commit is ignored.
-     * </p>
+     * 
      * 
      * @param t
      *            The instant of the frame 0 &ge; t &ge; 1.
@@ -118,15 +117,14 @@ public SpriteSheetLoader createSpriteSheetLoader() {
      * 
      */
     public void commitWorldState(double t) {
-        commitEntityState(t, entities.toArray(new Entity[entities.size()]));
+        commitState(t, true, entities.toArray(new Entity[entities.size()]));
     }
 
     /**
      * This entity's graphical counterpart, at instant t of the frame being computed, will have the same properties as the java object as it is now.
      * <p>
      * Only the most recent commit is kept for a given t.
      * <p>
-     * If the entity hasn't changed since its previous commit, the commit is ignored.
      * 
      * @param t
      *            The instant of the frame 0 &ge; t &ge; 1.
@@ -137,6 +135,10 @@ public void commitWorldState(double t) {
      * 
      */
     public void commitEntityState(double t, Entity<?>... entities) {
+        commitState(t, false, entities);
+    }
+
+    private void commitState(double t, boolean commitAll, Entity<?>... entities) {
         requireValidFrameInstant(t);
         requireNonEmpty(entities);
 
@@ -148,9 +150,15 @@ public void commitEntityState(double t, Entity<?>... entities) {
             worldStates.put(actualT, state);
         }
 
-        final WorldState finalState = state;
-        Stream.of(entities).forEach(entity -> finalState.flushEntityState(entity));
+        if (commitAll) {
+            state.markAsWorldCommit();
+        }
+        flushAllEntityStates(entities, state);
+
+    }
 
+    private void flushAllEntityStates(Entity<?>[] entities, WorldState state) {
+        Stream.of(entities).forEach(entity -> state.flushEntityState(entity));
     }
 
     private void requireNonEmpty(Object[] items) {
@@ -166,40 +174,48 @@ private static void requireValidFrameInstant(double t) {
     }
 
     private void sendFrameData() {
-        List<Object> commands = new ArrayList<>();
 
         autocommit();
 
-        newSpriteSheets.forEach(e -> commands.add(gameSerializer.serializeLoadSpriteSheet(e)));
+        Optional<String> load = gameSerializer.serializeLoadSpriteSheets(newSpriteSheets);
         newSpriteSheets.clear();
 
-        newEntities.stream().forEach(e -> {
-            commands.add(gameSerializer.serializeCreateEntity(e));
-        });
+        Optional<String> create = gameSerializer.serializeCreateEntities(newEntities);
         newEntities.clear();
 
         List<WorldState> orderedStates = worldStates.entrySet().stream()
             .sorted((e1, e2) -> e1.getValue().getFrameTime().compareTo(e2.getValue().getFrameTime()))
             .map(Entry::getValue)
             .collect(Collectors.toList());
 
+        List<String> worldCommitsBuilder = new ArrayList<>();
+        List<WorldState> updateBuilder = new ArrayList<>();
+
         for (WorldState nextWorldState : orderedStates) {
+            if (nextWorldState.isWorldCommit()) {
+                worldCommitsBuilder.add(nextWorldState.getFrameTime());
+            }
             WorldState worldStateDiff = nextWorldState.diffFromOtherWorldState(currentWorldState);
-            worldStateDiff.getEntityStateMap().forEach((entity, diff) -> {
-                String serializedStateDiff = gameSerializer.serializeEntitiesStateDiff(entity, diff, worldStateDiff.getFrameTime());
-                commands.add(serializedStateDiff);
-            });
-
+            updateBuilder.add(worldStateDiff);
             currentWorldState.updateAllEntities(nextWorldState);
         }
 
-        worldStates.clear();
+        Optional<String> worldCommits = gameSerializer.serializeWorldStateUpdates(worldCommitsBuilder);
 
-        gameManager.setViewData("entitymodule", commands);
+        Optional<String> update = gameSerializer.serializeWorldDiff(updateBuilder);
+
+        worldStates.clear();
+        gameManager.setViewData(
+            "entitymodule",
+            Stream.of(load, create, update, worldCommits)
+                .filter(Optional::isPresent)
+                .map(Optional::get)
+                .collect(Collectors.joining("\n"))
+        );
     }
 
     private void autocommit() {
-        WorldState state = worldStates.computeIfAbsent("1", (key) -> new WorldState("1", true));
+        WorldState state = worldStates.computeIfAbsent("1", (key) -> new WorldState("1"));
         state.flushMissingEntities(entities);
     }
 
@@ -279,7 +295,7 @@ public Group createGroup(Entity<?>... entities) {
         return e;
 
     }
-    
+
     /**
      * Creates a new BufferedGroup entity, its graphical counterpart will be created on the frame currently being computed.
      * <p>

engine/modules/entities/src/main/java/com/codingame/gameengine/module/entities/Serializer.java

@@ -3,7 +3,11 @@
 import java.text.DecimalFormat;
 import java.text.DecimalFormatSymbols;
 import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Optional;
+import java.util.Set;
 import java.util.HashMap;
+import java.util.List;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
@@ -12,8 +16,7 @@
 
 @Singleton
 class Serializer {
-
-    Map<String, String> commands, keys;
+    public Map<String, String> commands, keys, separators;
     Map<Entity.Type, String> types;
     Map<Curve, String> curves;
     private static DecimalFormat decimalFormat;
@@ -46,7 +49,7 @@ class Serializer {
         keys.put("fontFamily", "ff");
         keys.put("fontSize", "s");
         keys.put("text", "T");
-        keys.put("children", "C");
+        keys.put("children", "ch");
         keys.put("scaleX", "sx");
         keys.put("scaleY", "sy");
         keys.put("anchorX", "ax");
@@ -65,6 +68,13 @@ class Serializer {
         commands.put("CREATE", "C");
         commands.put("UPDATE", "U");
         commands.put("LOADSPRITESHEET", "L");
+        commands.put("WORLDUPDATE", "W");
+
+        separators = new HashMap<>();
+        separators.put("COMMAND", ";");
+        separators.put("COMMAND_ARGUMENT", " ");
+        separators.put("ARGUMENT_DETAILS", ",");
+        separators.put("COMMAND_TYPE", "\n");
 
         curves = new HashMap<>();
         curves.put(Curve.NONE, "_");
@@ -89,6 +99,9 @@ class Serializer {
         if (commands.values().stream().distinct().count() != commands.values().size()) {
             throw new RuntimeException("Duplicate commands");
         }
+        if (separators.values().stream().distinct().count() != separators.values().size()) {
+            throw new RuntimeException("Duplicate separators");
+        }
         if (types.values().stream().distinct().count() != types.values().size()) {
             throw new RuntimeException("Duplicate types");
         }
@@ -98,6 +111,14 @@ class Serializer {
         if (keys.values().stream().anyMatch(character -> curves.containsValue(character))) {
             throw new RuntimeException("Same string used for a curve and a property");
         }
+        if (separators.values().stream().anyMatch(
+            character -> curves.containsValue(character) ||
+                keys.containsValue(character) ||
+                types.containsValue(character) ||
+                commands.containsValue(character)
+        )) {
+            throw new RuntimeException("String already used as separator");
+        }
 
     }
 
@@ -120,11 +141,16 @@ static String escape(String text) {
         return escaped;
     }
 
-    public String serializeEntitiesStateDiff(Entity<?> entity, EntityState diff, String frameInstant) {
-        return join(
-            commands.get("UPDATE"),
+    private String serializeEntitiesStateDiff(Entity<?> entity, EntityState diff, String frameInstant) {
+        String meta = join(
             entity.getId(),
-            frameInstant,
+            frameInstant
+        );
+        if (diff.isEmpty()) {
+            return meta;
+        }
+        return join(
+            meta,
             minifyDiff(diff)
         );
     }
@@ -156,22 +182,94 @@ private String minifyKey(String key) {
     private String minifyDiff(EntityState diff) {
         return diff.entrySet().stream()
             .map((entry) -> join(minifyKey(entry.getKey()), minifyParam(entry.getKey(), entry.getValue())))
-            .collect(Collectors.joining(" "));
+            .collect(Collectors.joining(separators.get("COMMAND_ARGUMENT")));
     }
 
-    public String serializeCreateEntity(Entity<?> e) {
+    private String serializeCreateEntity(Entity<?> e) {
         return join(
-            commands.get("CREATE"),
             types.get(e.getType())
         );
     }
 
-    public Object serializeLoadSpriteSheet(SpriteSheetLoader spriteSheet) {
+    public Optional<String> serializeCreateEntities(List<Entity<?>> entities) {
+        if (entities.isEmpty()) {
+            return Optional.empty();
+        } else {
+            return Optional.of(
+                commands.get("CREATE") + entities.stream()
+                    .map(e -> serializeCreateEntity(e))
+                    .collect(Collectors.joining(separators.get("COMMAND")))
+            );
+        }
+    }
+
+    private String serializeLoadSpriteSheet(SpriteSheetLoader spriteSheet) {
         return join(
-            commands.get("LOADSPRITESHEET"), spriteSheet.getName(), spriteSheet.getSourceImage(),
+            spriteSheet.getName(), spriteSheet.getSourceImage(),
             spriteSheet.getWidth(), spriteSheet.getHeight(), spriteSheet.getOrigRow(), spriteSheet.getOrigCol(), spriteSheet.getImageCount(),
             spriteSheet.getImagesPerRow()
         );
     }
 
+    public Optional<String> serializeLoadSpriteSheets(List<SpriteSheetLoader> spriteSheets) {
+        if (spriteSheets.isEmpty()) {
+            return Optional.empty();
+        } else {
+            return Optional.of(
+                commands.get("LOADSPRITESHEET") + spriteSheets.stream()
+                    .map(e -> serializeLoadSpriteSheet(e))
+                    .collect(Collectors.joining(separators.get("COMMAND")))
+            );
+        }
+    }
+
+    public Optional<String> serializeWorldStateUpdates(List<String> worldUpdates) {
+        if (worldUpdates.isEmpty()) {
+            return Optional.empty();
+        } else {
+            return Optional.of(
+                commands.get("WORLDUPDATE") +
+                    worldUpdates.stream()
+                        .collect(Collectors.joining(separators.get("COMMAND_ARGUMENT")))
+            );
+        }
+    }
+
+    public Optional<String> serializeWorldDiff(List<WorldState> diffs) {
+        if (diffs.isEmpty()) {
+            return Optional.empty();
+        } else {
+            List<String> serialized = diffs.stream()
+                .map(worldDiff -> {
+                    Optional<String> result;
+                    Set<Entry<Entity<?>, EntityState>> diff = worldDiff.getEntityStateMap().entrySet();
+                    if (diff.isEmpty()) {
+                        result = Optional.empty();
+                    } else {
+                        result = Optional.of(
+                            diff
+                                .stream()
+                                .map(e -> {
+                                    return serializeEntitiesStateDiff(e.getKey(), e.getValue(), worldDiff.getFrameTime());
+                                })
+                                .collect(Collectors.joining(separators.get("COMMAND")))
+                        );
+                    }
+                    return result;
+                })
+                .filter(Optional::isPresent)
+                .map(Optional::get)
+                .collect(Collectors.toList());
+            if (serialized.isEmpty()) {
+                return Optional.empty();
+            } else {
+                return Optional.of(
+                    commands.get("UPDATE") + serialized
+                        .stream()
+                        .collect(Collectors.joining(separators.get("COMMAND")))
+                );
+            }
+        }
+    }
+
 }