root/trunk/Main.cpp

///////////////////////////////////////////////////////////
//                        TexGen                         //
//          утилита для подготовки текстур рельефа       //
//               для игры Проклятые Земли                //
//           Copyright (C) 2007-2008 Gipat Group         //
//              Распространяется на условиях             //
//    Gipat Group's opened EI-editor-utility license     //
//                      версии 1.0                       //
//                                                       //
//                  www.gipatgroup.org                   //
///////////////////////////////////////////////////////////

//К работе над данным файлом приложили руки, ноги.... короче аффтары:
// 1) Снайпер (sniper-rifle@rambler.ru)

////////////////////////////////////////////////////////////////////////

//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include "Main.h"

#include "BMP.cpp"
#include "Selector.cpp"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"


TG *G;
//---------------------------------------------------------------------------
__fastcall TG::TG(TComponent* Owner)
        : TForm(Owner)
{
}
//---------------------------------------------------------------------------
void __fastcall TG::mnuExitClick(TObject *Sender)
{
  Close(); //Самая умная кнопка %)
}
//---------------------------------------------------------------------------

void __fastcall TG::mnuAboutClick(TObject *Sender)
{
  ShowMessage("TexGen v1.05\r\nТретья переписка %)))\r\nИ ниволнует.");
}
//---------------------------------------------------------------------------

void __fastcall TG::btnExitClick(TObject *Sender)
{
  mnuExitClick(NULL);        
}
//---------------------------------------------------------------------------


void __fastcall TG::btnAllowDenyClick(TObject *Sender)
{
  TFromAllowDeny *F = new TFromAllowDeny(this);
  F->ShowModal();
  delete F;
}
//---------------------------------------------------------------------------
 //Работа с конфигом
void TG::LoadIni(AnsiString Path)
{
  //Загрузим файл в память
  Config->LoadConfig(Path);
  InitDirectories(Config);
//2. Собстно, - всё. Осталось запустить функцию выбора всех террейнов набора.
  //Все сделанные в процессе изменения запишем.
  SaveIni(Path);
}
//---------------------------------------------------------------------------
void TG::RefreshTileSets()
{
  FList->Directory = DList->Directory;
  SDir = DList->Directory;
  //Если был предыдущий набор тайлов - надо его отметить
  AnsiString Tmp = Config->GetValueEx("Main","LastTileSet","");
  //Заполняем список наборов тайлов
  TileSets->Items->Clear();
  for(int i=DList->ItemIndex+1;i<DList->Items->Count;i++)
  {
    TileSets->Items->Add(DList->Items->operator [](i));
    if(Tmp.LowerCase() == DList->Items->operator [](i).LowerCase())
      TileSets->Text = Tmp;
  }
}
//---------------------------------------------------------------------------
void TG::ApplyTileLayer(AnsiString Terrain, AnsiString Layer)
{
  //Сдезь ми далжны удолидь фсе тайлы, каторыи ни принодлЕжад слойу Layer
  //При этом считаем, что список файлов настроен на нужный набор - иначе пипец.
  AnsiString N,T, Dir=FList->Directory+"\\";//Собстно, вот.
  bool b;
  Terrain = Terrain.LowerCase();
  FList->Refresh();
  for(int i=1; i<FList->Items->Count; i++)
  {
    N = FList->Items->Strings[i].LowerCase();
    T = GetNext(&N);
    T = GetNext(&N); //Для верности %)
    if(T!=Layer) //Считаем, что слои заданы в виде "01" и т.д - регистра нет.
    {
      b=false;//Отметим, если мы удалили нужный файл
      for(int j=0;(j<4)&&(!b);j++)
      {
        T = GetNext(&N);
        if(T == Terrain)
        {
          b = true;
          N = FList->Items->Strings[i].LowerCase();
          if(FileExists(Dir+N))
          {
            //Брутально трём файл, ибо нефиг тут нам мозги пудридь
            DeleteFile(Dir+N);
          }
        }
      }
    }
  }
}
//---------------------------------------------------------------------------
void TG::SaveIni(AnsiString Path)
{
  //ХЗ зачем эта хрень, но наверное для удобства при вызове.
  Config->SaveConfig(Path);
}
//---------------------------------------------------------------------------
void TG::UpgradeIni(AnsiString P)
{
}
//---------------------------------------------------------------------------
//Работа с проектом
void TG::LoadProject(AnsiString Path)
{
        CConfigFile *C = new CConfigFile();
        C->LoadConfig(Path);
        Name = C->GetValueEx("Main","Name","Project");
        TileSet = C->GetValueEx("Main","TileSet","Gipat");
        TileSize = StrToInt(C->GetValueEx("Main","TileSize","64"));
        TerrList = C->GetValueEx("Terrains","Terr_List","");
        //Поcле сего многомудрого действа, нужные нам террейны должны быть
        //воодружены в дерево на главной странице
        
        TileList = C->GetValueEx("Last_Build","Tile_List","");
        delete C;
}
//---------------------------------------------------------------------------
void TG::SaveProject(AnsiString Path)
{
}
//---------------------------------------------------------------------------
void TG::BuildTerrains(AnsiString TileSet)
{
  FList->Hint = SDir+"\\"+TileSet;
  listAllTerrains->Clear();
  AnsiString Tile, Terr;
  if(DirectoryExists(FList->Hint))
  {
    FList->Directory = FList->Hint;
    for(int i=0;i<FList->Items->Count;i++)
    {
      Tile = FList->Items->Strings[i];     //Вообще, кусок выбирает из списка файлов тайлы
      if(IsTile(Tile))
      {
        GetNext(&Tile);
        GetNext(&Tile);
        for(int j=0;j<=3;j++) //Просто чтоб не писать 4 раза подряд одно и то же
        {
          Terr = GetNext(&Tile);
          if(!TerrainInCollection(Terr))
          {
            listAllTerrains->Items->Add(Terr);
          }
        }
      }
    }
  }
}
//---------------------------------------------------------------------------
bool TG::TileSetExists(AnsiString Terrain)
{
  bool Result = false;
  for(int i=0;(i<TileSets->Items->Count)&&(!Result);i++)
  {
    if(TileSets->Items->operator [](i).LowerCase() == Terrain.LowerCase() )
      Result = true;
  }
  return Result;
}
//---------------------------------------------------------------------------
//Дополнительные окна проекта
void TG::WndPermissions()        //Окошко по кнопке "разрешения"
{
}
//---------------------------------------------------------------------------
void TG::WndGenerateWTF()        //Окно с выбором, чего же мы будем генерировать
{
}
//---------------------------------------------------------------------------
void TG::WndEditOptions()        //Редактор файла проекта, некоторые переменные
{
}
//---------------------------------------------------------------------------
void TG::WndAddTerrains()        //Выбираем добавляемые террейны из списка в наборе тайлов
{
}
//---------------------------------------------------------------------------
//Спецфункции
void TG::CutTextures(AnsiString Name)
{
}
//---------------------------------------------------------------------------
void TG::MaskEditor ()
{
}
//---------------------------------------------------------------------------
void TG::TestFunction()
{
}
//---------------------------------------------------------------------------
//Различные инфошки
void TG::WillBe()
{
}
//---------------------------------------------------------------------------
void TG::ProgHelp()
{
}
//---------------------------------------------------------------------------
/*
  ---Texgen.ini---

  [Main]
  IniVer=1.0
  FirstLoad=1
  TileSetsDir=...
  MasksDir=...
  OutputDir=...
  LastTileSet=...
  LastProject=...

  ---*.tpr---

  [Main]
  Name=...
  TileSet=...
  Terrains=...
  [TilesList]
  Tile0=...
  Tile1=...
  ...
  TileN=...

--------------
Имя террайна:
   T_[layer]_Ter_Ter_Ter_Ter_00.bmp
*/

void __fastcall TG::FormCreate(TObject *Sender)
{
  //Начинаем нашу работу
  ProgDir = ExtractFilePath(Application->ExeName);
  Config = new CConfigFile();
  LoadIni(ProgDir+"TexGen.ini");
}
//---------------------------------------------------------------------------
AnsiString TG::GetNext(AnsiString *Src, AnsiString Sep)
{
  AnsiString Rez="";
  if(AnsiPos(Sep,*Src)>0)
  {
    Rez = LeftStr(*Src,AnsiPos(Sep,*Src)-1);
    *Src = RightStr(*Src,Src->Length() - AnsiPos(Sep,*Src));
  }
  else
  {
    Rez = *Src;
    *Src = "";
  }
  return Rez;
}
//---------------------------------------------------------------------------
bool TG::IsTile(AnsiString Tile)
{
  bool Rez = true;
  if(GetNext(&Tile).LowerCase() == "t") //Header of name: T_
  {
    AnsiString N = GetNext(&Tile);
    for(int i=1;i<=N.Length();i++)      //Number
    {
      if((N.operator [](i)<'0')||(N.operator [](i)>'9'))
      {
        Rez = false;
      }
    }
    for(int i=0;(i<4)&&(Rez);i++)       //4 not-null terrain names
    {
      N = GetNext(&Tile);
      if(N=="")Rez=false;
    }
    N = GetNext(&Tile,".");
    for(int i=1;i<=N.Length();i++)      //Number
    {
      if((N.operator [](i) <'0')||(N.operator [](i) >'9'))
      {
        Rez = false;
      }
    }
    if(Tile=="")Rez=false;                 //.bmp
  }
  else
  {
    Rez = false;
  }
  return Rez;
}
//---------------------------------------------------------------------------

void __fastcall TG::PagesChange(TObject *Sender)
{
  RefreshTileSets();
}
//---------------------------------------------------------------------------
//172.17.175.83
void __fastcall TG::FormDestroy(TObject *Sender)
{
  delete Config;        
}
//---------------------------------------------------------------------------
bool TG::TerrainInCollection(AnsiString Terrain)
{
  bool Rez=false;
  Terrain = Terrain.LowerCase();
  for(int i=0; (i<listAllTerrains->Items->Count)&&(!Rez); i++)
  {
    if(listAllTerrains->Items->Strings[i].LowerCase() == Terrain)
      Rez = true;
  }
  return Rez;
}

void __fastcall TG::mnuTestClick(TObject *Sender)
{
  //Tests :)
}
//---------------------------------------------------------------------------

void __fastcall TG::TileSetsChange(TObject *Sender)
{
  BuildTerrains(TileSets->Items->Strings[TileSets->ItemIndex]);        
}
//---------------------------------------------------------------------------

void __fastcall TG::LayerKeyPress(TObject *Sender, char &Key)
{
  if(Key==13)
  {
    //Тут типа надо сохранить слой, и переделать все террейны такого типа :)
    Layer->Font->Color = 0x000000;
  }
}
//---------------------------------------------------------------------------

void __fastcall TG::LayerChange(TObject *Sender)
{
  //Показываем, что инфа изменена
  Layer->Font->Color = 0x0000FF;
  Layer->ShowHint = true;
  for(int i=0;i<2;i++)
    if((Layer->Text.c_str()[i] < '0')||(Layer->Text.c_str()[i]>'9'))
    {
      Layer->Text = "00";
    }
}
//---------------------------------------------------------------------------

void __fastcall TG::listAllTerrainsClick(TObject *Sender)
{
  //По идее, нужно вывести информацию о выбраном терейне :)
  AnsiString N="", N1, Dir, TmpLayer, TmpNum, Layers="";
  bool Found, NotFound;
  if(listAllTerrains->ItemIndex >= 0)
  {
    N = listAllTerrains->Items->Strings[listAllTerrains->ItemIndex];
    N1 = N+"_"+N+"_"+N+"_"+N;
    Dir = FList->Directory;
    if(RightStr(Dir,1)!="\\")Dir+="\\";
    //Идем по всем слоям, в поисках существующего базового тайла
    for(int L = 0; L<99; L++)
    {
      Found = false;
      NotFound = false;
      for(int Ind=0; (Ind<99)&&(!Found)&&(!NotFound); Ind++)
      {
        if(FileExists(Dir + "T_"+FormatNumber(L,2)+"_"+N1+"_"+FormatNumber(Ind,2)+".bmp"))
        {
          Found = true;
          Layers += FormatNumber(L,2)+"\r\n";
        }
        if((Ind==0)&&(!Found))NotFound = true;
      }
    }
    //Теперь, если найдено больше 1 слоя - предлагаем юзеру выбрать%)
    if(Layers == "")Layers = "??";
    if(Layers.Length() > 4)
    {
      int Lr = WndSelect("Нусь, и какой слой будем\r\nсчитать родным для этого материала? %)", Layers);
      Layers = RightStr(Layers,Layers.Length() - Lr*4);
    }
    Layers = LeftStr(Layers, 2);
    //А теперь запишем значение слоя в поле и удалим лишние файлы
    Layer->Text = Layers;
    ApplyTileLayer(N,Layers);
    if(FileExists(Dir+"T_"+Layers+"_"+N1+"_00.bmp"))
    {
      //Базовый тайл =)
      baseTile->Picture->LoadFromFile(Dir+"T_"+Layers+"_"+N1+"_00.bmp");
      baseTile->Repaint();
      baseTile->Refresh();
    }
    else
    {
      Images->GetBitmap(0,baseTile->Picture->Bitmap);
      baseTile->Repaint();
      baseTile->Refresh();
    }
  }
}
//---------------------------------------------------------------------------
AnsiString TG::FormatNumber(int N, byte Size)
{
  AnsiString Rez=IntToStr(N);
  for(;Rez.Length() < Size;Rez="0"+Rez);
  return Rez;
}
//===========================================================================
int  TG::WndSelect(AnsiString Desc, AnsiString Vars)
{
  //Создать новую спрашивалку:
  TSelectVariant *SelVar;
  Application->CreateForm(__classid(TSelectVariant), &SelVar);
  SelVar->FillListEx(Vars);
  SelVar->Desc->Caption = Desc;
  SelVar->ShowModal();
  int Rez = SelVar->Result;
  return Rez;
}

void __fastcall TG::btnBaseMaskClick(TObject *Sender)
{
  WillBe();        
}
//---------------------------------------------------------------------------
bool TG::AskUser(AnsiString Q)
{
  TSelectVariant *SV=new TSelectVariant(this);
  SV->Caption = "Быть или не быть?";
  SV->Desc->Caption = Q;
  SV->FillListEx("Быть\r\nНе быть\r\n");
  SV->ShowModal();
  bool b=(SV->Result==0)||(SV->Result==-1);
  return b;
}
//---------------------------------------------------------------------------
void TG::InitDirectories(CConfigFile *C)
{
//1. "Найдём" инормацию по коллекциям тайлов
  DList->Hint = EnsureDir(C->GetValueEx("Main","TileSetsDir",ProgDir+"Collections\\"),"Collections\\");
  C->SetValue("Main","TileSetsDir",DList->Hint);
  DList->Directory = DList->Hint;
  RefreshTileSets();
//2. Директория с масками
  DList->Hint = EnsureDir(C->GetValueEx("Main","MasksDir",ProgDir+"Masks\\"),"Masks\\");
  C->SetValue("Main","MasksDir",DList->Hint);
//3. Директория для результата генерации
  DList->Hint = EnsureDir(C->GetValueEx("Main","OutputDir",ProgDir+"Output\\"),"Output\\");
  C->SetValue("Main","OutputDir",DList->Hint);
}
//---------------------------------------------------------------------------
AnsiString TG::EnsureDir(AnsiString P, AnsiString N)
{
  if(!DirectoryExists(P))
  {
    //Не существует нужная нам директория! Алярм! Ахтунг! Паника нах!
    AnsiString D=LeftStr(P,AnsiPos("\\",P));
    if(DirectoryExists(D))//Диск существует
    {
      //Спросить у юзера разрешения создать цепь директорий
      if(AskUser("Директория не существует. Создать?\r\n"+P))
      {
        if(!CreateDirChain(P))
        {
          CreateDirChain(ProgDir+N);
          P = ProgDir+N;
        }
      }
      else
      {
        CreateDirChain(ProgDir+N);
        P = ProgDir+N;
      }
    }
    else
    {
      CreateDirChain(ProgDir+N);
      P = ProgDir+N;
    }
  }
  return P;
}
//---------------------------------------------------------------------------
bool TG::CreateDirChain(AnsiString Path)
{
  AnsiString Prefix=LeftStr(Path,AnsiPos("\\",Path)), Temp;
  Path = RightStr(Path, Path.Length() - AnsiPos("\\",Path));
  if(RightStr(Path,1)!="\\")Path+="\\";
  bool Normal=true;
  while((Path!="")&&(Normal))
  {
    Temp = LeftStr(Path,AnsiPos("\\",Path)-1);
    Path = RightStr(Path, Path.Length() - AnsiPos("\\",Path));
    if(NormalDirName(Temp))
    {
      Prefix+=Temp+"\\";
      if(!DirectoryExists(Prefix))CreateDir(Prefix);
    }
    else
    {
      Normal=false;
    }
  }
  return Normal;
}
//--------------------------------------------------------------------------
bool TG::NormalDirName(AnsiString Name)
{
  bool b= Name!="";
  if(b)b=!AnsiContainsStr(Name,"\\");
  if(b)b=!AnsiContainsStr(Name,"/");
  if(b)b=!AnsiContainsStr(Name,":");
  if(b)b=!AnsiContainsStr(Name,"?");
  if(b)b=!AnsiContainsStr(Name,"*");
  if(b)b=!AnsiContainsStr(Name,"\"");
  if(b)b=!AnsiContainsStr(Name,"<");
  if(b)b=!AnsiContainsStr(Name,">");
  if(b)b=!AnsiContainsStr(Name,"|");
  return b;
}