CnC_Remastered_Collection/REDALERT/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 <string>
#include <stdio.h>

#include	"function.h"
#include "externs.h"
#include "DLLInterface.h"
#include "Gadget.h"
#include "defines.h" // VOC_COUNT, VOX_COUNT
#include "SidebarGlyphx.h"
#include	"mixfile.h"
#include "ccini.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);
extern "C" __declspec(dllexport) int __cdecl CNC_Editor_Get_Template_Data(int template_type_index, SAFEARRAY*& template_points);

int LoadScenario();

extern int DLL_Startup(const char * command_line);

char EditorMapINIBuffer[SHAPE_BUFFER_SIZE];
bool EditorMapInitialized = false;

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

const char* CD1Path = "\\RED_ALERT\\CD1\\";
const char* CD2Path = "\\RED_ALERT\\COUNTERSTRIKE\\";
const char* CD3Path = "\\RED_ALERT\\AFTERMATH\\";

char RedAlertINI[_MAX_PATH];

/**************************************************************************************************
* 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;
	*/

	RunningFromEditor = true;

	return EDITOR_COMMMAND_FAILURE;
}

/**************************************************************************************************
* 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()
{
	const char* MixFileNames[] =
	{
		"MAIN.MIX",
		"REDALERT.MIX",
		"EXPAND2.MIX",
		"EXPAND.MIX",
		"HIRES1.MIX",
		//"LORES1.MIX"
		
		"GENERAL.MIX",		
		
		"LOCAL.MIX",
		"HIRES.MIX",
		"NCHIRES.MIX",
		"CONQUER.MIX",
		
		"RUSSIAN.MIX",
		"ALLIES.MIX",

		"SNOW.MIX",
		"TEMPERAT.MIX",
		"INTERIOR.MIX",
	};

	int count = sizeof(MixFileNames) / sizeof(MixFileNames[0]);

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

	for (int i = 0; i < count; ++i)
	{
		MFCD* file = new MFCD(MixFileNames[i], &FastKey);
		file->Cache();
		
	}
	
}

/**************************************************************************************************
* CNC_Editor_Setup_Content_Directory
* Sets up where the system should load map data from.
*
* cncdata_directory: path of the base CNC data directory
* CD1: if true, consider this disc 1, otherwise consider this disc 2.
**************************************************************************************************/
void CNC_Editor_Setup_Content_Directory(char* cncdata_directory, int CD, char (&content_directory)[_MAX_PATH])
{

	switch (CD)
	{
	default:
	case 1:
		sprintf(content_directory, "%s%s", cncdata_directory, CD1Path);
		break;
	case 2:
		sprintf(content_directory, "%s%s", cncdata_directory, CD2Path);
		break;
	case 3:
		sprintf(content_directory, "%s%s", cncdata_directory, CD3Path);
		break;
	}

	//Setup red alert path
	sprintf(RedAlertINI, "%sREDALERT.INI",content_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);
	}
}

/**************************************************************************************************
* 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();

	ScenarioPlayerType scen_player;
	int CD = 1;
	if (stricmp(house_name, "SPAIN") == 0) {
		scen_player = SCEN_PLAYER_SPAIN;
		Whom = HOUSE_GOOD;

		if (scenario_index >= 40)
		{
			CD = 3;
		}
		else if (scenario_index >= 15)
		{
			CD = 2;
		}
	}

	if (stricmp(house_name, "GREECE") == 0 || stricmp(house_name, "ALLY") == 0) {
		scen_player = SCEN_PLAYER_GREECE;
		Whom = HOUSE_GOOD;

		if (scenario_index >= 40)
		{
			CD = 3;
		}
		else if (scenario_index >= 15)
		{
			CD = 2;
		}
	}

	if (stricmp(house_name, "USSR") == 0) {
		scen_player = SCEN_PLAYER_USSR;
		Whom = HOUSE_BAD;

		if (scenario_index >= 40)
		{
			CD = 3;
		}
		else if (scenario_index >= 15)
		{
			CD = 2;
		}
	}

	if (stricmp(house_name, "MULTI") == 0)
	{
		scen_player = SCEN_PLAYER_MPLAYER;
		Whom = HOUSE_MULTI1;

		if (scenario_index >= 25)
		{
			CD = 3;
		}

	}

	if (stricmp(house_name, "JAPAN") == 0)
	{
		scen_player = SCEN_PLAYER_JP;
		Whom = HOUSE_JP;
	}

	char content_directory[_MAX_PATH];

	CNC_Editor_Setup_Content_Directory(cncdata_directory, CD, content_directory);

	char command_line[_MAX_PATH];
	sprintf(command_line, "-CD%s", content_directory);

	DLL_Startup(command_line);

	Scen.Scenario = scenario_index;
	ScenarioDirType scen_dir;
	BuildLevel = 7;

	if (stricmp(east_west, "w") == 0)
	{
		scen_dir = SCEN_DIR_WEST;
	}
	else
	{
		scen_dir = 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;
	}

	Scen.Set_Scenario_Name(Scen.Scenario, scen_player, scen_dir, (ScenarioVarType)variant_enum);

	return LoadScenario();
}

/**************************************************************************************************
* CNC_Editor_Load_Map_By_Scenario_Name
* Loads the map with the given parameters.
*
* cncdata_directory: path of the base CNC data directory
* scenario_name: name of the scnario to load
*
* returns EDITOR_COMMMAND_SUCCESS on success, all other values are failure
**************************************************************************************************/
extern "C" __declspec(dllexport) int __cdecl CNC_Editor_Load_Map_By_Scenario_Name(
	char* cncdata_directory,
	char* scenario_name)
{
	int CD = 3; // Always use the aftermath cd
	if (strnlen(scenario_name, _MAX_PATH) >= 3 && (scenario_name[2] == 'a' || scenario_name[2] == 'A'))
	{
		// Ant missions are CD 2
		CD = 2;
	}

	CNC_Editor_Clear_Map();

	char content_directory[_MAX_PATH];

	CNC_Editor_Setup_Content_Directory(cncdata_directory, CD, content_directory);

	char command_line[_MAX_PATH];
	sprintf(command_line, "-CD%s", content_directory);

	DLL_Startup(command_line);

	snprintf(Scen.ScenarioName, _MAX_FNAME + _MAX_EXT, "%s.ini", scenario_name);

	return LoadScenario();
}

int LoadScenario()
{
	CCFileClass file(Scen.ScenarioName);
	
	if (!file.Is_Available())
	{
		return(EDITOR_COMMMAND_FAILURE);
	}


	CCINIClass ini;
	int result = ini.Load(file,true);
	if (result == 0)
	{
		return(EDITOR_COMMMAND_FAILURE);
	}

	if (result == 2) 
	{
		//		if (Session.Type == GAME_NORMAL || Session.ScenarioIsOfficial) {
					/*
					**	Make a special exception so that multiplayer maps from 1 through
					**	24 will not care if the message digest is in error. All other
					**	maps will abort the scenario load.
					*/
		if (Scen.ScenarioName[2] != 'M' || Scen.Scenario >= 25) 
		{
			return(EDITOR_COMMMAND_FAILURE);
		}
	}

	const char * const BASIC = "Basic";
	NewINIFormat = ini.Get_Int(BASIC, "NewINIFormat", 0);

	Map.One_Time();
	Map.Read_INI(ini);

	EditorMapInitialized = true;
	
	return EDITOR_COMMMAND_SUCCESS;
}

/**************************************************************************************************
*	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();
		EditorMapInitialized = false;

		return EDITOR_COMMMAND_SUCCESS;
	}
	else
	{
		return EDITOR_COMMMAND_FAILURE;
	}

	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 = Scen.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)
{
	CELL index = (CELL)cell_index;

	CellClass * cellptr = &Map[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;

		//TemplateTypeClass::As_Reference(ptr->TType).

		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 palette_index = (*pallete_index_ptr);
					out_buffer_ptr[0] = ((unsigned char)GamePalette[palette_index].Red_Component());
					out_buffer_ptr[1] = ((unsigned char)GamePalette[palette_index].Green_Component());
					out_buffer_ptr[2] = ((unsigned char)GamePalette[palette_index].Blue_Component());
				}
			}

			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_positions: 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;
}

extern "C" __declspec(dllexport) int __cdecl CNC_Editor_Get_Scenario_Names(char* cncdata_directory)
{
	char content_directory[_MAX_PATH];

	CNC_Editor_Setup_Content_Directory(cncdata_directory,false, content_directory);

	char command_line[_MAX_PATH];
	sprintf(command_line, "-CD%s", content_directory);
	DLL_Startup(command_line);

	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',
		'a',
		'u',
		'm'
	};
	*/
	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',
		'e',
		'f',
		'g',
		'h',
		'i',
		'j',
		'k',
		'l',
		'm',
		'n',
		'o',
		'p',
		'q',
		'r',
		's',
		't',
		'u',
		'v',
		'w',
		'x',
		'y',
		'z',
	};
	/*
	{
		'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];

	FILE * names_file = fopen("d:\\RA_Disk2.txt", "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())
					{
						fprintf(names_file, "%s\n", scenario_name);
					}
				}
			}
		}
	}

	fclose(names_file);

	return EDITOR_COMMMAND_SUCCESS;
}