/// <summary>
/// 子メニューを開く
/// </summary>
private void PopChildMenu()
{
if (NextSceneName != "")
{
SceneChangeSingleton.instance.LoadLevel(NextSceneName);
return;
}
IsPopChildMenu = true;
GameObject go = Instantiate(CurrentCursorItem.ChildMenuPrefab, CurrentCursorItem.transform.position + PopChildOffset, Quaternion.identity) as GameObject;
ChildMenu = go.GetComponent <MenuParentScript>();
ChildMenu.transform.parent = CurrentCursorItem.transform;
ChildMenu.MenuSelected += MenuSelected;
foreach (MenuItemScript item in Items)
{
SpriteRenderer itemSpriteRenderer = item.GetComponent <SpriteRenderer>();
if (itemSpriteRenderer != null)
{
itemSpriteRenderer.sortingLayerName = "BackGround";
itemSpriteRenderer.color = BackColor;
}
}
Selecter.GetComponentInChildren <Renderer>().enabled = false;
}
public void Generate()
{
if (mapWidth <= 0 || mapHeight <= 0)
{
Debug.Log("Please enter values greator than zero for the height and width");
}
else
{
FileStream stream = new FileStream("Assets/Resources/TileData/Test.XML", FileMode.Open);
XmlSerializer serializer = new XmlSerializer(typeof(List <TileTemplate>));
List <TileTemplate> tiles = (List <TileTemplate>)serializer.Deserialize(stream);
if (tiles.Count >= 1)
{
map = TileStats.GenerateBaseMap(mapWidth, mapHeight, Ground, tiles[0]);
UIController.SetBool("Map Generated", true);
cam.Center(Ground);
//Maybe find somwhere else to handle the transition
selecter = Selecter.createSelector(map, selectSpace);
}
else
{
Debug.Log("No Tile Data set found!");
}
}
}
void Start()
{
operatorBehaviour = GetComponent <OperatorMonoBehaviour> ();
selecter = GetComponent <Selecter> ();
operatingA = false;
operatingB = false;
}
// Start is called before the first frame update
void Start()
{
ct_killswitch = 0;
selecter = FindObjectOfType <Selecter>();
SB = FindObjectOfType <Scoreboard>();
SP = FindObjectOfType <Spawner>();
}
/**************************************************************************************************************/
/// <summary>
/// 过滤条件起点
/// </summary>
/// <param name="func">格式: it => it.CreatedOn >= WhereTest.CreatedOn</param>
public static WhereQ <M> Where <M>(this Selecter <M> selecter, Expression <Func <M, bool> > compareFunc)
where M : class
{
selecter.DC.Action = ActionEnum.Where;
selecter.WhereHandle(compareFunc);
return(new WhereQ <M>(selecter.DC));
}
/// <summary>
/// 过滤条件起点 -- 设置多个条件
/// </summary>
public static WhereQ <M> Where <M>(this Selecter <M> selecter, object mWhere)
where M : class
{
selecter.DC.Action = ActionEnum.Where;
selecter.WhereDynamicHandle <M>(mWhere);
return(new WhereQ <M>(selecter.DC));
}
public virtual ActionResult Select(JsSelectOptions Options)//string EntitySetName, string EntityName, Objects.JsIncludeParameter[] Includes = null, Objects.JsWhereParameter[] Wheres = null, Objects.JsOrderParameter[] Orders = null, int Skip = -1, int Take = -1, string WhereMethod = null, string OrderMethod = null)
{
string json = this.GetCache(Options);
if (json.IsNotNullOrEmpty())
{
return(this.Content(json, "application/json"));
}
System.Web.Script.Serialization.JavaScriptSerializer serializer = new System.Web.Script.Serialization.JavaScriptSerializer();
Selecter <ObjectContext> selecter = new Selecter <ObjectContext>(model);
JsSelectResult data = selecter.Select(Options);//EntitySetName, EntityName, Includes, Wheres, Orders, Skip, Take, WhereMethod, OrderMethod);
List <string> log = data.Data as List <string>;
if (log != null)
{
log.Add(string.Format("{0:hh:mm.ss:ffff} Select data serialized", DateTime.Now));
}
var result = new
{
code = 200,
result = data.ToJson()
};
json = serializer.Serialize(result);
this.SetCache(json, Options);
return(this.Content(json, "application/json"));
}
void Start()
{
SL = FindObjectOfType <Selecter>();
clear_sprites();
Debug.Log("Start");
total = 0;
health = 50;
carne_f = false;
lacteos_f = false;
verduras_f = false;
cereales_f = false;
frutas_f = false;
eatenCarne = 0;
eatenLacteos = 0;
eatenVerduras = 0;
eatenCereales = 0;
eatenFrutas = 0;
destroyedDulces = 0;
excesos = 0;
edad = int.Parse(PlayerPrefs.GetString("edad"));
SetPorcionesMeta();
}
internal SelectQueryer(Database db)
: base(db)
{
_Select = new Selecter(From);
_Where = new Wherer(Maker, db);
_Joins = new List <Joiner>();
Maker = Make;
}
public void Start()
{
mapName = "Untitled";
mapWidth = 0;
mapHeight = 0;
map = null;
selecter = null;
tile_options = null;
}
void Start()
{
root = new BehaviorTree();
sequence_1 = new Sequence();
sequence_2 = new Sequence();
selecter_1 = new Selecter();
condition_Dead = new Condition_Dead();
condition_Fine = new Condition_Find();
condition_AttackRange = new Condition_AttackRange();
condition_Arrive = new Condition_Arrive();
timeOut_RoamingDelay = new TimeDelay();
roaming = new Action_Roaming();
trace = new Action_Trace();
attack = new Action_Attack();
dead = new Action_Dead();
colliders = new Collider[5];
//========== 공격 ===================
condition_AttackRange.SetTask(attack);
selecter_1.AddTask(condition_AttackRange);
//===================================
//========== 추적 ===================
condition_Fine.SetTask(trace);
selecter_1.AddTask(condition_Fine);
//===================================
//========== 로밍 ===================
timeOut_RoamingDelay.SetTime(3.0f);
sequence_2.AddTask(timeOut_RoamingDelay);
sequence_2.AddTask(roaming);
condition_Arrive.SetTask(sequence_2);
selecter_1.AddTask(condition_Arrive);
//==================================
sequence_1.AddTask(selecter_1);
condition_Dead.SetTask(dead);
sequence_1.AddTask(condition_Dead);
root.Init(sequence_1);
enemyCharacter = GetComponentInChildren <Animator>().gameObject;
animatorController = GetComponentInChildren <Animator>();
StartCoroutine(Update_Coroution());
}
static public Selecter createSelector(TileStats[,] m_map, cursorDelegate act)
{
var g_ob = Resources.Load <GameObject>("Buttons/Pointer");
GameObject n_ob = Instantiate(g_ob);
Selecter temp = n_ob.GetComponent <Selecter>();
temp.map = m_map;
temp.transform.position = temp.map[temp.x, temp.y].Location;
temp.cursorAction = act;
return(temp);
}
/// <summary>
/// 子メニューから復帰
/// </summary>
private void ReturnChildMenu()
{
IsPopChildMenu = false;
foreach (MenuItemScript item in Items)
{
SpriteRenderer itemSpriteRenderer = item.GetComponent <SpriteRenderer>();
if (itemSpriteRenderer != null)
{
itemSpriteRenderer.sortingLayerName = "ForeGround";
itemSpriteRenderer.color = DefaultColor;
}
}
Selecter.GetComponentInChildren <Renderer>().enabled = true;
}
private void FormScene_MouseMove(object sender, MouseEventArgs e)
{
if (!_tracingMouse)
{
return;
}
else if (e.Button == MouseButtons.Left)
{
var w = Math.Abs(e.Location.X - _mousedownLocation.X);
var h = Math.Abs(e.Location.Y - _mousedownLocation.Y);
if (w > 0 && h > 0)
{
var a = Math.Min(e.Location.X, _mousedownLocation.X);
var b = Math.Min(e.Location.Y, _mousedownLocation.Y);
var selecter = new Selecter();
selecter.Location = new Point(a, b);
selecter.Bwidth = w;
selecter.Aheigth = h;
foreach (var figure in _figures)
{
figure.Color = figure.IsItOverllap(selecter, figure) ? Color.Gray : figure.ConstColoring;
}
Invalidate();
Application.DoEvents();
using (var graphics = CreateGraphics())
selecter.Paint(graphics);
}
}
else if (e.Button == MouseButtons.Right)
{
foreach (var figure in _Selectedfigure)
{
figure.Location = new Point(e.X - _mousedownLocation.X + figure.Location.X, e.Y - _mousedownLocation.Y + figure.Location.Y);
_mousedownLocation = e.Location;
Invalidate();
}
}
}
public void selectSpace(int x, int y)
{
//Create the Tile Display Object
GameObject template = Resources.Load <GameObject>("Buttons/TileDisplay");
GameObject tile_display = Instantiate(template, canvas.transform);
//Get the tile we are selecting
TileStats tile = map[x, y];
//Remove Selector
Destroy(selecter.gameObject);
selecter = null;
//add image to tile display
Image display = tile_display.transform.Find("Sprite Display").GetComponent <Image>();
display.sprite = tile.GetSprite();
//Add Options for Tiles
tile_options = tile_display.transform.Find("Tile Dropdown").GetComponent <Dropdown>();
//Add functionality to button
Button submit = tile_display.transform.Find("Select Tile").GetComponent <Button>();
submit.onClick.AddListener(delegate { ActivateTile(); });
//Find a different place for this, seems like we should have this loaded already
FileStream stream = new FileStream("Assets/Resources/TileData/Test.XML", FileMode.Open);
XmlSerializer serializer = new XmlSerializer(typeof(List <TileTemplate>));
List <TileTemplate> tile_temps = (List <TileTemplate>)serializer.Deserialize(stream);
foreach (TileTemplate tile_temp in tile_temps)
{
Dropdown.OptionData option = new Dropdown.OptionData(tile_temp.id);
tile_options.options.Add(option);
}
}
// Start is called before the first frame update
void Start()
{
ct_killswitch = 0;
selecter = FindObjectOfType <Selecter>();
}
/// <summary>
/// 过滤条件起点 -- 设置多个条件
/// </summary>
public static WhereQ <M> Where <M>(this Selecter <M> selecter, object mWhere)
{
selecter.DC.OP.WhereDynamicHandle <M>(mWhere);
return(new WhereQ <M>(selecter.DC));
}
/**************************************************************************************************************/
/// <summary>
/// 过滤条件起点
/// </summary>
/// <param name="func">格式: it => it.CreatedOn >= WhereTest.CreatedOn</param>
public static WhereQ <M> Where <M>(this Selecter <M> selecter, Expression <Func <M, bool> > func)
{
selecter.DC.OP.WhereHandle(func, CrudTypeEnum.Query);
return(new WhereQ <M>(selecter.DC));
}
void Start()
{
selecter = GameObject.Find(selecterGameObjectName).GetComponent<Selecter>();
selecter.register(this);
}
public static DistinctQ <M> Distinct <M>(this Selecter <M> selecter)
where M : class
{
selecter.DistinctHandle();
return(new DistinctQ <M>(selecter.DC));
}
public JsonResult Export(JsExportOptions Options)
{
byte[] content = null;
int startRow = 1, startColumn = 1;
JsonResult result = new JsonResult()
{
JsonRequestBehavior = JsonRequestBehavior.AllowGet
};
string id = Guid.NewGuid().ToString();
JsSelectOptions so = Options.SelectOptions;
if (Options.Type == ExportTypesEnum.AllRows)
{
so.Skip = -1;
so.Take = -1;
}
Selecter <ObjectContext> selecter = new Selecter <ObjectContext>(model);
JsSelectResult selectResult = selecter.Select(so);
IEnumerable <EntityObject> data = selectResult.Collections[so.EntitySetName];
string fileName = Options.Name.StringAndTrim();
fileName += !fileName.EndsWith(".xlsx") ? ".xlsx" : "";
fileName = fileName.Replace(System.IO.Path.GetInvalidFileNameChars(), "");
OfficeOpenXml.ExcelPackage p = new OfficeOpenXml.ExcelPackage();
OfficeOpenXml.ExcelWorkbook book = p.Workbook;
OfficeOpenXml.ExcelWorksheet sheet;
Type itType;
EntityObject first;
try
{
first = data.FirstOrDefault();
itType = first != null?first.GetType() : null;
sheet = book.Worksheets.Add(Options.Name);
int i = 0;
foreach (JsExportParameter ep in Options.Parameters)
{
ep.Compile(itType);
sheet.Cells[startRow, startColumn + i].Value = ep.Name;
sheet.Column(startColumn + i).AutoFit();
sheet.Column(startColumn + i).BestFit = true;
i++;
}
if (!data.Any())
{
sheet.Row(startRow).Style.Border.Bottom.Style = OfficeOpenXml.Style.ExcelBorderStyle.Thin;
sheet.Row(startRow).Style.Font.Bold = true;
using (MemoryStream ms = new MemoryStream())
{
p.SaveAs(ms);
content = ms.ToArray();
result.Data = new { Success = true, Result = data.Count(), ID = id };
HttpContext.Cache[id] = File(content, XlsxContentType, fileName);
return(result);
}
}
i = startRow + 1;
foreach (EntityObject item in data)
{
for (int j = 0; j < Options.Parameters.Length; j++)
{
JsExportParameter par = Options.Parameters[j];
object value = par.GetValue(item);
if (value != null && value.GetType() == typeof(DateTime))
{
value = ((DateTime)value).ToShortDateString();
}
sheet.Cells[i, startColumn + j].Value = value;
}
i++;
}
sheet.Row(startRow).Style.Border.Bottom.Style = OfficeOpenXml.Style.ExcelBorderStyle.Thin;
sheet.Row(startRow).Style.Font.Bold = true;
for (i = 0; i < sheet.Dimension.End.Column; i++)
{
sheet.Column(startColumn + i).AutoFit();
sheet.Column(startColumn + i).BestFit = true;
}
using (MemoryStream ms = new MemoryStream())
{
p.SaveAs(ms);
content = ms.ToArray();
result.Data = new { Success = true, Result = new { Count = data.Count(), ID = id }, Code = 200 };
HttpContext.Cache[id] = File(content, XlsxContentType, fileName);
}
}
catch (Exception ex)
{
result.Data = new { Success = false, Error = ex.Message };
}
finally
{
p.Dispose();
}
return(result);
}
void Start()
{
selecter = FindObjectOfType <Selecter>();
}
public Selecter Select(params string[] selects)
{
_Select = new Selecter(From, selects);
return(_Select);
}
public static OrderByQ <M> OrderBy <M, F>(this Selecter <M> target, Expression <Func <M, F> > propertyFunc, OrderByEnum orderBy = OrderByEnum.Desc)
where M : class
{
return(OrderByQ(target, propertyFunc, orderBy));
}
/// <summary>
/// Script parcourant toutes les roms d'un répertoire.
/// </summary>
/// <param name="romsDirectory">Répertoire contenant toutes les roms.</param>
/// <param name="exportDirectory">Répertoire vers lequelle les roms validées seront exportées.</param>
/// <param name="worldZones">Zones géographiques à exporter (ex : {"(U)", "(E)"}).</param>
/// <param name="patchsToApply">Patchs de traduction à appliquer (ex : {"Fre", "Eng"}).</param>
private static void BrowseRoms(string romsDirectory, string exportDirectory, string[] worldZones)
{
// Si le répertoire que l'utilisateur a spécifié n'existe pas, on balance une exception et on l'insulte.
if (!Directory.Exists(romsDirectory))
{
throw new Exception("Le répertoire que vous avez spécifié comme source pour les roms n'existe pas. Vous êtes mauvais.");
}
// Si le répertoire que l'utilisateur a spécifié n'existe pas, on balance une exception et on l'insulte un peu plus fort.
if (!Directory.Exists(romsDirectory))
{
throw new Exception("Le répertoire que vous avez spécifié pour l'export n'existe pas. Vous êtes très mauvais.");
}
// On va parcourir le dossier censé contenir les roms
string[] files = Directory.GetFiles(romsDirectory);
for (int i = 0; i < files.Count(); i++)
{
try
{
Console.Title = "RomRight : " + Math.Round(((i / (double)files.Count()) * 100)) + "%";
string romArchive = files[i];
if (Path.GetExtension(romArchive) == ".7z")
{
// Seuil de note en dessous duquel les roms ne seront pas prises
int threshold = 100;
// Pour éviter une sortie du buffer (fixé à 800) lors des déplacements de curseur
// On clear la console de temps en temps
if (Console.CursorTop > 700)
{
Console.Clear();
}
Utils.WriteLineInLog("\n======= Parcourt de " + romArchive);
string[] romFiles;
// On récupère tous les fichiers de roms
using (var tmp = new SevenZipExtractor(romArchive))
{
romFiles = tmp.ArchiveFileNames.ToArray();
}
// On va créer une liste des variations de roms, regroupées par leur nom commun
// Par exemple, "Sonic 1 [!]" et "Sonic 1 (W) [b1]" seront tous deux rangés sous l'id "Sonic 1"
Dictionary <string, List <RatedRom> > sortedRomsFiles = new Dictionary <string, List <RatedRom> >();
// On va trier les fichiers qu'on a récupéré
foreach (string romFile in romFiles)
{
// Expressions régulières correspondantes aux tags () et []
Regex regexParenthesis = new Regex("\\(.*?\\)");
Regex regexBracket = new Regex("\\[.*?\\]");
// On va récupérer les noms des roms sans les variantes () et []
string uid = Path.GetFileNameWithoutExtension(romFile);
uid = regexParenthesis.Replace(uid, "");
uid = regexBracket.Replace(uid, "");
uid = uid.Trim();
// Si on a encore jamais croisé cet uid, il faut créer la liste qui va contenir les noms des roms
if (!sortedRomsFiles.ContainsKey(uid))
{
sortedRomsFiles[uid] = new List <RatedRom>();
}
// On ajoute le fichier de rom à la liste
sortedRomsFiles[uid].Add(new RatedRom(Path.GetFileName(romFile), 0));
}
// On va lancer le système de notation des roms qui va permettre de choisir automatiquement
// la plus pertinente pour la collection.
foreach (string uid in sortedRomsFiles.Keys)
{
foreach (RatedRom ratedRom in sortedRomsFiles[uid])
{
ratedRom.Rate(worldZones);
// On calcule le seuil de la rom (le plancher de centaines le plus proche de sa note)
// Ex : pour une rom avec une note de 345, on aura 300.
int floorMark = (int)Math.Floor(ratedRom.Mark / 100.0) * 100;
// Si le seuil est plus bas, on le réhausse
if (threshold < floorMark)
{
threshold = floorMark;
}
}
}
List <string> finalRomList = new List <string>();
// On va chercher les roms les plus pertinentes (celles qui ont eu la meilleure note)
foreach (string uid in sortedRomsFiles.Keys)
{
List <RatedRom> topRoms = new List <RatedRom>();
int maxMark = 0;
foreach (RatedRom ratedRom in sortedRomsFiles[uid])
{
Utils.WriteLineInLog("--- " + ratedRom.Mark + " : " + ratedRom.RomFileName);
// On ignore les roms qui ont une note inférieur au seuil
if (ratedRom.Mark >= threshold)
{
// Si la rom actuelle a une note strictement supérieure au maximum trouvé jusqu'à maintenant
if (ratedRom.Mark > maxMark)
{
maxMark = ratedRom.Mark;
// On efface toutes les roms de la top list car on a trouvé mieux
topRoms.Clear();
topRoms.Add(ratedRom);
}
// Si la rom actuelle a une note identique à celle max trouvée, on ajoute simplement la rom à la liste
else if (ratedRom.Mark == maxMark)
{
topRoms.Add(ratedRom);
}
}
}
// Si l'algorithme n'a pas réussi à départager plusieurs roms, il faut demander à l'utilisateur de choisir manuellement
if (topRoms.Count() > 1)
{
// On construit le selecteur pour que l'utilisateur choisisse
ListChoice[] romChoices = new ListChoice[topRoms.Count()];
for (int j = 0; j < topRoms.Count(); j++)
{
romChoices[j] = new ListChoice(topRoms[j].RomFileName, topRoms[j].RomFileName);
}
Selecter selectBestRom = new Selecter(romChoices);
// On récupère la rom choisie par l'utilisateur et on l'ajoute dans la liste finale
ListChoice choosenRom = selectBestRom.Choose();
finalRomList.Add(choosenRom.Choice);
}
// Si on a qu'une seule rom dans le top, on la prend
else if (topRoms.Count() == 1)
{
finalRomList.Add(topRoms[0].RomFileName);
}
}
// On exporte les roms qui ont été sélectionnées comme les plus pertinentes
using (var tmp = new SevenZipExtractor(romArchive))
{
tmp.ExtractFiles(exportDirectory, finalRomList.ToArray());
}
// On affiche tous les fichiers de roms
foreach (string romFileName in finalRomList)
{
Utils.WriteLineInLog("*** " + romFileName);
}
}
}
catch (Exception e)
{
Utils.WriteLineInLog("Erreur lors du traitement de la rom : " + e.Message);
}
}
}
/// <summary>
/// Execute le script principal de RomRight.
/// </summary>
/// <param name="args">Arguments à passer</param>
private static void ExecRomRight(string[] args)
{
Console.Title = "RomRight";
Console.WindowHeight = 40;
Console.WindowWidth = 100;
Console.BackgroundColor = ConsoleColor.White;
Console.Clear();
Console.ForegroundColor = ConsoleColor.DarkBlue;
Console.BufferHeight = 800;
// Chargement de la dll 7zip
SevenZipExtractor.SetLibraryPath(@"7z.dll");
// On écrit le header
Console.WriteLine(TITLE_ASCII_ART + "\n");
Console.WriteLine("-----------------------------------------------------------\n");
Console.WriteLine("Développé par Francois BERTRAND (lamoutarde.fr), RomRight permet de créer automatiquement une bibliothèque de roms localisée à partir de fichiers 7z.\n");
Console.WriteLine("-----------------------------------------------------------\n");
string romsDirectory = null;
string exportDirectory = null;
////////////////////////////////////////////////////////
#region Choix du dossier source
////////////////////////////////////////////////////////
// Si l'utilisateur n'a pas passé d'arg[0], il va falloir lui demander de choisir un dossier où se trouvent les roms
if (args.Count() == 0)
{
Console.WriteLine("\nOù se trouve le répertoire contenant vos roms ?");
Selecter selectDirectory = new Selecter(new ListChoice[] {
new ListChoice("7z", "Répertoire 7z dans le dossier de l'application"),
new ListChoice("dialog", "Choisir le dossier dans l'explorateur Windows")
});
// Tant qu'on a pas de répertoire sur lequel travailler, on boucle sur le choix de l'utilisateur
// Y U NO SELECT SOMETHING CORRECT
while (romsDirectory == null)
{
string choice = selectDirectory.Choose().Choice;
// Si l'utilisateur souhaite utiliser le dossier 7z à la racine du projet
if (choice == "7z")
{
romsDirectory = "7z";
}
// Si l'utilisateur veut sélectionner le dossier des roms via une boite de dialog
else if (choice == "dialog")
{
romsDirectory = Utils.GetDirectoryWithDialog();
}
}
}
// Si l'utilisateur a saisi un arg[0], on considère qu'il s'agit du répertoire des roms
else
{
romsDirectory = args[0];
}
#endregion
////////////////////////////////////////////////////////
#region Choix du dossier d'export
////////////////////////////////////////////////////////
// Si l'utilisateur n'a pas passé d'arg[1], il va falloir lui demander de choisir un dossier pour l'export
if (args.Count() < 1)
{
Console.WriteLine("\nOù voulez vous exportez les fichiers finaux ?");
Selecter selectDirectory = new Selecter(new ListChoice[] {
new ListChoice("export", "Répertoire export dans le dossier de l'application"),
new ListChoice("dialog", "Choisir le dossier dans l'explorateur Windows")
});
// Tant qu'on a pas de répertoire sur lequel travailler, on boucle sur le choix de l'utilisateur
// Y U NO SELECT SOMETHING CORRECT
while (exportDirectory == null)
{
string choice = selectDirectory.Choose().Choice;
// Si l'utilisateur souhaite utiliser le dossier 7z à la racine du projet
if (choice == "export")
{
exportDirectory = "export";
// On vide le dossier d'export
if (Directory.Exists("export"))
{
Directory.Delete("export", true);
}
Directory.CreateDirectory("export");
}
// Si l'utilisateur veut sélectionner le dossier des roms via une boite de dialog
else if (choice == "dialog")
{
exportDirectory = Utils.GetDirectoryWithDialog();
}
}
}
// Si l'utilisateur a saisi un arg[1], on considère qu'il s'agit du répertoire des roms
else
{
exportDirectory = args[1];
}
#endregion
////////////////////////////////////////////////////////
#region Choix des zones géographiques
////////////////////////////////////////////////////////
string selectedZones = "";
// Si l'utilisateur n'a pas passé d'args[2], on va lui demander s'il veut saisir les codes pays
if (args.Count() < 2)
{
// Tant que l'utilisateur n'a rien sélectionné ou rien tappé, on boucle
while (selectedZones == "")
{
Console.WriteLine("\nQuelles zones doivent-être exportées ?");
Selecter selectZones = new Selecter(new ListChoice[] {
new ListChoice("default", "Garder la sélection par défaut pour la France (" + DEFAULT_ZONES + ")"),
new ListChoice("manual", "Entrer manuellement les zones à exporter"),
});
// S'il souhaite garder le choix par défaut
if (selectZones.Choose().Choice == "default")
{
selectedZones = DEFAULT_ZONES;
}
// S'il veut entrer manuellement les zones
else
{
Console.WriteLine("\nTappez les codes de pays, séparés par des espaces et sans parenthèse (ex : U E) :");
selectedZones = Console.ReadLine();
}
}
}
// Si l'utilisateur a saisi un args[2], on l'utilise pour les zones
else
{
selectedZones = args[2];
}
#endregion
// On lance l'algorithme qui va s'occuper des roms
BrowseRoms(romsDirectory, exportDirectory, selectedZones.Trim().Split(new char[] { ' ' }));
Console.Title = "RomRight";
Console.Write("\nFin du traitement. Appuyez sur une touche pour quitter le programme... ");
Console.ReadKey();
}
