1 /** 2 Copyright: Copyright (c) 2015-2016 Andrey Penechko. 3 License: $(WEB boost.org/LICENSE_1_0.txt, Boost License 1.0). 4 Authors: Andrey Penechko. 5 */ 6 module chunkmanager; 7 8 import std.experimental.logger; 9 import std.typecons : Nullable; 10 import server : ChunkWorldPos, ChunkDataSnapshot, Timestamp, BlockId, ChunkFreeList, BlockChange, HashSet; 11 12 private enum ChunkState { 13 non_loaded, 14 added_loaded, 15 removed_loading, 16 added_loading, 17 removed_loaded_saving, 18 removed_loaded_used, 19 added_loaded_saving, 20 } 21 22 private enum traceStateStr = q{ 23 //infof("state @%s %s => %s", cwp, state, 24 // chunkStates.get(cwp, ChunkState.non_loaded)); 25 }; 26 27 final class ChunkManager { 28 void delegate(ChunkWorldPos)[] onChunkAddedHandlers; 29 void delegate(ChunkWorldPos)[] onChunkRemovedHandlers; 30 void delegate(ChunkWorldPos, ChunkDataSnapshot)[] onChunkLoadedHandlers; 31 void delegate(ChunkWorldPos, BlockChange[])[] chunkChangesHandlers; 32 void delegate(ChunkWorldPos cwp, BlockId[] outBuffer) loadChunkHandler; 33 void delegate(ChunkWorldPos cwp, ChunkDataSnapshot snapshot) saveChunkHandler; 34 35 private ChunkFreeList freeList; 36 private ChunkDataSnapshot[ChunkWorldPos] snapshots; 37 private ChunkDataSnapshot[Timestamp][ChunkWorldPos] oldSnapshots; 38 private BlockId[][ChunkWorldPos] writeBuffers; 39 private BlockChange[][ChunkWorldPos] chunkChanges; 40 private ChunkState[ChunkWorldPos] chunkStates; 41 private HashSet!ChunkWorldPos modifiedChunks; 42 private size_t[ChunkWorldPos] numInternalChunkUsers; 43 private size_t[ChunkWorldPos] numExternalChunkUsers; 44 45 46 /// Performs save of all modified chunks. 47 /// Modified chunks 48 void save() { 49 foreach(cwp; modifiedChunks.items) { 50 auto state = chunkStates.get(cwp, ChunkState.non_loaded); 51 with(ChunkState) final switch(state) { 52 case non_loaded: 53 assert(false, "Save should not occur for not added chunks"); 54 case added_loaded: 55 chunkStates[cwp] = added_loaded_saving; 56 auto snap = cwp in snapshots; 57 ++snap.numUsers; 58 saveChunkHandler(cwp, *snap); 59 break; 60 case removed_loading: 61 assert(false, "Save should not occur for not loaded chunks"); 62 case added_loading: 63 assert(false, "Save should not occur for not loaded chunks"); 64 case removed_loaded_saving: 65 assert(false, "Save should not occur for not added chunks"); 66 case removed_loaded_used: 67 assert(false, "Save should not occur for not added chunks"); 68 case added_loaded_saving: 69 assert(false, "Save should not occur for not for saving chunk"); 70 } 71 mixin(traceStateStr); 72 } 73 modifiedChunks.clear(); 74 } 75 76 /// Sets number of users of chunk at cwp. 77 /// If total chunk users if greater than zero, then chunk is loaded, 78 /// if equal to zero, chunk will be unloaded. 79 void setExternalChunkUsers(ChunkWorldPos cwp, size_t numExternalUsers) { 80 numExternalChunkUsers[cwp] = numExternalUsers; 81 if (numExternalUsers == 0) 82 numExternalChunkUsers.remove(cwp); 83 setChunkTotalObservers(cwp, numInternalChunkUsers.get(cwp, 0) + numExternalUsers); 84 } 85 86 /// returned value isNull if chunk is not loaded/added 87 Nullable!ChunkDataSnapshot getChunkSnapshot(ChunkWorldPos cwp) { 88 auto state = chunkStates.get(cwp, ChunkState.non_loaded); 89 if (state == ChunkState.added_loaded || state == ChunkState.added_loaded_saving) 90 return Nullable!ChunkDataSnapshot(snapshots[cwp]); 91 else { 92 return Nullable!ChunkDataSnapshot.init; 93 } 94 } 95 96 /// Returns writeable copy of current chunk snapshot. 97 /// Any changes made to it must be reported trough onBlockChanges method. 98 /// This buffer is valid until commit. 99 /// After commit this buffer becomes next immutable snapshot. 100 /// Returns null if chunk is not added and/or not loaded. 101 BlockId[] getWriteBuffer(ChunkWorldPos cwp) { 102 auto newData = writeBuffers.get(cwp, null); 103 if (newData is null) { 104 newData = createWriteBuffer(cwp); 105 } 106 return newData; 107 } 108 109 import std.range : isInputRange, array; 110 /// Call this whenewer changes to write buffer are done. 111 /// Those changes will be passed to chunkChangesHandlers to be handled when sendChanges is called. 112 void onBlockChanges(R)(ChunkWorldPos cwp, R blockChanges) 113 if (isInputRange!(R)) 114 { 115 chunkChanges[cwp] = chunkChanges.get(cwp, null) ~ blockChanges.array; 116 } 117 118 /// Returns timestamp of current chunk snapshot. 119 /// Store this timestamp to use in removeSnapshotUser 120 Timestamp addCurrentSnapshotUser(ChunkWorldPos cwp) { 121 auto snap = cwp in snapshots; 122 assert(snap, "Cannot add chunk user. No such snapshot."); 123 124 auto state = chunkStates.get(cwp, ChunkState.non_loaded); 125 assert(state == ChunkState.added_loaded || state == ChunkState.added_loaded_saving, 126 "To add user chunk must be both added and loaded"); 127 128 ++snap.numUsers; 129 return snap.timestamp; 130 } 131 132 /// Generic removal of snapshot user. Removes chunk if numUsers == 0. 133 /// Use this to remove added snapshot user. Use timestamp returned from addCurrentSnapshotUser. 134 void removeSnapshotUser(ChunkWorldPos cwp, Timestamp timestamp) { 135 auto snap = cwp in snapshots; 136 if (snap && snap.timestamp == timestamp) { 137 auto numUsersLeft = removeCurrentSnapshotUser(cwp); 138 if (numUsersLeft == 0) { 139 auto state = chunkStates.get(cwp, ChunkState.non_loaded); 140 if (state == ChunkState.removed_loaded_used) { 141 chunkStates[cwp] = ChunkState.non_loaded; 142 clearChunkData(cwp); 143 } 144 } 145 } else { 146 auto snapshot = removeOldSnapshotUser(cwp, timestamp); 147 if (snapshot.numUsers == 0) 148 recycleSnapshotMemory(snapshot); 149 } 150 } 151 152 /// Internal. Called by code which loads chunks from storage. 153 void onSnapshotLoaded(ChunkWorldPos cwp, ChunkDataSnapshot snap) { 154 auto state = chunkStates.get(cwp, ChunkState.non_loaded); 155 with(ChunkState) final switch(state) { 156 case non_loaded: 157 assert(false); 158 case added_loaded: 159 assert(false, "On loaded should not occur for already loaded chunk"); 160 case removed_loading: 161 chunkStates[cwp] = non_loaded; 162 clearChunkData(cwp); 163 break; 164 case added_loading: 165 chunkStates[cwp] = added_loaded; 166 snapshots[cwp] = ChunkDataSnapshot(snap.blocks, snap.timestamp); 167 notifyLoaded(cwp); 168 break; 169 case removed_loaded_saving: 170 assert(false, "On loaded should not occur for already loaded chunk"); 171 case removed_loaded_used: 172 assert(false, "On loaded should not occur for already loaded chunk"); 173 case added_loaded_saving: 174 assert(false, "On loaded should not occur for already loaded chunk"); 175 } 176 mixin(traceStateStr); 177 } 178 179 /// Internal. Called by code which saves chunks to storage. 180 void onSnapshotSaved(ChunkWorldPos cwp, ChunkDataSnapshot savedSnap) { 181 auto snap = cwp in snapshots; 182 if (snap && snap.timestamp == savedSnap.timestamp) { 183 auto state = chunkStates.get(cwp, ChunkState.non_loaded); 184 with(ChunkState) final switch(state) { 185 case non_loaded: 186 assert(false, "On saved should not occur for not added chunks"); 187 case added_loaded: 188 assert(false, "On saved should not occur for not saving chunks"); 189 case removed_loading: 190 assert(false, "On saved should not occur for not loaded chunks"); 191 case added_loading: 192 assert(false, "On saved should not occur for not loaded chunks"); 193 case removed_loaded_saving: 194 auto numUsersLeft = removeCurrentSnapshotUser(cwp); 195 if (numUsersLeft == 0) { 196 chunkStates[cwp] = non_loaded; 197 clearChunkData(cwp); 198 } else { 199 chunkStates[cwp] = removed_loaded_used; 200 } 201 break; 202 case removed_loaded_used: 203 assert(false, "On saved should not occur for not saving chunks"); 204 case added_loaded_saving: 205 chunkStates[cwp] = added_loaded; 206 removeCurrentSnapshotUser(cwp); 207 break; 208 } 209 mixin(traceStateStr); 210 } else { // old snapshot saved 211 auto snapshot = removeOldSnapshotUser(cwp, savedSnap.timestamp); 212 if (snapshot.numUsers == 0) 213 recycleSnapshotMemory(snapshot); 214 } 215 } 216 217 /// called at the end of tick 218 void commitSnapshots(Timestamp currentTime) { 219 auto writeBuffersCopy = writeBuffers; 220 clearWriteBuffers(); 221 foreach(snapshot; writeBuffersCopy.byKeyValue) { 222 auto cwp = snapshot.key; 223 auto blocks = snapshot.value; 224 modifiedChunks.put(cwp); 225 commitChunkSnapshot(cwp, blocks, currentTime); 226 } 227 } 228 229 /// Send changes to clients 230 void sendChanges() { 231 foreach(changes; chunkChanges.byKeyValue) { 232 foreach(handler; chunkChangesHandlers) 233 handler(changes.key, changes.value); 234 } 235 clearChunkChanges(); 236 } 237 238 // PPPPPP RRRRRR IIIII VV VV AAA TTTTTTT EEEEEEE 239 // PP PP RR RR III VV VV AAAAA TTT EE 240 // PPPPPP RRRRRR III VV VV AA AA TTT EEEEE 241 // PP RR RR III VV VV AAAAAAA TTT EE 242 // PP RR RR IIIII VVV AA AA TTT EEEEEEE 243 // 244 245 private void notifyAdded(ChunkWorldPos cwp) { 246 foreach(handler; onChunkAddedHandlers) 247 handler(cwp); 248 } 249 250 private void notifyRemoved(ChunkWorldPos cwp) { 251 foreach(handler; onChunkRemovedHandlers) 252 handler(cwp); 253 } 254 255 private void notifyLoaded(ChunkWorldPos cwp) { 256 auto snap = getChunkSnapshot(cwp); 257 assert(!snap.isNull); 258 foreach(handler; onChunkLoadedHandlers) 259 handler(cwp, snap); 260 } 261 262 // Puts chunk in added state requesting load if needed. 263 // Notifies on add. Notifies on load if loaded. 264 private void loadChunk(ChunkWorldPos cwp) { 265 auto state = chunkStates.get(cwp, ChunkState.non_loaded); 266 with(ChunkState) final switch(state) { 267 case non_loaded: 268 chunkStates[cwp] = added_loading; 269 loadChunkHandler(cwp, freeList.allocate()); 270 notifyAdded(cwp); 271 break; 272 case added_loaded: 273 break; // ignore 274 case removed_loading: 275 chunkStates[cwp] = added_loading; 276 notifyAdded(cwp); 277 break; 278 case added_loading: 279 break; // ignore 280 case removed_loaded_saving: 281 chunkStates[cwp] = added_loaded_saving; 282 notifyAdded(cwp); 283 notifyLoaded(cwp); 284 break; 285 case removed_loaded_used: 286 chunkStates[cwp] = added_loaded; 287 notifyAdded(cwp); 288 notifyLoaded(cwp); 289 break; 290 case added_loaded_saving: 291 break; // ignore 292 } 293 mixin(traceStateStr); 294 } 295 296 // Puts chunk in removed state requesting save if needed. 297 // Notifies on remove. 298 private void unloadChunk(ChunkWorldPos cwp) { 299 auto state = chunkStates.get(cwp, ChunkState.non_loaded); 300 with(ChunkState) final switch(state) { 301 case non_loaded: 302 assert(false, "Unload should not occur when chunk was not yet loaded"); 303 case added_loaded: 304 assert(cwp !in writeBuffers, "Chunk with write buffer should not be unloaded"); 305 notifyRemoved(cwp); 306 auto snap = cwp in snapshots; 307 if(cwp in modifiedChunks) { 308 chunkStates[cwp] = removed_loaded_saving; 309 saveChunkHandler(cwp, *snap); 310 ++snap.numUsers; 311 modifiedChunks.remove(cwp); 312 } else { // state 0 313 chunkStates[cwp] = non_loaded; 314 clearChunkData(cwp); 315 } 316 break; 317 case removed_loading: 318 assert(false, "Unload should not occur when chunk is already removed"); 319 case added_loading: 320 notifyRemoved(cwp); 321 chunkStates[cwp] = removed_loading; 322 break; 323 case removed_loaded_saving: 324 assert(false, "Unload should not occur when chunk is already removed"); 325 case removed_loaded_used: 326 assert(false, "Unload should not occur when chunk is already removed"); 327 case added_loaded_saving: 328 notifyRemoved(cwp); 329 chunkStates[cwp] = removed_loaded_saving; 330 break; 331 } 332 mixin(traceStateStr); 333 } 334 335 // Fully removes chunk 336 private void clearChunkData(ChunkWorldPos cwp) { 337 snapshots.remove(cwp); 338 assert(cwp !in writeBuffers); 339 assert(cwp !in chunkChanges); 340 assert(cwp !in modifiedChunks); 341 chunkStates.remove(cwp); 342 } 343 344 // Creates write buffer for writing changes in it. 345 // Latest snapshot's data is copied in it. 346 // On commit stage this is moved into new snapshot and. 347 // Adds internal user that is removed on commit to prevent unloading with uncommitted changes. 348 private BlockId[] createWriteBuffer(ChunkWorldPos cwp) { 349 assert(writeBuffers.get(cwp, null) is null); 350 auto old = getChunkSnapshot(cwp); 351 if (old.isNull) { 352 return null; 353 } 354 auto newData = freeList.allocate(); 355 newData[] = old.blocks; 356 writeBuffers[cwp] = newData; 357 addInternalUser(cwp); // prevent unload until commit 358 return newData; 359 } 360 361 // Here comes sum of all internal and external chunk users which results in loading or unloading of specific chunk. 362 private void setChunkTotalObservers(ChunkWorldPos cwp, size_t totalObservers) { 363 if (totalObservers > 0) { 364 loadChunk(cwp); 365 } else { 366 unloadChunk(cwp); 367 } 368 } 369 370 // Used inside chunk manager to add chunk users, to prevent chunk unloading. 371 private void addInternalUser(ChunkWorldPos cwp) { 372 numInternalChunkUsers[cwp] = numInternalChunkUsers.get(cwp, 0) + 1; 373 auto totalUsers = numInternalChunkUsers[cwp] + numExternalChunkUsers.get(cwp, 0); 374 setChunkTotalObservers(cwp, totalUsers); 375 } 376 377 // Used inside chunk manager to remove chunk users. 378 private void removeInternalUser(ChunkWorldPos cwp) { 379 auto numUsers = numInternalChunkUsers.get(cwp, 0); 380 assert(numUsers > 0, "numInternalChunkUsers is zero when removing internal user"); 381 --numUsers; 382 if (numUsers == 0) 383 numInternalChunkUsers.remove(cwp); 384 else 385 numInternalChunkUsers[cwp] = numUsers; 386 auto totalUsers = numUsers + numExternalChunkUsers.get(cwp, 0); 387 setChunkTotalObservers(cwp, totalUsers); 388 } 389 390 private void clearWriteBuffers() { 391 writeBuffers = null; 392 } 393 394 private void clearChunkChanges() { 395 chunkChanges = null; 396 } 397 398 // Returns number of current snapshot users left. 399 private uint removeCurrentSnapshotUser(ChunkWorldPos cwp) { 400 auto snap = cwp in snapshots; 401 assert(snap, "Cannot remove chunk user. No such snapshot."); 402 assert(snap.numUsers > 0, "cannot remove chunk user. Snapshot has 0 users."); 403 --snap.numUsers; 404 return snap.numUsers; 405 } 406 407 // Returns that snapshot with updated numUsers. 408 // Snapshot is removed from oldSnapshots if numUsers == 0. 409 private ChunkDataSnapshot removeOldSnapshotUser(ChunkWorldPos cwp, Timestamp timestamp) { 410 ChunkDataSnapshot[Timestamp]* chunkSnaps = cwp in oldSnapshots; 411 assert(chunkSnaps, "old snapshot should have waited for releasing user"); 412 ChunkDataSnapshot* snapshot = timestamp in *chunkSnaps; 413 assert(snapshot, "cannot release snapshot user. No such snapshot"); 414 assert(snapshot.numUsers > 0, "snapshot with 0 users was not released"); 415 --snapshot.numUsers; 416 if (snapshot.numUsers == 0) { 417 (*chunkSnaps).remove(timestamp); 418 if ((*chunkSnaps).length == 0) { // all old snaps of one chunk released 419 oldSnapshots.remove(cwp); 420 } 421 } 422 return *snapshot; 423 } 424 425 // Commit for single chunk. 426 private void commitChunkSnapshot(ChunkWorldPos cwp, BlockId[] blocks, Timestamp currentTime) { 427 auto currentSnapshot = getChunkSnapshot(cwp); 428 assert(!currentSnapshot.isNull); 429 if (currentSnapshot.numUsers == 0) 430 recycleSnapshotMemory(currentSnapshot); 431 else { 432 ChunkDataSnapshot[Timestamp] chunkSnaps = oldSnapshots.get(cwp, null); 433 assert(currentTime !in chunkSnaps); 434 chunkSnaps[currentTime] = currentSnapshot.get; 435 } 436 snapshots[cwp] = ChunkDataSnapshot(blocks, currentTime); 437 438 auto state = chunkStates.get(cwp, ChunkState.non_loaded); 439 with(ChunkState) final switch(state) { 440 case non_loaded: 441 assert(false, "Commit is not possible for non-loaded chunk"); 442 case added_loaded: 443 break; // ignore 444 case removed_loading: 445 // Write buffer will be never returned when no snapshot is loaded. 446 assert(false, "Commit is not possible for removed chunk"); 447 case added_loading: 448 // Write buffer will be never returned when no snapshot is loaded. 449 assert(false, "Commit is not possible for non-loaded chunk"); 450 case removed_loaded_saving: 451 // This is guarded by internal user count. 452 assert(false, "Commit is not possible for removed chunk"); 453 case removed_loaded_used: 454 // This is guarded by internal user count. 455 assert(false, "Commit is not possible for removed chunk"); 456 case added_loaded_saving: 457 // This is now old snapshot with saving state. New one is not used by IO. 458 chunkStates[cwp] = added_loaded; 459 break; 460 } 461 removeInternalUser(cwp); // remove user added in getWriteBuffer 462 463 mixin(traceStateStr); 464 } 465 466 // Called when snapshot data can be recycled. 467 private void recycleSnapshotMemory(ChunkDataSnapshot snap) { 468 freeList.deallocate(snap.blocks); 469 } 470 } 471 472 // TTTTTTT EEEEEEE SSSSS TTTTTTT SSSSS 473 // TTT EE SS TTT SS 474 // TTT EEEEE SSSSS TTT SSSSS 475 // TTT EE SS TTT SS 476 // TTT EEEEEEE SSSSS TTT SSSSS 477 // 478 479 version(unittest) { 480 private struct Handlers { 481 void setup(ChunkManager cm) { 482 cm.onChunkAddedHandlers ~= &onChunkAddedHandler; 483 cm.onChunkRemovedHandlers ~= &onChunkRemovedHandler; 484 cm.onChunkLoadedHandlers ~= &onChunkLoadedHandler; 485 cm.chunkChangesHandlers ~= &chunkChangesHandler; 486 cm.loadChunkHandler = &loadChunkHandler; 487 cm.saveChunkHandler = &saveChunkHandler; 488 } 489 void onChunkAddedHandler(ChunkWorldPos) { 490 onChunkAddedHandlerCalled = true; 491 } 492 void onChunkRemovedHandler(ChunkWorldPos) { 493 onChunkRemovedHandlerCalled = true; 494 } 495 void onChunkLoadedHandler(ChunkWorldPos, ChunkDataSnapshot) { 496 onChunkLoadedHandlerCalled = true; 497 } 498 void chunkChangesHandler(ChunkWorldPos, BlockChange[]) { 499 chunkChangesHandlerCalled = true; 500 } 501 void loadChunkHandler(ChunkWorldPos cwp, BlockId[] outBuffer) { 502 loadChunkHandlerCalled = true; 503 } 504 void saveChunkHandler(ChunkWorldPos cwp, ChunkDataSnapshot snapshot) { 505 saveChunkHandlerCalled = true; 506 } 507 void assertCalled(size_t flags) { 508 assert(!(((flags & 0b0000_0001) > 0) ^ onChunkAddedHandlerCalled)); 509 assert(!(((flags & 0b0000_0010) > 0) ^ onChunkRemovedHandlerCalled)); 510 assert(!(((flags & 0b0000_0100) > 0) ^ onChunkLoadedHandlerCalled)); 511 assert(!(((flags & 0b0000_1000) > 0) ^ chunkChangesHandlerCalled)); 512 assert(!(((flags & 0b0001_0000) > 0) ^ loadChunkHandlerCalled)); 513 assert(!(((flags & 0b0010_0000) > 0) ^ saveChunkHandlerCalled)); 514 } 515 516 bool onChunkAddedHandlerCalled; 517 bool onChunkRemovedHandlerCalled; 518 bool onChunkLoadedHandlerCalled; 519 bool chunkChangesHandlerCalled; 520 bool loadChunkHandlerCalled; 521 bool saveChunkHandlerCalled; 522 } 523 524 private struct FSMTester { 525 auto cwp = ChunkWorldPos(0); 526 auto currentState(ref ChunkManager cm) { 527 return cm.chunkStates.get(ChunkWorldPos(0), ChunkState.non_loaded); 528 } 529 void resetChunk(ref ChunkManager cm) { 530 cm.snapshots.remove(cwp); 531 cm.oldSnapshots.remove(cwp); 532 cm.writeBuffers.remove(cwp); 533 cm.chunkChanges.remove(cwp); 534 cm.chunkStates.remove(cwp); 535 cm.modifiedChunks.remove(cwp); 536 cm.numInternalChunkUsers.remove(cwp); 537 cm.numExternalChunkUsers.remove(cwp); 538 } 539 void gotoState(ref ChunkManager cm, ChunkState state) { 540 resetChunk(cm); 541 with(ChunkState) final switch(state) { 542 case non_loaded: 543 break; 544 case added_loaded: 545 cm.setExternalChunkUsers(cwp, 1); 546 cm.onSnapshotLoaded(cwp, ChunkDataSnapshot(new BlockId[16])); 547 break; 548 case removed_loading: 549 cm.setExternalChunkUsers(cwp, 1); 550 cm.setExternalChunkUsers(cwp, 0); 551 break; 552 case added_loading: 553 cm.setExternalChunkUsers(cwp, 1); 554 break; 555 case removed_loaded_saving: 556 gotoState(cm, ChunkState.added_loaded_saving); 557 cm.setExternalChunkUsers(cwp, 0); 558 break; 559 case removed_loaded_used: 560 gotoState(cm, ChunkState.added_loaded); 561 cm.getWriteBuffer(cwp); 562 cm.commitSnapshots(1); 563 cm.addCurrentSnapshotUser(cwp); 564 cm.save(); 565 cm.setExternalChunkUsers(cwp, 0); 566 cm.onSnapshotSaved(cwp, ChunkDataSnapshot(new BlockId[16], Timestamp(1))); 567 break; 568 case added_loaded_saving: 569 gotoState(cm, ChunkState.added_loaded); 570 cm.getWriteBuffer(cwp); 571 cm.commitSnapshots(1); 572 cm.save(); 573 break; 574 } 575 import std.string : format; 576 assert(currentState(cm) == state, 577 format("Failed to set state %s, got %s", state, currentState(cm))); 578 } 579 } 580 } 581 582 583 unittest { 584 import voxelman.utils.log : setupLogger; 585 setupLogger("snapmantest.log"); 586 587 Handlers h; 588 ChunkManager cm; 589 FSMTester fsmTester; 590 ChunkWorldPos cwp = ChunkWorldPos(0); 591 592 void assertState(ChunkState state) { 593 import std.string : format; 594 auto actualState = cm.chunkStates.get(ChunkWorldPos(0), ChunkState.non_loaded); 595 assert(actualState == state, 596 format("Got state '%s', while needed '%s'", actualState, state)); 597 } 598 599 void resetHandlersState() { 600 h = Handlers.init; 601 } 602 void resetChunkManager() { 603 cm = new ChunkManager; 604 h.setup(cm); 605 } 606 void reset() { 607 resetHandlersState(); 608 resetChunkManager(); 609 } 610 611 void setupState(ChunkState state) { 612 fsmTester.gotoState(cm, state); 613 resetHandlersState(); 614 } 615 616 reset(); 617 618 //-------------------------------------------------------------------------- 619 // non_loaded -> added_loading 620 cm.setExternalChunkUsers(cwp, 1); 621 assertState(ChunkState.added_loading); 622 assert(cm.getChunkSnapshot(ChunkWorldPos(0)).isNull); 623 h.assertCalled(0b0001_0001); //onChunkAddedHandlerCalled, loadChunkHandlerCalled 624 625 626 //-------------------------------------------------------------------------- 627 setupState(ChunkState.added_loading); 628 // added_loading -> removed_loading 629 cm.setExternalChunkUsers(cwp, 0); 630 assertState(ChunkState.removed_loading); 631 assert( cm.getChunkSnapshot(ChunkWorldPos(0)).isNull); 632 h.assertCalled(0b0000_0010); //onChunkRemovedHandlerCalled 633 634 635 //-------------------------------------------------------------------------- 636 setupState(ChunkState.removed_loading); 637 // removed_loading -> added_loading 638 cm.setExternalChunkUsers(cwp, 1); 639 assertState(ChunkState.added_loading); 640 assert( cm.getChunkSnapshot(ChunkWorldPos(0)).isNull); 641 h.assertCalled(0b0000_0001); //onChunkAddedHandlerCalled 642 643 644 //-------------------------------------------------------------------------- 645 setupState(ChunkState.removed_loading); 646 // removed_loading -> non_loaded 647 cm.onSnapshotLoaded(ChunkWorldPos(0), ChunkDataSnapshot(new BlockId[16])); 648 assertState(ChunkState.non_loaded); 649 assert( cm.getChunkSnapshot(ChunkWorldPos(0)).isNull); // null 650 h.assertCalled(0b0000_0000); 651 652 //-------------------------------------------------------------------------- 653 setupState(ChunkState.added_loading); 654 // added_loading -> added_loaded 655 cm.onSnapshotLoaded(ChunkWorldPos(0), ChunkDataSnapshot(new BlockId[16])); 656 assertState(ChunkState.added_loaded); 657 assert(!cm.getChunkSnapshot(ChunkWorldPos(0)).isNull); // !null 658 h.assertCalled(0b0000_0100); //onChunkLoadedHandlerCalled 659 660 //-------------------------------------------------------------------------- 661 setupState(ChunkState.added_loaded); 662 // added_loaded -> non_loaded 663 cm.setExternalChunkUsers(cwp, 0); 664 assertState(ChunkState.non_loaded); 665 h.assertCalled(0b0000_0010); //onChunkRemovedHandlerCalled 666 667 //-------------------------------------------------------------------------- 668 setupState(ChunkState.added_loaded); 669 // added_loaded -> removed_loaded_saving 670 cm.getWriteBuffer(cwp); 671 cm.commitSnapshots(Timestamp(1)); 672 cm.setExternalChunkUsers(cwp, 0); 673 assertState(ChunkState.removed_loaded_saving); 674 h.assertCalled(0b0010_0010); //onChunkRemovedHandlerCalled, loadChunkHandlerCalled 675 676 677 //-------------------------------------------------------------------------- 678 setupState(ChunkState.added_loaded); 679 // added_loaded -> added_loaded_saving 680 cm.getWriteBuffer(cwp); 681 cm.commitSnapshots(Timestamp(1)); 682 cm.save(); 683 assertState(ChunkState.added_loaded_saving); 684 h.assertCalled(0b0010_0000); //loadChunkHandlerCalled 685 686 687 //-------------------------------------------------------------------------- 688 setupState(ChunkState.added_loaded_saving); 689 // added_loaded_saving -> added_loaded with commit 690 cm.getWriteBuffer(cwp); 691 cm.commitSnapshots(Timestamp(2)); 692 assertState(ChunkState.added_loaded); 693 h.assertCalled(0b0000_0000); 694 695 696 //-------------------------------------------------------------------------- 697 setupState(ChunkState.added_loaded_saving); 698 // added_loaded_saving -> added_loaded with on_saved 699 cm.onSnapshotSaved(cwp, ChunkDataSnapshot(new BlockId[16], Timestamp(1))); 700 assertState(ChunkState.added_loaded); 701 h.assertCalled(0b0000_0000); 702 703 704 //-------------------------------------------------------------------------- 705 setupState(ChunkState.added_loaded_saving); 706 // added_loaded_saving -> removed_loaded_saving 707 cm.setExternalChunkUsers(cwp, 0); 708 assertState(ChunkState.removed_loaded_saving); 709 h.assertCalled(0b0000_0010); //onChunkRemovedHandlerCalled 710 711 712 //-------------------------------------------------------------------------- 713 setupState(ChunkState.removed_loaded_saving); 714 // removed_loaded_saving -> non_loaded 715 cm.onSnapshotSaved(cwp, ChunkDataSnapshot(new BlockId[16], Timestamp(1))); 716 assertState(ChunkState.non_loaded); 717 h.assertCalled(0b0000_0000); 718 719 720 //-------------------------------------------------------------------------- 721 setupState(ChunkState.added_loaded_saving); 722 // removed_loaded_saving -> removed_loaded_used 723 cm.addCurrentSnapshotUser(cwp); 724 cm.setExternalChunkUsers(cwp, 0); 725 assertState(ChunkState.removed_loaded_saving); 726 cm.onSnapshotSaved(cwp, ChunkDataSnapshot(new BlockId[16], Timestamp(1))); 727 assertState(ChunkState.removed_loaded_used); 728 h.assertCalled(0b0000_0010); //onChunkRemovedHandlerCalled 729 730 731 //-------------------------------------------------------------------------- 732 setupState(ChunkState.removed_loaded_saving); 733 // removed_loaded_saving -> added_loaded_saving 734 cm.setExternalChunkUsers(cwp, 1); 735 assertState(ChunkState.added_loaded_saving); 736 h.assertCalled(0b0000_0101); //onChunkAddedHandlerCalled, onChunkLoadedHandlerCalled 737 738 739 //-------------------------------------------------------------------------- 740 setupState(ChunkState.removed_loaded_used); 741 // removed_loaded_used -> non_loaded 742 cm.removeSnapshotUser(cwp, Timestamp(1)); 743 assertState(ChunkState.non_loaded); 744 h.assertCalled(0b0000_0000); 745 746 747 //-------------------------------------------------------------------------- 748 setupState(ChunkState.removed_loaded_used); 749 // removed_loaded_used -> added_loaded 750 cm.setExternalChunkUsers(cwp, 1); 751 assertState(ChunkState.added_loaded); 752 h.assertCalled(0b0000_0101); //onChunkAddedHandlerCalled, onChunkLoadedHandlerCalled 753 }