Make sure do again ticks tick

Author: HParker

main.c

@@ -24,7 +24,8 @@ int main(int argc, char ** argv) {
   initRenderer();
 
   while (1) {
-    if (rt.pd->realTimeInterval > 0 && rt.pd->realTimeInterval*60.0f < frameCounter) {
+    // TODO: do a real again tick
+    if (rt.doAgain || (rt.pd->realTimeInterval > 0 && rt.pd->realTimeInterval*60.0f < frameCounter)) {
       tick(&rt);
       frameCounter = 0;
     }
@@ -40,7 +41,8 @@ int main(int argc, char ** argv) {
         break;
       }
       if (inputDir == UNDO && rt.statesCount > 0) {
-        undo(&rt, 0);
+        undo(&rt);
+        rt.didUndo = 0;
       } else {
         update(&rt, inputDir);
       }

notes.org

@@ -9,12 +9,16 @@ what does this rule actually do:
 
 TODO:
 - movement mask
+- don't preallocate for things that are setup at the beginning of the puzzle
+  rules can allocate while they are building performance doesn't matter as much
+  and it might help with the memory leak when expanding rules.
 - mark rule states that are 100% identical
 - move replace tile completely after checking the WHOLE match
 - smooth movement for a new demo
 - add any validations other then syntax
 - sounds
 
+
 3d api:
 - transfer levels with `lift` and `lower`
 - maybe specify 3d levels with,

puzzleData.c

@@ -334,7 +334,7 @@ void initPart(RulePart * part) {
   }
 }
 
-void initState(Pattern * ruleState) {
+void initPatern(Pattern * ruleState) {
   ruleState->partCount = 0;
   ruleState->partCapacity = 1;
   ruleState->parts = malloc(sizeof(RulePart) * ruleState->partCapacity);
@@ -357,14 +357,14 @@ void initRule(Rule * rule) {
   rule->commandCount = 0;
   rule->matchPaterns = malloc(sizeof(Pattern) * rule->matchPaternCapacity);
   for (int stateId = 0; stateId < rule->matchPaternCapacity; stateId++) {
-    initState(&rule->matchPaterns[stateId]);
+    initPatern(&rule->matchPaterns[stateId]);
   }
 
   rule->resultPaternCount = 0;
   rule->resultPaternCapacity = 1;
   rule->resultPaterns = malloc(sizeof(Pattern) * rule->resultPaternCapacity);
   for (int stateId = 0; stateId < rule->resultPaternCapacity; stateId++) {
-    initState(&rule->resultPaterns[stateId]);
+    initPatern(&rule->resultPaterns[stateId]);
   }
 }
 
@@ -380,15 +380,15 @@ void resetRule(Rule * rule) {
   free(rule->matchPaterns);
   rule->matchPaterns = malloc(sizeof(Pattern) * rule->matchPaternCapacity);
   for (int stateId = 0; stateId < rule->matchPaternCapacity; stateId++) {
-    initState(&rule->matchPaterns[stateId]);
+    initPatern(&rule->matchPaterns[stateId]);
   }
 
   rule->resultPaternCount = 0;
   rule->resultPaternCapacity = 1;
   free(rule->resultPaterns);
   rule->resultPaterns = malloc(sizeof(Pattern) * rule->resultPaternCapacity);
   for (int stateId = 0; stateId < rule->resultPaternCapacity; stateId++) {
-    initState(&rule->resultPaterns[stateId]);
+    initPatern(&rule->resultPaterns[stateId]);
   }
 }
 
@@ -415,7 +415,7 @@ void incRuleMatchState(Rule * rule) {
     rule->matchPaternCapacity += PUZZLE_MALLOC_INC;
     rule->matchPaterns = realloc(rule->matchPaterns, sizeof(Pattern) * rule->matchPaternCapacity);
     for (int stateId = rule->matchPaternCount + 1; stateId < rule->matchPaternCapacity; stateId++) {
-      initState(&rule->matchPaterns[stateId]);
+      initPatern(&rule->matchPaterns[stateId]);
     }
   }
   rule->matchPaternCount++;
@@ -427,7 +427,7 @@ void incRuleResultState(Rule * rule) {
     rule->resultPaterns = realloc(rule->resultPaterns, sizeof(Pattern) * rule->resultPaternCapacity);
 
     for (int stateId = rule->resultPaternCount + 1; stateId < rule->resultPaternCapacity; stateId++) {
-      initState(&rule->resultPaterns[stateId]);
+      initPatern(&rule->resultPaterns[stateId]);
     }
   }
   rule->resultPaternCount++;

puzzleData.h

@@ -287,6 +287,8 @@ typedef struct State {
   int objectCount;
   int objectCapacity;
   Obj * objects;
+  int * map;
+  char * oMap;
 } State;
 
 typedef struct Runtime {

runner.c

@@ -322,6 +322,7 @@ void undo(Runtime * rt) {
     // Don't undo more then once per update
     return;
   }
+
   if (rt->states[rt->statesCount].objectCount > 0) {
     free(rt->states[rt->statesCount].objects);
     rt->states[rt->statesCount].objectCount = 0;
@@ -339,6 +340,11 @@ void undo(Runtime * rt) {
 
   memcpy(rt->objects, rt->states[rt->statesCount - 1].objects, sizeof(Obj) * rt->objectCapacity);
 
+  if (rt->levelType == SQUARES) {
+    rt->map = rt->states[rt->statesCount - 1].map;
+    rt->oMap = rt->states[rt->statesCount - 1].oMap;
+  }
+
   rt->statesCount--;
   rt->historyCount--;
   rt->didUndo = 1;
@@ -450,7 +456,6 @@ void applyMatch(Runtime * rt, Match * match) {
     rt->doAgain = 1;
   }
   match->partCount = 0;
-
 }
 
 int distance(int i, int j) {
@@ -1034,6 +1039,16 @@ void addState(Runtime * rt) {
   rt->states[rt->statesCount].objects = malloc(sizeof(Obj) * rt->objectCapacity);
   memcpy(rt->states[rt->statesCount].objects, rt->objects, sizeof(Obj) * rt->objectCapacity);
 
+  if (rt->levelType == SQUARES) {
+    rt->states[rt->statesCount].map = malloc((sizeof(int) * rt->height * rt->width * rt->pd->layerCount));
+    memcpy(rt->states[rt->statesCount].map, rt->map, (sizeof(int) * rt->height * rt->width * rt->pd->layerCount));
+
+    int bytePerRecord = rt->pd->objectCount/8+1;
+    rt->states[rt->statesCount].oMap = malloc((rt->height * rt->width * bytePerRecord));
+    memcpy(rt->states[rt->statesCount].oMap, rt->oMap, (rt->height * rt->width * bytePerRecord));
+  }
+
+
   rt->statesCount++;
 }