public void SetState()
{
StateLocation loc = Locations.Find(x => x.state == NewGameState);
bigfoot.transform.position = loc.transform.position;
updateObj.ChangeState(NewGameState);
if (updateObj.CurrentObjective != GameState.FindClothes)
{
disguiseManager.PickUpDisguise(DisguiseTypes.Hunter);
}
else
{
disguiseManager.LoseDisguise();
}
if (updateObj.CurrentObjective > GameState.GoToDriverAfterSpeech)
{
speechNPC.CanBeInteractedWith = false;
}
else
{
speechNPC.CanBeInteractedWith = true;
}
}
public int AddOpenNode(TState val, int hash, double g, double h, int parent = kTBDNoNode,
StateLocation whichQueue = StateLocation.OpenWaiting)
{
// should do lookup here...
if (_table.ContainsKey(hash))
{
throw new InvalidOperationException("Cannot add the same open node twice");
}
if (whichQueue == StateLocation.OpenReady)
{
_elements.Add(new BDOpenClosedData <TState>(val, g, h, parent,
_priorityQueues[0].Count, StateLocation.OpenReady));
}
else if (whichQueue == StateLocation.OpenWaiting)
{
_elements.Add(new BDOpenClosedData <TState>(val, g, h, parent,
_priorityQueues[1].Count, StateLocation.OpenWaiting));
}
if (parent == kTBDNoNode)
{
_elements.Last().ParentID = _elements.Count - 1;
}
_table[hash] = _elements.Count - 1; // hashing to element list location
_priorityQueues[(int)whichQueue].Add(_elements.Count - 1);
HeapifyUp(_priorityQueues[(int)whichQueue].Count - 1, (int)whichQueue);
return(_elements.Count - 1);
}
public StateLocationModel(StateLocation location)
{
Building = location.Building;
Address1 = location.Address_Line_1;
Address2 = location.Address_Line_2;
City = location.City;
Zipcode = location.Zipcode.GetValueOrDefault().ToString();
}
public BDOpenClosedData(TState theData, double gCost, double hCost, int parent, int openLoc, StateLocation location)
{
Data = theData;
G = gCost;
H = hCost;
ParentID = parent;
OpenLocation = openLoc;
Where = location;
Reopened = false;
}
public double GetNodeBackwardG(TState s)
{
StateLocation l = _queue.BackwardQueue.Lookup(_getStateHash(s), out int childID);
if (l != StateLocation.Unseen)
{
return(_queue.BackwardQueue.Lookat(childID).G);
}
return(-1);
}
public BDOpenClosedData <TState> PeekAt(StateLocation whichQueue)
{
if (whichQueue == StateLocation.OpenReady)
{
if (OpenReadySize() == 0)
{
throw new InvalidOperationException("cannot peek at empty ready queue");
}
}
else if (whichQueue == StateLocation.OpenWaiting)
{
if (OpenWaitingSize() == 0)
{
throw new InvalidOperationException("cannot peek at empty waiting queue");
}
}
return(_elements[_priorityQueues[(int)whichQueue][0]]);
}
public int Peek(StateLocation whichQueue)
{
if (whichQueue == StateLocation.OpenReady)
{
if (OpenReadySize() == 0)
{
throw new InvalidOperationException("cannot peek at empty ready queue");
}
}
else if (whichQueue == StateLocation.OpenWaiting)
{
if (OpenWaitingSize() == 0)
{
throw new InvalidOperationException("cannot peek at empty waiting queue");
}
}
return(_priorityQueues[(int)whichQueue][0]);
}
public int GetDoubleExpansions()
{
int doubles = 0;
for (int x = 0; x < _queue.ForwardQueue.Size(); x++)
{
int key;
BDOpenClosedData <TState> data = _queue.ForwardQueue.Lookat(x);
if (data.Where == StateLocation.Closed)
{
StateLocation loc = _queue.BackwardQueue.Lookup(_getStateHash(data.Data), out key);
if (loc == StateLocation.Closed)
{
doubles++;
}
}
}
return(doubles);
}
public int GetOpenItem(int which, StateLocation where)
{
return(_priorityQueues[(int)where][which]);
}
private void Expand(int nextID, BDOpenClosed <TState> current,
BDOpenClosed <TState> opposite, HCost <TState> heuristic, TState target)
{
current.Close();
//this can happen when we expand a single node instead of a pair
if (FPUtil.GreaterEq(current.Lookup(nextID).G + current.Lookup(nextID).H, _currentCost))
{
return;
}
_nodesExpanded++;
IEnumerable <TState> neighbors = _getSuccessors(current.Lookup(nextID).Data);
foreach (TState succ in neighbors)
{
_nodesTouched++;
StateLocation loc = current.Lookup(_getStateHash(succ), out int childID);
// screening
double edgeCost = _gCost(current.Lookup(nextID).Data, succ);
if (FPUtil.GreaterEq(current.Lookup(nextID).G + edgeCost, _currentCost))
{
continue;
}
switch (loc)
{
case StateLocation.Closed: // ignore
break;
case StateLocation.OpenReady: // update cost if needed
case StateLocation.OpenWaiting:
{
if (FPUtil.Less(current.Lookup(nextID).G + edgeCost, current.Lookup(childID).G))
{
double oldGCost = current.Lookup(childID).G;
current.Lookup(childID).ParentID = nextID;
current.Lookup(childID).G = current.Lookup(nextID).G + edgeCost;
current.KeyChanged(childID);
StateLocation loc2 = opposite.Lookup(_getStateHash(succ), out int reverseLoc);
if (loc2 == StateLocation.OpenReady || loc2 == StateLocation.OpenWaiting)
{
if (FPUtil.Less(current.Lookup(nextID).G + edgeCost + opposite.Lookup(reverseLoc).G, _currentCost))
{
_currentCost = current.Lookup(nextID).G + edgeCost + opposite.Lookup(reverseLoc).G;
_middleNode = succ;
}
}
else if (loc == StateLocation.Closed)
{
current.Remove(childID);
}
}
}
break;
case StateLocation.Unseen:
{
StateLocation locReverse = opposite.Lookup(_getStateHash(succ), out int reverseLoc);
if (locReverse != StateLocation.Closed)
{
double newNodeF = current.Lookup(nextID).G + edgeCost + heuristic(succ, target);
if (FPUtil.Less(newNodeF, _currentCost))
{
if (FPUtil.Less(newNodeF, _queue.GetLowerBound()))
{
current.AddOpenNode(succ,
_getStateHash(succ),
current.Lookup(nextID).G + edgeCost,
heuristic(succ, target),
nextID, StateLocation.OpenReady);
}
else
{
current.AddOpenNode(succ,
_getStateHash(succ),
current.Lookup(nextID).G + edgeCost,
heuristic(succ, target),
nextID, StateLocation.OpenWaiting);
}
if (locReverse == StateLocation.OpenReady || locReverse == StateLocation.OpenWaiting)
{
if (FPUtil.Less(current.Lookup(nextID).G + edgeCost + opposite.Lookup(reverseLoc).G, _currentCost))
{
_currentCost = current.Lookup(nextID).G + edgeCost + opposite.Lookup(reverseLoc).G;
_middleNode = succ;
}
}
}
}
}
break;
}
}
}
