CnC_Remastered_Collection/TIBERIANDAWN/DLLInterfaceEditor.cpp

//
// Copyright 2020 Electronic Arts Inc.
//
// TiberianDawn.DLL and RedAlert.dll and corresponding source code is free 
// software: you can redistribute it and/or modify it under the terms of 
// the GNU General Public License as published by the Free Software Foundation, 
// either version 3 of the License, or (at your option) any later version.

// TiberianDawn.DLL and RedAlert.dll and corresponding source code is distributed 
// in the hope that it will be useful, but with permitted additional restrictions 
// under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT 
// distributed with this program. You should have received a copy of the 
// GNU General Public License along with permitted additional restrictions 
// with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection

#include <stdio.h>
//#include <iostream>
//#include <fstream>

#include	"function.h"
#include "externs.h"
#include "DLLInterface.h"
#include "Gadget.h"
#include "defines.h" // VOC_COUNT, VOX_COUNT
#include "SidebarGlyphx.h"
#include "TEMPLATE.H"

extern "C" __declspec(dllexport) int __cdecl CNC_Editor_Startup();
extern "C" __declspec(dllexport) int __cdecl CNC_Editor_Cleanup();
extern "C" __declspec(dllexport) int __cdecl CNC_Editor_Load_Map(char* cncdata_directory, char* house_name, int scenario_index, char* east_west, char* variant);
extern "C" __declspec(dllexport) int __cdecl CNC_Editor_Load_Map_By_Scenario_Name(char* cncdata_directory, char* scenario_name);
extern "C" __declspec(dllexport) int __cdecl CNC_Editor_Clear_Map();
extern "C" __declspec(dllexport) int __cdecl CNC_Editor_Get_Map_Stats(int& map_width, int& map_height, int& theater);
extern "C" __declspec(dllexport) int __cdecl CNC_Editor_Get_Cell_Data_By_Index(int cell_index, char* cell_name, unsigned long cell_name_size, int& template_type, int& template_icon_index);
extern "C" __declspec(dllexport) int __cdecl CNC_Editor_Get_Cell_Data(int x, int y, char* cell_name, unsigned long cell_name_size, int& template_type, int& template_icon_index);
extern "C" __declspec(dllexport) int __cdecl CNC_Editor_Get_Cell_Texture_Buffer(int x, int y, int& out_width, int& out_height, SAFEARRAY*& out_texture_array);
extern "C" __declspec(dllexport) int __cdecl CNC_Editor_Get_Scenario_Names(char* cncdata_directory, int CD);
extern "C" __declspec(dllexport) int __cdecl CNC_Editor_Get_Template_Data(int template_type_index, SAFEARRAY*& template_points);

char EditorMapINIBuffer[SHAPE_BUFFER_SIZE];
bool EditorMapInitialized = false;

const static int EDITOR_COMMMAND_SUCCESS = 0;
const static int EDITOR_COMMMAND_FAILURE = 1;

const static char* MixFileNames[] =
{
	"GENERAL.MIX",
	"SC-000.MIX",
	"SC-001.MIX",
	"DESERT.MIX",
	"TEMPERAT.MIX",
	"WINTER.MIX"
};

extern MixFileClass *TheaterIcons;
extern bool Read_Movies_From_Scenario_Ini(char *root, bool fresh);

/**************************************************************************************************
* CNC_Editor_Startup
* Initializes the system to allow map loading for the editor
**************************************************************************************************/
extern "C" __declspec(dllexport) int __cdecl CNC_Editor_Startup()
{
	BlackPalette = new(MEM_CLEAR | MEM_REAL) unsigned char[768];
	GamePalette = new(MEM_CLEAR | MEM_REAL) unsigned char[768];
	OriginalPalette = new(MEM_CLEAR | MEM_REAL) unsigned char[768];
	WhitePalette = new(MEM_CLEAR | MEM_REAL) unsigned char[768];
	memset(WhitePalette, 63, 768);


	Set_Palette(GamePalette);

	TheaterData = 0;
	TheaterIcons = 0;
	LowTheaterData = 0;

	return EDITOR_COMMMAND_SUCCESS;
}

/**************************************************************************************************
* CNC_Editor_Cleanup
* Cleans up systems initialized by the editor
**************************************************************************************************/
extern "C" __declspec(dllexport) int __cdecl CNC_Editor_Cleanup()
{
	if (BlackPalette)
	{
		delete[] BlackPalette;
	}

	if (GamePalette)
	{
		delete[] GamePalette;
	}

	if (OriginalPalette)
	{
		delete[] OriginalPalette;
	}
	if (WhitePalette)
	{
		delete[] WhitePalette;
	}

	return EDITOR_COMMMAND_SUCCESS;
}
/**************************************************************************************************
* CNC_Editor_Load_Mix_Files
* Loads all the Mix files for Tiberian Dawn
**************************************************************************************************/
void CNC_Editor_Load_Mix_Files()
{
	int count = sizeof(MixFileNames) / sizeof(MixFileNames[0]);

	for (int i = count - 1; i >= 0; --i)
	{
		MixFileClass::Free(MixFileNames[i]);
	}

	for (int i = 0; i < count; ++i)
	{
		new MixFileClass(MixFileNames[i]);
		MixFileClass::Cache(MixFileNames[i]);
	}
}

/**************************************************************************************************
* CNC_Editor_Setup_Content_Directory
* Sets up where the system should load map data from.
**************************************************************************************************/
void CNC_Editor_Setup_Content_Directory(char* cncdata_directory, char* cd_directory)
{
	char content_directory[_MAX_PATH];

	sprintf(content_directory, "%s\\TIBERIAN_DAWN\\%s\\", cncdata_directory, cd_directory);

	if (strlen(content_directory) != 0) {
		CCFileClass::Clear_Search_Drives();
		CCFileClass::Reset_Raw_Path();
		char *dll_dir = strdup(content_directory);
		CCFileClass::Set_Search_Drives(dll_dir);
		free(dll_dir);
	}
}

void CNC_Editor_Setup_Content_Directory(char* cncdata_directory, int CD_index)
{
	char cd_name[_MAX_PATH];
	sprintf(cd_name, "CD%i", CD_index);
	CNC_Editor_Setup_Content_Directory(cncdata_directory, cd_name);
}




/**************************************************************************************************
* CNC_Editor_Load_Map
* Loads the map with the given parameters.
*
* cncdata_directory: path of the base CNC data directory
* faction: the name of the faction we are loading the map for
* scenario_index: int scenario index
* east_west:
* variant:
*
* returns EDITOR_COMMMAND_SUCCESS on success, all other values are failure
**************************************************************************************************/
extern "C" __declspec(dllexport) int __cdecl CNC_Editor_Load_Map(
	char* cncdata_directory, 
	char* house_name, 
	int scenario_index, 
	char* east_west,
	char* variant)
{
	CNC_Editor_Clear_Map();

	int CD = 1;
	if (stricmp(house_name, "GDI") == 0) {
		ScenPlayer = SCEN_PLAYER_GDI;
		GameToPlay = GAME_NORMAL;

		if (scenario_index == 30 || scenario_index == 90) {
			CD = 5;
		}
		else if (scenario_index >= 60 && scenario_index <= 72) {
			CD = 4;
		}
		else if (scenario_index >= 20 && scenario_index < 60) {
			CD = 3;
		}
	}

	if (stricmp(house_name, "NOD") == 0) {
		ScenPlayer = SCEN_PLAYER_NOD;
		GameToPlay = GAME_NORMAL;
		CD = 2;

		// Hack a fix for scenario 21 since the same mission number is used in Covert Ops and N64
		if (scenario_index == 81 || scenario_index == 22) {
			CD = 5;
			if (scenario_index == 81) {
				scenario_index = 21;
			}
		}
		else if (scenario_index >= 60 && scenario_index <= 61) {
			CD = 4;
		}
		else if (scenario_index >= 20 && scenario_index < 60) {
			CD = 3;
		}
	}

	if (stricmp(house_name, "MULTI") == 0)
	{
		ScenPlayer = SCEN_PLAYER_MPLAYER;
		GameToPlay = GAME_GLYPHX_MULTIPLAYER;
	}

	if (stricmp(house_name, "JUR") == 0)
	{
		ScenPlayer = SCEN_PLAYER_JP;
		GameToPlay = GAME_NORMAL;
	}

	switch (CD)
	{
		case 4:
			CNC_Editor_Setup_Content_Directory(cncdata_directory, "CONSOLE_1");
			break;
		case 5:
			CNC_Editor_Setup_Content_Directory(cncdata_directory, "CONSOLE_2");
			break;
		default:
			CNC_Editor_Setup_Content_Directory(cncdata_directory, CD);
			break;
	}

	CNC_Editor_Load_Mix_Files();

	Scenario = scenario_index;
	BuildLevel = 7;

	if (stricmp(east_west, "w") == 0)
	{
		ScenDir = SCEN_DIR_WEST;
	}
	else
	{
		ScenDir = SCEN_DIR_EAST;
	}

	ScenarioVarType variant_enum;

	if (stricmp(variant, "b") == 0)
	{
		variant_enum = SCEN_VAR_B;
	}
	else if (stricmp(variant, "c") == 0)
	{
		variant_enum = SCEN_VAR_C;
	}
	else if (stricmp(variant, "d") == 0)
	{
		variant_enum = SCEN_VAR_D;
	}
	else
	{
		variant_enum = SCEN_VAR_A;
	}

	Set_Scenario_Name(ScenarioName, Scenario, ScenPlayer, ScenDir, variant_enum);

	char fname[_MAX_FNAME + _MAX_EXT];
	sprintf(fname, "%s.INI", ScenarioName);
	CCFileClass file(fname);
	if (!file.Is_Available())
	{
		return(EDITOR_COMMMAND_FAILURE);
	}
	else
	{
		memset(EditorMapINIBuffer, 0, SHAPE_BUFFER_SIZE);
		file.Read(EditorMapINIBuffer, SHAPE_BUFFER_SIZE - 1);
	}

	Map.One_Time_Editor();
	Map.Read_INI(EditorMapINIBuffer);
	if (Map.Read_Binary(ScenarioName, &ScenarioCRC))
	{
		EditorMapInitialized = true;
		return EDITOR_COMMMAND_SUCCESS;
	}
	else
	{
		return EDITOR_COMMMAND_FAILURE;
	}
}


extern "C" __declspec(dllexport) int __cdecl CNC_Editor_Load_Map_By_Scenario_Name(char* cncdata_directory, char* scenario_name)
{
	return EDITOR_COMMMAND_FAILURE;
}

/**************************************************************************************************
*	CNC_Editor_Clear_Map
*	Deletes the data for the currently loaded map.
*
* returns EDITOR_COMMMAND_SUCCESS on success, all other values are failure
**************************************************************************************************/
extern "C" __declspec(dllexport) int __cdecl CNC_Editor_Clear_Map()
{
	if (EditorMapInitialized)
	{
		Map.Init_Clear();
		
		int count = sizeof(MixFileNames) / sizeof(MixFileNames[0]);
		for (int i = count - 1; i >= 0; --i)
		{
			MixFileClass::Free(MixFileNames[i]);
		}

		EditorMapInitialized = false;
		TheaterData = nullptr;
		TheaterIcons = nullptr;

		return EDITOR_COMMMAND_SUCCESS;
	}
	else
	{
		return EDITOR_COMMMAND_FAILURE;
	}

}

/**************************************************************************************************
* CNC_Editor_Get_Map_Stats
* Gets the stats for the currently loaded map
*
* map_width: out parameter storing the width of the map
* map_height: out parameter storing the height of the map
* theater: out paramter storing the theater of the map
*
* returns EDITOR_COMMMAND_SUCCESS on success, all other values are failure
**************************************************************************************************/
extern "C" __declspec(dllexport) int __cdecl CNC_Editor_Get_Map_Stats(int& map_width, int& map_height, int& theater)
{
	if (EditorMapInitialized)
	{
		map_width = Map.MapCellWidth + 1;
		map_height = Map.MapCellHeight + 1;
		theater = Map.Theater;
		return EDITOR_COMMMAND_SUCCESS;
	}

	map_width = -1;
	map_height = -1;
	theater = -1;
	return EDITOR_COMMMAND_FAILURE;
}

/**************************************************************************************************
* CNC_Editor_Get_Cell_Data_By_Index
* Get the data from the given cell.
*
* cell_index: The index of the desired cell.
* cell_name: out buffer to be filled with the name of the given cell.
* cell_name_size: the size of the cell name buffer.
*
*
* returns EDITOR_COMMMAND_SUCCESS on success, all other values are failure
**************************************************************************************************/
extern "C" __declspec(dllexport) int __cdecl CNC_Editor_Get_Cell_Data_By_Index(int cell_index, char* cell_name, unsigned long cell_name_size, int& template_type, int& template_icon_index)
{
	CellClass * cellptr = &Map[cell_index];

	cell_name[0] = 0;
	int icon = 0;
	void *image_data = 0;

	char template_name[10];
	if (cellptr->Get_Template_Info(template_name, icon, image_data))
	{
		snprintf(cell_name, cell_name_size, "%s-%04d", template_name, icon);

		template_type = cellptr->TType;
		template_icon_index = icon;

		return EDITOR_COMMMAND_SUCCESS;
	}

	return EDITOR_COMMMAND_FAILURE;
}

/**************************************************************************************************
* CNC_Editor_Get_Cell_Data
* Get the data from the given cell.
*
* x,y: The corrdinates of the desired cell.
* cell_name: out buffer to be filled with the name of the given cell.
* cell_name_size: the size of the cell name buffer.
*
* returns EDITOR_COMMMAND_SUCCESS on success, all other values are failure
**************************************************************************************************/

extern "C" __declspec(dllexport) int __cdecl CNC_Editor_Get_Cell_Data(int x, int y, char* cell_name, unsigned long cell_name_size, int& template_type, int& template_icon_index)
{
	if (!EditorMapInitialized)
	{
		return EDITOR_COMMMAND_FAILURE;
	}


	int map_cell_x = Map.MapCellX;
	int map_cell_y = Map.MapCellY;
	int map_cell_width = Map.MapCellWidth;
	int map_cell_height = Map.MapCellHeight;

	if (map_cell_x > 0) {
		map_cell_x--;
		map_cell_width++;
	}

	if (map_cell_width < MAP_MAX_CELL_WIDTH) {
		map_cell_width++;
	}

	if (map_cell_y > 0) {
		map_cell_y--;
		map_cell_height++;
	}

	if (map_cell_height < MAP_MAX_CELL_HEIGHT) {
		map_cell_height++;
	}

	CELL cell = XY_Cell(map_cell_x + x, map_cell_y + y);

	return CNC_Editor_Get_Cell_Data_By_Index((int)cell, cell_name, cell_name_size, template_type, template_icon_index);
}

/**************************************************************************************************
* CNC_Editor_Get_Cell_Texture_Buffer
*
* x,y: 
* out_width, out_height: dimensions of the outputed texture array
* out_texture_array: output array of unsigned chars storing the color data for the requested object,
*							every 3 chars is a set of RGB values
**************************************************************************************************/
extern "C" __declspec(dllexport) int __cdecl CNC_Editor_Get_Cell_Texture_Buffer(int x, int y, int& out_width, int& out_height, SAFEARRAY*& out_texture_array)
{
	
	int map_cell_x = Map.MapCellX;
	int map_cell_y = Map.MapCellY;
	int map_cell_width = Map.MapCellWidth;
	int map_cell_height = Map.MapCellHeight;

	if (map_cell_x > 0) {
		map_cell_x--;
		map_cell_width++;
	}

	if (map_cell_width < MAP_MAX_CELL_WIDTH) {
		map_cell_width++;
	}

	if (map_cell_y > 0) {
		map_cell_y--;
		map_cell_height++;
	}

	if (map_cell_height < MAP_MAX_CELL_HEIGHT) {
		map_cell_height++;
	}

	CELL cell = XY_Cell(map_cell_x + x, map_cell_y + y);
	CellClass * cellptr = &Map[cell];

	char cell_name[_MAX_PATH];

	int icon = 0;
	void *image_data = 0;
	if (cellptr->Get_Template_Info(cell_name, icon, image_data))
	{
		GraphicBufferClass temp_gbuffer(24, 24);
		GraphicViewPortClass	temp_viewport(&temp_gbuffer, 0, 0, 24, 24);

		WindowList[WINDOW_CUSTOM][WINDOWX] = 0;
		WindowList[WINDOW_CUSTOM][WINDOWY] = 0;
		WindowList[WINDOW_CUSTOM][WINDOWWIDTH] = 24;
		WindowList[WINDOW_CUSTOM][WINDOWHEIGHT] = 24;

		temp_viewport.Draw_Stamp(image_data, icon, 0, 0, NULL, WINDOW_CUSTOM);

		out_width = temp_viewport.Get_Width();
		out_height = temp_viewport.Get_Height();

		const int COLOR_SIZE = 3;

		SAFEARRAYBOUND  Bound;
		Bound.lLbound = 0;
		Bound.cElements = out_width * out_height * COLOR_SIZE;

		out_texture_array = SafeArrayCreate(VT_UI1, 1, &Bound);

		unsigned char* out_buffer;

		HRESULT hr = SafeArrayAccessData(out_texture_array, (void **)&out_buffer);
		if (SUCCEEDED(hr))
		{
			GraphicBufferClass* Graphic_Buffer = temp_viewport.Get_Graphic_Buffer();

			int VP_Scan_Line = temp_viewport.Get_Width() + temp_viewport.Get_XAdd();

			char * start_ptr;
			start_ptr = (char *)Graphic_Buffer->Get_Buffer();
			start_ptr += ((temp_viewport.Get_YPos() * VP_Scan_Line) + temp_viewport.Get_XPos());

			for (int y = 0; y < out_height; ++y)
			{
				unsigned char* scanline_ptr = (unsigned char*)start_ptr + y * VP_Scan_Line;
				unsigned char* out_buffer_y_ptr = out_buffer + (y * out_width * COLOR_SIZE);
				for (int x = 0; x < out_width; ++x)
				{
					unsigned char* pallete_index_ptr = scanline_ptr + x;
					unsigned char* out_buffer_ptr = out_buffer_y_ptr + (x * COLOR_SIZE);

					int red_palette_index = (*pallete_index_ptr) * COLOR_SIZE;
					out_buffer_ptr[0] = GamePalette[red_palette_index] << 2;
					out_buffer_ptr[1] = GamePalette[red_palette_index + 1] << 2;
					out_buffer_ptr[2] = GamePalette[red_palette_index + 2] << 2;
				}
			}

			SafeArrayUnaccessData(out_texture_array);

			return EDITOR_COMMMAND_SUCCESS;
		}
	}
	
	return EDITOR_COMMMAND_FAILURE;
}

/**************************************************************************************************
* CNC_Editor_Get_Template_Data
* Get the data from the given tile template type.
*
* template_type_index: The index of the template type to use. should come from the Get_Cell_Data function.
* template_points: Out buffer to be filled with the list of positions of the tiles as offsets from the origin of the template.
*							This data is store is an X, Y, X, Y, X, Y format.
*
* returns EDITOR_COMMMAND_SUCCESS on success, all other values are failure
**************************************************************************************************/
extern "C" __declspec(dllexport) int __cdecl CNC_Editor_Get_Template_Data(int template_type_index, SAFEARRAY*& template_points)
{
	if (template_type_index >= TEMPLATE_COUNT || template_type_index == TEMPLATE_NONE)
	{
		return EDITOR_COMMMAND_FAILURE;
	}

	const TemplateTypeClass& template_type = TemplateTypeClass::As_Reference((TemplateType)template_type_index);
	if (template_type.Get_Image_Data() == nullptr)
	{
		return EDITOR_COMMMAND_FAILURE;
	}

	short const * occupy_list = template_type.Occupy_List();

	short const * counter = occupy_list;
	while (counter && *counter != REFRESH_EOL)
	{
		counter++;
	}

	int occupy_list_size = counter - occupy_list;


	SAFEARRAYBOUND  bounds;
	bounds.lLbound = 0;
	bounds.cElements = occupy_list_size * 2;
	template_points = SafeArrayCreate(VT_I4, 1, &bounds);

	int *pData;
	HRESULT hr = SafeArrayAccessData(template_points, (void **)&pData);
	if (SUCCEEDED(hr))
	{
		for (int i = 0; i < occupy_list_size; i++)
		{
			CELL cell = occupy_list[i];

			int x = Cell_X(cell);
			int y = Cell_Y(cell);

			pData[i * 2] = x;
			pData[i * 2 + 1] = y;
		}

		SafeArrayUnaccessData(template_points);

		return EDITOR_COMMMAND_SUCCESS;
	}

	return EDITOR_COMMMAND_FAILURE;
}


/**************************************************************************************************
* CNC_Editor_Get_Scenario_Names
* 
**************************************************************************************************/
extern "C" __declspec(dllexport) int __cdecl CNC_Editor_Get_Scenario_Names(char* cncdata_directory, int CD)
{
	unsigned char read_buffer[SHAPE_BUFFER_SIZE];
	Set_Shape_Buffer(read_buffer, SHAPE_BUFFER_SIZE);

	char team_ids[] =
	{
		'a',
		'b',
		'c',
		'd',
		'e',
		'f',
		'g',
		'h',
		'i',
		'j',
		'k',
		'l',
		'm',
		'n',
		'o',
		'p',
		'q',
		'r',
		's',
		't',
		'u',
		'v',
		'w',
		'x',
		'y',
		'z',
	};
		/*
	{
		'g',
		'b',
		'm',
		'j'
	};
	*/
	const int team_count = sizeof(team_ids) / sizeof(char);

	char direction_ids[] =
	{
		'e',
		'w'
	};
	const int direction_count = sizeof(direction_ids) / sizeof(char);

	char variant_ids[] =
	{
	'a',
	'b',
	'c',
	'd'
	};

	const int variant_count = sizeof(variant_ids) / sizeof(char);

	const int min_scenario_index = 1;
	const int max_scenario_index = 99;

	char scenario_name[_MAX_FNAME + _MAX_EXT];
	char file_name[_MAX_FNAME + _MAX_EXT];

	CNC_Editor_Setup_Content_Directory(cncdata_directory, CD);
	CNC_Editor_Load_Mix_Files();

	char output_file_name[256];
	snprintf(output_file_name, 256, "d:\\TD_Disk%d_Names.txt", CD);

	FILE * names_file = fopen(output_file_name, "w+");

	for (int team_index = 0; team_index < team_count; team_index++)
	{
		for (int scenario_index = min_scenario_index; scenario_index <= max_scenario_index; ++scenario_index)
		{
			for (int direction_index = 0; direction_index < direction_count; direction_index++)
			{
				for (int variant_index = 0; variant_index < variant_count; variant_index++)
				{
					sprintf(scenario_name, "sc%c%.2d%c%c",
						team_ids[team_index],
						scenario_index,
						direction_ids[direction_index],
						variant_ids[variant_index]);

					sprintf(file_name, "%s.INI", scenario_name);
					CCFileClass file(file_name);
					if (file.Is_Available())
					{
						if (Read_Movies_From_Scenario_Ini(scenario_name, false))
						{
							//fprintf(names_file, "%s - \t$Intro:%s \t\t$Brief:%s \t\t$Win:%s \t\t$Lose:%s \t\t$Action:%s \t\t$Theme:%s", scenario_name, IntroMovie, BriefMovie, WinMovie, LoseMovie, ActionMovie, MovieThemeName);
							fprintf(names_file, "------------------%s-------------- %s \n", scenario_name, MovieThemeName);
							
							if (stricmp("x", IntroMovie) != 0)
							{
								fprintf(names_file, "<IntroMovieName network=\"client\">%s</IntroMovieName>\n", IntroMovie);
							}
							if (stricmp("x", BriefMovie) != 0)
							{
								fprintf(names_file, "<BriefMovieName network=\"client\">%s</BriefMovieName>\n", BriefMovie);
							}
							if (stricmp("x", ActionMovie) != 0)
							{
								fprintf(names_file, "<ActionMovieName network=\"client\">%s</ActionMovieName>\n", ActionMovie);
							}
							if (stricmp("x", WinMovie) != 0)
							{
								fprintf(names_file, "<WinMovieName network=\"client\">%s</WinMovieName>\n", WinMovie);
							}
						}

						fprintf(names_file, "\n");
					}


					
				}
			}
		}
	}

	fclose(names_file);

	return EDITOR_COMMMAND_SUCCESS;
}