/// <summary>
/// Создает новый дочерний узел для текущего узла
/// </summary>
/// <param name="value">Числовое значение текущего узла</param>
/// <returns>Новый узел</returns>
public TreeNode CreateNext(int value)
{
TreeNode node = new TreeNode(value);
Next.Add(node);
return(node);
}
public void Add(int?value)
{
if (_value == null)
{
_value = value;
return;
}
else if (_value > value)
{
var newItem = new LinkedListNode(value)
{
Previous = Previous,
Next = this
};
if (Previous != null)
{
Previous.Next = newItem;
}
Previous = newItem;
return;
//We place the new Node before this one
}
if (Next == null)
{
Next = new LinkedListNode
{
Previous = this
};
}
;
Next.Add(value);
}
public void AddNextKeyword(StreamizKeyword n)
{
if (!Next.Contains(n))
{
Next.Add(n);
}
}
public void Add(ElementType Data)
{
if (Element.CompareTo(Data) == 0)
{
if (Next == null)
{
Next = new DoubleLinkedList <ElementType>(Data);
Next.Previous = this;
}
else
{
DoubleLinkedList <ElementType> temp = new DoubleLinkedList <ElementType>(Data);
temp.Next = Next;
temp.Previous = this;
Next.Previous = temp;
Next = temp;
}
}
else if (Element.CompareTo(Data) > 0)
{
if (Previous == null)
{
Previous = new DoubleLinkedList <ElementType>(Data);
Previous.Next = this;
}
else if (Previous.Element.CompareTo(Data) > 0)
{
Previous.Add(Data);
}
else
{
DoubleLinkedList <ElementType> temp = new DoubleLinkedList <ElementType>(Data);
temp.Next = this;
temp.Previous = Previous;
Previous.Next = temp;
Previous = temp;
}
}
else
{
if (Next == null)
{
Next = new DoubleLinkedList <ElementType>(Data);
Next.Previous = this;
}
else if (Next.Element.CompareTo(Data) < 0)
{
Next.Add(Data);
}
else
{
DoubleLinkedList <ElementType> temp = new DoubleLinkedList <ElementType>(Data);
temp.Next = Next;
temp.Previous = this;
Next.Previous = temp;
this.Next = temp;
}
}
}
public void AddNext(int nextId)
{
if (Next == null)
{
Next = new List <int>();
}
Next.Add(nextId);
}
public void Add(T node)
{
if (Next == null)
{
Next = new LinkSetCollection <T>(this);
}
Next.Add(node);
}
public void AddNext(List <T> next)
{
for (int i = 0; i < next.Count; i++)
{
if (!Next.Contains(next[i]))
{
Next.Add(next[i]);
}
}
}
public void AddNext(params T[] next)
{
for (int i = 0; i < next.Length; i++)
{
if (!Next.Contains(next[i]))
{
Next.Add(next[i]);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="t"></param>
public void Add(T t)
{
if (Next == null)
{
Next = t;
}
else
{
Next.Add(t);
}
}
public MashupElement(string stereotype, IList <MashupElement> nextElements, IList <string> nextNames) : this(stereotype)
{
foreach (MashupElement e in nextElements)
{
Next.Add(e);
}
foreach (string e in nextNames)
{
NextNames.Add(e);
}
}
public void AddNode(PhraseNode node)
{
var nodeWithSameWord = Next.FirstOrDefault(n => n.BaseWord == node.BaseWord);
if (nodeWithSameWord == null)
{
Next.Add(node);
}
else
{
MergeNodes(nodeWithSameWord, node);
}
}
public void Add(T data, Node <T> headNode)
{
if (Next == null)
{
Next = new Node <T>(data)
{
Previous = headNode
};
}
else
{
Next.Add(data, Next);
}
}
public void Add(T value, T nextTo = default)
{
if (Value == null)
{
Value = value;
}
else if (Value.Equals(nextTo) || Next == null)
{
Next = new Item <T>(value, Next);
}
else
{
Next.Add(value, nextTo);
}
}
public void Add(VaccAssigner newPerson)
{
if (Next is null)
{
Next = newPerson;
return;
}
if (Next.VacCat.CompareTo(newPerson.VacCat) > 0)
{
var temp = Next;
Next = newPerson;
Next.Next = temp;
return;
}
Next.Add(newPerson);
}
public void Add(T item, IDoublyLinkedList <T> caller = null)
{
if (caller == null)
{
caller = this;
}
if (Node == null)
{
Node = item;
Next = new DoublyLinkedList <T>();
Previous = caller;
}
else
{
Next.Add(item, caller);
}
}
public new void Add(TComparableKey key, TItem value)
{
// todo: remeber to apply the IsFit Optimization
base.Add(key, value);
if (Count <= _sizeLimit)
{
return;
}
if (Next == null)
{
Next = new SortedBucket <TComparableKey, TItem>(_sizeLimit, _sortMode);
}
var lastIndex = Count - 1;
var lastItem = this.Last().Value;
var lastKey = Keys.Last();
RemoveAt(lastIndex);
Next.Add(lastKey, lastItem);
Next.Previous = this;
}
public List <TreeNode> AddNext(TreeNode _newNode)
{
// Add new Node to "next" field
Next.Add(_newNode);
return(Next);
}
// Metoda, ve které se uskutečňuje pohyb agenta po hracím poli
public void PohybujSe(int pocetBehu)
{
for (int b = 0; b < pocetBehu; b++)
{
// Pomocné pole pro uložení výsledku posunu agenta ve třídě POZICE
int[] report_pomocna = new int[4];
// Do tohoto pole si uložím možné směry agenta, které zjišťuji v metodě expandujVrcholy
int[] expanduj_pomocna = ExpandujVrcholy(agent.AktPozice[0], agent.AktPozice[1]);
// Směr je nejprve na sever, protože směry v expanduj_pomocna jsou uloženy od severu
int smer = 0;
// Projdu všechny směry v expanduj_pomocna
foreach (int i in expanduj_pomocna)
{
// Pokud je dany smer povoleny, tedy -- 1, tak se vytvori nova POZICE s hodnotami tohoto policka
if (i == 1)
{
// Prozkoumám pozici daným směrem a získám report se vším potřebným pro vytvoření této pozice
report_pomocna = agent.Pohyb(smer);
// Výpočet heuristické funkce pro danou pozici
// Vstupem je X -- Y -- aktuální cena cesty
int celkovaCena = HeuristickaFunkce(report_pomocna[1], report_pomocna[2], report_pomocna[0]);
// Přidání nalezené pozice do NEXT, tedy budoucích pozicí, kam je možné jít
Next.Add(new Pozice(IDVrcholu, report_pomocna[0], report_pomocna[1], report_pomocna[2], report_pomocna[3], celkovaCena));
// Zvýším ID, aby další vrchol měl jedičné
IDVrcholu++;
// Porovnám pozice v NEXT podle celkové ceny cesty SESTUPNE
IEnumerable <Pozice> zalozni = Next.OrderBy(a => a.CelkovaCenaCesty);
Next = new List <Pozice>();
// Porovnanou kolekci si uložím z5 do původní, tedy do NEXT
foreach (Pozice p in zalozni)
{
Next.Add(p);
}
}
// Zvýším proměnnou směr, čímž půjdu na směr posunutý o 90°
smer++;
}
// Do prozkoumaných pozic ve STACK si uložím současnou pozici agenta, tedy poslední prozkoumanou
Stack.Add(agent);
// Vezmu první pozici v NEXT, tedy ta s nejnižší celkovou cenou cesty
agent = Next[0];
// Kontrola zda tato nová pozice, která se bude při dalším běhu této metody prozkoumávat není výherní
if (Vyhra(agent.AktPozice[0], agent.AktPozice[1], b))
{
break;
}
// Vykreslím hrací pole, kde pozici agenta znázorňuje prázdná pozice
ZobrazHraciPole(agent.AktPozice[0], agent.AktPozice[1]);
// Smažu pozici, kterou jsem si uložil do agenta z NEXT
Next.RemoveAt(0);
}
Console.WriteLine("\n---------------STACK-----------------\n|X |Y |AktCena|CelkCena");
foreach (Pozice p in Stack)
{
Console.WriteLine(p);
}
Console.WriteLine("\n---------------NEXT-----------------\n|X |Y |AktCena|CelkCena");
foreach (Pozice p in Next)
{
Console.WriteLine(p);
}
Console.WriteLine("\n---------------AGENT-----------------\n|X |Y |AktCena|CelkCena");
Console.WriteLine(agent);
}
public MashupElement(string stereotype, MashupElement nextElement, string nextName) : this(stereotype)
{
Next.Add(nextElement);
NextNames.Add(nextName);
}
public ISinglyLinkedNode <T> Add(InnerNode <T> innerNode)
{
Next = Next.Add(innerNode);
return(this);
}
protected virtual void AddNext(SMElementEditor e)
{
Next.Add(e);
}
//add handle that has transition out of this state
public void AddNext(Handle h)
{
NextElem.AddRange(h.NextElem);
Next.Add(h);
}
