public void RefreshMovementRangeProjection(HashSet <EnvironmentNode> nodes, EnvironmentNode center)
{
int xMin = int.MaxValue, xMax = int.MinValue, yMin = int.MaxValue, yMax = int.MinValue;
int temp;
foreach (EnvironmentNode n in nodes)
{
temp = n.indexPosition.x - center.indexPosition.x;
xMin = Mathf.Min(xMin, temp);
xMax = Mathf.Max(xMax, temp);
temp = n.indexPosition.y - center.indexPosition.y;
yMin = Mathf.Min(yMin, temp);
yMax = Mathf.Max(yMax, temp);
}
Vector2Int movementRangeInTiles = new Vector2Int(Mathf.Max(-xMin, xMax), Mathf.Max(-yMin, yMax));
Vector2Int delta = movementRangeInTiles - center.indexPosition;
bool[,] b = new bool[movementRangeInTiles.x * 2 + 1, movementRangeInTiles.y * 2 + 1];
foreach (EnvironmentNode v in nodes)
{
b[v.indexPosition.x + delta.x, v.indexPosition.y + delta.y] = true;
}
RefreshMovementRangeProjection(b, center.indexPosition);
}
/// <summary>
/// Creates and positions the rock at nodeIndex and updates the status of the node.
/// </summary>
/// <param name="nodeIndex">Node Index of the node</param>
private void PlaceRock(Vector2Int nodeIndex)
{
EnvironmentNode n = EnvironmentManager.nodeMap[nodeIndex.x, nodeIndex.y];
n.isAccessible = false;
n.terrain.Add(TerrainType.Boulder);
propsTransforms.Add(Instantiate(rocksPrefabs[Random.Range(0, rocksPrefabs.Length)], n.position, Quaternion.Euler(Vector3.up * Random.value * 360), propParent).transform);
}
public override void StoreSettings()
{
EnvironmentNode node = (EnvironmentNode)parentNode;
foreach (EnvironmentItem item in listView.Items)
{
node.Colors[item.arrayIndex] = item.Color;
}
}
public void AddEnvironmentNodeAddsNode()
{
AddEnvironmentNodeCommand addEnvironmentCommand = new AddEnvironmentNodeCommand(ServiceProvider);
addEnvironmentCommand.Execute(ApplicationNode);
EnvironmentNode environmentNode = ApplicationNode.Hierarchy.FindNodeByType(typeof(EnvironmentNode)) as EnvironmentNode;
Assert.IsNotNull(environmentNode);
}
public EnvironmentOptionPanel(EnvironmentNode parent) : base(parent)
{
SetupFromXmlFile(System.IO.Path.Combine(PropertyService.DataDirectory,
@"resources\panels\HighlightingEditor\Environment.xfrm"));
button = (Button)ControlDictionary["button"];
button.Click += new EventHandler(EditButtonClicked);
listView = (ListView)ControlDictionary["listView"];
listView.Font = new Font(listView.Font.FontFamily, 10);
}
public override void LoadSettings()
{
EnvironmentNode node = (EnvironmentNode)parentNode;
listView.Items.Clear();
for (int i = 0; i <= EnvironmentNode.ColorNames.GetUpperBound(0); ++i)
{
listView.Items.Add(new EnvironmentItem(i, node.ColorDescs[i], node.Colors[i], listView.Font));
}
}
/// <summary>
/// Checks if a node fullfill conditions to be a TerrainType and add it
/// </summary>
/// <param name="node">Node to check. </param>
private void DetectAndAddTerrainTypes(ref EnvironmentNode node)
{
if (node.position.y <= EnvironmentManager.trueWaterLevel)
{
node.terrain.Add(TerrainType.Water);
//node.isAccessible = false;
}
if (node.position.y >= EnvironmentManager.trueSnowLineLevel)
{
node.terrain.Add(TerrainType.Mountain);
}
}
public void TryGoTo(EnvironmentNode n)
{
if (nodesInRange == null)
{
nodesInRange = Pathfinder.IsInRange(EnvironmentManager.allNodes, currentNode, characterClass.moveRange, PathfindingD);
}
if (nodesInRange.Contains(n))
{
GoTo(Pathfinder.Solve(EnvironmentManager.allNodes, currentNode, n, PathfindingD, PathfindingH));
}
SelectionManager.instance.Deselect();
}
public void AddEnvironmentNodeAddsNodeWithDefaultVaues()
{
AddEnvironmentNodeCommand addEnvironmentCommand = new AddEnvironmentNodeCommand(ServiceProvider);
addEnvironmentCommand.Execute(ApplicationNode);
EnvironmentNode environmentNode = ApplicationNode.Hierarchy.FindNodeByType(typeof(EnvironmentNode)) as EnvironmentNode;
Assert.IsNotNull(environmentNode);
Assert.AreEqual("Environment", environmentNode.Name);
Assert.AreEqual("Environment.dconfig", environmentNode.EnvironmentDeltaFile);
Assert.AreEqual(string.Empty, environmentNode.EnvironmentConfigurationFile);
}
/// <summary>
/// Creates and positins the tree at nodeIndex and updates the status of the node.
/// </summary>
/// <param name="nodeIndex">Node Index of the node</param>
/// <param name="isBig">if the tree should be fully grown</param>
private void GrowTree(Vector2Int nodeIndex, bool isBig)
{
EnvironmentNode n = EnvironmentManager.nodeMap[nodeIndex.x, nodeIndex.y];
n.terrain.Add(TerrainType.Trees);
if (n.position.y < EnvironmentManager.trueCoastLineLevel)
{
propsTransforms.Add(Instantiate(isBig ? palmTreesPrefabs[1] : palmTreesPrefabs[0], n.position, Quaternion.Euler(Vector3.up * Random.value * 360), propParent).transform);
}
else
{
propsTransforms.Add(Instantiate(isBig ? treesPrefabs[1] : treesPrefabs[0], n.position, Quaternion.Euler(Vector3.up * Random.value * 360), propParent).transform);
}
}
public void InitCharacter(EnvironmentNode startNode, int teamId = -1)
{
if (characterClass.unnavigableTerrain == null)
{
characterClass.SetupCharacterClass();
}
currentNode = startNode;
this.teamId = teamId;
currentHp = characterClass.hp;
transform.position = currentNode.position;
NotifySelectionManager();
}
private bool CanGrowTrees(EnvironmentNode node, EnvironmentNode from = null)
{
if (node.terrain.Contains(TerrainType.Water) || node.terrain.Contains(TerrainType.Mountain) || node.terrain.Contains(TerrainType.Boulder))
{
return(false);
}
if (from == null)
{
return(true);
}
else
{
return(node.position.y <= EnvironmentManager.trueCoastLineLevel == from.position.y <= EnvironmentManager.trueCoastLineLevel);
}
}
private EnvironmentNode LoadConfigurationMergeFile(IConfigurationUIHierarchy mainConfigurationHierarchy, string configurationMergeFile, IServiceProvider serviceProvider)
{
EnvironmentNodeBuilder nodeBuilder = new EnvironmentNodeBuilder(serviceProvider);
EnvironmentNode environmentNode = nodeBuilder.Build(configurationMergeFile, mainConfigurationHierarchy);
EnvironmentalOverridesNode environmentNodeContainer = mainConfigurationHierarchy.FindNodeByType(typeof(EnvironmentalOverridesNode)) as EnvironmentalOverridesNode;
if (environmentNodeContainer == null)
{
throw new ApplicationException(Resources.ErrorNoEnvironmentContainer);
}
environmentNodeContainer.AddNode(environmentNode);
return(environmentNode);
}
public void MergeAndSaveConfiguration(string configurationFile)
{
IConfigurationUIHierarchy mainConfigurationHierarchy = LoadMainConfiguration(mainConfigurationFile, serviceContainer);
EnvironmentNode environmentNode = LoadConfigurationMergeFile(mainConfigurationHierarchy, configurationMergeFile, serviceContainer);
if (!String.IsNullOrEmpty(configurationFile))
{
environmentNode.EnvironmentConfigurationFile = configurationFile;
}
SaveMergedEnvironmentCommand saveMergedConfigurationComand = new SaveMergedEnvironmentCommand(serviceContainer);
saveMergedConfigurationComand.Execute(environmentNode);
mergeSucceeded = saveMergedConfigurationComand.MergeSucceeded;
mergedConfigurationFile = saveMergedConfigurationComand.MergedConfigurationFile;
}
public void EnvironmentalOverridesValidatesDuplicateMergeFilePaths()
{
EnvironmentalOverridesNode overridesNode = base.ApplicationNode.Hierarchy.FindNodeByType(typeof(EnvironmentalOverridesNode)) as EnvironmentalOverridesNode;
EnvironmentNode node1 = new EnvironmentNode();
EnvironmentNode node2 = new EnvironmentNode();
overridesNode.AddNode(node1);
overridesNode.AddNode(node2);
node1.EnvironmentDeltaFile = "mergefile";
node2.EnvironmentDeltaFile = "mergefile";
List<ValidationError> errorList = new List<ValidationError>();
overridesNode.Validate(errorList);
Assert.AreEqual(1, errorList.Count);
}
public void EnvironmentalOverridesValidatesDuplicateMergeFilePaths()
{
EnvironmentalOverridesNode overridesNode = base.ApplicationNode.Hierarchy.FindNodeByType(typeof(EnvironmentalOverridesNode)) as EnvironmentalOverridesNode;
EnvironmentNode node1 = new EnvironmentNode();
EnvironmentNode node2 = new EnvironmentNode();
overridesNode.AddNode(node1);
overridesNode.AddNode(node2);
node1.EnvironmentDeltaFile = "mergefile";
node2.EnvironmentDeltaFile = "mergefile";
List <ValidationError> errorList = new List <ValidationError>();
overridesNode.Validate(errorList);
Assert.AreEqual(1, errorList.Count);
}
public float PathfindingD(EnvironmentNode n1, EnvironmentNode n2)
{
float cost = Vector2.Distance(n1.indexPosition, n2.indexPosition);
if (!n2.terrain.Contains(TerrainType.Water))
{
cost += (n2.effortWeightage - n1.effortWeightage) * characterClass.inclinedMovementEffortMultiplier;
}
foreach (TerrainType terrainType in n2.terrain)
{
if (characterClass.unnavigableTerrain.Contains(terrainType))
{
return(float.MaxValue);
}
if (characterClass.navigatableTerrainWeightage.ContainsKey(terrainType))
{
cost *= characterClass.navigatableTerrainWeightage[terrainType];
}
}
return(cost);
}
public void EnvironmentNodeCanNotExtendEnvironmentNode()
{
EnvironmentNode environmentNode = new EnvironmentNode();
Assert.IsFalse(environmentNode.CanExtend(environmentNode));
}
public float PathfindingH(EnvironmentNode n1, EnvironmentNode n2)
{
return(Mathf.Sqrt(Vector2.SqrMagnitude(n1.indexPosition - n2.indexPosition) + Mathf.Pow(n2.effortWeightage - n1.effortWeightage, 2)));
}
public void EnvironmentNodeCanNotExtendEnvironmentNode()
{
EnvironmentNode environmentNode = new EnvironmentNode();
Assert.IsFalse(environmentNode.CanExtend(environmentNode));
}
