public void TestLimitedFlatPathWriter()
{
var gc = new GlobalContext();
IEnumerable <Dependency> dependencies = new PathMarker().CreateSomeTestDependencies(gc.CurrentGraph);
string result = FindPathsAndWriteFlat(gc, dependencies, "A",
CreateDefaultOptions("A", "{a:}#_(_._{c:}_._:_|_._[^{c:}]_)*", maxPathLength: 4));
Assert.AreEqual(@"-- A0
T3:a:aa:aaa'A0=5+A1=5+A2=5+A3=5 #
T3:b:bb:bbb'A $
T3:c:cc:ccc'A
T3:d:dd:ddd'A $
T3:e:ee:eee'A $
-- A1
T3:a:aa:aaa'A0=5+A1=5+A2=5+A3=5 #
T3:b:bb:bbb'A $
T3:c:cc:ccc'A
T3:d:dd:ddd'A $
<= T3:b:bb:bbb'A $
-- A2
T3:a:aa:aaa'A0=5+A1=5+A2=5+A3=5 #
T3:b:bb:bbb'A $
T3:g:gg:ggg'A $
-- A3
T3:a:aa:aaa'A0=5+A1=5+A2=5+A3=5 #
T3:h:hh:hhh'A $
T3:g:gg:ggg'A $", result.Trim());
}
/*UPGRADE / SWAP OPTIONS
* Path types:
* -------
* Path
* Trail
* Road
* -----
* PathMarker->TrailMarker->RoadMarker
* PathMarker->CrossPath
* TrailMarker->CrossTrail
* RoadMarker->CrossRoad
*/
public override WIListOption GetListOption(IItemOfInterest targetObject)
{
//Debug.Log ("Getting list option for improve path");
WIListOption listOption = base.GetListOption(targetObject);
listOption.Flavors.Clear();
mLastflavors.Clear();
HashSet <string> flavors = new HashSet <string> ();
PathMarker targetPathMarker = null;
if (targetObject.worlditem.Is <PathMarker> (out targetPathMarker))
{
ImprovePathMarker(targetPathMarker, flavors);
}
//keep flavors in the dictionary, we don't know which will be relevant
//it's only move and swap for now but there may be more
int flavorNum = 0;
foreach (string flavor in flavors)
{
//Debug.Log ("Adding flavor " + flavor);
listOption.Flavors.Add(flavor);
mLastflavors.Add(flavorNum, flavor);
flavorNum++;
}
return(listOption);
}
public override bool Use(IItemOfInterest targetObject, int flavorIndex)
{
if (targetObject.IOIType != ItemOfInterestType.WorldItem)
{
return(false);
}
PathMarker pathMarker = null;
if (targetObject.worlditem.Is <PathMarker> (out pathMarker))
{
switch (flavorIndex)
{
case flavorIndexMove:
return(pathMarker.Move());
case flavorIndexRemove:
return(pathMarker.RemoveFromPath());
case flavorIndexAdd:
break;
default:
break;
}
}
return(false);
}
public void SetConnection(PathMarker pathMarker, PathMarker pathOrigin, MarkerAlterAction alterAction, PathSkill skillToUse)
{
ConnectionPathMarker = pathMarker;
ConnectionPathOrigin = pathOrigin;
PathAlterAction = alterAction;
SkillToUse = skillToUse;
}
public void Spawn(Maze maze)
{
// Loop through each maze cell
for (int i = 0; i < maze.width; i++)
{
for (int k = 0; k < maze.height; k++)
{
// Check if neighbor cells are all floors
if (maze.cells[i, k].isFloor &&
maze.cells[i + 1, k].isFloor &&
maze.cells[i - 1, k].isFloor &&
maze.cells[i, k + 1].isFloor &&
maze.cells[i, k - 1].isFloor &&
maze.cells[i + 1, k + 1].isFloor &&
maze.cells[i + 1, k - 1].isFloor &&
maze.cells[i - 1, k + 1].isFloor &&
maze.cells[i - 1, k - 1].isFloor)
{
// Put a path marker on that cell
pathMarker = Instantiate(pathMarkerPrefab) as PathMarker;
pathMarker.transform.parent = transform;
pathMarker.name = "Path marker (" + maze.cells[i, k].transform.localPosition.x + ", " + maze.cells[i, k].transform.localPosition.z + ")";
pathMarker.transform.localPosition = new Vector3(maze.cells[i, k].transform.localPosition.x, 0, maze.cells[i, k].transform.localPosition.z);
// Add path marker to the list
spawnedPathMarker.Add(pathMarker);
}
}
}
}
public void TestSimpleFlatPathWriter()
{
var gc = new GlobalContext();
IEnumerable <Dependency> dependencies = new PathMarker().CreateSomeTestDependencies(gc.CurrentGraph);
string result = FindPathsAndWriteFlat(gc, dependencies, "A",
CreateDefaultOptions("A", "{a:}(.{c:}.:|.[^{c:}])*"));
Assert.AreEqual(@"-- A0
T3:a:aa:aaa'A0+A1+A2+A3
T3:b:bb:bbb $
T3:c:cc:ccc
T3:d:dd:ddd $
T3:e:ee:eee $
T3:f:ff:fff $
-- A1
T3:a:aa:aaa'A0+A1+A2+A3
T3:b:bb:bbb $
T3:c:cc:ccc
T3:d:dd:ddd $
<= T3:b:bb:bbb $
-- A2
T3:a:aa:aaa'A0+A1+A2+A3
T3:b:bb:bbb $
T3:g:gg:ggg $
-- A3
T3:a:aa:aaa'A0+A1+A2+A3
T3:h:hh:hhh $
T3:g:gg:ggg $", result.Trim());
}
private void OnTriggerEnter(Collider other)
{
if (other.gameObject.tag == "PathMarker")
{
target = other.gameObject.GetComponent <PathMarker>().nextMarker;
MoveTo();
}
}
// Start is called before the first frame update
void Start()
{
// figure closest marker to start with
ClosestMarker = PathMarker.FindClosest(gameObject.transform.position);
// queue couple of random paths
var markers = FindObjectsOfType <PathMarker>();
for (int i = 0; i < 5; i++)
{
var marker = markers[Random.Range(0, markers.Length)];
QueueGoToMarker(marker);
Debug.Log($"{i}: {marker.gameObject.name}");
}
}
public void Finish()
{
if (mFinished)
{
return;
}
ConnectionPathMarker = null;
ConnectionPathOrigin = null;
PathAlterAction = MarkerAlterAction.None;
SkillToUse = null;
mFinished = true;
GameObject.Destroy(gameObject);
}
private void GeneratePathMarkers()
{
if (StepsToVisualize == -1)
{
StepsToVisualize = Path.Length;
}
for (int i = 0; i < StepsToVisualize; i++)
{
PathMarker Marker = Instantiate(pathMarker);
Marker.GridManager = this;
Marker.Offset = i + 1;
Marker.OnStep();
}
}
public bool FastTravel(PathMarker startingPathMarker)
{
if (State == FastTravelState.None)
{
if (startingPathMarker.HasPathMarkerProps)
{
OnStartTraveling(startingPathMarker.Props, startingPathMarker.Props.PathName);
State = FastTravelState.ArrivingAtDestination;
}
else
{
Debug.Log("Starting path maker had no properties");
}
}
return(true);
}
private static string FindPathsAndWriteFlat(GlobalContext gc, IEnumerable <Dependency> dependencies,
string markerPrefix, PathMarker.TransformOptions transformOptions)
{
var pm = new PathMarker();
var transformedDependencies = new List <Dependency>();
pm.Transform(gc, Ignore.Om, transformOptions, dependencies, transformedDependencies);
string result;
using (var s = new MemoryStream()) {
var w = new FlatPathWriter();
w.RenderToStreamForUnitTests(gc, transformedDependencies, s, $"{markerPrefix}* -sm");
result = Encoding.ASCII.GetString(s.ToArray());
}
return(result);
}
public override bool Use(IItemOfInterest targetObject, int flavorIndex)
{
PathMarker targetPathMarker = null;
if (targetObject.worlditem.Is <PathMarker> (out targetPathMarker))
{
//now see which flavor we used
string flavorName = "Move";
mLastflavors.TryGetValue(flavorIndex, out flavorName);
switch (flavorName)
{
case "Move":
default:
if (Player.Local.ItemPlacement.ItemCarry(targetPathMarker.worlditem, true))
{
OnSuccess();
return(true);
}
break;
case "Swap":
//this is kind of an odd operation
//we just set the state on the two objects
//and boom! They're swapped
PathMarker equippedPathMarker = null;
bool hasEquippedPathMarker = false;
if (Player.Local.Tool.IsEquipped && Player.Local.Tool.HasWorldItem)
{
if (Player.Local.Tool.worlditem.Is <PathMarker> (out equippedPathMarker))
{
//we're not going to go through the type check song and dance
//we'll just swap assuming it's all correct
string downgradeState = targetPathMarker.worlditem.State;
string upgradeState = equippedPathMarker.worlditem.State;
targetPathMarker.worlditem.State = upgradeState;
equippedPathMarker.worlditem.State = downgradeState;
}
}
break;
}
}
return(false);
}
public override WIListOption GetListOption(IItemOfInterest targetObject)
{
if (targetObject.IOIType != ItemOfInterestType.WorldItem)
{
return(WIListOption.Empty);
}
PathMarker pathMarker = null;
if (!Paths.HasActivePath || !targetObject.worlditem.Is <PathMarker> (out pathMarker))
{
return(WIListOption.Empty);
}
WIListOption listOption = base.GetListOption(targetObject);
List <string> flavors = new List <string> ();
flavors.Add("Remove");
flavors.Add("Move");
listOption.Flavors = flavors;
return(listOption);
}
private void LoadStreets()
{
RemoveStreets();
string strFilename = $"{Tool.StartupPath}\\streets_bw.sqlite";
RectLatLng bb = this.mcMapControl.ViewArea;
//TODO: Check if the area is not to big ... But what is big ?
SQLiteConnectionStringBuilder csbDatabase = new SQLiteConnectionStringBuilder
{
DataSource = strFilename
};
using (SQLiteConnection dbConnection = new SQLiteConnection(csbDatabase.ConnectionString))
{
dbConnection.Open();
try
{
// 0 1 2 3
//const string strSelectStatement = "select highway,ref,name,way from streets_bw where highway in ('motorway','motorway_link','trunk','trunk_link','primary','secondary','primary_link','secondary_link','residential')";
const string strSelectStatement = "select highway,ref,name,way from streets_bw";
uint iCounter = 0;
DateTime dtStart = DateTime.Now;
using (SQLiteCommand dbSelectCommand = new SQLiteCommand(strSelectStatement, dbConnection))
{
using (SQLiteDataReader dbResult = dbSelectCommand.ExecuteReader())
{
while (dbResult.Read())
{
Highway type = Highway.Unknown;
try
{
type = (Highway)Enum.Parse(typeof(Highway), dbResult.GetString(0), true);
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
string strRef = dbResult.GetStringOrNull(1);
string strName = dbResult.GetStringOrNull(2);
LineString way = (LineString)dbResult.GetGeometryFromWKB(3);
if (bb.Contains(way.Coordinate.ToPointLatLng()))
{
List <PointLatLng> list = new List <PointLatLng>(way.Count);
list.AddRange(way.Coordinates.Select(pos => pos.ToPointLatLng()));
this.Dispatcher.Invoke(() =>
{
PathMarker mrWay = new PathMarker(this.mcMapControl, list, type, $"{( strName.IsNotEmpty() ? strName : "Unknown" )}{( strRef.IsNotEmpty() ? $" ({strRef})" : "" )}")
{
Tag = type
};
this.mcMapControl.Markers.Add(mrWay);
});
iCounter++;
}
}
}
}
DateTime dtStop = DateTime.Now;
MB.Information("Load {0} Ways In {1}.", iCounter, (dtStop - dtStart).ToHHMMSSString());
}
catch (Exception ex)
{
MB.Error(ex);
}
finally
{
if (dbConnection.State == ConnectionState.Open)
{
dbConnection.Close();
}
}
}
}
protected void ImprovePathMarker(PathMarker targetPathMarker, HashSet <string> flavors)
{
PathMarker equippedPathMarker = null;
bool hasEquippedPathMarker = false;
if (Player.Local.Tool.IsEquipped && Player.Local.Tool.HasWorldItem)
{
hasEquippedPathMarker = Player.Local.Tool.worlditem.Is <PathMarker> (out equippedPathMarker);
}
switch (targetPathMarker.worlditem.State)
{
case "PathMarker":
flavors.Add("Move");
if (hasEquippedPathMarker)
{
switch (equippedPathMarker.worlditem.State)
{
case "CrossPath":
case "TrailMarker":
//Debug.Log ("Cross path is path marker, can upgrade");
flavors.Add("Swap");
break;
default:
break;
}
}
break;
case "CrossPath":
flavors.Add("Move");
if (hasEquippedPathMarker)
{
switch (equippedPathMarker.worlditem.State)
{
case "TrailMarker":
case "CrossTrail":
flavors.Add("Swap");
break;
default:
break;
}
}
break;
case "TrailMarker":
flavors.Add("Move");
if (hasEquippedPathMarker)
{
switch (equippedPathMarker.worlditem.State)
{
case "RoadMarker":
case "CrossTrail":
flavors.Add("Swap");
break;
default:
break;
}
}
break;
case "RoadMarker":
if (hasEquippedPathMarker)
{
switch (equippedPathMarker.worlditem.State)
{
case "CrossRoad":
flavors.Add("Swap");
break;
default:
break;
}
}
break;
default:
break;
}
}
public void Awake()
{
pathMarker = (PathMarker)target;
}
/**
* Will tell the crew member to go to the given marker
* this takes the path marking into account
*/
public void QueueGoToMarker(PathMarker target)
{
QueueTask(new CrewMovementTask(target));
}
