added asking for and uploading tapes to score server (only once)
[rocksndiamonds.git] / src / libgame / snapshot.c
1 // ============================================================================
2 // Artsoft Retro-Game Library
3 // ----------------------------------------------------------------------------
4 // (c) 1995-2014 by Artsoft Entertainment
5 //                  Holger Schemel
6 //                  info@artsoft.org
7 //                  https://www.artsoft.org/
8 // ----------------------------------------------------------------------------
9 // snapshot.c
10 // ============================================================================
11
12 #include "snapshot.h"
13
14
15 #ifdef DEBUG
16 #define DEBUG_SNAPSHOTS                 0
17 #endif
18
19 static ListNode *snapshot_single = NULL;
20 static ListNode *snapshot_list = NULL;
21 static ListNode *snapshot_current = NULL;
22
23 static int num_snapshots = 0;
24 static int num_snapshot_buffers = 0;
25 static int num_snapshot_bytes = 0;
26 static int next_snapshot_key = 0;
27
28
29 // -----------------------------------------------------------------------------
30 // functions for handling buffers for a single snapshot
31 // -----------------------------------------------------------------------------
32
33 void SaveSnapshotBuffer(ListNode **snapshot_buffers, void *buffer, int size)
34 {
35   struct SnapshotNodeInfo *bi =
36     checked_calloc(sizeof(struct SnapshotNodeInfo));
37
38   bi->buffer_orig = buffer;
39   bi->buffer_copy = checked_malloc(size);
40   bi->size = size;
41
42   memcpy(bi->buffer_copy, buffer, size);
43
44   addNodeToList(snapshot_buffers, NULL, bi);
45
46   num_snapshot_buffers++;
47   num_snapshot_bytes += size;
48 }
49
50 static void LoadSnapshotBuffer(struct SnapshotNodeInfo *bi)
51 {
52   memcpy(bi->buffer_orig, bi->buffer_copy, bi->size);
53 }
54
55 void LoadSnapshotBuffers(ListNode *snapshot_buffers)
56 {
57   while (snapshot_buffers != NULL)
58   {
59     LoadSnapshotBuffer((struct SnapshotNodeInfo *)snapshot_buffers->content);
60
61     snapshot_buffers = snapshot_buffers->next;
62   }
63 }
64
65 static void FreeSnapshotBuffer(void *bi_raw)
66 {
67   struct SnapshotNodeInfo *bi = (struct SnapshotNodeInfo *)bi_raw;
68
69   num_snapshot_buffers--;
70   num_snapshot_bytes -= bi->size;
71
72   checked_free(bi->buffer_copy);
73   checked_free(bi);
74 }
75
76 void FreeSnapshotBuffers(ListNode *snapshot_buffers)
77 {
78   while (snapshot_buffers != NULL)
79     deleteNodeFromList(&snapshot_buffers, NULL, FreeSnapshotBuffer);
80 }
81
82 // -----------------------------------------------------------------------------
83 // functions for handling single shapshot or list of snapshots
84 // -----------------------------------------------------------------------------
85
86 static void FreeSnapshot(void *snapshot_buffers_ptr)
87 {
88   FreeSnapshotBuffers(snapshot_buffers_ptr);
89 }
90
91 void FreeSnapshotSingle(void)
92 {
93   FreeSnapshotBuffers(snapshot_single);
94
95   snapshot_single = NULL;
96 }
97
98 static void FreeSnapshotList_UpToNode(ListNode *node)
99 {
100   while (snapshot_list != node)
101   {
102 #if DEBUG_SNAPSHOTS
103     Debug("snapshot:FreeSnapshotList_UpToNode", "[%s, %d, %d]",
104           snapshot_list->key, num_snapshot_buffers, num_snapshot_bytes);
105 #endif
106
107     deleteNodeFromList(&snapshot_list, snapshot_list->key, FreeSnapshot);
108
109     num_snapshots--;
110     next_snapshot_key = (snapshot_list ? atoi(snapshot_list->key) + 1 : 0);
111   }
112 }
113
114 void FreeSnapshotList(void)
115 {
116 #if DEBUG_SNAPSHOTS
117   Debug("snapshot:FreeSnapshotList", "");
118 #endif
119
120   FreeSnapshotList_UpToNode(NULL);
121
122   num_snapshots = 0;
123   num_snapshot_buffers = 0;
124   num_snapshot_bytes = 0;
125   next_snapshot_key = 0;
126
127   snapshot_current = NULL;
128 }
129
130 static void ReduceSnapshotList(void)
131 {
132 #if DEBUG_SNAPSHOTS
133   int num_snapshots_last = num_snapshots;
134 #endif
135
136   // maximum number of snapshots exceeded -- thin out list of snapshots
137   ListNode *node = snapshot_list;
138   int num_snapshots_to_skip = num_snapshots / 10;
139
140   // do not remove the newest snapshots from the list
141   while (node && num_snapshots_to_skip--)
142     node = node->next;
143
144   // remove every second snapshot from the remaining list
145   while (node)
146   {
147     // never delete the first list node (snapshot at game start)
148     if (node->next == NULL)
149       break;
150
151     // in alternation, delete one node from the list ...
152     deleteNodeFromList(&node, node->key, FreeSnapshot);
153     num_snapshots--;
154
155     // ... and keep one node (which always exists here)
156     node = node->next;
157   }
158
159 #if DEBUG_SNAPSHOTS
160   Debug("snapshot:ReduceSnapshotList",
161         "(Reducing number of snapshots from %d to %d.)",
162         num_snapshots_last, num_snapshots);
163
164 #if 0
165   node = snapshot_list;
166   while (node)
167   {
168     Debug("snapshot:ReduceSnapshotList", "key: %s", node->key);
169
170     node = node->next;
171   }
172 #endif
173 #endif
174 }
175
176 void SaveSnapshotSingle(ListNode *snapshot_buffers)
177 {
178   if (snapshot_single)
179     FreeSnapshotSingle();
180
181   snapshot_single = snapshot_buffers;
182 }
183
184 void SaveSnapshotToList(ListNode *snapshot_buffers)
185 {
186   if (snapshot_current != snapshot_list)
187     FreeSnapshotList_UpToNode(snapshot_current);
188
189 #if DEBUG_SNAPSHOTS
190   Debug("snapshot:SaveSnapshotToList",
191         "[%d] [%d snapshots, %d buffers, %d bytes]",
192         next_snapshot_key, num_snapshots,
193         num_snapshot_buffers, num_snapshot_bytes);
194 #endif
195
196   addNodeToList(&snapshot_list, i_to_a(next_snapshot_key),
197                 snapshot_buffers);
198
199   snapshot_current = snapshot_list;
200
201   num_snapshots++;
202   next_snapshot_key++;
203
204   if (num_snapshot_bytes > setup.engine_snapshot_memory)
205     ReduceSnapshotList();
206 }
207
208 boolean LoadSnapshotSingle(void)
209 {
210   if (snapshot_single)
211   {
212     LoadSnapshotBuffers(snapshot_single);
213
214     return TRUE;
215   }
216
217   return FALSE;
218 }
219
220 boolean LoadSnapshotFromList_Older(int steps)
221 {
222   if (snapshot_current && snapshot_current->next)
223   {
224     while (snapshot_current->next && steps--)
225       snapshot_current = snapshot_current->next;
226
227     LoadSnapshotBuffers(snapshot_current->content);
228
229 #if DEBUG_SNAPSHOTS
230     Debug("snapshot:LoadSnapshotFromList_Older", "[%s]", snapshot_current->key);
231 #endif
232
233     return TRUE;
234   }
235
236   return FALSE;
237 }
238
239 boolean LoadSnapshotFromList_Newer(int steps)
240 {
241   if (snapshot_current && snapshot_current->prev)
242   {
243     while (snapshot_current->prev && steps--)
244       snapshot_current = snapshot_current->prev;
245
246     LoadSnapshotBuffers(snapshot_current->content);
247
248 #if DEBUG_SNAPSHOTS
249     Debug("snapshot:LoadSnapshotFromList_Newer", "[%s]", snapshot_current->key);
250 #endif
251
252     return TRUE;
253   }
254
255   return FALSE;
256 }
257
258 boolean CheckSnapshotList(void)
259 {
260   return (snapshot_list ? TRUE : FALSE);
261 }