main.cpp

#include <iostream>
#include <unordered_map>

#include "converter.h"

#include "id/mapfile.h"
#include "math/maths.h"

#define CHECK_ARG(x) N_CheckArg(argc, argv, #x, &x)
#define LIGHT_POS_Z_OFFSET 10.0f

using std::cout;
using std::endl;

static idVec3 ENV_LIGHT_COLOR = { 0.6, 0.6, 0.6 };
static bool noshadows = false;

static std::unordered_map<int, idList<int>> areaPortalMap;

static idVec3 N_GetStartPos(const idNETLizardConverter *converter, const idMapFile &map, int level)
{
	idVec3 startpos = map.StartPos();
	switch(converter->Game())
	{
		case NL_SHADOW_OF_EGYPT_3D:
			if(level == 8 || level == 9 || level == 12 || level == 10)
				startpos[2] += 20;
			else if(level == 1)
				startpos[2] += 70;
			break;
		case NL_CLONE_3D:
			if(level == 12)
				startpos[2] += 70;
			break;
	}
	return startpos;
}

static void N_ConvertMapAreaPortalFunc(const idNETLizardConverter *converter, idMapFile &map, int level, int i, int prev_scene, int next_scene, const idVec3 v[4])
{
	idEntity e;
	idBounds bv;
	bv += v[0];
	bv += v[1];
	bv += v[2];
	bv += v[3];

	idVec3 center = bv.Center();
	idPlane plane;
	plane.FromPoints(v[0], v[1], v[2]);
	if(fabs(plane.Normal()[2]) < 0.00001f && (bv[1][2] - bv[0][2]) >= 80.0f)
	{
		idVec3 pos(center[0], center[1], bv[0][2] + 1.0f);
		idBounds bbc = {
			{-20.0f, -20.0f, -40.0f},
			{20.0f, 20.0f, 40.0f}
		};
		bbc.Translate(center);
		idBounds bb = {
			{-20.0f, -20.0f, 0.0f},
			{20.0f, 20.0f, 80.0f}
		};
		bb.Translate(center);
		if(!map.IntersectItem(bb) && map.InArea(bbc))
		{
			e.info_player_deathmatch(pos);
			//printf("zzz %f - %f = %f\n", bv[1][2] , bv[0][2], bv[1][2] - bv[0][2]);
			e.NameByClass("_%d", i);
			map << e;
		}
	}

#if 1
	idBounds bounds = map.AreaBounds(prev_scene);
	bounds += map.AreaBounds(next_scene);
	idVec3 radius = bounds.Size() * idVec3{0.5f, 0.5f, 2.0f};
	e.light({center[0], center[1], idMath::Max(bv[1][2] - LIGHT_POS_Z_OFFSET, center[2])}, radius, noshadows, true, ENV_LIGHT_COLOR);
	e.Name("area_portal_light_%d", i);
	map << e;
#endif

	if(fabs(plane.Normal()[2]) < 0.00001f)
	{
		areaPortalMap[prev_scene].Append(next_scene);
		areaPortalMap[next_scene].Append(prev_scene);
	}
}

static void N_ConvertMapAreaFunc(const idNETLizardConverter *converter, idMapFile &map, int index, int i, const idBounds &bv)
{
	idEntity e;
	idVec3 center = bv.Center();
#if 0
	e.info_player_deathmatch({center[0], center[1], bv[0][2] + 1.0f});
	e.NameByClass("_%d", i);
	map << e;
#endif

	idVec3 radius = bv.Size();// * idVec3{0.5f, 0.5f, 1.0f};
	bool noshadow = true;
	if(converter->Game() == NL_SHADOW_OF_EGYPT_3D && (index == 8 || index == 9 || index == 12 || (index == 10 && i == 0) || index == 0))
	{
		if(index == 0)
		{
			center[2] = center.GetMaxAxisLength() * 2.0f;
			radius[2] = center[2];
		}
		else
			center[2] = bv[1][2];
		radius/*[2]*/ *= 2.0f;
		noshadow = false;
	}
	e.light(
			//{center[0], center[1], idMath::Max(bv[1][2] - LIGHT_POS_Z_OFFSET, center[2])}
			center
			, radius, noshadow, true, ENV_LIGHT_COLOR);
	e.Name("area_light_%d", i);
	map << e;
}

static void N_ConvertMapFunc(const idNETLizardConverter *converter, idMapFile &map, int level)
{
	int index = 0;

	auto endlevel_f = [&](const NETLizard_Game_Level_Start_End *area,bool trigger) {
		char *to = nullptr;
		NLint end;
		idVec3 pos;
		idVec3 size;
		idBounds bv;

		if(area)
		{
			if(area->end < 0)
				end = area->start;
			else
				end = area->end;
			bv = map.AreaBounds(end);
			pos = bv.Center();
			pos[2] = bv[0][2];
			if(area->to >= 0)
				to = nlGet3DGameLevelFileName(converter->Game(), area->to);
			end = area->to;
		}
		else
		{
			pos = map.StartPos();
			bv = map.AreaBounds(end);
			to = strdup(idStr::va("lvl%d", level + 1));
			end = level + 1;
		}
		size = {60, 60, bv[1][2] - bv[0][2]};

		if(trigger)
		{
			idEntity entity;
			if(to)
				entity.text(idStr::va("End level: %d. %s", end, to));
			else
				entity.text("End game");
			entity.NameByClass("_endlevel_%d", index);
			entity.Origin(pos + idVec3{0.0f, 0.0f, size[2] * 0.5f});
			map << entity;

			entity.target_endLevel(to ? idStr::va("%s/%s", converter->Gamename(), to) : nullptr);
			entity.NameByClass("_endlevel_%d", index);
			entity.Origin(pos);
			map << entity;

			idStr target = entity.Name();
			entity.func_waitforbutton(target);
			entity.NameByClass("_endlevel_%d", index);
			entity.Size({size[0] * 0.5f, size[1] * 0.5f, size[2]});
			entity.Origin(pos);
			map << entity;

			target = entity.Name();
			entity.trigger_multiple({target});
			entity.NameByClass("_endlevel_%d", index);
			entity.Size(size);
			entity.Origin(pos);
			map << entity;

			free(to);
		}

		if(converter->Version() == MAP_VERSION_QUAKE4)
		{
			idEntity entity;
			entity.target_exitAreaAlert();
			entity.NameByClass(index);
			entity.Origin(pos);
			map << entity;

			idStr target = entity.Name();
			entity.trigger_multiple({target});
			entity.NameByClass("_exitalert_%d", index);
			entity.Size(bv.Size());
			entity.Origin(pos);
			map << entity;
		}
	};

	idEntity e;
	idVec3 startpos = N_GetStartPos(converter, map, level);
	e.info_player_start(startpos, map.StartAngle());
	e.Name("info_player_start_1");
	map << e;

    char menuMusic[8];
    bool hasMenuMusic = nullptr != nlGet3DGameMenuMusicFileName(converter->Game(), menuMusic);

    char levelMusic[8];
    bool hasLevelMusic = nullptr != nlGet3DGameLevelMusicFileName(converter->Game(), level, levelMusic);
    if(hasMenuMusic || hasLevelMusic)
    {
        const char *mf = hasLevelMusic ? levelMusic : menuMusic;
		idStr music(converter->Gamename());
		music += "_";
		music += mf;
        e.speaker(music, true, true, false);
        e.Name("global_background_music_1");
        map << e;
    }

	bool endLevelTrigger = (converter->Game() != NL_SHADOW_OF_EGYPT_3D || (level != 2 && level != 4 && level != 6 && level != 7 && level != 8 && level != 9 && /*level != 10 &&*/ level != 11 && level != 12 && level != 13 && level != 14 && level != 15));
	NLint length;
	const NETLizard_Game_Level_Start_End *area = nlGet3DGameStartEndArea(converter->Game(), -1, -1, &length);
	if(area)
	{
		for(int i = 0; i < length; i++)
		{
			const NETLizard_Game_Level_Start_End *a = area + i;
			if(a->level == level)
			{
				endlevel_f(a, endLevelTrigger);
				index++;
			}
		}
	}
	else
		endlevel_f(nullptr, endLevelTrigger);


	idEntity entity;
	entity.info_player_teleport(startpos, map.StartAngle());
	entity.NameByClass("_map_floor");
	idVec3 center = map.Bounds().Center();
	center[2] = map.Bounds()[0][2];
	entity.Origin(center);
	map << entity;
	idStr target = entity.Name();

	entity.trigger_multiple({target});
	entity.NameByClass("_map_floor");
	entity.Model();
	idVec3 size = map.Bounds().Size();
	size[2] = 60;
	if(!map.HasSky())
		center[2] -= 200;
	entity.Origin(center);
	entity.Size(size);
	map << entity;

	if(converter->Version() == MAP_VERSION_QUAKE4)
	{
		for(auto &[i, next_scenes] : areaPortalMap)
		{
			idBounds bv = map.AreaBounds(i);
			if(!bv.IsValid())
				continue;
			bool isStart = bv.ContainsPoint(startpos);
			if(!isStart && next_scenes.size() < 2)
				continue;
			idVec3 center = bv.Center();
#define SPAWNER_TARGET_SPACING (16 + 1)
			idVec3 minSpawnerSize(32 * 4, 32 * 4, 70);
			auto planes = map.AreaPlanes(i);
			auto sizeEnough = bv.Size() > minSpawnerSize && !planes.empty();
			auto isBox = map.AreaBoundsInPlanes(i);
			auto getcenter = [&center](int c, float p) -> float {
				return center[c] + (p - center[c]) * 0.5f;
			};
			float z = bv[0][2] + SPAWNER_TARGET_SPACING;
			idVec3 targets[] = {
				{center[0], center[1], z},
				{getcenter(0, bv[0][0]), getcenter(1, bv[0][1]), z},
				{getcenter(0, bv[1][0]), getcenter(1, bv[0][1]), z},
				{getcenter(0, bv[0][0]), getcenter(1, bv[1][1]), z},
				{getcenter(0, bv[1][0]), getcenter(1, bv[1][1]), z},
				{getcenter(0, center[0]), getcenter(1, bv[0][1]), z},
				{getcenter(0, center[0]), getcenter(1, bv[1][1]), z},
				{getcenter(0, bv[0][0]), getcenter(1, center[1]), z},
				{getcenter(0, bv[1][0]), getcenter(1, center[1]), z},
			};
			auto fullTarget = sizeEnough && std::all_of(std::cbegin(targets), std::cend(targets), [i, &map](auto &x) {
						return map.InArea(x, i);
						});

			if(!isStart && fullTarget)
			{
				idStrList targetNames;
				int j = 1;
				for(auto &a : targets)
				{
					e.Reset();
					e.Classname("target_null");
					e.NameByClass("_spawner_%d_target_%d", i, j++);
					e.Origin(a);
					map << e;
					targetNames.Append(e.Name());
				}

				e.func_spawner({"monster_tactical","monster_tactical_mgun", "monster_tactical_blaster", "monster_tactical_railgun"});
				e.Origin(center);
				e.NameByClass(i);
				e("delay", 5);
				e("max_active", isBox ? 3 : 2);
				j = 1;
				for(auto &a : targetNames)
					e("target", j++, a.c_str());
				map << e;
				targetNames.Append(e.Name());

				e.text(idStr::va("Barracks(%d)", i));
				e.NameByClass("_spawner_%d", i);
				e.Origin(center);
				map << e;
				targetNames.Append(e.Name());

				center[2] = bv[0][2];
				e.func_remove(targetNames);
				e.NameByClass("_spawner_remove_%d", i);
				e.Origin(center);
				map << e;
				idStr target = e.Name();

				e.trigger_once({target});
				e.NameByClass("_remove_spawner_%d", i);
				e.Origin(center);
				e.Size(bv.Size());
				map << e;
			}
			else
			{
				if(isStart && sizeEnough)
				{
					idStrList targetNames;
					int j = 1;
					for(auto &a : targets)
					{
						e.Reset();
						e.Classname("target_null");
						e.NameByClass("_spawner_%d_target_%d", i, j++);
						e.Origin(a);
						map << e;
						targetNames.Append(e.Name());
					}

					e.func_spawner({"char_marine_medic_armed","char_marine_shotgun", "char_marine_hyperblaster","char_marine_tech_armed"});
					e.Origin(center);
					e.NameByClass(i);
					e("delay", 4);
					e("max_active", isBox ? 4 : 3);
					e("face_enemy", true);
					e("skipVisible", false);
					e("neverDormant", true);
					e("spawn_neverDormant", false);
					e("spawn_gib", true);
					j = 1;
					for(auto &a : targetNames)
						e("target", j++, a.c_str());
					map << e;

					e.text(idStr::va("Home(%d)", i));
					e.NameByClass("_home_spawner_%d", i);
					e.Origin(center);
					map << e;
					idStr target = e.Name();

					center[2] = bv[0][2];
					e.trigger_once({target});
					e.NameByClass("_home_spawner_%d", i);
					e.Origin(center);
					e.Size(bv.Size());
					map << e;
				}
				else
				{
					center[2] = bv[0][2];
					e.trigger_once({});
					e.NameByClass("_remove_spawner_%d", i);
					e.Origin(center);
					e.Size(bv.Size());
					map << e;
				}
			}
		}

		for(const auto &[prev_scene, next_scenes] : areaPortalMap)
		{
			idStr from = idStr::va("%s_remove_spawner_%d", idEntity::CLASSNAME_TRIGGER_ONCE, prev_scene);
			auto p = map.Find(from);
			if(!p)
				continue;
			int j = 1;
			for(auto a : next_scenes)
			{
				idStr to = idStr::va("%s_%d", idEntity::CLASSNAME_FUNC_SPAWNER, a);
				auto t = map.Find(to);
				if(!t)
					continue;
				(*p)("target", j++, to);
			}
		}

		areaPortalMap.clear();
	}
}

static bool N_CheckArg(int argc, char *argv[], const char *target, bool def)
{
	bool res = def;
	idStr yes = idStr::va("--%s", target);
	idStr no = idStr::va("--no-%s", target);

	for(int i = 1; i < argc; i++)
	{
		if(!idStr::Cmp(yes, argv[i]))
			res = true;
		else if(!idStr::Cmp(no, argv[i]))
			res = false;
	}

	return res;
}

static bool N_CheckArg(int argc, char *argv[], const char *target, bool *ret)
{
	bool res = false;
	idStr yes = idStr::va("--%s", target);
	idStr no = idStr::va("--no-%s", target);

	for(int i = 1; i < argc; i++)
	{
		if(!idStr::Cmp(yes, argv[i]))
		{
			res = true;
			if(ret)
				*ret = true;
		}
		else if(!idStr::Cmp(no, argv[i]))
		{
			res = true;
			if(ret)
				*ret = false;
		}
	}

	return res;
}

static const char * N_CheckArg(int argc, char *argv[], const char *target, const char *def)
{
	const char *res = def;
	idStr yes = idStr::va("--%s", target);

	for(int i = 1; i < argc; i++)
	{
		if(!idStr::Cmp(yes, argv[i]))
		{
			i++;
			if(i < argc)
				res = argv[i];
		}
	}

	return res;
}

static bool N_CheckArg(int argc, char *argv[], const char *target, const char **ret)
{
	bool res = false;
	idStr yes = idStr::va("--%s", target);

	for(int i = 1; i < argc; i++)
	{
		if(!idStr::Cmp(yes, argv[i]))
		{
			i++;
			if(i < argc)
			{
				res = true;
				if(ret)
					*ret = argv[i];
			}
		}
	}

	return res;
}


int main(int argc, char *argv[])
{
	using namespace std;

#if 1
	const char *game = argv[1];
	const char *source_path = argv[2];
	const char *target_path = argv[3];
#else
	const char *game = "0";
#ifdef _MSC_VER
	const char *source_path = R"(D:/project/harmattan/NETLizard_idTech4/resource/re3d)";
	const char *target_path = R"(F:/pak/test/doom3/base)";
#else
	const char *source_path = "./egypt3d";
	const char *target_path = "/sdcard/diii4a/base";
#endif
#endif
	idNETLizardConverter converter(static_cast<NETLizard_Game>(atoi(game)), source_path, target_path);

	converter.SetConvertMapAreaCallback(N_ConvertMapAreaFunc);
	converter.SetConvertMapAreaPortalCallback(N_ConvertMapAreaPortalFunc);
	converter.SetConvertMapCallback(N_ConvertMapFunc);

	mapVersion_t version = MAP_VERSION_DOOM3;
#if 0
	if(strstr(target_path, "quake4"))
		version = MAP_VERSION_QUAKE4;
#endif
	const char *ver = NULL;
	if(N_CheckArg(argc, argv, "version", &ver))
	{
		if(!strcmp(ver, "quake4"))
			version = MAP_VERSION_QUAKE4;
	}
	CHECK_ARG(noshadows);

	cout << "noshadows: " << noshadows << endl;
	cout << "version: " << version << endl;

	converter.Version(version);
	converter.ConvertMaterials();
	converter.ConvertTextures();
	converter.ConvertMaps();
	converter.ConvertMapDefs();
    converter.ConvertSounds();
	idStr cmd = converter.GenDmapCommand();
	std::cout << std::endl;
	std::cout << cmd.c_str() << std::endl;
	std::cout << std::endl;
	std::cout << "done" << std::endl;
	return 0;
}