LevelLoader.cpp 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338
  1. /*
  2. * 2D Game Engine
  3. * LevelLoader.cpp.c:
  4. * Based on pikuma.com 2D game engine in C++ and Lua course
  5. * Copyright (c) 2021 986-Studio. All rights reserved.
  6. *
  7. * Created by Manoël Trapier on 28/02/2021.
  8. */
  9. #include <math.h>
  10. #include <fstream>
  11. #include <sol/sol.hpp>
  12. #include <LevelLoader.h>
  13. #include <Game.h>
  14. #include <Components/Animation.h>
  15. #include <Components/Transform.h>
  16. #include <Components/RigidBody.h>
  17. #include <Components/Sprite.h>
  18. #include <Components/BoxCollider.h>
  19. #include <Components/KeyboardControl.h>
  20. #include <Components/CameraFollow.h>
  21. #include <Components/Heakth.h>
  22. #include <Components/ProjectileEmitter.h>
  23. #include <Components/TextLabel.h>
  24. LevelLoader::LevelLoader()
  25. {
  26. }
  27. LevelLoader::~LevelLoader()
  28. {
  29. }
  30. void LevelLoader::loadAssetTable(sol::table &assetsTable,
  31. const std::unique_ptr<AssetStore> &assetStore,
  32. SDL_Renderer *renderer)
  33. {
  34. int i = 0;
  35. while(true)
  36. {
  37. sol::optional<sol::table> hasAsset = assetsTable[i];
  38. if (hasAsset == sol::nullopt)
  39. {
  40. break;
  41. }
  42. sol::table asset = assetsTable[i];
  43. std::string assetType = asset["type"];
  44. if (assetType == "texture")
  45. {
  46. assetStore->addTexture(renderer, asset["id"], asset["file"]);
  47. }
  48. else if (assetType == "font")
  49. {
  50. assetStore->addFont(asset["id"], asset["file"], asset["font_size"]);
  51. }
  52. i++;
  53. }
  54. }
  55. void LevelLoader::loadTileMap(sol::table &tileMap,
  56. const std::unique_ptr<Registry> &registry)
  57. {
  58. int tileSize = tileMap["tile_size"];
  59. double tileScale = tileMap["scale"];
  60. int mapNumCols = tileMap["num_cols"];
  61. int mapNumRows = tileMap["num_rows"];
  62. std::string tilesetId = tileMap["texture_asset_id"];
  63. std::fstream mapFile;
  64. std::string mapFilePath = tileMap["map_file"];
  65. mapFile.open(mapFilePath.c_str());
  66. if (!mapFile.is_open())
  67. {
  68. Logger::Error("Cannot open the mapfile '%s'!!", mapFilePath.c_str());
  69. }
  70. for (int y = 0; y < mapNumRows; y++)
  71. {
  72. for (int x = 0; x < mapNumCols; x++)
  73. {
  74. char ch[2] = {0, 0};
  75. mapFile.get(ch[0]);
  76. int srcRectY = atoi(ch) * tileSize;
  77. mapFile.get(ch[0]);
  78. int srcRectX = atoi(ch) * tileSize;
  79. mapFile.ignore();
  80. Entity tile = registry->createEntity();
  81. tile.addComponent<TransformComponent>(glm::vec2(x * (tileScale * tileSize), y * (tileScale * tileSize)), glm::vec2(tileScale, tileScale), 0.0);
  82. tile.addComponent<SpriteComponent>(tilesetId, 0, tileSize, tileSize, false, srcRectX, srcRectY);
  83. tile.group("tiles");
  84. }
  85. }
  86. mapFile.close();
  87. Game::mapWidth = mapNumCols * tileSize * tileScale;
  88. Game::mapHeight = mapNumRows * tileSize * tileScale;
  89. }
  90. void LevelLoader::loadEntities(sol::table &entitiesTable,
  91. const std::unique_ptr<Registry> &registry)
  92. {
  93. uint32_t i;
  94. for(i = 0; i <= entitiesTable.size(); i++)
  95. {
  96. sol::table entity = entitiesTable[i];
  97. Entity newEntity = registry->createEntity();
  98. sol::optional<std::string> tag = entity["tag"];
  99. if (tag != sol::nullopt)
  100. {
  101. newEntity.tag(tag->c_str());
  102. }
  103. sol::optional<std::string> group = entity["group"];
  104. if (group != sol::nullopt)
  105. {
  106. newEntity.group(group->c_str());
  107. }
  108. sol::table componentTable = entity["components"];
  109. for (const auto& key_value_pair : componentTable ) {
  110. sol::object key = key_value_pair.first;
  111. sol::table component = key_value_pair.second;
  112. std::string componentName = key.as<std::string>();
  113. if (componentName == "transform")
  114. {
  115. newEntity.addComponent<TransformComponent>(glm::vec2(component["position"]["x"], component["position"]["y"]),
  116. glm::vec2(component["scale"]["x"], component["scale"]["y"]),
  117. component["rotation"]);
  118. }
  119. else if (componentName == "rigidbody")
  120. {
  121. newEntity.addComponent<RigidBodyComponent>(glm::vec2(component["velocity"]["x"], component["velocity"]["y"]));
  122. }
  123. else if (componentName == "sprite")
  124. {
  125. newEntity.addComponent<SpriteComponent>(component["texture_asset_id"],
  126. component["z_index"],
  127. component["width"],
  128. component["height"],
  129. component["fixed"].get_or(false),
  130. component["src_rect_x"].get_or(0),
  131. component["src_rect_y"].get_or(0));
  132. }
  133. else if (componentName == "animation")
  134. {
  135. newEntity.addComponent<AnimationComponent>(component["num_frames"].get_or(1),
  136. component["speed_rate"].get_or(1),
  137. true);
  138. }
  139. else if (componentName == "boxcollider")
  140. {
  141. newEntity.addComponent<BoxColliderComponent>(component["width"],
  142. component["height"],
  143. glm::vec2(component["offset"]["x"].get_or(0), component["offset"]["y"].get_or(0)));
  144. }
  145. else if (componentName == "health")
  146. {
  147. newEntity.addComponent<HealthComponent>(component["health_percentage"].get_or(100));
  148. }
  149. else if (componentName == "projectile_emitter")
  150. {
  151. double projectileDuration = component["projectile_duration"];
  152. double repeatFrequency = component["repeat_frequency"];
  153. newEntity.addComponent<ProjectileEmitterComponent>(glm::vec2(component["projectile_velocity"]["x"], component["projectile_velocity"]["y"]),
  154. repeatFrequency * 1000,
  155. projectileDuration * 1000,
  156. component["hit_percentage_damage"],
  157. component["friendly"]);
  158. }
  159. else if (componentName == "keyboard_controller")
  160. {
  161. newEntity.addComponent<KeyboardControlComponent>(glm::vec2(component["up_velocity"]["x"], component["up_velocity"]["y"]),
  162. glm::vec2(component["right_velocity"]["x"], component["right_velocity"]["y"]),
  163. glm::vec2(component["down_velocity"]["x"], component["down_velocity"]["y"]),
  164. glm::vec2(component["left_velocity"]["x"], component["left_velocity"]["y"]));
  165. }
  166. else if (componentName == "camera_follow")
  167. {
  168. newEntity.addComponent<CameraFollowComponent>();
  169. }
  170. else
  171. {
  172. Logger::Error("Unknown component: %s for entity id#%d", componentName.c_str(), newEntity.getId());
  173. }
  174. }
  175. }
  176. }
  177. void LevelLoader::LoadLevel(sol::state &lua,
  178. const std::unique_ptr<Registry> &registry,
  179. const std::unique_ptr<AssetStore> &assetStore,
  180. SDL_Renderer *renderer,
  181. int levelNumber)
  182. {
  183. char luaFileName[50];
  184. sprintf(luaFileName, "assets/scripts/Level%d.lua", levelNumber);
  185. sol::load_result script = lua.load_file(luaFileName);
  186. if (!script.valid())
  187. {
  188. Logger::Error("Error in the Lua script for level #%d:", levelNumber);
  189. sol::error err = script;
  190. std::string errorMessage = err.what();
  191. Logger::Error(errorMessage.c_str());
  192. return;
  193. }
  194. lua.script_file(luaFileName);
  195. Logger::Info("Opened level #%d", levelNumber);
  196. sol::table level = lua["Level"];
  197. sol::table assetsTable = level["assets"];
  198. sol::table tileMap = level["tilemap"];
  199. sol::table entitiesTable = level["entities"];
  200. this->loadAssetTable(assetsTable, assetStore, renderer);
  201. this->loadTileMap(tileMap, registry);
  202. this->loadEntities(entitiesTable, registry);
  203. #if 0
  204. assetStore->addTexture(renderer, "tank-image", "assets/images/tank-panther-right.png");
  205. assetStore->addTexture(renderer, "tree-image", "assets/images/tree.png");
  206. assetStore->addTexture(renderer, "truck-image", "assets/images/truck-ford-right.png");
  207. assetStore->addTexture(renderer, "chopper-image", "assets/images/chopper-spritesheet.png");
  208. assetStore->addTexture(renderer, "main-tileset", "assets/tilemaps/jungle.png");
  209. assetStore->addTexture(renderer, "radar-image", "assets/images/radar.png");
  210. assetStore->addTexture(renderer, "bullet-image", "assets/images/bullet.png");
  211. assetStore->addFont("charriot-font", "assets/fonts/charriot.ttf", 20);
  212. assetStore->addFont("arial-font", "assets/fonts/charriot.ttf", 20);
  213. assetStore->addFont("pico8-font", "assets/fonts/charriot.ttf", 10);
  214. // jungle.map
  215. int tileSize = 32;
  216. double tileScale = 2.0;
  217. int mapNumCols = 25;
  218. int mapNumRows = 20;
  219. std::fstream mapFile;
  220. mapFile.open("assets/tilemaps/jungle.map");
  221. assert(mapFile.is_open());
  222. for (int y = 0; y < mapNumRows; y++)
  223. {
  224. for (int x = 0; x < mapNumCols; x++)
  225. {
  226. char ch[2] = {0, 0};
  227. mapFile.get(ch[0]);
  228. int srcRectY = atoi(ch) * tileSize;
  229. mapFile.get(ch[0]);
  230. int srcRectX = atoi(ch) * tileSize;
  231. mapFile.ignore();
  232. Entity tile = registry->createEntity();
  233. tile.addComponent<TransformComponent>(glm::vec2(x * (tileScale * tileSize), y * (tileScale * tileSize)), glm::vec2(tileScale, tileScale), 0.0);
  234. tile.addComponent<SpriteComponent>("main-tileset", 0, tileSize, tileSize, false, srcRectX, srcRectY);
  235. tile.group("tiles");
  236. }
  237. }
  238. mapFile.close();
  239. Game::mapWidth = mapNumCols * tileSize * tileScale;
  240. Game::mapHeight = mapNumRows * tileSize * tileScale;
  241. Entity chopper = registry->createEntity();
  242. chopper.addComponent<TransformComponent>(glm::vec2(240, 110), glm::vec2(1, 1), 0);
  243. chopper.addComponent<SpriteComponent>("chopper-image", 1, 32, 32);
  244. chopper.addComponent<RigidBodyComponent>(glm::vec2(0, 0));
  245. chopper.addComponent<BoxColliderComponent>(32, 25, glm::vec2(0, 5));
  246. chopper.addComponent<AnimationComponent>(2, 15, true);
  247. chopper.addComponent<KeyboardControlComponent>(glm::vec2(0, -80), glm::vec2(80, 0),
  248. glm::vec2(0, 80), glm::vec2(-80, 0));
  249. chopper.addComponent<ProjectileEmitterComponent>(glm::vec2(180, 180), 0, 10000, 10, true);
  250. chopper.addComponent<HealthComponent>(100);
  251. chopper.addComponent<CameraFollowComponent>();
  252. chopper.tag("player");
  253. Entity radar = registry->createEntity();
  254. radar.addComponent<TransformComponent>(glm::vec2(Game::windowsWidth - 75, 10), glm::vec2(1, 1), 0);
  255. radar.addComponent<RigidBodyComponent>(glm::vec2(0, 0));
  256. radar.addComponent<SpriteComponent>("radar-image", 3, 64, 64, true);
  257. radar.addComponent<AnimationComponent>(8, 5, true);
  258. Entity tank = registry->createEntity();
  259. tank.addComponent<TransformComponent>(glm::vec2(500, 500), glm::vec2(1, 1), 0);
  260. tank.addComponent<RigidBodyComponent>(glm::vec2(20, 0));
  261. tank.addComponent<SpriteComponent>("tank-image", 1, 32, 32);
  262. tank.addComponent<BoxColliderComponent>(25, 18, glm::vec2(5, 7));
  263. tank.addComponent<HealthComponent>(100);
  264. tank.group("enemies");
  265. Entity truck = registry->createEntity();
  266. truck.addComponent<TransformComponent>(glm::vec2(120, 500), glm::vec2(1, 1), 0);
  267. truck.addComponent<RigidBodyComponent>(glm::vec2(0, 0));
  268. truck.addComponent<SpriteComponent>("truck-image", 2, 32, 32);
  269. truck.addComponent<BoxColliderComponent>(25, 20, glm::vec2(5, 5));
  270. truck.addComponent<ProjectileEmitterComponent>(glm::vec2(0, -100), 2000, 5000, 10, false);
  271. truck.addComponent<HealthComponent>(100);
  272. truck.group("enemies");
  273. Entity treeA = registry->createEntity();
  274. treeA.addComponent<TransformComponent>(glm::vec2(600, 495), glm::vec2(1, 1), 0);
  275. treeA.addComponent<SpriteComponent>("tree-image", 2, 16, 32);
  276. treeA.addComponent<BoxColliderComponent>(16, 32);
  277. treeA.group("obstacles");
  278. Entity treeB = registry->createEntity();
  279. treeB.addComponent<TransformComponent>(glm::vec2(400, 495), glm::vec2(1, 1), 0);
  280. treeB.addComponent<SpriteComponent>("tree-image", 2, 16, 32);
  281. treeB.addComponent<BoxColliderComponent>(16, 32);
  282. treeB.group("obstacles");
  283. SDL_Color green = { 64, 255, 127, 255 };
  284. Entity label = registry->createEntity();
  285. label.addComponent<TextLabelComponent>(glm::vec2(Game::windowsWidth/2 - 60, 10), "SUPER CHOPPER BROS 1.0", "charriot-font", green);
  286. #endif
  287. }