// Draw the property inside the given rect
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
// Using BeginProperty / EndProperty on the parent property means that
// prefab override logic works on the entire property.
EditorGUI.BeginProperty(position, label, property);
var valueProp = property.FindPropertyRelative("value");
var nameProp = property.FindPropertyRelative("resource").FindPropertyRelative("m_name");
if (!Mathc.ArrayContains(ref GameManagerEditor.availableResources, nameProp.stringValue, out lastIndex))
{
lastIndex = 0;
}
// Draw label
position = EditorGUI.PrefixLabel(position, GUIUtility.GetControlID(FocusType.Passive), label);
// Don't make child fields be indented
var indent = EditorGUI.indentLevel;
EditorGUI.indentLevel = 0;
// Calculate rects
var nameRect = new Rect(position.x + 2, position.y, 135, position.height); // min = x+2 || max = x+137
var amount = new Rect(nameRect.xMax + 7, position.y, 135, position.height); // min = prevMax+7 || max = x+279
lastIndex = EditorGUI.Popup(nameRect, lastIndex, GameManagerEditor.availableResources);
nameProp.stringValue = GameManagerEditor.availableResources[lastIndex];
valueProp.floatValue = EditorGUI.FloatField(amount, valueProp.floatValue);
// Set indent back to what it was
EditorGUI.indentLevel = indent;
EditorGUI.EndProperty();
}
public bool AddNodeToLayer(int layer, bool randomWeights, float weightVal = 0.0f, float biasVal = 0.0f)
{
if (!Mathc.ValueIsBetween(layer, -1, layerCount, true))
{
return(false);
}
Neuron newNode = new Neuron(nodeCount++, randomWeights ? Random.value * 2 - 1 : biasVal);
nodeLayers[layer].Add(newNode);
if (layer > 0)
{
foreach (var node in nodeLayers[layer - 1])
{
node.ConnectNode(newNode, randomWeights ? Random.value * 2 - 1 : weightVal);
}
}
if (layer < layerCount - 1)
{
foreach (var node in nodeLayers[layer + 1])
{
newNode.ConnectNode(node, randomWeights ? Random.value * 2 - 1 : weightVal);
}
}
return(true);
}
public NodeController GetRandomOwnedNode()
{
if (ownedNodes.Count < 1)
{
return(null);
}
return(Mathc.GetRandomValueFromDict(ref ownedNodes));
}
public void DrawConnections(Gradient relationGradient)
{
foreach (var axon in axons)
{
Gizmos.color = relationGradient.Evaluate(Mathc.NormalizeBetween(axon.weight, -1, 1));
Gizmos.DrawLine(pos, axon.receivingNode.pos);
}
}
public NodeController GetNodeFromIndex(int index)
{
if (Mathc.ValueIsBetween(index, -1, nodes.Count, true))
{
return(nodes[index]);
}
return(null);
}
public NodeController GetRandomBorderNode()
{
if (m_borderNodes.Count < 1)
{
return(null);
}
return(Mathc.GetRandomValueFromDict(ref m_borderNodes));
}
public NodeBuildingCont(NodeController pNode)
{
parentNode = pNode;
var types = Mathc.GetEnumValues <BUILDING_TYPE>();
foreach (var t in types)
{
buildingTypeCount.Add(t, 0);
}
}
public static void Save(Window window, Type viewModelType)
{
var filename = Path.Combine(ApplicationData.Current.LocalFolder.FullName, viewModelType.FullName.GetHash() + "_Navigator");
var dictionary = new KeyRawValueDictionary();
dictionary.Add("Width", Mathc.Clamp(PersistentWindowProperties.GetWidth(window), window.MinWidth, window.MaxWidth));
dictionary.Add("Height", Mathc.Clamp(PersistentWindowProperties.GetHeight(window), window.MinHeight, window.MaxHeight));
dictionary.Add("Top", window.Top);
dictionary.Add("Left", window.Left);
dictionary.Add("WindowState", (int)window.WindowState);
File.WriteAllBytes(filename, dictionary.Serialize());
}
public bool RemoveLayer(int index, bool replaceConnections)
{
if (!Mathc.ValueIsBetween(index, 0, layerCount - 1, true))
{
return(false);
}
var currLayer = nodeLayers[index];
var prevLayer = nodeLayers[index - 1];
var nextLayer = nodeLayers[index + 1];
if (prevLayer.Count != currLayer.Count)
{
replaceConnections = true;
}
if (!replaceConnections)
{
for (int i = 0; i < currLayer.Count; ++i)
{
var n0 = currLayer[i];
var n1 = prevLayer[i];
n1.RemoveAllConnections();
foreach (var n2 in nextLayer)
{
n0.ReplaceConnection(n2, n1, false);
}
}
}
else
{
foreach (var n0 in prevLayer)
{
n0.RemoveAllConnections();
foreach (var n1 in nextLayer)
{
n0.ConnectNode(n1, Random.value * 2 - 1);
}
}
}
nodeLayers.RemoveAt(index);
return(true);
}
public string GetConnectionSummary()
{
StringBuilder msg = new StringBuilder($"\n {tileNum}[{layer}]: ");
for (int i = 0; i < 6; ++i)
{
if (connections[i] == null)
{
msg.Append($"[{i}, null] ");
continue;
}
Vector2 nPos = connections[i].pos - pos;
float ang = Mathf.Atan2(nPos.y, nPos.x);
ang = Mathc.AnglePiToAngle2Pi(ang) * Mathf.Rad2Deg;
msg.Append($"[{i}, {ang.ToString("F1")}, {nPos.ToString("F2")}] ");
}
return(msg.ToString());
}
/// <summary> Returns the closest point to "pos" that is connected to "index" </summary>
int GetClosestConnectedPoint(int index, Vector2 pos)
{
int cIndex = 0;
float dist = 0;
foreach (var link in graphPoints[index].connections)
{
if (graphPoints[link.index].isBlocked)
{
continue;
}
float comp = Mathc.SqrDist2D(PointPos(link.index), pos);
if (comp < dist)
{
dist = comp;
cIndex = link.index;
}
}
return(cIndex);
}
// Misc Public Graph Data
#region
public int GetClosestPointTo(Vector2 pos)
{
int cIndex = 0;
float dist = float.MaxValue;
foreach (var point in graphPoints)
{
if (point.isBlocked)
{
continue;
}
float comp = Mathc.SqrDist2D(point.position, pos);
if (comp < dist)
{
dist = comp;
cIndex = graphPoints.IndexOf(point);
}
}
return(cIndex);
}
void InitializeBuildings()
{
buildingList = new ReadOnlyCollection <BuildingData>(m_buildingList);
buildingDict = new ReadOnlyDictionary <int, BuildingData>(m_buildingDict);
maxBuildingTypesDict = new ReadOnlyDictionary <BUILDING_TYPE, int>(m_maxBuildingTypesDict);
foreach (var t in Mathc.GetEnumValues <BUILDING_TYPE>())
{
m_BuildingsByType.Add(t, new List <BuildingData>());
}
foreach (var bData in m_buildingList)
{
bData.Init();
m_buildingDict.Add(bData.key, bData);
m_BuildingsByType[bData.buildingType].Add(bData);
}
foreach (var t2 in m_maxBuildingTypesList)
{
m_maxBuildingTypesDict.Add(t2.type, t2.max);
}
}
public static void Load(Window window, Type viewModelType)
{
PersistentWindowProperties.SetHeight(window, Mathc.Clamp(window.ActualHeight, window.MinHeight, window.MaxHeight));
PersistentWindowProperties.SetWidth(window, Mathc.Clamp(window.ActualWidth, window.MinWidth, window.MaxWidth));
var filename = Path.Combine(ApplicationData.Current.LocalFolder.FullName, viewModelType.FullName.GetHash() + "_Navigator");
if (!File.Exists(filename))
{
return;
}
var dictionary = new KeyRawValueDictionary();
dictionary.Deserialize(File.ReadAllBytes(filename));
window.WindowStartupLocation = WindowStartupLocation.Manual;
window.Left = dictionary["Left"].ToDouble();
window.Top = dictionary["Top"].ToDouble();
window.Height = Math.Max(dictionary["Height"].ToDouble(), 1);
window.Width = Math.Max(dictionary["Width"].ToDouble(), 1);
window.WindowState = (WindowState)dictionary["WindowState"].ToInteger();
}
public bool RemoveNodeFromLayer(int layerIndex)
{
if (!Mathc.ValueIsBetween(layerIndex, -1, layerCount, true))
{
return(false);
}
var layer = nodeLayers[layerIndex];
var neuron = layer[layer.Count - 1];
if (layerIndex > 0)
{
foreach (var n in nodeLayers[layerIndex - 1])
{
n.RemoveConnection(neuron);
}
}
neuron.RemoveAllConnections();
layer.RemoveAt(layer.Count - 1);
nodeCount--;
return(true);
}
private void ChangeValue()
{
var value = Mathc.ValueOf(this.AssociatedObject.Value, this.AssociatedObject.Maximum, this.mainGrid.ActualWidth);
ProgressBarProperties.SetValue(this.AssociatedObject, value);
}
/// <summary>
/// Checks the password's strength
/// </summary>
/// <param name="password">The password to check</param>
/// <returns>Returns <see cref="PasswordScore"/> rating</returns>
public static PasswordScore GetPasswordScore(string password)
{
// Origin: http://social.msdn.microsoft.com/Forums/vstudio/en-US/5e3f27d2-49af-410a-85a2-3c47e3f77fb1/how-to-check-for-password-strength
if (string.IsNullOrEmpty(password))
{
return(PasswordScore.Blank);
}
int score = 1;
if (password.Length < 4)
{
return(PasswordScore.VeryWeak);
}
if (password.Length >= 8)
{
score++;
}
if (password.Length >= 12)
{
score++;
}
// If 90% of the password are numbers then lower the score
if (Mathc.ValueOf(Regex.Match(password, @"[0-9]+(\.[0-9][0-9]?)?").Length, password.Length, 100) > 90)
{
score--;
}
// At least 4 of the chars should be numbers
else if (Regex.Match(password, @"[0-9]+(\.[0-9][0-9]?)?").Length > 4)
{
score++;
}
// If 99% of the password are letters then lower the score
if (Mathc.ValueOf(Regex.Match(password, @"^(?=.*[a-z])(?=.*[A-Z]).+$").Length, password.Length, 100) == 99)
{
score--;
}
else if (Regex.IsMatch(password, @"^(?=.*[a-z])(?=.*[A-Z]).+$"))
{
score++;
}
if (Regex.IsMatch(password, @"[!,@,#,$,%,^,&,*,?,_,~,-,£,(,)]"))
{
score++;
}
if (string.Equals(password, "password", StringComparison.CurrentCultureIgnoreCase) ||
string.Equals(password, "p4ssw0rd", StringComparison.CurrentCultureIgnoreCase) ||
string.Equals(password, "p455w0rd", StringComparison.CurrentCultureIgnoreCase))
{
score = 1;
}
if (password.Distinct(new DynamicEqualityComparer <char>((a, b) => a == b)).Count() == 1)
{
score = score - 2;
}
return((PasswordScore)Mathc.Clamp(score, 1, 5));
}
// Graph Navigation.
#region
void NavigateBetweenAstar(int indexA, int indexB)
{
int nextIndex = indexB;
var q = new List <int>();
int cIndex = 0;
bool foundTarget = false;
float dist = float.MaxValue;
startIndex = indexA;
finalIndex = indexB;
if (startIndex == finalIndex)
{
return;
}
ClearPointNavData();
graphPoints[indexA].navData = new GraphPoint.NavData(indexA, 0.0f);
graphPoints[indexB].navData.wasTarget = true;
foreach (var link in graphPoints[indexA].connections)
{
float comp = Mathc.SqrDist2D(PointPos(link.index), PointPos(indexB));
if (comp < dist)
{
dist = comp;
cIndex = graphPoints[indexA].connections.IndexOf(link);
}
else
{
graphPoints[link.index].navData.evaluated = true;
}
}
graphPoints[indexA].navData.evaluated = true;
dist = graphPoints[indexA].connections[cIndex].dist;
cIndex = graphPoints[indexA].connections[cIndex].index;
graphPoints[cIndex].navData = new GraphPoint.NavData(indexA, dist);
q.Add(cIndex);
while (q.Count > 0)
{
int curIndex = q[0];
if (curIndex == indexB)
{
foundTarget = true;
}
else if (graphPoints[curIndex].navData.evaluated)
{
q.Remove(curIndex);
continue;
}
cIndex = 0;
dist = float.MaxValue;
foreach (var link in graphPoints[curIndex].connections)
{
if (graphPoints[link.index].navData.evaluated)
{
continue;
}
float comp = Mathc.SqrDist2D(PointPos(link.index), PointPos(indexB));
if (comp < dist)
{
dist = comp;
cIndex = graphPoints[curIndex].connections.IndexOf(link);
}
else
{
graphPoints[link.index].navData.evaluated = true;
}
}
dist = graphPoints[curIndex].connections[cIndex].dist + graphPoints[curIndex].navData.tDist;
cIndex = graphPoints[curIndex].connections[cIndex].index;
if (dist < graphPoints[cIndex].navData.tDist)
{
graphPoints[cIndex].navData = new GraphPoint.NavData(curIndex, dist);
}
if (!foundTarget)
{
q.Add(cIndex);
}
graphPoints[curIndex].navData.evaluated = true;
q.Remove(curIndex);
}
// Record path.
q.Clear();
q.Add(nextIndex);
for (int a = 0; a < graphPoints.Count && nextIndex != indexA; a++)
{
nextIndex = graphPoints[nextIndex].navData.pIndex;
q.Add(nextIndex);
}
navPath.Clear();
for (int a = 0; a < q.Count; a++)
{
navPath.Add(q[q.Count - (a + 1)]);
}
}
public NodeController GetRandomConnection()
{
return(Mathc.GetRandomValueFromDict(ref connections));
}
/// <summary> </summary>
/// <param name="index"></param>
/// <param name="numNodes"></param>
/// <param name="replaceAxonWeights">
/// If you do not want to change the inputs going into this layer, set to false.
/// NOTE: If the layer does not contain the same number of nodes as the one before it, THIS OPTION WILL DO NOTHING!!
/// </param>
/// <param name="randomWeights"></param>
/// <param name="weightVal"></param>
/// <param name="biasVal"></param>
/// <returns></returns>
public bool AddLayer(int index, int numNodes, bool replaceAxonWeights, bool randomWeights, float weightVal = 1.0f, float biasVal = 0.0f)
{
if (!Mathc.ValueIsBetween(index, 0, layerCount, true))
{
return(false);
}
// If the added layer and previous layer do not have the same number of nodes, copying connections can't be done.
//Debug.Log($"{numNodes} != {nodeLayers[index-1].Count}");
if (numNodes != nodeLayers[index - 1].Count)
{
replaceAxonWeights = true;
}
NeuronListWrapper newLayer = new List <Neuron>(numNodes);
// Create and insert newLayer
for (int i = 0; i < numNodes; ++i)
{
newLayer.Add(new Neuron(nodeCount++, randomWeights ? Random.value * 2 - 1 : biasVal));
}
nodeLayers.Insert(index, newLayer);
var prevLayer = nodeLayers[index - 1];
var nextLayer = nodeLayers[index + 1];
// If possible, copy prevLayer->nextLayer connections to corresponding newLayer->nextLayer connections
if (!replaceAxonWeights)
{
//Debug.Log("Copying connections");
for (int i = 0; i < prevLayer.Count; ++i)
{
var n0 = prevLayer[i];
var n1 = newLayer[i];
foreach (var n2 in nextLayer)
{
n0.ReplaceConnection(n2, n1, false);
}
}
}
// If not copying, remove prevLayer's connections, and then connect newLayer to nextLayer.
else
{
//Debug.Log("Replacing connections");
foreach (var n0 in prevLayer)
{
n0.RemoveAllConnections();
}
foreach (var n0 in newLayer)
{
foreach (var n1 in nextLayer)
{
n0.ConnectNode(n1, randomWeights ? Random.value * 2 - 1 : weightVal);
}
}
}
// Connect prevLayer to newLayer
foreach (var n0 in prevLayer)
{
foreach (var n1 in newLayer)
{
n0.ConnectNode(n1, randomWeights ? Random.value * 2 - 1 : weightVal);
}
}
return(true);
}
