Added rewind method.

include/dawn/game/poker/pokergame.h

@@ -7,6 +7,7 @@
 
 #pragma once
 #include "../../libs.h"
+#include "../../display/animation/queue.h"
 #include "pokergameassets.h"
 #include "pokerworld.h"
 #include "pokerui.h"
@@ -44,4 +45,7 @@ typedef struct {
 
   /** UI For the Game */
   pokerui_t ui;
+
+  /** Data for the actions */
+  pokergameactiondata_t actionData[ANIMATION_QUEUE_ITEM_MAX];
 } pokergame_t;

include/dawn/game/poker/pokergameaction.h

@@ -10,6 +10,5 @@
 
 
 typedef struct {
-  pokergame_t *game;
-  uint8_t player;
-} pokergameactionlook_t;
+  uint8_t lookAtPlayer;
+} pokergameactiondata_t;

src/display/animation/queue.c

@@ -67,21 +67,16 @@ void queueDispose(queue_t *queue) {
 
 void queueRestack(queue_t *queue) {
   uint8_t i;
-  queueaction_t items[ANIMATION_QUEUE_ITEM_MAX];
 
-  // Take the current queue and copy it.
-  arrayCopy(sizeof(queueaction_t),
-    queue->items+queue->current, queue->count - queue->current,
-    items
+  // Rewind the array.
+  arrayRewind(sizeof(queueaction_t), queue->items, ANIMATION_QUEUE_START,
+    queue->current, queue->count
   );
 
   // Now rewind the stack
   queue->count -= queue->current;
   queue->current = 0;
 
-  // Now copy back
-  arrayCopy(sizeof(queueaction_t), items, queue->count, queue->items);
-
   // Now fix indexes
   for(i = 0; i < queue->count; i++) {
     queue->items[i].index = i;

src/game/poker/actions/bet.c

@@ -16,7 +16,6 @@ void _pokerGameActionBetOnUpdate(
   pokergame_t *game = (pokergame_t *)action->data;
   pokerplayer_t *player;
 
-
   // As of right now the queue should basically be empty besides this item, so
   // let's restack
   queueRestack(queue);

src/game/poker/actions/look.c

@@ -11,14 +11,15 @@
 void _pokerGameActionLookOnStart(
   queue_t *queue, queueaction_t *action, uint8_t i
 ) { 
-
-  printf("Looking at %u\n", (uint8_t)action->data);
-  pokerWorldLookAtPlayer(action);
+  pokergame_t *game = (pokergame_t *)action->data;
+  pokergameactiondata_t *data = game->actionData + i;
+  printf("Looking at %u\n", data->lookAtPlayer);
   queueNext(queue);
 }
 
 queueaction_t * pokerGameActionLookAdd(pokergame_t *game, uint8_t playerIndex) {
   queueaction_t *action = pokerGameActionAdd(game);
   action->onStart = &_pokerGameActionLookOnStart;
+  game->actionData[action->index].lookAtPlayer = playerIndex;
   return action;
 }

src/util/array.c

@@ -87,3 +87,21 @@ int32_t arrayFindString(char **array, int32_t arrayLength, char *value) {
   }
   return -1;
 }
+
+void arrayRewind(size_t size, void *source, int32_t length, int32_t start,
+  int32_t count
+) {
+  if(count == -1) count = length - start;
+
+  // Create a temporary new array to house the data.
+  void *temporary = malloc(size * count);
+  
+  // Copy the data from the source to the temporary array.
+  arrayCopy(size, arrayGet(size, source, start), count, temporary);
+
+  // Now copy the data back to the source array.
+  arrayCopy(size, temporary, count, source);
+
+  // Cleanup the temporary array.
+  free(temporary);
+}

src/util/array.h

@@ -100,3 +100,18 @@ int32_t _arraySorterUint8(const void* left, const void* right);
  * @return The index that the strings exists within the array.
  */
 int32_t arrayFindString(char **array, int32_t arrayLength, char *value);
+
+/**
+ * Rewinds an array backwards. This is used to take an array that has some data
+ * used towards the end of an array, but the data near the start is no longer
+ * used. This will take the end data and put it back at the start.
+ * 
+ * @param size The size of each element within the array.
+ * @param source The array itself.
+ * @param length The total length of the array.
+ * @param start The first index within the array that you want to keep.
+ * @param count Count of items after start to use. Use -1 to take the remaining.
+ */
+void arrayRewind(size_t size, void *source, int32_t length, int32_t start,
+  int32_t end
+);