private bool AcceptChangeCanExecute(object parameter)
{
ElementName elementName = new ElementName(_element.Fullname);
elementName.AddNamePart(Name);
return((Name.Length > 0) && (_application.GetElementByFullname(elementName.FullName) == null));
}
private async Task <T> ImportAsync(
XmlReader reader,
ulong ignoreFlags,
CancellationToken cancel)
{
string previousTree = "";
Type t = typeof(T);
ElementName name = t.GetCustomAttribute <ElementName>();
if (name == null || string.IsNullOrEmpty(name.Name))
{
Engine.PrintLine(t.GetFriendlyName() + " has no 'Name' attribute.");
return(null);
}
bool found;
while (!(found = await reader.MoveToContentAsync() == XmlNodeType.Element &&
string.Equals(name.Name, reader.Name, StringComparison.InvariantCulture)))
{
;
}
if (found)
{
IElement e = await ParseElementAsync(t, null, reader, null, ignoreFlags, previousTree, 0, cancel);
return(e as T);
}
return(null);
}
public override int GetHashCode()
{
unchecked
{
return(((ElementName?.GetHashCode() ?? 0) * 397) ^ (AttributeName?.GetHashCode() ?? 0));
}
}
protected override void OnPreRender(EventArgs e)
{
if (!String.IsNullOrWhiteSpace(_value))
{
var htmlToRender = new StringBuilder();
if (!String.IsNullOrEmpty(this.ElementName))
{
htmlToRender.Append("<").Append(ElementName.ToLowerInvariant());
// GS Fix: Should be testing for "Not" empty
if (!String.IsNullOrEmpty(ID))
{
htmlToRender.Append(" id=\"").Append(ID).Append("\"");
}
if (!String.IsNullOrEmpty(CssClass))
{
htmlToRender.Append(" class=\"").Append(CssClass).Append("\"");
}
htmlToRender.Append(">");
}
htmlToRender.Append(_value);
if (!String.IsNullOrEmpty(this.ElementName))
{
htmlToRender.Append("</").Append(ElementName.ToLowerInvariant()).Append(">");
}
Controls.Add(new LiteralControl(htmlToRender.ToString()));
}
base.OnPreRender(e);
}
protected override void OnPreRender(EventArgs e)
{
if (_value != null)
{
var htmlToRender = new StringBuilder();
if (!String.IsNullOrEmpty(this.ElementName))
{
htmlToRender.Append("<").Append(ElementName.ToLowerInvariant());
if (!String.IsNullOrEmpty(ID)) htmlToRender.Append(" id=\"").Append(ID).Append("\"");
if (!String.IsNullOrEmpty(CssClass)) htmlToRender.Append(" class=\"").Append(CssClass).Append("\"");
htmlToRender.Append(">");
}
htmlToRender.Append("<a href=\"").Append(AttachmentUrl).Append("\">").Append(_value.Name).Append("</a>");
if (!String.IsNullOrEmpty(this.ElementName))
{
htmlToRender.Append("</").Append(ElementName.ToLowerInvariant()).Append(">");
}
Controls.Add(new LiteralControl(htmlToRender.ToString()));
}
base.OnPreRender(e);
}
protected internal XmlDeserializationException FailEnum(string s, Type type)
{
if (string.IsNullOrEmpty(s))
{
throw new XmlDeserializationException(string.Format(NullException, ElementName, type.Name));
}
var badXml = new StringBuilder();
var nameStr = ElementName.ToString();
var index = nameStr.IndexOf("_raw");
if (index != -1)
{
nameStr = nameStr.Substring(0, index);
BuildNode(badXml, nameStr, PreviousElementValue, false);
}
BuildNode(badXml, ElementName, LastElementValue);
if (reader.ReadToFollowing("message"))
{
var node = WebUtility.HtmlDecode(Document.ReadNode(reader).OuterXml);
badXml.Append(node);
}
throw new XmlDeserializationException($"Could not deserialize value '{s}' as it is not a valid member of type '{type}'. Could not process XML '{badXml}'.");
}
private void updateMethodHeader()
{
//public double getData(){
//public static boolean CustomConversionUpdate2(DataType long arg0) {
string methodHeader = "public";
string staticText = "";
string outputTypeText = "";
string methodNameText = "";
string argumentsText = "(";
staticText = InputTypes.Empty() ? "" : " static";
outputTypeText = " " + OutputType.MinimizedName;
methodNameText = InputTypes.Empty() ? " getData" : " " + ElementName.RemoveAll(" ", "_");
for (int i = 0; i < InputTypes.Count; i++)
{
if (i != 0)
{
argumentsText += ", ";
}
argumentsText += InputTypes[i].MinimizedName + " arg" + i;
}
argumentsText = argumentsText + ")";
methodHeader = methodHeader + staticText + outputTypeText + methodNameText + argumentsText + " {";
tempTbHeader.Text = methodHeader;
}
public IDsmElement AddElement(string name, string type, int?parentId)
{
Logger.LogDataModelMessage($"Add element name={name} type={type} parentId={parentId}");
string fullname = name;
if (parentId.HasValue)
{
if (_elementsById.ContainsKey(parentId.Value))
{
ElementName elementName = new ElementName(_elementsById[parentId.Value].Fullname);
elementName.AddNamePart(name);
fullname = elementName.FullName;
}
}
IDsmElement element = FindElementByFullname(fullname);
if (element == null)
{
_lastElementId++;
element = AddElement(_lastElementId, name, type, 0, false, parentId, false);
}
return(element);
}
public IsotopeInfo(ElementName elementName, int protons, int neutrons, IsotopeStability stability)
{
ElementName = elementName;
Protons = protons;
Neutrons = neutrons;
Stability = stability;
}
public GameElement(ElementName type, int x, int y)
{
Nom = type;
posX = x;
posY = y;
this.Height = 10;
this.Width = 10;
}
public void WhenElementNameIsConstructedWithNoArgumentThenItsHasOneNamePartWhichIsAnEmptyString()
{
ElementName elementName = new ElementName();
Assert.AreEqual("", elementName.FullName);
Assert.AreEqual("", elementName.ParentName);
Assert.AreEqual("", elementName.LastNamePart);
Assert.AreEqual(1, elementName.NamePartCount);
}
public int[,] GenerateRandom(int hauteur, int largeur, int nbChangeDir)
{
ElementName[,] tab = new ElementName[hauteur, largeur];
Point2D debut = GenererCaseStartEnd(tab, hauteur, largeur);
tab[debut.y, debut.x] = ElementName.Start;
GenererCheminAvecObjectif(tab, debut, nbChangeDir, hauteur, largeur);
GenererObstacle(tab, (int)((hauteur*largeur*15)/100), hauteur, largeur);
return ConvertTabInt (tab, hauteur, largeur);
}
public static Atom FromStableIsotope(ElementName element)
{
var isotope = IsotopeTable.GetStableIsotopeOf(element).FirstOrDefault();
if (isotope == null)
{
throw new ChemistryException($"No stable isotope known for {element}");
}
return(new Atom(isotope.Protons, isotope.Neutrons));
}
public override int GetHashCode()
{
unchecked
{
int hash = 17;
hash = hash * 23 + (ElementName != null ? ElementName.GetHashCode() : 0);
hash = hash * 23 + (Value != null ? Value.GetHashCode() : 0);
return(hash);
}
}
/// <summary>
/// Constructor for MathML.
/// </summary>
internal StackNode(ElementName elementName, T node, string popName, bool markAsIntegrationPoint)
{
this.flags = PrepareMathFlags(elementName.Flags, markAsIntegrationPoint);
this.name = elementName.name;
this.popName = popName;
this.ns = "http://www.w3.org/1998/Math/MathML";
this.node = node;
this.attributes = null;
this.refcount = 1;
}
/// <summary>
/// Short hand for well-known HTML elements.
/// </summary>
internal StackNode(ElementName elementName, T node)
{
this.flags = elementName.Flags;
this.name = elementName.name;
this.popName = elementName.name;
this.ns = "http://www.w3.org/1999/xhtml";
this.node = node;
this.attributes = null;
this.refcount = 1;
}
/// <summary>
/// Constructor for SVG elements. Note that the order of the arguments is
/// what distinguishes this from the HTML constructor. This is ugly, but
/// AFAICT the least disruptive way to make this work with Java's generics
/// and without unnecessary branches. :-(
/// </summary>
internal StackNode(ElementName elementName, string popName, T node)
{
this.flags = PrepareSvgFlags(elementName.Flags);
this.name = elementName.name;
this.popName = popName;
this.ns = "http://www.w3.org/2000/svg";
this.node = node;
this.attributes = null;
this.refcount = 1;
}
public static string LanguageResource(ElementName element)
{
var resource = LanguageResources.TextResources.FirstOrDefault(f => f.ElementName == element && f.LanguageId == SelectedLanguage.ID).ToString();
if (resource == null)
{
resource = LanguageResources.TextResources.FirstOrDefault(f => f.ElementName == element && f.LanguageId == 1).ToString();
}
return(resource);
}
public void GivenAnEmptyElementNameWhenAddPartIsCalledThenItsHasOneNamePart()
{
ElementName elementName = new ElementName();
elementName.AddNamePart("a");
Assert.AreEqual("a", elementName.FullName);
Assert.AreEqual("", elementName.ParentName);
Assert.AreEqual("a", elementName.LastNamePart);
Assert.AreEqual(1, elementName.NamePartCount);
Assert.AreEqual("a", elementName.NameParts[0]);
}
public override int GetHashCode()
{
int hashCode = 7443; // "large" prime to start the seed
// Bitshifting and subtracting once is an efficient way to multiply by our second "large" prime, 0x7ffff = 524287
hashCode = (hashCode << 19) - hashCode + (RootNamespace?.GetHashCode() ?? 0);
hashCode = (hashCode << 19) - hashCode + ElementName.GetHashCode();
hashCode = (hashCode << 19) - hashCode + ElementType.GetHashCode();
return(hashCode);
}
public void WhenElementNameIsConstructedWithTwoArgumentsThenItsHasTheJoinedMultipleNameParts()
{
ElementName elementName = new ElementName("a.b", "c");
Assert.AreEqual("a.b.c", elementName.FullName);
Assert.AreEqual("a.b", elementName.ParentName);
Assert.AreEqual("c", elementName.LastNamePart);
Assert.AreEqual(3, elementName.NamePartCount);
Assert.AreEqual("a", elementName.NameParts[0]);
Assert.AreEqual("b", elementName.NameParts[1]);
Assert.AreEqual("c", elementName.NameParts[2]);
}
public void GivenFilledElementNameWhenAddPartIsCalledThenItsHasOneAdditionalNamePart()
{
ElementName elementName = new ElementName("a.b");
elementName.AddNamePart("c");
Assert.AreEqual("a.b.c", elementName.FullName);
Assert.AreEqual("a.b", elementName.ParentName);
Assert.AreEqual("c", elementName.LastNamePart);
Assert.AreEqual(3, elementName.NamePartCount);
Assert.AreEqual("a", elementName.NameParts[0]);
Assert.AreEqual("b", elementName.NameParts[1]);
Assert.AreEqual("c", elementName.NameParts[2]);
}
public GameElement (ElementName type, int x, int y)
{
this.Nom = type;
this.Location= new System.Drawing.Point(x, y);
this.PosX = x;
this.PosY = y;
this.Height = 10;
this.Width = 10;
if (type == ElementName.SNAKEBODY) { this.Image = global::Project_Snake.Properties.Resources.snake_corps; }
else if (type == ElementName.SNAKEHEAD) { this.Image = global::Project_Snake.Properties.Resources.snake_tete; }
else if (type == ElementName.WALL) { this.Image = global::Project_Snake.Properties.Resources.mur; }
else if (type == ElementName.FRUIT) { this.Image = global::Project_Snake.Properties.Resources.fruit; }
this.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage;
}
protected override void OnPreRender(EventArgs e)
{
if (!String.IsNullOrWhiteSpace(Html))
{
if (!Paragraphs)
{
Html = Regex.Replace(Html, "(<p>|<p [^>]*>|</p>|<br />)", String.Empty);
}
var htmlToRender = new StringBuilder();
if (!String.IsNullOrEmpty(this.ElementName))
{
// GS Fix: The Umbraco RTE puts P tags around content automatically, so adding a P tag here will produce an empty tag instead of wrapping the content.
// Therefore, if ElementName is "p", remove the surrounding P tag from the content first.
if (ElementName.ToLowerInvariant() == "p")
{
Html = umbraco.library.RemoveFirstParagraphTag(Html);
}
htmlToRender.Append("<").Append(ElementName.ToLowerInvariant());
// GS Fix: Should be testing for "Not" empty
if (!String.IsNullOrEmpty(ID))
{
htmlToRender.Append(" id=\"").Append(ID).Append("\"");
}
if (!String.IsNullOrEmpty(CssClass))
{
htmlToRender.Append(" class=\"").Append(CssClass).Append("\"");
}
htmlToRender.Append(">");
}
htmlToRender.Append(Html);
if (!String.IsNullOrEmpty(this.ElementName))
{
htmlToRender.Append("</").Append(ElementName.ToLowerInvariant()).Append(">");
}
Controls.Add(new LiteralControl(htmlToRender.ToString()));
}
base.OnPreRender(e);
}
/// <summary>
/// The common-case HTML constructor.
/// </summary>
internal StackNode(ElementName elementName, T node, [Local] string popName
// [NOCPP[
, TaintableLocator locator
// ]NOCPP]
)
{
this.flags = elementName.Flags;
this.name = elementName.name;
this.popName = popName;
this.ns = "http://www.w3.org/1999/xhtml";
this.node = node;
this.attributes = null;
this.refcount = 1;
// [NOCPP[
this.locator = locator;
// ]NOCPP]
}
/// <summary>
/// Constructor for SVG elements. Note that the order of the arguments is
/// what distinguishes this from the HTML constructor. This is ugly, but
/// AFAICT the least disruptive way to make this work with Java's generics
/// and without unnecessary branches. :-(
/// </summary>
internal StackNode(ElementName elementName, [Local] string popName, T node
// [NOCPP[
, TaintableLocator locator
// ]NOCPP]
)
{
this.flags = PrepareSvgFlags(elementName.Flags);
this.name = elementName.name;
this.popName = popName;
this.ns = "http://www.w3.org/2000/svg";
this.node = node;
this.attributes = null;
this.refcount = 1;
// [NOCPP[
this.locator = locator;
// ]NOCPP]
}
/// <summary>
/// Constructor for HTML formatting elements.
/// </summary>
internal StackNode(ElementName elementName, T node, HtmlAttributes attributes
// [NOCPP[
, TaintableLocator locator
// ]NOCPP]
)
{
this.flags = elementName.Flags;
this.name = elementName.name;
this.popName = elementName.name;
this.ns = "http://www.w3.org/1999/xhtml";
this.node = node;
this.attributes = attributes;
this.refcount = 1;
Debug.Assert(!elementName.IsCustom, "Don't use this constructor for custom elements.");
// [NOCPP[
this.locator = locator;
// ]NOCPP]
}
/// <summary>
/// Constructor for MathML.
/// </summary>
internal StackNode(ElementName elementName, T node, [Local] string popName,
bool markAsIntegrationPoint
// [NOCPP[
, TaintableLocator locator
// ]NOCPP]
)
{
this.flags = PrepareMathFlags(elementName.Flags, markAsIntegrationPoint);
this.name = elementName.name;
this.popName = popName;
this.ns = "http://www.w3.org/1998/Math/MathML";
this.node = node;
this.attributes = null;
this.refcount = 1;
// [NOCPP[
this.locator = locator;
// ]NOCPP]
}
private TransformationNodeClass GenerateClassAsTransformation()
{
string javaFreandlyName = ElementName.RemoveAll(" ", "_");
string description = Description;
string mainClass = PackageName + "." + javaFreandlyName;
string creator = Environment.UserName;
string[] neededOtherClasses = new string[0];
INeedsExtra[] neededExtras = new INeedsExtra[0];
ConfigElement[] config = new ConfigElement[0];
ProxyProperty[] proxyProperties = new ProxyProperty[0];
string methodName = javaFreandlyName;
bool isStatic = true;
return(new TransformationNodeClass(javaFreandlyName, ElementName, description, creator, OutputType, InputTypes.ToArray(),
mainClass, neededOtherClasses, neededExtras, config, proxyProperties, true, Path.Combine(WorkSpace.DIR, WorkSpace.CREATED_DIR, javaFreandlyName),
methodName, isStatic));
}
public void HandleElement(XElement ancestor)
{
if (ancestor == null)
{
throw new ArgumentNullException("ancestor");
}
if (!ElementName.Equals(ancestor.Name.LocalName, StringComparison.OrdinalIgnoreCase))
{
throw new XmlConfigurationException(ancestor, "Unexpected element '{0}' (expecting '{1}').",
ancestor.Name.LocalName, ElementName);
}
IList <T> result = new List <T>();
foreach (XElement element in ancestor.Elements())
{
string typeName = element.Name.LocalName;
if (!_collector.Value.Contains(typeName))
{
throw new XmlConfigurationException(element, "Unknown element");
}
ConfigurationTypeInfo typeInfo = _collector.Value.GetTypeInfo(typeName);
IConfigurationData <T> data = typeInfo.CreateInstance <IConfigurationData <T> >();
var attributes = element.Attributes().Select(x => new KeyValuePair <string, string>(x.Name.LocalName, x.Value));
var subelements = element.Elements().Select(x => new KeyValuePair <string, string>(x.Name.LocalName, x.Value));
foreach (var kv in attributes.Concat(subelements))
{
SetPropertyValue(element, typeInfo, data, kv.Key, kv.Value);
}
T item = data.CreateObject();
string id = GetItemId(item);
if (_items.ContainsKey(id))
{
throw new XmlConfigurationException(element, "Duplicate item (id '{0}') found.", id);
}
_items.Add(id, item);
}
}
private DataSourceNodeClass GenerateClassAsDataSource()
{
string javaFreandlyName = ElementName.RemoveAll(" ", "_");
string description = Description;
string mainClass = PackageName + "." + javaFreandlyName;
string creator = Environment.UserName;
string[] neededOtherClasses = new string[0];
INeedsExtra[] neededExtras = new INeedsExtra[0];
ConfigElement[] config = new ConfigElement[0];
ProxyProperty[] proxyProperties = new ProxyProperty[0];
string dataMethod = "getData";
string startMethod = "start";
string stopMethod = "stop";
return(new DataSourceNodeClass(javaFreandlyName, ElementName, description, creator, OutputType,
mainClass, neededOtherClasses, neededExtras, config, proxyProperties, true, Path.Combine(WorkSpace.DIR, WorkSpace.CREATED_DIR, javaFreandlyName),
dataMethod, startMethod, stopMethod));
}
private void ImportDsiElement(IDsiElement dsiElement)
{
IDsmElement parent = null;
ElementName elementName = new ElementName();
foreach (string name in new ElementName(dsiElement.Name).NameParts)
{
elementName.AddNamePart(name);
bool isElementLeaf = (dsiElement.Name == elementName.FullName);
string elementType = isElementLeaf ? dsiElement.Type : "";
IDsmElement element = _importPolicy.ImportElement(elementName.FullName, name, elementType, parent);
parent = element;
if (isElementLeaf)
{
_dsiToDsmMapping[dsiElement.Id] = element.Id;
}
}
}
internal static void parseStream(InputStream input, SimpleSaxHandler handler)
{
var reader = XmlReader.Create(input.Stream);
while (reader.Read())
{
switch (reader.NodeType)
{
case XmlNodeType.Element:
var name = new ElementName(reader.NamespaceURI, reader.LocalName);
var attributes = new HashMap <ElementName, string>();
var isEmpty = reader.IsEmptyElement;
for (int attributeIndex = 0; attributeIndex < reader.AttributeCount; attributeIndex++)
{
reader.MoveToAttribute(attributeIndex);
attributes.put(new ElementName(reader.NamespaceURI, reader.LocalName), reader.Value);
}
handler.startElement(name, attributes);
if (isEmpty)
{
handler.endElement();
}
break;
case XmlNodeType.CDATA:
case XmlNodeType.Text:
case XmlNodeType.SignificantWhitespace:
handler.characters(reader.Value);
break;
case XmlNodeType.EntityReference:
throw new System.NotImplementedException();
case XmlNodeType.EndElement:
handler.endElement();
break;
}
}
}
private Point2D DrawCheminNord(ElementName[,] tab, Point2D pos, int distance)
{
for (int i = pos.y - 1; i >= pos.y - distance; i--)
{
tab [i, pos.x] = ElementName.Chemin;
currentChemin.Add(new Point2D(pos.x, i));
}
return new Point2D(pos.x, pos.y - distance);
}
void TreeBuilder_OnStartTag(ElementName eltName, HtmlAttributes attributes, bool selfClosing)
{
GlobalLog.Write(string.Format("Start tag {0} with {1} attributes, selfClosing <{2}>", eltName.name, attributes.Length, selfClosing), "TreeBulder");
}
void TreeBuilder_OnEndTag(ElementName eltName)
{
GlobalLog.Write(string.Format("End tag: {0}", eltName.name), "TreeBulder");
}
private Point2D DrawChemin(ElementName[,] tab, Point2D pos, string direction, int distance)
{
currentChemin = new List<Point2D>();
switch (direction)
{
case "O":
return DrawCheminOuest(tab, pos, distance);
case "N":
return DrawCheminNord(tab, pos, distance);
case "E":
return DrawCheminEst(tab, pos, distance);
case "S":
return DrawCheminSud(tab, pos, distance);
}
return pos;
}
private int[,] ConvertTabInt(ElementName[,] tab, int hauteur, int largeur)
{
int[,] newTab = new int[hauteur, largeur];
for (int i = 0; i<hauteur; i++)
{
for(int j=0; j<largeur; j++)
{
switch(tab[i,j])
{
case ElementName.Vide:
newTab[i,j] = -1;
break;
case ElementName.Orientation:
newTab[i,j] = -1;//-1
break;
case ElementName.Chemin:
newTab[i,j] = -4;//-1
break;
case ElementName.Start:
newTab[i,j] = 0;
break;
case ElementName.End:
newTab[i,j] = 1;
break;
case ElementName.Obstacle:
newTab[i,j] = 2;
break;
case ElementName.Objectif:
newTab[i,j] = 3;
break;
default:
newTab[i,j] = -1;
break;
}
}
}
return newTab;
}
private Point2D DrawCheminSud(ElementName[,] tab, Point2D pos, int distance)
{
for (int i = pos.y + 1; i <= pos.y + distance; i++)
{
tab [i, pos.x] = ElementName.Chemin;
currentChemin.Add(new Point2D(pos.x, i));
}
return new Point2D(pos.x, pos.y + distance);
}
private Point2D DrawCheminOuest(ElementName[,] tab, Point2D pos, int distance)
{
for (int i = pos.x - 1; i >= pos.x - distance; i--)
{
tab [pos.y, i] = ElementName.Chemin;
currentChemin.Add(new Point2D(i, pos.y));
}
return new Point2D(pos.x - distance, pos.y);
}
private Point2D GenererCaseStartEnd(ElementName[,] tab, int hauteur, int largeur, Point2D end = null)
{
int posxStart, posyStart, posxEnd, posyEnd;
posyStart = Random.Range(0, hauteur);
posxStart = Random.Range(0, largeur);
tab[posyStart, posxStart] = ElementName.Start;
do
{
posyEnd = Random.Range(0, hauteur);
posxEnd = Random.Range(0, largeur);
}
while(posyEnd == posyStart && posxStart == posxEnd);
//tab[posyEnd, posxEnd] = ElementName.Red;
if (end != null)
{
end.x = posxEnd;
end.y = posyEnd;
}
return new Point2D(posxStart, posyStart);
}
private bool VerifDistance(ElementName[,] tab, Point2D pos, string direction, int distance, int chDirection)
{
if (distance == 1)
{
nbCheminNul++;
if(nbCheminNul>chDirection/4)
return false;
}
switch (direction)
{
case "O":
if (tab[pos.y, pos.x - distance] != ElementName.Vide)// && tab[pos.y, pos.x - distance] != ElementName.Chemin)
return false;
break;
case "N":
if (tab[pos.y - distance, pos.x] != ElementName.Vide)// && tab[pos.y - distance, pos.x] != ElementName.Chemin)
return false;
break;
case "E":
if (tab[pos.y, pos.x + distance] != ElementName.Vide)// && tab[pos.y, pos.x + distance] != ElementName.Chemin)
return false;
break;
case "S":
if (tab[pos.y + distance, pos.x] != ElementName.Vide)// && tab[pos.y + distance, pos.x] != ElementName.Chemin)
return false;
break;
}
return true;
}
private void GenererObstacle(ElementName[,] tab, int nbObstacle, int hauteur, int largeur)
{
int compteur = 0;
while (compteur < nbObstacle)
{
Point2D posObs = new Point2D(0, 0);
posObs.x = Random.Range(0, largeur);
posObs.y = Random.Range(0, hauteur);
if (tab[posObs.y, posObs.x] != ElementName.Vide)
continue;
tab[posObs.y, posObs.x] = ElementName.Obstacle;
compteur++;
}
}
private void GenererObjectifOnCurrentChemin(ElementName[,] tab)
{
if (currentChemin.Count < 1)
return;
int value = Random.Range (0, 4);
if (value == 3 && !cheminSansObjectif)
{
cheminSansObjectif = true;
return;
}
int nbObjectif = 1;
if (currentChemin.Count > 4)
nbObjectif += (int)((currentChemin.Count - 5) / 4);
int securite=0;
while (nbObjectif>0)
{
if(securite++ >20)
{
Debug.LogError ("Securité a pris la main!");
return;
}
value = Random.Range (0, currentChemin.Count-1);
if(tab[currentChemin[value].y, currentChemin[value].x] != ElementName.Chemin)
continue;
tab[currentChemin[value].y, currentChemin[value].x] = ElementName.Objectif;
nbObjectif--;
}
}
private void GenererCheminAvecObjectif(ElementName[,] tab, Point2D posDepart, int nbChangementDirection, int hauteur, int largeur)
{
Point2D pos = new Point2D(posDepart.x, posDepart.y);
int distance, compteurSecurite;
string direction, currentDir = "E";
for (int i = 0; i <= nbChangementDirection; i++)
{
compteurSecurite = 0;
do
{
compteurSecurite++;
direction = ChoisirDirection(currentDir);
distance = DefinirDistance(pos, direction, hauteur, largeur);
if (compteurSecurite >= 40) break;
}
while (!VerifDirection(direction, pos, hauteur, largeur) || !VerifDistance(tab, pos, direction, distance, nbChangementDirection));
if (compteurSecurite >= 40) continue;
currentDir = direction;
AjouterDirection(currentDir);
pos = DrawChemin(tab, pos, direction, distance);
GenererObjectifOnCurrentChemin(tab);
tab[pos.y, pos.x] = ElementName.Orientation;
}
tab[pos.y, pos.x] = ElementName.End;
listActions.Remove (listActions [0]);//On supprime le premier qui n'est pas une direction mais le sens de depart du joueur
}
