Merge branch 'master' into 'fix-dsk-upgrade-player'

# Conflicts:
#   playground/misc/misc-3-release-notes.md

Author: Julien Poulton

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

@@ -200,14 +200,12 @@ private void sendFrameData() {
             currentWorldState.updateAllEntities(nextWorldState);
         }
 
-        Optional<String> worldCommits = gameSerializer.serializeWorldCommits(worldCommitsBuilder);
-
         Optional<String> update = gameSerializer.serializeWorldDiff(updateBuilder);
 
         worldStates.clear();
         gameManager.setViewData(
             "entitymodule",
-            Stream.of(load, create, update, worldCommits)
+            Stream.of(load, create, update)
                 .filter(Optional::isPresent)
                 .map(Optional::get)
                 .collect(Collectors.joining("\n"))

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

@@ -71,7 +71,6 @@ class Serializer {
         commands.put("CREATE", "C");
         commands.put("UPDATE", "U");
         commands.put("LOADSPRITESHEET", "L");
-        commands.put("WORLDUPDATE", "W");
 
         separators = new HashMap<>();
         separators.put("COMMAND", ";");
@@ -229,18 +228,6 @@ public Optional<String> serializeLoadSpriteSheets(List<SpriteSheetSplitter> spri
         }
     }
 
-    public Optional<String> serializeWorldCommits(List<String> worldCommits) {
-        if (worldCommits.isEmpty()) {
-            return Optional.empty();
-        } else {
-            return Optional.of(
-                commands.get("WORLDUPDATE") +
-                worldCommits.stream()
-                        .collect(Collectors.joining(separators.get("COMMAND_ARGUMENT")))
-            );
-        }
-    }
-
     public Optional<String> serializeWorldDiff(List<WorldState> diffs) {
         if (diffs.isEmpty()) {
             return Optional.empty();

engine/modules/entities/src/main/resources/view/entity-module/Command.js

@@ -152,18 +152,6 @@ export class PropertiesCommand {
   apply (entities, frameInfo) {
     let entity = entities.get(this.id)
     entity.addState(this.t, { values: this.params, curve: this.curve }, frameInfo.number, frameInfo)
-  }
-}
-export class WorldCommitCommand {
-  constructor (args, globalData) {
-    this.times = args.map(v => +v)
-  }
-
-  apply (entities, frameInfo) {
-    entities.forEach(entity => {
-      this.times.forEach(time => {
-        entity.addState(time, { values: {}, curve: {} }, frameInfo.number, frameInfo)
-      })
-    })
+    entity.stateAdded = true
   }
 }

engine/modules/entities/src/main/resources/view/entity-module/CommandParser.js

@@ -1,10 +1,9 @@
-import { CreateCommand, PropertiesCommand, LoadCommand, WorldCommitCommand } from './Command.js'
+import { CreateCommand, PropertiesCommand, LoadCommand } from './Command.js'
 
 const COMMAND_KEY_MAP = {
   C: CreateCommand,
   U: PropertiesCommand,
-  L: LoadCommand,
-  W: WorldCommitCommand
+  L: LoadCommand
 }
 
 function splitOnCharOutsideQuotes (text, charParam) {

engine/modules/entities/src/main/resources/view/entity-module/Entity.js

@@ -62,19 +62,31 @@ export class Entity {
   render (progress, data, globalData) {
     let subframes = this.states[data.number]
     this.container.visible = false
+    let start = null
+    let end
+    // This t is used to animate the interpolation
+    let t = 1
     if (subframes && subframes.length) {
       let index = 0
       while (index < subframes.length - 1 && subframes[index].t < progress) {
         index++
       }
-      let start = subframes[index - 1]
-      let end = subframes[index]
-      // This t is used to animate the interpolation
-      let t
+
+      start = subframes[index - 1]
+      end = subframes[index]
 
       if (!start) {
-        // The start frame must be at the end of the previous turn
-        var prev = this.states[data.previous.number] || []
+        // The start frame must be at the end of a previous turn
+        let frameNumbers = Object.keys(this.states)
+        let index = frameNumbers.indexOf(data.number.toString()) - 1
+        // Failsafe
+        if (index === -1) {
+          index = frameNumbers.length - 1
+        }
+        while (index >= 0 && frameNumbers[index] >= data.number) {
+          index--
+        }
+        let prev = this.states[frameNumbers[index]] || []
         start = prev[prev.length - 1]
 
         // If it didn't exist on the previous turn, don't even animate it
@@ -88,41 +100,53 @@ export class Entity {
       } else {
         t = unlerp(start.t, end.t, progress)
       }
-      if (start) {
-        const changed = {}
-        const state = Object.assign({}, this.currentState)
-
-        for (let property of this.properties) {
-          const opts = PROPERTIES[property] || PROPERTIES.default
-          const lerpMethod = opts.lerpMethod
-          const curve = end.curve[property] || (a => a)
-          const newValue = lerpMethod(start[property], end[property], curve(t))
-          if (newValue !== this.currentState[property]) {
-            changed[property] = true
-            state[property] = newValue
-          }
-        }
-        this.updateDisplay(state, changed, globalData, data, progress)
-        Object.assign(this.currentState, state)
-        this.container.visible = this.container._visible
-        if (changed.children) {
-          globalData.mustResetTree = true
-          if (typeof this.postUpdate === 'function') {
-            globalData.updatedBuffers.push(this)
-          }
-        }
-        if (changed.zIndex) {
-          globalData.mustResort = true
-        }
-        if (changed.mask) {
-          globalData.maskUpdates[this.id] = state.mask
+    } else {
+      // Look for the most recent state, but don't interpolate?
+      let frameNumbers = Object.keys(this.states)
+      let index = frameNumbers.length - 1
+      while (index >= 0 && frameNumbers[index] > data.number) {
+        index--
+      }
+      let substates = this.states[frameNumbers[index]]
+
+      if (substates != null) {
+        start = substates[substates.length - 1]
+        end = start
+      } else {
+        Object.assign(this.currentState, this.defaultState)
+      }
+    }
+    if (start) {
+      const changed = {}
+      const state = Object.assign({}, this.currentState)
+      for (let property of this.properties) {
+        const opts = PROPERTIES[property] || PROPERTIES.default
+        const lerpMethod = opts.lerpMethod
+        const curve = end.curve[property] || (a => a)
+        const newValue = lerpMethod(start[property], end[property], curve(t))
+        if (newValue !== this.currentState[property]) {
+          changed[property] = true
+          state[property] = newValue
         }
-        if (Object.keys(changed).length !== 0 && this.parent) {
-          this.parent.notifyChange()
+      }
+      this.updateDisplay(state, changed, globalData, data, progress)
+      Object.assign(this.currentState, state)
+      this.container.visible = this.container._visible
+      if (changed.children) {
+        globalData.mustResetTree = true
+        if (typeof this.postUpdate === 'function') {
+          globalData.updatedBuffers.push(this)
         }
       }
-    } else {
-      Object.assign(this.currentState, this.defaultState)
+      if (changed.zIndex) {
+        globalData.mustResort = true
+      }
+      if (changed.mask) {
+        globalData.maskUpdates[this.id] = state.mask
+      }
+      if (Object.keys(changed).length !== 0 && this.parent) {
+        this.parent.notifyChange()
+      }
     }
   }
 

engine/modules/entities/src/main/resources/view/entity-module/GraphicEntityModule.js

@@ -75,6 +75,13 @@ export class GraphicEntityModule {
     const previousFrameNumber = frameInfo.previous.number
     this
       .entities.forEach(entity => {
+        // Only create if entity is affected by this frameInfo
+        if (entity.stateAdded) {
+          entity.stateAdded = false
+        } else {
+          return
+        }
+
         // Create empty substate array if none
         if (!entity.states[frameNumber]) {
           entity.states[frameNumber] = []

engine/modules/tooltip/src/main/resources/view/tooltip-module/TooltipModule.js

@@ -15,8 +15,21 @@ function getMouseOutFunc (id, tooltip) {
   }
 }
 
+function getEntityCurrentSubStates (entity, frame) {
+  if (entity.states[frame]) {
+    return entity.states[frame]
+  }
+  let frameNumbers = Object.keys(entity.states)
+  let index = frameNumbers.length - 1
+
+  while (index >= 0 && frameNumbers[index] > frame) {
+    index--
+  }
+  return entity.states[frameNumbers[index]] || []
+}
+
 function getEntityState (entity, frame) {
-  const subStates = entity.states[frame]
+  const subStates = getEntityCurrentSubStates(entity, frame)
   if (subStates && subStates.length) {
     return subStates[subStates.length - 1]
   }

playground/misc/misc-3-release-notes.md

@@ -9,6 +9,7 @@ The CodinGame SDK is regularly updated and improved. This document lets you know
 - `Invalid negative values for colours no longer crash the game`
 - `Fixed missing line breaks in the Game Summary console`
 - `Frames now start at 0 in local test page`
+- `Games now require less RAM in the CodinGame IDE`
 
 ## 3.4.8
 

runner/src/main/java/com/codingame/gameengine/runner/CommandLinePlayerAgent.java

@@ -13,21 +13,29 @@ public class CommandLinePlayerAgent extends Agent {
     private OutputStream processStdin;
     private InputStream processStdout;
     private InputStream processStderr;
-    private String commandLine;
+    private String[] commandArray;
     private Process process;
 
     /**
      * Creates an Agent for your game, will run the given commandLine at game start
      * 
      * @param commandLine
-     *            the commandLine to run
+     *            the command line to run
      */
     public CommandLinePlayerAgent(String commandLine) {
         super();
-        try {
-            this.commandLine = commandLine;
-        } catch (Exception e) {
-        }
+        this.commandArray = commandLine.split(" ");
+    }
+    
+    /**
+     * Creates an Agent for your game, will run the given commandLine at game start
+     * 
+     * @param commandArray
+     *            the command array to run
+     */
+    public CommandLinePlayerAgent(String[] commandArray) {
+        super();
+        this.commandArray = commandArray;
     }
 
     @Override
@@ -47,11 +55,10 @@ protected InputStream getErrorStream() {
 
     @Override
     public void initialize(Properties conf) {
-
         try {
-            this.process = Runtime.getRuntime().exec(commandLine);
+            this.process = Runtime.getRuntime().exec(commandArray);
         } catch (IOException e) {
-            throw new RuntimeException("Failed to launch " + commandLine, e);
+            throw new RuntimeException("Failed to launch " + String.join(" ", commandArray));
         }
         processStdin = process.getOutputStream();
         processStdout = process.getInputStream();

runner/src/main/java/com/codingame/gameengine/runner/GameRunner.java

@@ -270,11 +270,22 @@ private String getNextPlayerOutput(NextPlayerInfo nextPlayerInfo, String nextPla
         String playerOutput = player.getOutput(nextPlayerInfo.nbLinesNextOutput, nextPlayerInfo.timeout);
         if (playerOutput != null)
             playerOutput = playerOutput.replace('\r', '\n');
-        readError(player);
 
-        if (checkOutput(playerOutput, nextPlayerInfo.nbLinesNextOutput) != OutputResult.OK) {
+        if (checkOutput(playerOutput, nextPlayerInfo.nbLinesNextOutput) == OutputResult.OK) {
+            // Read this turn's stderr
+            readError(player);
+        } else {
+            // Give the agent time to crash cleanly
+            try {
+                Thread.sleep(nextPlayerInfo.timeout);
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+            // Read this turns stderr and the crash output
+            readError(player);
             return null;
         }
+
         if ((playerOutput != null) && playerOutput.isEmpty() && (nextPlayerInfo.nbLinesNextOutput == 1)) {
             return "\n";
         }