protected void AddAssociations(IEnumerable <Association> associations)
{
foreach (var aso in associations)
{
var allNodes = Layout.AllNodes.ToList();
NodeLayout memberEndNL = null;
NodeLayout memberEnd1NL = null;
foreach (var n in allNodes)
{
var namedNode = (MetaDslx.Languages.Uml.Model.NamedElement)n.NodeObject;
if (string.Equals(namedNode.Name, aso.MemberEnd[0].Type.Name))
{
memberEndNL = Layout.FindNodeLayout(namedNode);
}
else if (string.Equals(namedNode.Name, aso.MemberEnd[1].Type.Name))
{
memberEnd1NL = Layout.FindNodeLayout(namedNode);
}
}
if (memberEndNL != null && memberEnd1NL != null)
{
var e = Layout.AddEdge(memberEndNL.NodeObject, memberEnd1NL.NodeObject, memberEndNL.NodeObject.ToString() + "-" + memberEnd1NL.NodeObject.ToString());
}
}
}
protected void AddIncludes(IEnumerable <Include> includes)
{
foreach (var inc in includes)
{
var allNodes = Layout.AllNodes.ToList();
NodeLayout includingNL = null;
NodeLayout additionNL = null;
foreach (var n in allNodes)
{
var namedNode = (MetaDslx.Languages.Uml.Model.NamedElement)n.NodeObject;
if (string.Equals(namedNode.Name, inc.IncludingCase.Name))
{
includingNL = Layout.FindNodeLayout(namedNode);
}
else if (string.Equals(namedNode.Name, inc.Addition.Name))
{
additionNL = Layout.FindNodeLayout(namedNode);
}
}
if (includingNL != null && additionNL != null)
{
var e = Layout.AddEdge(additionNL.NodeObject, includingNL.NodeObject, additionNL.NodeObject.ToString() + "--|>" + includingNL.NodeObject.ToString());
}
}
}
protected void AddDependecies(IEnumerable <Dependency> dependencies)
{
foreach (var dep in dependencies)
{
var allNodes = Layout.AllNodes.ToList();
NodeLayout clientNL = null;
NodeLayout supplierNL = null;
foreach (var n in allNodes)
{
var namedNode = (MetaDslx.Languages.Uml.Model.NamedElement)n.NodeObject;
if (string.Equals(namedNode.Name, dep.Client.FirstOrDefault().Name))
{
clientNL = Layout.FindNodeLayout(namedNode);
}
else if (string.Equals(namedNode.Name, dep.Supplier.FirstOrDefault().Name))
{
supplierNL = Layout.FindNodeLayout(namedNode);
}
}
if (clientNL != null && supplierNL != null)
{
var e = Layout.AddEdge(clientNL.NodeObject, supplierNL.NodeObject, clientNL.NodeObject.ToString() + "-->" + supplierNL.NodeObject.ToString());
}
}
}
protected void AddInterfaceRealizations(IEnumerable <InterfaceRealization> interfaceRealizations)
{
foreach (var intrf in interfaceRealizations)
{
var allNodes = Layout.AllNodes.ToList();
Layout.FindNodeLayout(intrf.Supplier.FirstOrDefault().Name);
NodeLayout clientNL = null;
NodeLayout supplierNL = null;
foreach (var n in allNodes)
{
var namedNode = (MetaDslx.Languages.Uml.Model.NamedElement)n.NodeObject;
if (string.Equals(namedNode.Name, intrf.Client.FirstOrDefault().Name))
{
clientNL = Layout.FindNodeLayout(namedNode);
}
else if (string.Equals(namedNode.Name, intrf.Supplier.FirstOrDefault().Name))
{
supplierNL = Layout.FindNodeLayout(namedNode);
}
}
if (clientNL != null && supplierNL != null)
{
var e = Layout.AddEdge(clientNL.NodeObject, supplierNL.NodeObject, clientNL.NodeObject.ToString() + "--|>" + supplierNL.NodeObject.ToString());
}
}
}
void Render(XmlWriter writer, NodeLayout <Graph <TNode, TTransition> .Transition> node)
{
writer.WriteStartElement("g");
WriteTranslationAttribute(writer, node.Location.X, node.Location.Y);
RenderCore(node.Data, writer, node.Size);
writer.WriteEndElement();
}
protected void AddExtends(IEnumerable <Extend> extends)
{
foreach (var ext in extends)
{
var allNodes = Layout.AllNodes.ToList();
NodeLayout extendCaseNL = null;
NodeLayout extensionNL = null;
foreach (var n in allNodes)
{
var namedNode = (MetaDslx.Languages.Uml.Model.NamedElement)n.NodeObject;
if (string.Equals(namedNode.Name, ext.ExtendedCase.Name))
{
extendCaseNL = Layout.FindNodeLayout(namedNode);
}
else if (string.Equals(namedNode.Name, ext.Extension.Name))
{
extensionNL = Layout.FindNodeLayout(namedNode);
}
}
if (extendCaseNL != null && extensionNL != null)
{
var e = Layout.AddEdge(extensionNL.NodeObject, extendCaseNL.NodeObject, extensionNL.NodeObject.ToString() + "--|>" + extendCaseNL.NodeObject.ToString());
}
}
}
protected void AddGeneralizations(IEnumerable <Generalization> generalizations)
{
foreach (var gen in generalizations)
{
var allnodes = Layout.AllNodes.ToList();
NodeLayout specNL = null;
NodeLayout genNL = null;
foreach (var n in allnodes)
{
var namedNode = (MetaDslx.Languages.Uml.Model.NamedElement)n.NodeObject;
if (string.Equals(namedNode.Name, gen.Specific.Name))
{
specNL = Layout.FindNodeLayout(namedNode);
}
else if (string.Equals(namedNode.Name, gen.General.Name))
{
genNL = Layout.FindNodeLayout(namedNode);
}
}
//if (specObject == null) { Layout.AddNode(gen.Specific.Name); specObject = Layout.FindNodeLayout(gen.Specific.Name); }
//if (genObject == null) { Layout.AddNode(gen.General.Name); genObject = Layout.FindNodeLayout(gen.General.Name); }
if (specNL != null && genNL != null)
{
var e = Layout.AddEdge(specNL.NodeObject, genNL.NodeObject, specNL.NodeObject.ToString() + "-|>" + genNL.NodeObject.ToString());
}
}
}
// TODO: we should interpret the shape/style/color attributes ...
public void Draw(NodeLayout layoutState)
{
var style = myPresentation.GetPropertySetFor <NodeStyle>().Get(Owner.Id);
var label = myPresentation.GetPropertySetFor <Caption>().Get(Owner.Id);
Visual = new DrawingVisual();
var dc = Visual.RenderOpen();
if (style.Shape.Equals("rectangle", StringComparison.OrdinalIgnoreCase))
{
var rect = layoutState.GetBoundingBox();
dc.DrawRectangle(style.FillColor, new Pen(style.BorderColor, 0.016), rect);
}
else
{
dc.DrawEllipse(style.FillColor, new Pen(style.BorderColor, 0.016), layoutState.Center, layoutState.Width, layoutState.Height);
}
var tx = new FormattedText(label.DisplayText,
CultureInfo.InvariantCulture,
FlowDirection.LeftToRight,
myFont,
layoutState.Height * 0.7, Brushes.Black);
dc.DrawText(tx, new Point(layoutState.Center.X - tx.Width / 2, layoutState.Center.Y - tx.Height / 2));
dc.Close();
Visual.SetValue(GraphItemProperty, Owner);
}
public static void GenerateWorld(bool teamplay, bool cluster_water, bool nat_starts, List <PlayerData> picks, NodeLayout layout)
{
m_num_players = picks.Count;
m_nations = picks;
m_nat_starts = nat_starts;
m_teamplay = teamplay;
m_cluster_water = cluster_water;
m_layout = layout;
generate_nodes();
generate_connections();
calculate_triangles();
generate_caprings();
generate_seas();
generate_lakes();
assign_water_terrain();
List <Node> valid = m_nodes.Where(x => !x.HasNation && !x.IsAssignedTerrain && !x.ProvinceData.IsWater).ToList();
List <Connection> valid_conn = m_connections.Where(x => !x.IsCap && !x.IsInsideCapRing && !x.IsTouchingSea).ToList();
if (!m_nat_starts)
{
valid = m_nodes.Where(x => !x.ProvinceData.IsWater).ToList();
}
generate_swamps(valid);
generate_misc(valid);
generate_rivers(valid_conn);
generate_cliffs(valid_conn);
generate_roads(valid_conn);
generate_farms(valid);
generate_sized(valid);
generate_thrones();
cleanup_connections();
}
public void OnGenerate()
{
if (ElementManager.s_element_manager.GeneratedObjects.Any())
{
ElementManager.s_element_manager.WipeGeneratedObjects();
}
List <PlayerData> picks = new List <PlayerData>();
foreach (GameObject obj in m_content)
{
NationPicker np = obj.GetComponent <NationPicker>();
string str = np.NationName;
NationData data = AllNationData.AllNations.FirstOrDefault(x => x.Name == str);
PlayerData pd = new PlayerData(data, np.TeamNum);
if (data == null || (picks.Any(x => x.NationData.Name == data.Name) && !m_generic_starts))
{
GetComponent <AudioSource>().PlayOneShot(DenyAudio);
return;
}
picks.Add(pd);
}
m_nations = picks;
GetComponent <AudioSource>().PlayOneShot(AcceptAudio);
NodeLayout layout = m_layouts.Layouts.FirstOrDefault(x => x.Name == LayoutDropdown.options[LayoutDropdown.value].text && x.NumPlayers == m_player_count);
MoveCameraForGeneration(layout);
Resources.UnloadUnusedAssets();
StartCoroutine(perform_async(() => do_generate(layout), true));
}
internal bool OnDrawNode(NodeLayout nodeLayout, DrawingContext drawingContext)
{
if (DrawNode != null)
{
DrawNode(this, new DrawNodeEventArgs(nodeLayout, drawingContext));
return(true);
}
return(false);
}
void MoveCameraForGeneration(NodeLayout layout)
{
var main_cam = Camera.main;
var p = main_cam.transform.position;
p.x = layout.X;
p.y = layout.Y * 0.5f;
main_cam.transform.position = p;
}
public NodeLayout ReadNodeLayout(string nodeId)
{
var layout = new NodeLayout(nodeId);
layout.Center = ReadPoint();
layout.Width = myReader.ReadDouble() / 2;
layout.Height = myReader.ReadDouble() / 2;
return(layout);
}
public TransitionOutPoint(EditorStateNode node, NodeLayout layout, TransitionRequest requestType, float buttonSize = 5f)
{
this.layout = layout;
this.Node = node ?? throw new ArgumentNullException(nameof(node));
Transition = null;
Type = requestType;
this.buttonSize = buttonSize;
var info = Type.GetInfo();
toolTip = info != null ? info.DisplayName : Type.GetType().Name;
}
static void create_team_nodes(NodeLayout nl, List <PlayerData> nats)
{
for (int x = 0; x < nl.X; x++) // create all nodes first
{
for (int y = 0; y < nl.Y; y++)
{
Node node = new Node(x, y, new ProvinceData());
if ((x == 0 && y == 0) || (x == nl.X - 1 && y == nl.Y - 1))
{
node.SetWrapCorner(true);
}
m_nodes.Add(node);
}
}
List <SpawnPoint> spawns = new List <SpawnPoint>();
spawns.AddRange(nl.Spawns.Where(x => x.SpawnType == SpawnType.PLAYER));
spawns = spawns.OrderBy(x => x.Y).ThenBy(x => x.X).ToList();
while (nats.Any())
{
PlayerData pd = nats[0];
List <PlayerData> all = new List <PlayerData>();
all.AddRange(nats.Where(x => x.TeamNum == pd.TeamNum));
nats.RemoveAll(x => x.TeamNum == pd.TeamNum);
SpawnPoint anchor = spawns[0];
List <SpawnPoint> ordered = spawns.OrderBy(x => x.DistanceTo(anchor)).ToList();
int i = 0;
foreach (PlayerData p in all)
{
SpawnPoint s = ordered[i];
spawns.Remove(s);
Node n = m_nodes.FirstOrDefault(x => x.X == s.X && x.Y == s.Y);
n.SetPlayerInfo(p, new ProvinceData(p.NationData.CapTerrain));
n.SetAssignedTerrain(true);
m_starts.Add(n);
i++;
}
}
}
private void DrawNode(NodeLayout node)
{
if (_nodeContents.TryGetValue(node, out var nodeContent))
{
if (node.IsSubGraph)
{
nodeContent.Arrange(new Rect(node.Left, node.Top, node.Width, node.Height));
nodeContent.Width = node.Width;
nodeContent.Height = node.Height;
}
nodeContent.SetValue(FrameworkElement.TagProperty, node);
_view._hostCanvas.Children.Add(nodeContent);
nodeContent.MouseMove += NodeContent_MouseMove;
nodeContent.MouseLeave += NodeContent_MouseLeave;
}
else
{
var visual = new DrawingVisual();
DrawingContext drawingContext = visual.RenderOpen();
if (!_view.OnDrawNode(node, drawingContext))
{
Rect rect = new Rect(new Point(node.Position.X - node.Size.X / 2, node.Position.Y - node.Size.Y / 2), new Size(node.Size.X, node.Size.Y));
drawingContext.DrawRectangle(brushes[brushCounter], node.IsSubGraph ? EdgeTemplate.DefaultPen : null, rect);
++brushCounter;
if (brushCounter >= brushes.Length)
{
brushCounter = 0;
}
}
drawingContext.Close();
visual.SetValue(FrameworkElement.TagProperty, node);
_visuals.Children.Add(visual);
}
if (node.IsSubGraph)
{
foreach (var childNode in node.Nodes)
{
this.DrawNode(childNode);
}
}
}
public void CalcAdjacent(List <Connection> conns, NodeLayout nl)
{
if (Diagonal)
{
List <Node> diags = Node1.ConnectedNodes.Where(x => Node2.ConnectedNodes.Contains(x)).ToList();
diags.Add(Node1);
diags.Add(Node2);
Adjacent = conns.Where(x => diags.Contains(x.Node1) && diags.Contains(x.Node2) && x != this).ToList();
}
else
{
List <Node> diags = Node1.ConnectedNodes.Where(x => Node2.ConnectedNodes.Contains(x)).ToList();
diags.Add(Node1);
diags.Add(Node2);
Adjacent = conns.Where(x => diags.Contains(x.Node1) && diags.Contains(x.Node2) && x.Diagonal && x != this).ToList();
}
}
IEnumerator do_generate(NodeLayout layout) // pipeline for initial generation of all nodes and stuff
{
foreach (GameObject obj in HideableButtons)
{
obj.SetActive(false);
}
if (layout == null)
{
layout = m_layouts.Layouts.FirstOrDefault(x => x.NumPlayers == m_player_count);
}
m_season = Season.SUMMER;
// create the conceptual nodes and connections first
WorldGenerator.GenerateWorld(m_teamplay, m_cluster_water, NatStarts.isOn, m_nations, layout);
List <Connection> conns = WorldGenerator.GetConnections();
List <Node> nodes = WorldGenerator.GetNodes();
// generate the unity objects using the conceptual nodes
ElementManager mgr = GetComponent <ElementManager>();
// position and resize the cameras
Vector3 campos = new Vector3(layout.X * 0.5f * mgr.X - mgr.X, layout.Y * 0.5f * mgr.Y - mgr.Y, -10);
CaptureCamera.transform.position = campos;
float ortho = (mgr.Y * layout.Y * 100) / 100f / 2f;
CaptureCamera.orthographicSize = ortho;
yield return(StartCoroutine(mgr.GenerateElements(nodes, conns, layout)));
ProvinceManager.s_province_manager.SetLayout(layout);
ConnectionManager.s_connection_manager.SetLayout(layout);
Camera.main.transform.position = campos + new Vector3(500f, 0f, 0f);
foreach (GameObject obj in HideableButtons)
{
obj.SetActive(true);
}
}
private XamDataTree CreateXamDataTree()
{
XamDataTree MyTree = new XamDataTree();
ExperimentNode experiment1 = new ExperimentNode("Experiment1");
CompoundsGroupNode compoundsGroup = new CompoundsGroupNode("CompoundsGroup1");
ClusterNode cluster = new ClusterNode("Cluster1");
cluster.AddChild(new ExperimentNode("Experiment2"));
ExperimentNode experiment3 = new ExperimentNode("Experiment3");
experiment3.HoverText = "My experiment";
experiment3.AddChild(new CompoundsGroupNode("CompoundsGroup2"));
experiment3.AddChild(new CompoundsGroupNode("CompoundsGroup3"));
cluster.AddChild(experiment3);
experiment1.AddChild(compoundsGroup);
experiment1.AddChild(cluster);
MyTree.ItemsSource = new ObservableCollection <IDataNode> {
experiment1
};
NodeLayout mylayout = new NodeLayout();
mylayout.Key = "NodeLayout1";
mylayout.TargetTypeName = "IDataNode";
mylayout.DisplayMemberPath = "Name";
MyTree.GlobalNodeLayouts.Add(mylayout);
return(MyTree);
}
public IEnumerator GenerateElements(List <ProvinceMarker> provs, List <ConnectionMarker> conns, NodeLayout layout, float x, float y)
{
setup_cam(x, y);
return(m_art.Generate(provs, conns, layout));// todo: allow the user to pick which art style?
}
public void RegenerateElements(List <ProvinceMarker> provs, List <ConnectionMarker> conns, NodeLayout layout) // totally regen these provinces and their connections
{
m_art.Regenerate(provs, conns, layout);
}
public NodeEditorViewModel(NodeLayout nodeLayout)
{
NodeLayout = nodeLayout;
}
public static void GenerateText(string mapname, NodeLayout layout, ElementManager mgr, List<PlayerData> nations, Vector2 mins, Vector2 maxs, List<ProvinceMarker> provs, bool teamplay, int[] province_ids)
{
string data_folder = Application.dataPath;
string folder = data_folder + "/Export/";
string path = folder + mapname + ".map";
if (!Directory.Exists(folder))
{
Directory.CreateDirectory(folder);
}
if (File.Exists(path))
{
File.Delete(path);
}
int x = Mathf.RoundToInt(layout.X * mgr.X * 100);
int y = Mathf.RoundToInt(layout.Y * mgr.Y * 100);
provs = provs.Where(p => !p.IsDummy).ToList();
provs = provs.OrderBy(p => p.ProvinceNumber).ToList();
using (FileStream fs = File.Create(path))
{
var dom_col_r = (int)(GenerationManager.s_generation_manager.OverlayColor.r * 255f);
var dom_col_g = (int)(GenerationManager.s_generation_manager.OverlayColor.g * 255f);
var dom_col_b = (int)(GenerationManager.s_generation_manager.OverlayColor.b * 255f);
var dom_col_a = (int)(GenerationManager.s_generation_manager.OverlayColor.a * 255f);
string map_stats = string.Format("Player count: {0}, Throne count: {1}, Province count: {2}", layout.NumPlayers, layout.NumThrones, layout.TotalProvinces);
write(fs, "-- Basic Map Information");
write(fs, "#dom2title " + mapname);
write(fs, "#imagefile " + mapname + ".tga");
write(fs, "#winterimagefile " + mapname + "_winter.tga");
write(fs, "#mapsize " + x + " " + y);
write(fs, "#wraparound");
write(fs, "#maptextcol 0.2 0.0 0.0 1.0");
write(fs, $"#mapdomcol {dom_col_r} {dom_col_g} {dom_col_b} {dom_col_a}");
write(fs, "#description \"[Generated by MapNuke] " + map_stats + "\"");
write(fs, "\n-- Start Location Data");
foreach (PlayerData d in nations)
{
if (d.NationData.ID > -1)
{
write(fs, "#allowedplayer " + d.NationData.ID);
}
}
foreach (ProvinceMarker m in provs)
{
if (m.Node.HasNation)
{
if (m.Node.Nation.NationData.ID == -1)
{
if (teamplay)
{
write(fs, "#teamstart " + m.ProvinceNumber + " " + m.Node.Nation.TeamNum);
}
else
{
write(fs, "#start " + m.ProvinceNumber);
}
}
else
{
write(fs, "#specstart " + m.Node.Nation.NationData.ID + " " + m.ProvinceNumber);
}
}
}
write(fs, "\n-- Terrain Data");
foreach (ProvinceMarker m in provs)
{
Terrain terr = m.Node.ProvinceData.Terrain;
if (GeneratorSettings.s_generator_settings.UseClassicMountains && !terr.IsFlagSet(Terrain.MOUNTAINS) && mountain_count(m) >= 1f)
{
terr |= Terrain.MOUNTAINS;
}
if (m.Node.Connections.Any(c => c.ConnectionType == ConnectionType.RIVER || c.ConnectionType == ConnectionType.SHALLOWRIVER))
{
terr |= Terrain.FRESHWATER;
}
if (m.Node.HasNation)
{
terr |= Terrain.START;
}
write(fs, "#terrain " + m.ProvinceNumber + " " + (int)terr);
}
write(fs, "\n-- Province Neighbour Data");
foreach (ProvinceMarker m in provs)
{
foreach (Connection c in m.Node.Connections)
{
write(fs, "#neighbour " + c.Node1.ID + " " + c.Node2.ID);
if (c.ConnectionType != ConnectionType.STANDARD && c.ConnectionType != ConnectionType.SHALLOWRIVER)
{
write(fs, "#neighbourspec " + c.Node1.ID + " " + c.Node2.ID + " " + (int)c.ConnectionType);
}
}
}
write(fs, "\n-- Province Border Data");
{
int cur = 0;
for (int cur_y = 0; cur_y < y; ++cur_y)
{
int cur_id = 0;
int cur_px = 0;
int cur_x = 0;
for (; cur_x < x; ++cur_x)
{
int nex_id = province_ids[cur];
if (nex_id != cur_id)
{
if (cur_id != 0)
{
write(fs, "#pb " + (cur_x - cur_px) + " " + cur_y + " " + cur_px + " " + cur_id);
}
cur_px = 0;
}
cur_id = nex_id;
cur_px++;
cur++;
}
if (cur_id != 0) write(fs, "#pb " + (cur_x - cur_px) + " " + cur_y + " " + cur_px + " " + cur_id);
}
}
fs.Close();
}
}
public void SetLayout(NodeLayout layout)
{
m_layout = layout;
}
public NodeEditorViewModel(NodeLayout nodeLayout)
{
NodeLayout = nodeLayout;
}
private void Drop(ElementNode elementNode, Point point)
{
var element = elementNode;
var elementLocation = new NodeLayout { LeftOffset = point.X, TopOffset = point.Y, NodeId = element.Id };
NodeLayouts.Add(elementLocation);
}
public abstract void Regenerate(List <ProvinceMarker> provs, List <ConnectionMarker> conns, NodeLayout layout);
public abstract IEnumerator Generate(List <ProvinceMarker> provs, List <ConnectionMarker> conns, NodeLayout layout);
public override void Regenerate(List <ProvinceMarker> provs, List <ConnectionMarker> conns, NodeLayout layout)
{
List <GameObject> result = new List <GameObject>();
List <ConnectionMarker> linked = new List <ConnectionMarker>();
foreach (ConnectionMarker m in conns)
{
if (m.LinkedConnection != null)
{
linked.Add(m.LinkedConnection);
}
}
conns.AddRange(linked);
foreach (ConnectionMarker m in m_all_conns)
{
m.ClearTriangles();
}
calc_triangles(m_all_conns, layout);
foreach (ConnectionMarker cm in conns)
{
cm.CreatePolyBorder();
cm.ClearWrapMeshes();
cm.RecalculatePoly();
}
foreach (ProvinceMarker pm in provs)
{
pm.UpdateLabel();
pm.RecalculatePoly();
pm.ConstructPoly();
pm.ClearWrapMeshes();
result.AddRange(pm.CreateWrapMeshes()); // also create connection wrap meshes
}
List <ProvinceMarker> bad = provs.Where(x => x.NeedsRegen).ToList();
List <ProvinceMarker> add = new List <ProvinceMarker>();
if (bad.Any())
{
Debug.LogError(bad.Count + " provinces have invalid PolyBorders. Regenerating additional provinces.");
foreach (ProvinceMarker b in bad)
{
foreach (ProvinceMarker adj in b.ConnectedProvinces)
{
if (provs.Contains(adj))
{
continue;
}
if (adj.IsDummy)
{
add.AddRange(adj.LinkedProvinces);
if (adj.LinkedProvinces[0].LinkedProvinces.Count > 1)
{
foreach (ProvinceMarker link in adj.LinkedProvinces[0].LinkedProvinces) // 3 dummies
{
add.AddRange(adj.ConnectedProvinces);
}
}
else
{
add.AddRange(adj.LinkedProvinces[0].ConnectedProvinces);
}
}
else
{
add.Add(adj);
if (adj.LinkedProvinces != null && adj.LinkedProvinces.Any())
{
foreach (ProvinceMarker link in adj.LinkedProvinces)
{
add.AddRange(link.ConnectedProvinces);
}
}
}
if (!add.Contains(adj))
{
add.Add(adj);
}
}
if (b.LinkedProvinces != null && b.LinkedProvinces.Any())
{
foreach (ProvinceMarker link in b.LinkedProvinces)
{
add.AddRange(link.ConnectedProvinces);
}
}
}
foreach (ProvinceMarker pm in add)
{
foreach (ConnectionMarker m in pm.Connections)
{
if (!conns.Contains(m) && ((provs.Contains(m.Prov1) || add.Contains(m.Prov1)) && (provs.Contains(m.Prov2) || add.Contains(m.Prov2))))
{
conns.Add(m);
}
}
}
foreach (ConnectionMarker cm in conns)
{
cm.CreatePolyBorder();
cm.ClearWrapMeshes();
cm.RecalculatePoly();
}
foreach (ProvinceMarker pm in add)
{
pm.UpdateLabel();
pm.RecalculatePoly();
pm.ConstructPoly();
pm.ClearWrapMeshes();
result.AddRange(pm.CreateWrapMeshes()); // also create connection wrap meshes
}
foreach (ProvinceMarker pm in provs)
{
pm.UpdateLabel();
pm.RecalculatePoly();
pm.ConstructPoly();
pm.ClearWrapMeshes();
result.AddRange(pm.CreateWrapMeshes()); // also create connection wrap meshes
}
}
foreach (ConnectionMarker cm in conns)
{
m_all_sprites.AddRange(cm.PlaceSprites());
}
foreach (ProvinceMarker pm in provs)
{
foreach (var unused in pm.CalculateSpritePoints())
{
}
m_all_sprites.AddRange(pm.PlaceSprites());
}
List <SpriteMarker> all = new List <SpriteMarker>();
foreach (SpriteMarker m in m_all_sprites)
{
if (m != null && m.gameObject != null)
{
all.Add(m);
result.Add(m.gameObject);
}
}
m_all_sprites = all;
ElementManager.s_element_manager.AddGeneratedObjects(result);
CaptureCam.s_capture_cam.Render();
}
/// <summary>
/// Every diagonal connection forms a triangle with its adjacent connections, we want to compute the center of these triangles.
/// Some trickery has to be done to account for the wrapping connections.
/// </summary>
void calc_triangles(List <ConnectionMarker> conns, NodeLayout layout)
{
foreach (ConnectionMarker c in conns)
{
List <ConnectionMarker> adj = get_adjacent(conns, c);
if (adj.Count == 4)
{
if (c.IsEdge)
{
if (c.Dummy.Node.X == 0 && c.Dummy.Node.Y == 0)
{
ConnectionMarker upper = adj.FirstOrDefault(x => x.Connection.Pos.y == 0f);
ConnectionMarker right = adj.FirstOrDefault(x => x.Connection.Pos.x == 0f);
ConnectionMarker lower = adj.FirstOrDefault(x => x != right && x != upper && x.Connection.Pos.x == c.Connection.Pos.x);
ConnectionMarker left = adj.FirstOrDefault(x => x != right && x != upper && x != lower);
Vector3 upperpos = upper.transform.position;
Vector3 rightpos = right.transform.position;
Vector3 upperoffset = Vector3.zero;
Vector3 rightoffset = Vector3.zero;
bool is_upper = false;
bool is_right = false;
if (Vector3.Distance(upperpos, c.transform.position) > 4f)
{
upperoffset = new Vector3(0f, c.DummyOffset.y);
upperpos += upperoffset;
is_upper = true;
}
if (Vector3.Distance(rightpos, c.transform.position) > 4f)
{
rightoffset = new Vector3(c.DummyOffset.x, 0f);
rightpos += rightoffset;
is_right = true;
}
if (unique_nodes(c, lower, left) == 3)
{
Vector3 mid1 = (c.transform.position + lower.transform.position + left.transform.position) / 3;
Vector3 mid2 = (c.transform.position + upperpos + rightpos) / 3;
c.AddTriangleCenter(mid1);
lower.AddTriangleCenter(mid1);
left.AddTriangleCenter(mid1);
c.AddTriangleCenter(mid2);
if (is_upper)
{
upper.AddTriangleCenter(mid2 - upperoffset);
}
else
{
upper.AddTriangleCenter(mid2);
}
if (is_right)
{
right.AddTriangleCenter(mid2 - rightoffset);
}
else
{
right.AddTriangleCenter(mid2);
}
}
else
{
Vector3 mid1 = (c.transform.position + lower.transform.position + rightpos) / 3;
Vector3 mid2 = (c.transform.position + upperpos + left.transform.position) / 3;
c.AddTriangleCenter(mid1);
lower.AddTriangleCenter(mid1);
if (is_right)
{
right.AddTriangleCenter(mid1 - rightoffset);
}
else
{
right.AddTriangleCenter(mid1);
}
c.AddTriangleCenter(mid2);
left.AddTriangleCenter(mid2);
if (is_upper)
{
upper.AddTriangleCenter(mid2 - upperoffset);
}
else
{
upper.AddTriangleCenter(mid2);
}
}
}
else
{
ConnectionMarker upper = adj.FirstOrDefault(x => x.Connection.Pos.y == c.Connection.Pos.y + 0.5f || c.Connection.Pos.y == 0f);
ConnectionMarker lower = adj.FirstOrDefault(x => x.Connection.Pos.y != c.Connection.Pos.y && x != upper);
ConnectionMarker right = adj.FirstOrDefault(x => x.Connection.Pos.x == c.Connection.Pos.x + 0.5f || c.Connection.Pos.x == 0f);
ConnectionMarker left = adj.FirstOrDefault(x => x.Connection.Pos.x != c.Connection.Pos.x && x != right);
Vector3 upperpos = upper.transform.position;
Vector3 rightpos = right.transform.position;
Vector3 upperoffset = Vector3.zero;
Vector3 rightoffset = Vector3.zero;
bool is_upper = false;
bool is_right = false;
if (Vector3.Distance(upperpos, c.transform.position) > 4f)
{
upperoffset = c.DummyOffset;
upperpos += upperoffset;
is_upper = true;
}
if (Vector3.Distance(rightpos, c.transform.position) > 4f)
{
rightoffset = c.DummyOffset;
rightpos += rightoffset;
is_right = true;
}
if (unique_nodes(c, lower, left) == 3)
{
Vector3 mid1 = (c.transform.position + lower.transform.position + left.transform.position) / 3;
Vector3 mid2 = (c.transform.position + upperpos + rightpos) / 3;
c.AddTriangleCenter(mid1);
lower.AddTriangleCenter(mid1);
left.AddTriangleCenter(mid1);
c.AddTriangleCenter(mid2);
if (is_upper)
{
upper.AddTriangleCenter(mid2 - upperoffset);
}
else
{
upper.AddTriangleCenter(mid2);
}
if (is_right)
{
right.AddTriangleCenter(mid2 - rightoffset);
}
else
{
right.AddTriangleCenter(mid2);
}
}
else
{
Vector3 mid1 = (c.transform.position + lower.transform.position + rightpos) / 3;
Vector3 mid2 = (c.transform.position + upperpos + left.transform.position) / 3;
c.AddTriangleCenter(mid1);
lower.AddTriangleCenter(mid1);
if (is_right)
{
right.AddTriangleCenter(mid1 - rightoffset);
}
else
{
right.AddTriangleCenter(mid1);
}
c.AddTriangleCenter(mid2);
left.AddTriangleCenter(mid2);
if (is_upper)
{
upper.AddTriangleCenter(mid2 - upperoffset);
}
else
{
upper.AddTriangleCenter(mid2);
}
}
}
}
else
{
ConnectionMarker anchor = adj[0];
ConnectionMarker other = null;
adj.Remove(anchor);
foreach (ConnectionMarker c2 in adj)
{
if (unique_nodes(c, c2, anchor) == 3)
{
other = c2;
Vector3 mid = (c.transform.position + c2.transform.position + anchor.transform.position) / 3;
c.AddTriangleCenter(mid);
c2.AddTriangleCenter(mid);
anchor.AddTriangleCenter(mid);
break;
}
}
adj.Remove(other);
anchor = adj[0];
ConnectionMarker c3 = adj[1];
Vector3 mid2 = (c.transform.position + c3.transform.position + anchor.transform.position) / 3;
c.AddTriangleCenter(mid2);
c3.AddTriangleCenter(mid2);
anchor.AddTriangleCenter(mid2);
}
}
}
}
public override IEnumerator Generate(List <ProvinceMarker> provs, List <ConnectionMarker> conns, NodeLayout layout)
{
List <GameObject> result = new List <GameObject>();
m_all_conns = conns;
m_all_provs = provs;
calc_triangles(conns, layout);
foreach (ConnectionMarker cm in conns)
{
cm.CreatePolyBorder();
cm.ClearWrapMeshes();
cm.RecalculatePoly();
if (Util.ShouldYield())
{
yield return(null);
}
}
foreach (ProvinceMarker pm in provs)
{
pm.UpdateLabel();
pm.RecalculatePoly();
pm.ConstructPoly();
pm.ClearWrapMeshes();
result.AddRange(pm.CreateWrapMeshes());
if (Util.ShouldYield())
{
yield return(null);
}
}
m_all_sprites = new List <SpriteMarker>();
foreach (ConnectionMarker cm in conns)
{
m_all_sprites.AddRange(cm.PlaceSprites());
if (Util.ShouldYield())
{
yield return(null);
}
}
foreach (ProvinceMarker pm in provs)
{
foreach (var x in pm.CalculateSpritePoints())
{
yield return(x);
}
m_all_sprites.AddRange(pm.PlaceSprites());
if (Util.ShouldYield())
{
yield return(null);
}
}
foreach (SpriteMarker m in m_all_sprites)
{
result.Add(m.gameObject);
if (Util.ShouldYield())
{
yield return(null);
}
}
ElementManager.s_element_manager.AddGeneratedObjects(result);
CaptureCam.s_capture_cam.Render();
}
static void create_basic_nodes(NodeLayout nl, List <PlayerData> nats, List <PlayerData> water)
{
for (int x = 0; x < nl.X; x++) // create all nodes first
{
for (int y = 0; y < nl.Y; y++)
{
Node node = new Node(x, y, new ProvinceData());
if ((x == 0 && y == 0) || (x == nl.X - 1 && y == nl.Y - 1))
{
node.SetWrapCorner(true);
}
m_nodes.Add(node);
if (nl.HasSpawn(x, y, SpawnType.PLAYER))
{
node.ProvinceData.AddTerrainFlag(Terrain.START);
m_starts.Add(node);
}
}
}
if (m_cluster_water) // put water nations close together if the user has this option ticked
{
List <Node> starts = m_nodes.Where(x => x.ProvinceData.Terrain.IsFlagSet(Terrain.START)).ToList();
Node start = starts.GetRandom();
List <Node> nodes = get_closest_nodes(start);
foreach (PlayerData d in water)
{
Node n = nodes[0];
nodes.Remove(n);
starts.Remove(n);
n.SetPlayerInfo(d, new ProvinceData(d.NationData.CapTerrain));
n.SetAssignedTerrain(true);
}
foreach (PlayerData d in nats)
{
Node n = starts.GetRandom();
starts.Remove(n);
n.SetPlayerInfo(d, new ProvinceData(d.NationData.CapTerrain));
n.SetAssignedTerrain(true);
}
}
else
{
nats.AddRange(water);
foreach (Node n in m_nodes.Where(x => x.ProvinceData.Terrain.IsFlagSet(Terrain.START)))
{
PlayerData d = nats.GetRandom();
nats.Remove(d);
n.SetPlayerInfo(d, new ProvinceData(d.NationData.CapTerrain));
n.SetAssignedTerrain(true);
}
}
}
private void Drop(ChannelNode channelNode, Point point)
{
var channel = channelNode;
var channelLocation = new NodeLayout { LeftOffset = point.X, TopOffset = point.Y, NodeId = channel.Id };
NodeLayouts.Add(channelLocation);
}
