/// <summary>
/// Cette Méthode permet de choisir le nom d'un animal par random dans la liste d'animaux de la bibliotheque.
/// Le random choisi un index du tableau (de 0 à 8).
/// </summary>
/// <param name="tete"></param>
/// <param name="corps"></param>
public void RandomAnimal(Tete tete, Corps corps)
{
Bibliotheque liste = new Bibliotheque();
Random rand = new Random();
do
{
_indexPattes = rand.Next(liste.ListAnimaux.Count);
} while (_indexPattes == tete.IndexTete || _indexPattes == corps.IndexCorps);
_nomAnimal = liste.ListAnimaux[_indexPattes];
}
/// <summary>
/// Constructeur de l'Animorphe
/// </summary>
public Animorphe()
{
Tete teteChoisie = new Tete();
Corps corpsChoisi = new Corps(teteChoisie);
Pattes pattesChoisies = new Pattes(teteChoisie, corpsChoisi);
this.Tete = teteChoisie.NomAnimal;
this.SyllabeNomTete = teteChoisie.ParticuleNom;
this.Corps = corpsChoisi.NomAnimal;
this.SyllabeNomCorps = corpsChoisi.ParticuleNom;
this.Pattes = pattesChoisies.NomAnimal;
this.SyllabeNomPattes = pattesChoisies.ParticuleNom;
this.Nom = this.SyllabeNomTete + this.SyllabeNomCorps + this.SyllabeNomPattes;
}
public SpecialisedSoldier(int id, string firstName, string lastName, decimal salary, Corps corps)
: base(id, firstName, lastName, salary)
{
this.Corps = corps;
}
public override void Calculate(RoamingNPC t)
{
if (!t.isDead)
{
t.isDead = true;
}
else
{
return;
}
if (t.enemySO.leavesCorpse)
{
MapManager.map[t.__position.x, t.__position.y].enemy = null;
MapManager.map[t.__position.x, t.__position.y].isWalkable = true;
Corps corpse = new Corps();
//ITEM IN CORPSE
bool droppedItem = false;
//CHANCE TO DROP CORPSE ITEM
if (t.enemySO.E_possileDrops != null && t.enemySO.E_possileDrops.Count > 0)
{
corpse.itemInCorpse = t.enemySO.E_possileDrops[Random.Range(0, t.enemySO.E_possileDrops.Count)];
if (corpse.itemInCorpse != null)
{
droppedItem = true;
}
}
if (MapManager.map[t.__position.x, t.__position.y].structure == null)
{
/*if (droppedItem)
* {
* /*MapManager.map[t.__position.x, t.__position.y].timeColor = new Color(0, 0, 0);
* MapManager.map[t.__position.x, t.__position.y].letter = "";
* GameManager.manager.itemSpawner.SpawnAt(t.__position.x, t.__position.y, corpse.itemInCorpse);
* }
* else
* {
* MapManager.map[t.__position.x, t.__position.y].baseChar = t.EnemySymbol;
* MapManager.map[t.__position.x, t.__position.y].exploredColor = new Color(0.2784f, 0, 0);
* MapManager.map[t.__position.x, t.__position.y].letter = "";
* }*/
if (droppedItem)
{
GameManager.manager.itemSpawner.SpawnAt(MapManager.CurrentFloor, t.__position.x, t.__position.y, corpse.itemInCorpse);
}
MapManager.map[t.__position.x, t.__position.y].baseChar = t.EnemySymbol;
MapManager.map[t.__position.x, t.__position.y].exploredColor = new Color(0.2784f, 0, 0);
MapManager.map[t.__position.x, t.__position.y].letter = "";
corpse.enemyBody = t.enemySO;
MapManager.map[t.__position.x, t.__position.y].structure = corpse;
}
}
else
{
MapManager.map[t.__position.x, t.__position.y].enemy = null;
MapManager.map[t.__position.x, t.__position.y].letter = "";
MapManager.map[t.__position.x, t.__position.y].isWalkable = true;
}
t.manager.playerStats.__sanity += 10;
t.manager.UpdateMessages($"You have killed the <color=#{t.EnemyColor}>{t.EnemyName}</color>");
RunManager.CurrentRun.Set(RunManager.Names.EnemiesKilled,
RunManager.CurrentRun.Get <int>(RunManager.Names.EnemiesKilled) + 1);
RunManager.UnitKilledWithAttack();
// handle xp and stuff like that
t.manager.playerStats.UpdateLevel(t.xpDrop);
/*
* GameObject e = null;
*
* foreach (var enemy in manager.enemies)
* {
* if(enemy.GetComponent<RoamingNPC>().__position == __position)
* {
* e = enemy;
* }
* }
*
* foreach (var enemy in t.manager.enemies)
* {
* if (enemy == t.gameObject)
* {
* e = enemy;
* }
* }
*/
t.manager.StartPlayersTurn();
// t.manager.gameObject.GetComponent<Bestiary>().UpdateEnemyList(t.enemySO);
t.manager.enemies.Remove(t.gameObject);
DungeonGenerator.dungeonGenerator.DrawMap(MapManager.map);
Destroy(t.gameObject);
}
public Engineer(string id, string firstName, string lastName, decimal salary, Corps corps)
{
this.Id = id;
this.FirstName = firstName;
this.LastName = lastName;
this.Corps = corps;
this.Salary = salary;
this.Repairs = new List <Repair>();
}
public Commando(int id, string firstName, string lastName, decimal salary, Corps corps, ICollection <IMission> missions)
: base(id, firstName, lastName, salary, corps)
{
Missions = missions;
}
public Engineer(int id, string firstname, string lastname, decimal salary, Corps corps)
: base(id, firstname, lastname, salary, corps)
{
}
/// <summary>
/// Pour pouvoir obtenir une référence unique pour chaque dossier de corps, identiques
/// dans l'assemblage, on passe par la création d'une propriété dans chaque dossier.
/// Cette propriété est liée à une cote dans une esquisse dont la valeur est égale au repère.
/// Suivant la configuration, la valeur de la cote peut changer et donc le repère du dossier.
/// C'est le seul moyen pour avoir un lien entre les dossiers et la configuration du modèle.
/// Les propriétés des dossiers ne sont pas configurables.
/// </summary>
protected override void Command()
{
try
{
App.Sw.CommandInProgress = true;
// Si aucun corps n'a déjà été repéré, on reinitialise tout
if (ListeCorps.Count == 0)
{
// On supprime tout les fichiers
foreach (FileInfo file in new DirectoryInfo(MdlBase.pDossierPiece()).GetFiles())
{
file.Delete();
}
}
if (ReinitCampagneActuelle && (ListeCorps.Count > 0))
{
// On supprime les repères de la campagne actuelle
// On recherche les repères appartenant aux campagnes précédentes
// pour ne pas supprimer les fichiers
// Si la somme des quantités des campagnes précédente est superieure à 0
// on garde le repère
ListeSortedCorps FichierAsauvegarder = new ListeSortedCorps();
FichierAsauvegarder.CampagneDepartDecompte = ListeCorps.CampagneDepartDecompte;
foreach (var corps in ListeCorps.Values)
{
int nb = 0;
foreach (var camp in corps.Campagne)
{
if (camp.Key < IndiceCampagne)
{
nb += camp.Value;
}
else
{
break;
}
}
if (nb > 0)
{
FichierAsauvegarder.Add(corps.Repere, corps);
}
}
// On nettoie les fichiers précedement crées
foreach (var corps in ListeCorps.Values)
{
if (FichierAsauvegarder.ContainsKey(corps.Repere))
{
continue;
}
corps.SupprimerFichier();
}
ListeCorps = FichierAsauvegarder;
}
// On supprime les campagnes superieures à l'indice actuelle
foreach (var corps in ListeCorps.Values)
{
for (int i = IndiceCampagne; i < corps.Campagne.Keys.Max(); i++)
{
if (corps.Campagne.ContainsKey(i + 1))
{
corps.Campagne.Remove(i + 1);
}
}
}
WindowLog.SautDeLigne();
WindowLog.EcrireF("Campagne de départ : {0}", ListeCorps.CampagneDepartDecompte);
// On charge les corps existant à partir des fichiers
// et seulement ceux dont la quantité pour CampagneDepartDecompte est supérieure à 0
if (CombinerCorpsIdentiques && (ListeCorps.Count > 0))
{
var FiltreCampagne = IndiceCampagne;
if (CombinerAvecCampagnePrecedente)
{
FiltreCampagne = ListeCorps.CampagneDepartDecompte;
}
WindowLog.SautDeLigne();
WindowLog.Ecrire("Chargement des corps existants :");
foreach (var corps in ListeCorps.Values)
{
// On additionne les quantités pour les corps supperieur à filtreCampagne
// S
if (corps.Campagne.ContainsKey(FiltreCampagne) &&
corps.Campagne.Sum(d => d.Key >= FiltreCampagne? d.Value : 0) > 0 &&
File.Exists(corps.CheminFichierRepere)
)
{
WindowLog.EcrireF(" - {0}", corps.RepereComplet);
corps.ChargerCorps();
}
}
}
// On reinitialise la quantité pour la campagne actuelle à 0
foreach (var corps in ListeCorps.Values)
{
corps.InitCampagne(IndiceCampagne);
}
////////////////////////////////// DEBUT DU REPERAGE ////////////////////////////////////////////////////
MdlBase.eActiver(swRebuildOnActivation_e.swRebuildActiveDoc);
MdlBase.eActiverManager(false);
WindowLog.SautDeLigne();
WindowLog.Ecrire("Debut du repérage");
// On recherche l'indice de repere max
if (ListeCorps.Count > 0)
{
_GenRepereDossier = ListeCorps.Keys.Max();
}
// On liste les composants
var ListeComposants = MdlBase.pListerComposants();
// On boucle sur les modeles
foreach (var mdl in ListeComposants.Keys)
{
mdl.eActiver(swRebuildOnActivation_e.swRebuildActiveDoc);
mdl.eActiverManager(false);
// On met à jour les options
mdl.Extension.SetUserPreferenceToggle(((int)(swUserPreferenceToggle_e.swDisableDerivedConfigurations)), 0, false);
mdl.Extension.SetUserPreferenceToggle(((int)(swUserPreferenceToggle_e.swWeldmentRenameCutlistDescriptionPropertyValue)), 0, true);
mdl.Extension.SetUserPreferenceToggle(((int)(swUserPreferenceToggle_e.swWeldmentCollectIdenticalBodies)), 0, true);
mdl.Extension.SetUserPreferenceString(((int)(swUserPreferenceStringValue_e.swSheetMetalDescription)), 0, "Tôle");
if (mdl.ePartDoc().eDossierListeDesPiecesSoudees().GetAutomaticUpdate() == false)
{
mdl.ePartDoc().eMajListeDesPiecesSoudeesAuto(true);
mdl.EditRebuild3();
}
// On crée l'esquisse pour le reperage des dossiers
mdl.pEsquisseRepere();
// Si le modele est a repérer complètement
Boolean InitModele = true;
// On recherche l'index de la dimension maximum
int IndexDimension = 0;
// On liste les dossiers déja traité pour l'attribution des nouveaux index de dimension
HashSet <int> HashPieceIdDossiers = new HashSet <int>();
// Les données sont stockées dans des propriétés du modèle
// Le nom du modèle est stocké dans une propriété, si le modèle est copié
// la propriété n'est plus valable, on force le repérage
// On récupère également le dernier indice de la dimension utilisée
if (mdl.ePropExiste(CONST_PRODUCTION.ID_PIECE) && (mdl.eGetProp(CONST_PRODUCTION.ID_PIECE) == mdl.eNomSansExt()))
{
InitModele = false;
if (mdl.ePropExiste(CONST_PRODUCTION.MAX_INDEXDIM))
{
IndexDimension = mdl.eGetProp(CONST_PRODUCTION.MAX_INDEXDIM).eToInteger();
}
if (mdl.ePropExiste(CONST_PRODUCTION.PIECE_ID_DOSSIERS))
{
var tab = mdl.eGetProp(CONST_PRODUCTION.PIECE_ID_DOSSIERS).Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
foreach (var id in tab)
{
HashPieceIdDossiers.Add(id.eToInteger());
}
}
}
////////////////////////////////// BOUCLE SUR LES CONFIGS ////////////////////////////////////////////////////
foreach (var nomCfg in ListeComposants[mdl].Keys)
{
mdl.ShowConfiguration2(nomCfg);
mdl.EditRebuild3();
WindowLog.SautDeLigne();
WindowLog.EcrireF("{0} \"{1}\"", mdl.eNomSansExt(), nomCfg);
HashSet <int> HashConfigIdDossiers = new HashSet <int>();
Boolean InitConfig = true;
int IdCfg = mdl.GetConfigurationByName(nomCfg).GetID();
// Idem modèle, on stock l'id de la config dans une propriété.
// Si une nouvelle config est crée, la valeur de cette propriété devient caduc,
// on repère alors les dossiers
// On en profite pour récupérer la liste des ids de dossiers déjà traité dans les précédentes
// campagne de repérage
if (!InitModele && mdl.ePropExiste(CONST_PRODUCTION.ID_CONFIG, nomCfg) && (mdl.eGetProp(CONST_PRODUCTION.ID_CONFIG, nomCfg) == IdCfg.ToString()))
{
InitConfig = false;
if (mdl.ePropExiste(CONST_PRODUCTION.CONFIG_ID_DOSSIERS, nomCfg))
{
var tab = mdl.eGetProp(CONST_PRODUCTION.CONFIG_ID_DOSSIERS, nomCfg).Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
foreach (var id in tab)
{
HashConfigIdDossiers.Add(id.eToInteger());
}
}
}
var piece = mdl.ePartDoc();
var ListeDossier = piece.eListeDesFonctionsDePiecesSoudees(
swD =>
{
BodyFolder Dossier = swD.GetSpecificFeature2();
// Si le dossier est la racine d'un sous-ensemble soudé, il n'y a rien dedans
if (Dossier.IsRef() && (Dossier.eNbCorps() > 0) && !Dossier.eEstExclu() &&
FiltrerCorps.HasFlag(Dossier.eTypeDeDossier()))
{
return(true);
}
return(false);
}
);
var NbConfig = ListeComposants[mdl][nomCfg];
////////////////////////////////// BOUCLE SUR LES DOSSIERS ////////////////////////////////////////////////////
foreach (var fDossier in ListeDossier)
{
BodyFolder Dossier = fDossier.GetSpecificFeature2();
int IdDossier = fDossier.GetID();
Dimension param = null;
if (!HashPieceIdDossiers.Contains(IdDossier))
{
param = CreerParam(mdl, fDossier, nomCfg, ++IndexDimension);
}
else
{
param = GetParam(mdl, fDossier, nomCfg);
}
var SwCorps = Dossier.ePremierCorps();
var NomCorps = SwCorps.Name;
var MateriauCorps = SwCorps.eGetMateriauCorpsOuPiece(piece, nomCfg);
eTypeCorps TypeCorps = Dossier.eTypeDeDossier();
var nbCorps = Dossier.eNbCorps() * NbConfig;
int Repere = -1;
if (CombinerCorpsIdentiques)
{
// On recherche s'il existe des corps identiques
// Si oui, on applique le même repère au parametre
foreach (var CorpsTest in ListeCorps.Values)
{
if (CorpsTest.SwCorps.IsRef() &&
(CombinerAvecCampagnePrecedente || CorpsTest.Campagne.ContainsKey(IndiceCampagne)) &&
(MateriauCorps == CorpsTest.Materiau) &&
(TypeCorps == CorpsTest.TypeCorps) &&
SwCorps.eComparerGeometrie(CorpsTest.SwCorps) == Sw.Comparaison_e.Semblable)
{
Repere = CorpsTest.Repere;
SetRepere(param, CorpsTest.Repere, nomCfg);
break;
}
}
}
// Initialisation du repère
if (Repere.eEstNegatif())
{
// A tester
// Si on est mode "MajCampagnePrecedente", ça évite de repérer une seconde fois les pièces
// Si on est pas en mode "Combiner les corps"
// on recupère le repère du dossier
// Sinon c'est forcément un nouveau repère
if (!CombinerCorpsIdentiques)
{
Repere = GetRepere(param, nomCfg);
}
// Création d'un nouveau repère suivant conditions
// Dans tous les cas, si la clé est négative, on crée un nouveau repère
if (Repere.eEstNegatif() ||
InitConfig ||
!HashConfigIdDossiers.Contains(IdDossier) ||
!ListeCorps.ContainsKey(Repere))
{
Repere = GenRepereDossier;
SetRepere(param, Repere, nomCfg);
}
}
// Initialisation du corps
Corps corps = null;
if (!ListeCorps.ContainsKey(Repere))
{
corps = new Corps(SwCorps, TypeCorps, MateriauCorps, MdlBase);
corps.InitCampagne(IndiceCampagne);
ListeCorps.Add(Repere, corps);
}
else
{
corps = ListeCorps[Repere];
}
corps.Campagne[IndiceCampagne] += nbCorps;
corps.Repere = Repere;
corps.InitCaracteristiques(Dossier, SwCorps);
corps.AjouterModele(mdl, nomCfg, IdDossier, NomCorps);
HashPieceIdDossiers.Add(IdDossier);
HashConfigIdDossiers.Add(IdDossier);
WindowLog.EcrireF(" - {1} -> {0}", fDossier.Name, corps.RepereComplet);
}
mdl.ePropAdd(CONST_PRODUCTION.ID_CONFIG, IdCfg, nomCfg);
mdl.ePropAdd(CONST_PRODUCTION.CONFIG_ID_DOSSIERS, String.Join(" ", HashConfigIdDossiers), nomCfg);
}
mdl.ePropAdd(CONST_PRODUCTION.ID_PIECE, mdl.eNomSansExt());
mdl.ePropAdd(CONST_PRODUCTION.PIECE_ID_DOSSIERS, String.Join(" ", HashPieceIdDossiers));
mdl.ePropAdd(CONST_PRODUCTION.MAX_INDEXDIM, IndexDimension);
mdl.eActiverManager(true);
mdl.eSauver();
mdl.eFermerSiDifferent(MdlBase);
}
MdlBase.eActiverManager(true);
MdlBase.eActiver(swRebuildOnActivation_e.swRebuildActiveDoc);
MdlBase.EditRebuild3();
MdlBase.eSauver();
////////////////////////////////// FIN DU REPERAGE ////////////////////////////////////////////////////
// On fermer les fichiers chargé
foreach (var corps in ListeCorps.Values)
{
Sw.eFermer(corps.CheminFichierRepere);
}
WindowLog.SautDeLigne();
if (ListeCorps.Count > 0)
{
WindowLog.EcrireF("Nb de repères : {0}", ListeCorps.Keys.Max());
}
else
{
WindowLog.Ecrire("Aucun corps repéré");
}
// S'il n'y a aucun corps, on se barre
if (ListeCorps.Count == 0)
{
return;
}
////////////////////////////////// EXPORTER LES CORPS /////////////////////////////////////////////////
WindowLog.SautDeLigne();
WindowLog.Ecrire("Export des corps :");
foreach (var corps in ListeCorps.Values)
{
if (corps.Modele.IsNull())
{
continue;
}
// Si on est pas en mode "Combiner corps identique" et que le fichier existe
// on le supprime pour le mettre à jour, sinon on peut se retrouver
// avec des fichiers ne correpondants pas au corps
if (!CombinerCorpsIdentiques)
{
corps.SupprimerFichier();
}
// Si le fichier existe, on passe au suivant
if (File.Exists(corps.CheminFichierRepere))
{
continue;
}
WindowLog.EcrireF("- {0} exporté", CONSTANTES.PREFIXE_REF_DOSSIER + corps.Repere);
corps.SauverRepere(CreerDvp);
}
////////////////////////////////// RECAP /////////////////////////////////////////////////
// Petit récap
WindowLog.SautDeLigne();
WindowLog.EcrireF("Nb de corps unique : {0}", ListeCorps.Count);
int nbtt = 0;
foreach (var corps in ListeCorps.Values)
{
nbtt += corps.Campagne[IndiceCampagne];
if (corps.Campagne[IndiceCampagne] > 0)
{
WindowLog.EcrireF("{2} P{0} ×{1}", corps.Repere, corps.Campagne[IndiceCampagne], IndiceCampagne);
}
}
WindowLog.EcrireF("Nb total de corps : {0}", nbtt);
////////////////////////////////// SAUVEGARDE DE LA NOMENCLATURE /////////////////////////////////////////////
ListeCorps.EcrireNomenclature(MdlBase.pDossierPiece(), IndiceCampagne);
////////////////////////////////////////////////////////////////////////////////////////////////////////////
MdlBase.eActiver(swRebuildOnActivation_e.swRebuildActiveDoc);
App.Sw.CommandInProgress = false;
var aff = new AffichageElementWPF(ListeCorps, IndiceCampagne);
aff.ShowDialog();
ListeCorps = null;
ListeComposants = null;
}
catch (Exception e) { this.LogErreur(new Object[] { e }); }
}
public void Run()
{
ICollection <ISoldier> soldiers = new List <ISoldier>();
string input = string.Empty;
while ((input = Console.ReadLine()) != "End")
{
var tokens = input.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries).ToList();
var type = tokens[0];
tokens.Remove(tokens.First());
string id = tokens[0];
string firstName = tokens[1];
string lastName = tokens[2];
if (type != "Spy")
{
double salary = double.Parse(tokens[3]);
if (type == "Private")
{
soldiers.Add(new Private(id, firstName, lastName, salary));
}
else if (type == "LeutenantGeneral")
{
tokens = tokens.Skip(4).ToList();
LeutenantGeneral general = new LeutenantGeneral(id, firstName, lastName, salary);
foreach (var soldId in tokens)
{
var currentPrivate = soldiers.First(p => p.Id == soldId);
general.Privates.Add(currentPrivate as IPrivate);
}
soldiers.Add(general);
}
else if (type == "Engineer" || type == "Commando")
{
Corps corps = Corps.Marines;
if (System.Enum.TryParse(tokens[4], out corps))
{
if (type == "Engineer")
{
Engineer engi = new Engineer(id, firstName, lastName, salary, corps);
tokens = tokens.Skip(5).ToList();
for (int i = 0; i < tokens.Count; i += 2)
{
string partName = tokens[i];
int hoursWorked = int.Parse(tokens[i + 1]);
IRepair repair = new Repair(partName, hoursWorked);
engi.Repairs.Add(repair);
}
soldiers.Add(engi);
}
else if (type == "Commando")
{
Commando comm = new Commando(id, firstName, lastName, salary, corps);
tokens = tokens.Skip(5).ToList();
for (int i = 0; i < tokens.Count; i += 2)
{
string missionCodeName = tokens[i];
MissionState missionState = MissionState.inProgress;
if (System.Enum.TryParse(tokens[i + 1], out missionState))
{
IMission mission = new Mission(missionCodeName, missionState);
comm.Missions.Add(mission);
}
}
soldiers.Add(comm);
}
}
}
}
else if (type == "Spy")
{
string codeNumber = tokens[3];
Spy spy = new Spy(id, firstName, lastName, int.Parse(codeNumber));
soldiers.Add(spy);
}
}
foreach (var sold in soldiers)
{
Console.WriteLine(sold.ToString());
}
}
private ISoldier GetCommando(int id, string firstName, string lastName, decimal salary, Corps corps, string[] comands)
{
ICommando solder = new Commando(id, firstName, lastName, salary, corps);
for (int i = 6; i < comands.Length; i += 2)
{
string codeName = comands[i];
if (!Enum.TryParse(comands[i + 1], out State stat))
{
continue;
}
IMission mision = new Mission(codeName, stat);
solder.Missions.Add(mision);
}
return(solder);
}
public Engineer(int id, string firstName, string lastName, double salary, Corps corps)
: base(id, firstName, lastName, salary)
{
this.Corps = corps;
this.setOfRepairs = new HashSet <Repair>();
}
public IActionResult EditCorp(Corps corp)
{
db.Entry(corp).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("ShowCorps"));
}
public Engineer(int id, string firstName, string lastName, decimal salary, Corps corps)
: base(id, firstName, lastName, salary)
{
Corps = corps;
Repairs = new List <IRepair>();
}
static void Main(string[] args)
{
//Engineer engineer = new Engineer("12", "first", "last", 1000M, Enums.Corps.Airforces);
//engineer.AddRepair(new Repair("partName", 4));
//Console.WriteLine(engineer.ToString());
//Commando commando = new Commando("15", "commFirst", "commLast", 1500M, Enums.Corps.Marines);
//commando.AddMission(new Mission("Frenzy", Enums.MissionStatus.inProgress));
//commando.Missions.FirstOrDefault(k => k.CodeName == "Frenzy").CompleteMission();
//Console.WriteLine(commando.ToString());
;
List <Private> privates = new List <Private>();
string input;
while ((input = Console.ReadLine()) != "End")
{
string[] tokens = input.Split();
string soldierRank = tokens[0];
string ID = tokens[1],
firstName = tokens[2],
lastName = tokens[3];
switch (soldierRank)
{
case "Private":
decimal salary = decimal.Parse(tokens[4]);
Private prPrivate = new Private(ID, firstName, lastName, salary);
Console.WriteLine(prPrivate.ToString());
privates.Add(prPrivate);
break;
case "LieutenantGeneral":
salary = decimal.Parse(tokens[4]);
LieutenantGeneral lieutenant = new LieutenantGeneral(ID, firstName, lastName, salary);
AddPrivates(privates, tokens, lieutenant);
Console.WriteLine(lieutenant.ToString());
break;
case "Engineer":
salary = decimal.Parse(tokens[4]);
Corps corp = Corps.neither;
if (tokens[5] == "Airforces")
{
corp = Corps.Airforces;
}
else if (tokens[5] == "Marines")
{
corp = Corps.Marines;
}
if (!(corp == Corps.neither))
{
Engineer engineer = new Engineer(ID, firstName, lastName, salary, corp);
AddRepairs(tokens, engineer);
Console.WriteLine(engineer.ToString());
}
break;
case "Commando":
salary = decimal.Parse(tokens[4]);
corp = Corps.neither;
corp = ValidateCorps(tokens, corp);
if (!(corp == Corps.neither))
{
Commando commando = new Commando(ID, firstName, lastName, salary, corp);
AddValidMissions(tokens, commando);
Console.WriteLine(commando.ToString());
}
break;
case "Spy":
int codeNumber = int.Parse(tokens[4]);
Spy spy = new Spy(ID, firstName, lastName, codeNumber);
Console.WriteLine(spy.ToString());
break;
default:
break;
}
}
}
private String CreerBarre(Corps corps)
{
string CheminFichierExportBarre = "";
if (!corps.Dvp)
{
return(CheminFichierExportBarre);
}
var QuantiteDiff = Quantite * (corps.Qte + corps.QteSup);
var cheminFichier = corps.CheminFichierRepere;
if (!File.Exists(cheminFichier))
{
return(CheminFichierExportBarre);
}
String Repere = corps.RepereComplet;
String Profil = corps.Dimension;
String Longueur = corps.Volume;
String Materiau = corps.Materiau;
String NomFichierBarre = ConstruireNomFichierBarre(Repere, IndiceCampagne, QuantiteDiff);
var mdlCorps = Sw.eOuvrir(cheminFichier);
if (mdlCorps.IsNull())
{
return(CheminFichierExportBarre);
}
var Piece = mdlCorps.ePartDoc();
corps.SwCorps = Piece.ePremierCorps();
Body2 Barre = corps.SwCorps;
if (corps.Maj)
{
WindowLog.EcrireF("{0} x{1}", corps.RepereComplet, QuantiteDiff);
}
mdlCorps.EditRebuild3();
try
{
List <String> Liste = new List <String>()
{
Repere, Materiau, Profil, Math.Round(Longueur.eToDouble()).ToString(), "× " + QuantiteDiff.ToString()
};
if (ListerUsinages)
{
var analyse = new AnalyseBarre(Barre, mdlCorps);
Dictionary <String, Double> Dic = new Dictionary <string, double>();
foreach (var u in analyse.ListeFaceUsinageSection)
{
String nom = u.ListeFaceDecoupe.Count + " face - Lg " + Math.Round(u.LgUsinage * 1000, 1);
if (Dic.ContainsKey(nom))
{
Dic[nom] += 1;
}
else
{
Dic.Add(nom, 1);
}
}
Liste.Add(Math.Round(analyse.ListeFaceUsinageExtremite[0].LgUsinage * 1000, 1).ToString());
if (analyse.ListeFaceUsinageExtremite.Count > 1)
{
Liste.Add(Math.Round(analyse.ListeFaceUsinageExtremite[1].LgUsinage * 1000, 1).ToString());
}
else
{
Liste.Add("");
}
foreach (var nom in Dic.Keys)
{
Liste.Add(Dic[nom] + "x [ " + nom + " ]");
}
}
Nomenclature.AjouterLigne(Liste.ToArray());
if (corps.Maj && ExporterBarres)
{
ModelDoc2 mdlBarre = Barre.eEnregistrerSous(Piece, DossierBarre, NomFichierBarre, TypeExport, out CheminFichierExportBarre);
if (CreerPdf3D)
{
String CheminPDF = Path.Combine(DossierBarrePDF, NomFichierBarre + eTypeFichierExport.PDF.GetEnumInfo <ExtFichier>());
mdlBarre.SauverEnPdf3D(CheminPDF);
}
mdlBarre.eFermer();
}
}
catch (Exception e)
{
WindowLog.Ecrire(" - Erreur");
this.LogMethode(new Object[] { e });
}
finally
{
WindowLog.Ecrire(" - Ok");
}
mdlCorps.eFermer();
return(CheminFichierExportBarre);
}
public Engineer(int id, string firstName, string lastNAme, decimal salary, Corps corps, ICollection <IRepair> repairs)
: base(id, firstName, lastNAme, salary, corps)
{
this.Repairs = repairs;
}
public Commando(int id, string firstname, string lastname, decimal salary, Corps corps)
: base(id, firstname, lastname, salary, corps)
{
this.Missions = new List <IMission>();
}
private ISoldier GetEngineer(int id, string firstName, string lastName, decimal salary, Corps corps, string[] comands)
{
IEngineer solder = new Engineer(id, firstName, lastName, salary, corps);
for (int i = 6; i < comands.Length; i += 2)
{
string part = comands[i];
int hours = int.Parse(comands[i + 1]);
IRepair repair = new Repair(part, hours);
solder.Repairs.Add(repair);
}
return(solder);
}
public static void Main()
{
var soldiers = new Dictionary <int, Soldier>();
string input;
while ((input = Console.ReadLine()) != "End")
{
var split = input.Split();
Soldier soldier = null;
int id = int.Parse(split[1]);
string firstName = split[2];
string lastName = split[3];
switch (split[0])
{
case "Private":
{
double salary = double.Parse(split[4]);
soldier = new Private(id, firstName, lastName, salary);
break;
}
case "LeutenantGeneral":
{
double salary = double.Parse(split[4]);
List <Private> privates = split.Skip(5).Select(pid => (Private)soldiers[int.Parse(pid)]).ToList();
soldier = new LeutenantGeneral(id, firstName, lastName, salary, privates);
break;
}
case "Engineer":
{
double salary = double.Parse(split[4]);
if (!Enum.TryParse <Corps>(split[5], out Corps corps))
{
continue;
}
List <Repair> repairs = new List <Repair>();
for (int i = 6; i < split.Length - 1; i += 2)
{
repairs.Add(new Repair(split[i], int.Parse(split[i + 1])));
}
soldier = new Engineer(id, firstName, lastName, salary, corps, repairs);
break;
}
case "Commando":
{
double salary = double.Parse(split[4]);
Corps corps = Enum.Parse <Corps>(split[5]);
List <Mission> missions = new List <Mission>();
for (int i = 6; i < split.Length - 1; i += 2)
{
if (!Enum.TryParse <MissionState>(split[i + 1], out MissionState state))
{
continue;
}
missions.Add(new Mission(split[i], state));
}
soldier = new Commando(id, firstName, lastName, salary, corps, missions);
break;
}
case "Spy":
{
int codeNumber = int.Parse(split[4]);
soldier = new Spy(id, firstName, lastName, codeNumber);
break;
}
}
soldiers.Add(id, soldier);
}
foreach (var soldier in soldiers.Values)
{
Console.WriteLine(soldier);
}
}
public SpecialisedSoldier(string id, string firstName, string lastName, double salary, Corps corps)
: base(id, firstName, lastName, salary)
{
this.Corps = corps;
}
public Commando(string id, string firstName, string lastName, decimal salary, Corps corps)
{
this.Id = id;
this.FirstName = firstName;
this.LastName = lastName;
this.Salary = salary;
this.Corps = corps;
this.Missions = new List <Mission>();
}
public Engineer(string id, string firstName, string lastName, decimal salary, Corps corps) : base(id, firstName, lastName, salary, corps)
{
repairs = new List <IRepair>();
}
protected SpecialisedSoldier(string id, string firstName, string lastName, decimal salary, Corps corps)
: base(id, firstName, lastName, salary)
{
this.Corps = corps;
}
public Engineer(int id, string first, string last, decimal salary, Corps corps)
: base(id, first, last, salary, corps)
{
this.Repairs = new List <IRepair>();
}
protected SpecialisedSoldier(int id, string firstName, string lastName, double salary, Corps corps) : base(id, firstName, lastName, salary)
{
Corps = corps;
}
public Engineer(string id, string firstName, string lastName, double salary, Corps corps) : base(id, firstName, lastName, salary, corps)
{
this.Repairs = new List <IRepair>();
}
/// <summary>
/// Constructeur de la Class Pattes
/// </summary>
/// <param name="tete">Récupère l'objet Tete</param>
/// <param name="corps">Récupère l'objet Corps</param>
public Pattes(Tete tete, Corps corps)
{
this.RandomAnimal(tete, corps);
this.RécupererParticuleNom();
}
public Commando(string id, string firstName, string lastName, decimal salary, Corps corp)
: base(id, firstName, lastName, salary, corp)
{
this.missions = new List <IMission>();
}
public Commando(string id, string firstName, string lastName, decimal price, Corps corps)
: base(id, firstName, lastName, price)
{
Corps = corps;
missions = new List <IMission>();
}
public Engineer(int id, string firstName, string lastName, double salary, Corps corps, List <Repair> repairs) : base(id, firstName, lastName, salary, corps)
{
Repairs = repairs;
}
public Engineer(int id, string firstName, string lastName, decimal salary, Corps corps, params IRepair[] repairs)
: base(id, firstName, lastName, salary, corps)
{
this.repairs = new List <IRepair>(repairs);
}
/// <summary>
/// Pour pouvoir obtenir une référence unique pour chaque dossier de corps, identiques
/// dans l'assemblage, on passe par la création d'une propriété dans chaque dossier.
/// Cette propriété est liée à une cote dans une esquisse dont la valeur est égale au repère.
/// Suivant la configuration, la valeur de la cote peut changer et donc le repère du dossier.
/// C'est le seul moyen pour avoir un lien entre les dossiers et la configuration du modèle.
/// Les propriétés des dossiers ne sont pas configurables.
/// </summary>
protected override void Command()
{
try
{
if (MajDossiers)
{
IndiceMax();
}
var ListeCorps = new List <Corps>();
var lst = MdlBase.ListerComposants(false);
foreach (var mdl in lst.Keys)
{
mdl.eActiver(swRebuildOnActivation_e.swRebuildActiveDoc);
EsquisseRepere(mdl);
foreach (var cfg in lst[mdl].Keys)
{
mdl.ShowConfiguration2(cfg);
mdl.EditRebuild3();
WindowLog.SautDeLigne();
WindowLog.EcrireF("{0} \"{1}\"", mdl.eNomSansExt(), cfg);
var piece = mdl.ePartDoc();
var NbConfig = lst[mdl][cfg];
var ListeDossier = piece.eListeDesFonctionsDePiecesSoudees(
swD =>
{
BodyFolder Dossier = swD.GetSpecificFeature2();
// Si le dossier est la racine d'un sous-ensemble soudé, il n'y a rien dedans
if (Dossier.IsRef() && Dossier.eNbCorps() > 0 &&
(eTypeCorps.Barre | eTypeCorps.Tole).HasFlag(Dossier.eTypeDeDossier()))
{
return(true);
}
return(false);
}
);
foreach (var fDossier in ListeDossier)
{
BodyFolder Dossier = fDossier.GetSpecificFeature2();
CustomPropertyManager PM = fDossier.CustomPropertyManager;
// Si MajDossier et PropExiste, ne pas mettre à jour
Boolean Maj = !(MajDossiers && PM.ePropExiste(CONSTANTES.REF_DOSSIER));
String NomParam = "";
WindowLog.EcrireF(" {0}", fDossier.Name);
// On recherche si le dossier à déjà été traité.
// Si non, on ajoute le dossier à la liste
// On met à jour la liste des index des dimensions :
// On ajoute le nom du modele et on itiniatile l'index à 1
// Ou, puisque c'est un nouveau dossier, on ajoute un à l'index existant.
// On créer le nom du paramètre
// On ajoute la propriété au dossier selon le modèle suivant :
// P"D1@REPERAGE_DOSSIER@Nom_de_la_piece.SLDPRT"
// Si oui, on récupère le nom du paramètre
var clef = HashDossier(mdl, fDossier);
if (!DossierTraite.Contains(clef))
{
DossierTraite.Add(clef);
IndexDimension.AddIfNotExistOrPlus(mdl.GetPathName());
NomParam = String.Format("D{0}@{1}", IndexDimension[mdl.GetPathName()]++, CONSTANTES.NOM_ESQUISSE_NUMEROTER);
var propVal = String.Format("{0}\"{1}@{2}\"", CONSTANTES.PREFIXE_REF_DOSSIER, NomParam, mdl.eNomAvecExt());
var r = PM.ePropAdd(CONSTANTES.REF_DOSSIER, propVal);
if (r > 0)
{
WindowLog.EcrireF("{0}-{1}-{2} : Pas de propriété ajoutée {3}", mdl.eNomSansExt(), cfg, fDossier.Name, (swCustomInfoAddResult_e)r);
}
PM.ePropAdd(CONSTANTES.DESC_DOSSIER, propVal);
}
else
{
String val, result = ""; Boolean wasResolved, link;
var r = PM.Get6(CONSTANTES.REF_DOSSIER, false, out val, out result, out wasResolved, out link);
if (r == 1)
{
WindowLog.EcrireF("{0}-{1}-{2} : Pas de propriété {3}", mdl.eNomSansExt(), cfg, fDossier.Name, (swCustomInfoGetResult_e)r);
}
NomParam = ExtractNomParam(val);
}
{
String val, result = ""; Boolean wasResolved, link;
var r = PM.Get6(CONSTANTES.REF_DOSSIER, false, out val, out result, out wasResolved, out link);
PM.ePropAdd(CONSTANTES.DESC_DOSSIER, val);
}
// On ajoute la propriété NomDossier
// permettant de récupérer le nom du dossier dans la mise en plan
if (!PM.ePropExiste(CONSTANTES.NOM_DOSSIER))
{
var propVal = String.Format("\"SW-CutListItemName@@@{0}@{1}\"", fDossier.Name, mdl.eNomAvecExt());
PM.ePropAdd(CONSTANTES.NOM_DOSSIER, propVal);
}
var SwCorps = Dossier.ePremierCorps();
Boolean Ajoute = false;
var MateriauCorps = SwCorps.eGetMateriauCorpsOuPiece(piece, cfg);
var nbCorps = Dossier.eNbCorps() * NbConfig;
Dimension param = mdl.Parameter(NomParam);
eTypeCorps TypeCorps = Dossier.eTypeDeDossier();
if (CombinerCorpsIdentiques)
{
// On recherche s'il existe des corps identiques
// Si oui, on applique le même repère au parametre
foreach (var CorpsTest in ListeCorps)
{
if ((MateriauCorps != CorpsTest.Materiau) || (TypeCorps != CorpsTest.TypeCorps))
{
continue;
}
if (SwCorps.eComparerGeometrie(CorpsTest.SwCorps) == Sw.Comparaison_e.Semblable)
{
CorpsTest.Nb += nbCorps;
if (Maj)
{
var errors = param.SetSystemValue3(CorpsTest.Repere * 0.001, (int)swSetValueInConfiguration_e.swSetValue_InSpecificConfigurations, cfg);
if (errors > 0)
{
WindowLog.EcrireF(" Erreur de mise à jour {0}", (swSetValueReturnStatus_e)errors);
}
}
CorpsTest.AjouterModele(mdl, cfg, fDossier.GetID());
Ajoute = true;
break;
}
}
}
if ((Ajoute == false) && Maj)
{
var rep = GenRepereDossier;
var errors = param.SetSystemValue3(rep * 0.001, (int)swSetValueInConfiguration_e.swSetValue_InSpecificConfigurations, cfg);
if (errors > 0)
{
WindowLog.EcrireF(" Erreur de mise à jour {0}", (swSetValueReturnStatus_e)errors);
}
var corps = new Corps(SwCorps, TypeCorps, MateriauCorps);
corps.Nb = nbCorps;
corps.Repere = rep;
corps.AjouterModele(mdl, cfg, fDossier.GetID());
ListeCorps.Add(corps);
}
}
}
mdl.eFermerSiDifferent(MdlBase);
}
MdlBase.eActiver(swRebuildOnActivation_e.swRebuildActiveDoc);
int Errors = 0, Warnings = 0;
MdlBase.Save3((int)swSaveAsOptions_e.swSaveAsOptions_SaveReferenced + (int)swSaveAsOptions_e.swSaveAsOptions_Silent, ref Errors, ref Warnings);
MdlBase.EditRebuild3();
// Petit récap
WindowLog.SautDeLigne();
WindowLog.EcrireF("Nb de corps unique : {0}", ListeCorps.Count);
int nbtt = 0;
foreach (var corps in ListeCorps)
{
nbtt += corps.Nb;
WindowLog.EcrireF("P{0} ×{1}", corps.Repere, corps.Nb);
}
WindowLog.EcrireF("Nb total de corps : {0}", nbtt);
}
catch (Exception e)
{
this.LogErreur(new Object[] { e });
}
}
public Engineer(string id, string firstName, string lastName, decimal salary, Corps corps, IEnumerable <Repair> repairs)
: base(id, firstName, lastName, salary, corps)
{
this.Repairs = repairs;
}
