Refactor Overworld loading to use async tasks

Refactored Overworld::LoadSprites to use std::async for concurrent sprite loading, improving efficiency. Modified Overworld::LoadOverworldMaps to wait for all async tasks and check results for errors. Updated Overworld::LoadSpritesFromMap to use mutable_current_graphics() for mutable access to current graphics. Added mutable_current_graphics method to OverworldMap class. Optimized Sprite constructor to take a const reference to avoid unnecessary copying.

src/app/zelda3/overworld/overworld.cc

@@ -281,6 +281,7 @@ absl::Status Overworld::LoadOverworldMaps() {
 
   // Wait for all tasks to complete and check their results
   for (auto &future : futures) {
+    future.wait();
     RETURN_IF_ERROR(future.get());
   }
   return absl::OkStatus();
@@ -447,13 +448,21 @@ absl::Status Overworld::LoadItems() {
 }
 
 absl::Status Overworld::LoadSprites() {
-  for (int i = 0; i < 3; i++) {
+  std::vector<std::future<absl::Status>> futures;
-    all_sprites_.emplace_back();
+	futures.emplace_back(std::async(std::launch::async, [this]() {
-  }
+		return LoadSpritesFromMap(kOverworldSpritesBeginning, 64, 0);
+		}));
+	futures.emplace_back(std::async(std::launch::async, [this]() {
+		return LoadSpritesFromMap(kOverworldSpritesZelda, 144, 1);
+		}));
+	futures.emplace_back(std::async(std::launch::async, [this]() {
+		return LoadSpritesFromMap(kOverworldSpritesAgahnim, 144, 2);
+		}));
 
-  RETURN_IF_ERROR(LoadSpritesFromMap(kOverworldSpritesBeginning, 64, 0));
+	for (auto& future : futures) {
-  RETURN_IF_ERROR(LoadSpritesFromMap(kOverworldSpritesZelda, 144, 1));
+		future.wait();
-  RETURN_IF_ERROR(LoadSpritesFromMap(kOverworldSpritesAgahnim, 144, 2));
+		RETURN_IF_ERROR(future.get());
+	}
   return absl::OkStatus();
 }
 
@@ -484,8 +493,8 @@ absl::Status Overworld::LoadSpritesFromMap(int sprites_per_gamestate_ptr,
 
       int realX = ((b2 & 0x3F) * 16) + mapX * 512;
       int realY = ((b1 & 0x3F) * 16) + mapY * 512;
-      auto current_gfx = overworld_maps_[i].current_graphics();
+      all_sprites_[game_state].emplace_back(*overworld_maps_[i].mutable_current_graphics(), 
-      all_sprites_[game_state].emplace_back(current_gfx, (uint8_t)i, b3,
+                                            (uint8_t)i, b3,
                                             (uint8_t)(b2 & 0x3F),
                                             (uint8_t)(b1 & 0x3F), realX, realY);
       all_sprites_[game_state][i].Draw();

src/app/zelda3/overworld/overworld_map.h

@@ -110,6 +110,7 @@ class OverworldMap : public gfx::GfxContext {
   auto static_graphics(int i) const { return static_graphics_[i]; }
   auto large_index() const { return large_index_; }
 
+	auto mutable_current_graphics() { return &current_gfx_; }
   auto mutable_area_graphics() { return &area_graphics_; }
   auto mutable_area_palette() { return &area_palette_; }
   auto mutable_sprite_graphics(int i) { return &sprite_graphics_[i]; }

src/app/zelda3/sprite/sprite.h

@@ -279,7 +279,7 @@ static const std::string kSpriteDefaultNames[]{
 class Sprite : public GameEntity {
  public:
   Sprite() = default;
-  Sprite(std::vector<uint8_t> src, uint8_t overworld_map_id, uint8_t id,
+  Sprite(const std::vector<uint8_t>& src, uint8_t overworld_map_id, uint8_t id,
          uint8_t x, uint8_t y, int map_x, int map_y)
       : map_id_(static_cast<int>(overworld_map_id)),
         id_(id),