public override void Clone(ScalableObject toClone, Vector2 positioner)
{
PathObject pathObjectToClone = toClone as PathObject;
Init();
BezierCurve.Clear();
BezierCurve = pathObjectToClone.BezierCurve.ConvertAll(segment => new BezierSegment(this, segment));
IsClosed = pathObjectToClone.IsClosed;
OrganizeAllNeighbors();
HandOverPointsToRenderer();
_pathRenderer.UpdateRenderer();
_pathSelectionRenderer.UpdateRenderer();
Anchors(GetAllPoints());
PositionAtCenter(positioner);
SortPoints(GetAllPoints());
UpdateInlineAreaRenderer();
IColorable selectable = toClone as IColorable;
UpdateFillRendererColor(selectable.GetInlineAreaColor());
UpdateLineRendererColor(selectable.GetPathColor());
UpdateLineRendererThickness(selectable.GetPathThickness());
Hover(false);
ShowBoundingRect(false);
selected = false;
SegmentCount = BezierCurve.Count;
showPointsHandles = false;
}
protected virtual void WritePathObjectToXML(XmlWriter writer, Level level, PathObject obj)
{
writer.WriteStartElement("PathObject");
writer.WriteElementString("StartNodeIndex", obj.Parameters[0].ToString());
writer.WriteElementString("Length", obj.Parameters[1].ToString());
writer.WriteStartElement("Parameters");
writer.WriteAttributeString("count", "3");
for (int j = 0; j < 3; j++)
{
writer.WriteStartElement("Parameter");
writer.WriteAttributeString("id", j.ToString());
writer.WriteString(obj.Parameters[j + 2].ToString());
writer.WriteEndElement();
}
writer.WriteEndElement();
IEnumerable <LevelObject> nodes = level.GetAllObjectsByType(LevelObject.Type.PATH_NODE);
writer.WriteStartElement("Nodes");
for (int j = obj.Parameters[0]; j < (obj.Parameters[0] + obj.Parameters[1]); j++)
{
WritePathNodeObjectToXML(writer, (PathPointObject)nodes.ElementAt(j), j);
}
writer.WriteEndElement();
writer.WriteEndElement();
}
public bool saveDocument(string document, string serverPath, string dirName, string name)
{
var path = serverPath + @"\Generated_Lists" + @"\" + dirName;
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
path = path + @"\" + name + @".txt";
if (File.Exists(path))
{
return(false);
}
var writer = new StreamWriter(path, false);
writer.Write(document);
writer.Close();
var pathObj = new PathObject();
pathObj.id = MasterDictionary.GetCount() + 1;
pathObj.dirName = dirName;
pathObj.path = path;
pathObj.isAvail = (dirName == name) ? false : true;
pathObj.isCompleted = false;
pathObj.LastIndex = 0;
MasterDictionary.AddEntry(name, pathObj);
return(true);
}
public PPDEffectPool(PPDDevice device, PathObject filename, int count, PPDFramework.Resource.ResourceManager resourceManager)
: base(device, count)
{
this.filename = filename;
this.resourceManager = resourceManager;
Initialize();
}
public List <PathObject> CalculatePath(PathObject start, PathObject end, List <PathObject> path)
{
var currentPath = new List <PathObject>(path);
currentPath.Add(start);
if (start.Id == end.Id)
{
return(currentPath);
}
var neighbors = new Stack <PathObject>(start.Neighbors);
List <PathObject> calcPath = null;
while (neighbors.Count > 0)
{
List <PathObject> tempPath = null;
var pathObject = neighbors.Pop();
if (!checkIfPathContains(pathObject.Id, currentPath))
{
tempPath = CalculatePath(pathObject, end, currentPath);
}
if (tempPath != null)
{
if (calcPath == null || calcPath.Count > tempPath.Count)
{
calcPath = tempPath;
}
}
}
return(calcPath);
}
public int AddPath(PathObject _path)
{
int id = GetUniquePathId();
mDicPathAll.Add(id, _path);
return(id);
}
public UserComponent(PPDDevice device, PPDFramework.Resource.ResourceManager resourceManager, User user) : base(device)
{
this.resourceManager = resourceManager;
User = user;
this.AddChild((userIcon = new PictureObject(device, resourceManager, PathObject.Absolute(currentUserIconPath), true)
{
Position = new Vector2(21, 21)
}));
this.AddChild((userNameString = new TextureString(device, "", 18, 160, PPDColors.White)
{
Position = new Vector2(42, 12)
}));
this.AddChild(rectangle = new RectangleComponent(device, resourceManager, PPDColors.White)
{
Hidden = true,
Position = new Vector2(5, 5),
RectangleHeight = 30
});
AddBinding(new Binding(user, "Name", this, "UserName"));
AddBinding(new Binding(user, "ImagePath", this, "UserImagePath"));
ChangeUserIconScale();
}
public override void OnInspectorGUI()
{
serializedObject.Update();
EditorGUILayout.PropertyField(serializedObject.FindProperty(nameof(_path)));
EditorGUILayout.LabelField("Objects:", EditorStyles.boldLabel);
GUI.enabled = false;
EditorGUI.indentLevel++;
SerializedProperty objects = serializedObject.FindProperty(nameof(_objects));
List <PathObject> objectsList = objects.MakeList <PathObject>();
for (int i = 0; i < objectsList.Count; i++)
{
PathObject pathObject = objectsList[i];
EditorGUILayout.ObjectField($"{i} [{pathObject.Position}]", pathObject, typeof(PathObject), allowSceneObjects: true);
}
EditorGUI.indentLevel--;
GUI.enabled = true;
serializedObject.ApplyModifiedProperties();
}
public override void EnterLoading()
{
if (imageFiles != null && imageFiles.Length > 0)
{
if (currentImage != null)
{
RemoveChild(currentImage);
currentImage.Dispose();
currentImage = null;
}
var index = new Random().Next(imageFiles.Length);
currentImage = new PictureObject(device, ResourceManager, PathObject.Absolute(imageFiles[index]), true)
{
Position = new Vector2(400, 225)
};
var aspect = currentImage.Width / currentImage.Height;
var displayAspect = 16 / 9f;
Vector2 scale;
if (aspect > displayAspect)
{
scale = new Vector2(800 / currentImage.Width);
}
else
{
scale = new Vector2(450 / currentImage.Height);
}
currentImage.Scale = scale;
AddChild(currentImage);
}
}
public ActivityPickupQuest(Task t, PathObject obj, String QuestName, String QuestID)
: base(t, "PickupQuest " + QuestName)
{
this.pathObject = obj;
this.QuestName = QuestName;
this.QuestID = QuestID;
}
public static void Create()
{
PathObject asset = ScriptableObject.CreateInstance <PathObject>();
AssetDatabase.CreateAsset(asset, "Assets/Paths/NewPathObject.asset");
AssetDatabase.SaveAssets();
}
private static void WritePathObjectToXML(XmlWriter writer, PathObject obj)
{
writer.WriteStartElement("PathObject");
writer.WriteElementString("StartNodeIndex", obj.Parameters[0].ToString());
writer.WriteElementString("Length", obj.Parameters[1].ToString());
writer.WriteStartElement("Parameters");
writer.WriteAttributeString("count", "3");
for (int j = 0; j < 3; j++)
{
writer.WriteStartElement("Parameter");
writer.WriteAttributeString("id", j.ToString());
writer.WriteString(obj.Parameters[j + 2].ToString());
writer.WriteEndElement();
}
writer.WriteEndElement();
IEnumerable <LevelObject> nodes = m_LevelObjects.Values.Where(obj0 => (obj0.m_Type) == 2);
writer.WriteStartElement("Nodes");
for (int j = obj.Parameters[0]; j < (obj.Parameters[0] + obj.Parameters[1]); j++)
{
WritePathNodeObjectToXML(writer, (PathPointObject)nodes.ElementAt(j), j);
}
writer.WriteEndElement();
writer.WriteEndElement();
}
public static BatchData GetBatch(string name)
{
string document = null;
PathObject pathObject = mastDictionary[name];
if (pathObject.isAvail)
{
var reader = new StreamReader(pathObject.path);
document = reader.ReadToEnd();
reader.Close();
// update dictionary entry
pathObject.isAvail = false;
mastDictionary[name] = pathObject;
SaveDictionaryToDisk();
}
BatchData batch = new BatchData();
batch.Data = document.Replace("\r", "");
batch.Id = pathObject.id;
batch.Key = name;
batch.LastComplete = pathObject.LastIndex;
return(batch);
}
public PathObject AddPathObject()
{
PathObject obj = new PathObject(
InitialiseDataForObject(LevelObject.Type.PATH), (int)GetNextUniqueID());
m_LevelObjects.Add(obj.m_UniqueID, obj);
return(obj);
}
void UpdatePathObject(ScalableObject current)
{
_currentHoveredObject = current;
_currentPathObject = current as PathObject;
if (_currentPathObject != null)
{
_segments = _currentPathObject.BezierCurve;
}
}
public ActivityHandinQuest(Task t, PathObject obj, String QuestName, String QuestID, int Reward, bool Repeatable)
: base(t, "HandinQuest " + QuestName)
{
this.pathObject = obj;
this.QuestName = QuestName;
this.QuestID = QuestID;
this.Reward = Reward;
this.t = t;
this.Repeatable = Repeatable;
}
public PathPointObject AddPathPointObject(PathObject parent)
{
// Calculate the Node ID using the parent path's start offset and length
int nodeID = parent.Parameters[0] + parent.Parameters[1];
PathPointObject obj = new PathPointObject(
InitialiseDataForObject(LevelObject.Type.PATH_NODE), (int)GetNextUniqueID(), nodeID);
m_LevelObjects.Add(obj.m_UniqueID, obj);
return(obj);
}
public static bool AddEntry(string key, PathObject obj)
{
var result = mastDictionary.TryAdd(key, obj);
if (result)
{
SaveDictionaryToDisk();
}
return(result);
}
public BezierSegment(PathObject pathObject, BezierSegment toClone)
{
_pathObject = pathObject;
Point = toClone.Point;
FirstHandle = toClone.FirstHandle;
SecondHandle = toClone.SecondHandle;
SegmentCount = toClone.SegmentCount;
SegmentPoints = new List <Vector2>(toClone.SegmentPoints);
isFirst = toClone.isFirst;
}
// Use this for initialization
void Start() {
GameObject camera = GameObject.FindWithTag("MainCamera");
m_World = camera.GetComponent<World>();
GameObject pPrev = Instantiate(pathPrefab);
m_PathPreview = pPrev.GetComponent<PathObject>();
pathPreviewRenderer = m_PathPreview.GetComponent<Renderer>();
pathPreviewRenderer.enabled = false;
editingPoints = new Vector2[2]{new Vector2(-1, -1), new Vector2(-1, -1)};
this.transform.position = new Vector3(this.transform.position[0], this.transform.position[1], -1);
}
//
//
void OnEnable()
{
me = target as PathPoint;
//Tools.hidden = true;
if (me == null || me.transform.parent == null)
{
return;
}
myLeader = me.transform.parent.GetComponent <PathObject>();
myLeader.gameObject.SetActive(true);
}
public GroupObject(string tmpKey, int tnr, string tname, PathObject pathObject)
{
key = tmpKey;
toolNr = tnr;
toolName = tname;
groupRelatedGCode = "";
pathDimension = new Dimensions();
pathDimension.addDimensionXY(pathObject.Dimension);
groupPath = new List <PathObject>();
groupPath.Add(pathObject);
AddInfo(pathObject);
}
public PathObject AddPathObject()
{
IEnumerable <LevelObject> paths = GetAllObjectsByType(LevelObject.Type.PATH);
IEnumerable <LevelObject> pathNodes = GetAllObjectsByType(LevelObject.Type.PATH_NODE);
int maxid = (paths.Count() < 1) ? -1 : paths.Max(obj2 => ((PathObject)obj2).m_PathID);
int maxNode = (pathNodes.Count() < 1) ? -1 : pathNodes.Max(obj2 => ((PathPointObject)obj2).m_NodeID);
PathObject obj = new PathObject(
InitialiseDataForObject(LevelObject.Type.PATH), (int)GetNextUniqueID(), (ushort)(maxid + 1));
obj.Parameters[0] = (ushort)(maxNode + 1);
m_LevelObjects.Add(obj.m_UniqueID, obj);
return(obj);
}
void OnEnable()
{
path = target as PathObject;
//touchAction = touchObjectControl.touchAction;
// we want to start toolbar where we left off
//toolBar = EditorPrefs.GetInt("index",0);
if (path == null)
{
return;
}
Tools.hidden = true;
path.gameObject.SetActive(true);
}
public static void UpdateEntry(string key, bool isComplete, int lastIndex)
{
// update dictionary entry
PathObject tmp = mastDictionary[key];
if (!tmp.isCompleted)
{
tmp.isCompleted = isComplete;
tmp.isAvail = !isComplete;
tmp.LastIndex = lastIndex;
mastDictionary[key] = tmp;
SaveDictionaryToDisk();
}
}
public static int StartPath(PathObject pathObject)//string cmt)
{
Point coordxy = pathObject.Start;
double angle = 0;
angle = pathObject.StartAngle;
PenUp(); // Don't set xmlMarker.figureEnd
if (!pathInfo.IsSameAs(pathObject.Info) || FigureEndTagWasSet)
{
if (!FigureEndTagWasSet)
{
SetFigureEndTag();
}
FigureEndTagWasSet = true;
string xml = string.Format("{0} Id=\"{1}\"{2}> ", xmlMarker.figureStart, (++PathCount), getFigureAttributes(pathObject).ToString()); //attributeGeometry, attributeId, attributeColor, attributeToolNr);
if (figureEnable)
{
Comment(xml);
}
if (logCoordinates)
{
Logger.Trace(" StartPath Option:{0} {1}", pathObject.Options, xml);
}
FigureEndTagWasSet = false;
pathInfo = pathObject.Info.Copy();
if ((pathObject.Options & CreationOptions.AddPause) > 0)
{
gcode.Pause(gcodeString);
}
}
double setangle = 180 * angle / Math.PI;
gcode.setTangential(gcodeString, setangle);
gcode.MoveToRapid(gcodeString, coordxy);
PenDown("");
if (logCoordinates)
{
Logger.Trace(" StartPath at x{0:0.000} y{1:0.000} a={2:0.00}", coordxy.X, coordxy.Y, setangle);
}
lastGC = coordxy;
return(PathCount);
}
private void Awake()
{
anim = GetComponentInChildren <Animator>();
SafeDistance = DetectionRadius;
SC = this.GetComponent <SphereCollider>();
SC.radius = DetectionRadius;
detectionRay = new Ray();
myManager = GameObject.FindGameObjectWithTag("Manager").GetComponent <ManagerScript>();
humanNavAgent = this.gameObject.GetComponent <NavMeshAgent>();
CurrentPath = KitchenPath;
//CurrentPathPoint = 0;
InvokeRepeating("AlienDetection", 2f, 2f);
}
/// <summary>
/// Constructs a new Path (with the desired thickness) between each adjacent landmark given,
/// and returns that series of Path objects.
/// </summary>
/// <param name="landmarks">Landmarks to be connected. Note that these don't necessarily have to be on the same line.</param>
/// <param name="thickness">Thickness of the Path objects to be created.</param>
/// <returns></returns>
private List <PathObject> getFullPath(List <Coord2DObject> landmarks, int thickness)
{
List <PathObject> paths = new List <PathObject>(landmarks.Count);
for (int i = 0; i < landmarks.Count - 1; i++)
{
Coord2DObject landmark1 = landmarks[i];
Coord2DObject landmark2 = landmarks[i + 1];
PathObject p = new PathObject(this, landmark1, landmark2, thickness);
paths.Add(p);
}
return(paths);
}
private static StringBuilder getFigureAttributes(PathObject pathObject)
{
StringBuilder attributes = new StringBuilder();
if (pathObject.Info.pathGeometry.Length > 0)
{
attributes.Append(string.Format(" Geometry=\"{0}\"", pathObject.Info.pathGeometry));
}
if (pathObject.Info.groupAttributes[1].Length > 0)
{
attributes.Append(string.Format(" PenColor=\"{0}\"", pathObject.Info.groupAttributes[1]));
}
if (pathObject.Info.groupAttributes[2].Length > 0)
{
attributes.Append(string.Format(" PenWidth=\"{0}\"", pathObject.Info.groupAttributes[2]));
}
if (pathObject.Info.groupAttributes[3].Length > 0)
{
attributes.Append(string.Format(" Layer=\"{0}\"", pathObject.Info.groupAttributes[3]));
}
if (pathObject.Info.groupAttributes[4].Length > 0)
{
attributes.Append(string.Format(" Tile=\"{0}\"", pathObject.Info.groupAttributes[4]));
}
if (pathObject.Info.groupAttributes[5].Length > 0)
{
attributes.Append(string.Format(" Type=\"{0}\"", pathObject.Info.groupAttributes[5]));
}
if (pathObject.Info.pathId.Length > 0)
{
attributes.Append(string.Format(" PathID=\"{0}\"", pathObject.Info.pathId));
}
if (pathObject.PathLength > 0)
{
attributes.Append(string.Format(" PathLength=\"{0:0.0}\"", pathObject.PathLength));
}
/* attributes.Append((pathObject.Info.pathGeometry.Length > 0) ? string.Format(" Geometry=\"{0}\"", pathObject.Info.pathGeometry) : "");
* attributes.Append((pathObject.Info.groupAttributes[1].Length > 0)? string.Format(" PenColor=\"{0}\"", pathObject.Info.groupAttributes[1]) : "");
* attributes.Append((pathObject.Info.groupAttributes[2].Length > 0) ? string.Format(" PenWidth=\"{0}\"", pathObject.Info.groupAttributes[2]) : "");
* attributes.Append((pathObject.Info.groupAttributes[3].Length > 0) ? string.Format(" Layer=\"{0}\"", pathObject.Info.groupAttributes[3]) : "");
* attributes.Append((pathObject.Info.groupAttributes[4].Length > 0) ? string.Format(" Tile=\"{0}\"", pathObject.Info.groupAttributes[4]) : "");
* attributes.Append((pathObject.Info.groupAttributes[5].Length > 0) ? string.Format(" Type=\"{0}\"", pathObject.Info.groupAttributes[5]) : "");
* attributes.Append((pathObject.Info.pathId.Length > 0) ? string.Format(" PathID=\"{0}\"", pathObject.Info.pathId) : "");
* attributes.Append((pathObject.PathLength > 0) ? string.Format(" PathLength=\"{0:0.0}\"", pathObject.PathLength) : "");
*/return(attributes);
}
public static GhostInformation FromPathObject(PathObject pathObject)
{
GhostInformation information = new GhostInformation();
information.Room = pathObject.room;
information.Movement = pathObject.movement.Cast <JArray>().Select <JArray, Vector2>((JArray jarray) => {
return(new Vector2(jarray[0].Value <float>(), jarray[1].Value <float>()));
}).ToArray();
information.Interactions = pathObject.interaction.Cast <JArray>().Select(jarray => {
float x = jarray[0].Value <float>();
float y = jarray[1].Value <float>();
string interaction = jarray[2].Value <string>();
return(new GhostInteraction(new Vector2(x, y), interaction));
}).ToArray();
return(information);
}
//Path Get
public void RunSendPath(Int32 x, Int32 y, string name, string room, ArrayList movement, ArrayList interaction)
{
ArrayList playerPos = new ArrayList();
playerPos.Add(x);
playerPos.Add(y);
PathObject pathObj = new PathObject();
pathObj.position = playerPos;
pathObj.name = name;
pathObj.room = room;
pathObj.movement = movement;
pathObj.interaction = interaction;
StartCoroutine(CRSendPath(pathObj));
}
private static void WritePathObjectToXML(XmlWriter writer, PathObject obj)
{
writer.WriteStartElement("PathObject");
writer.WriteElementString("StartNodeIndex", obj.Parameters[0].ToString());
writer.WriteElementString("Length", obj.Parameters[1].ToString());
writer.WriteStartElement("Parameters");
writer.WriteAttributeString("count", "3");
for (int j = 0; j < 3; j++)
{
writer.WriteStartElement("Parameter");
writer.WriteAttributeString("id", j.ToString());
writer.WriteString(obj.Parameters[j + 2].ToString());
writer.WriteEndElement();
}
writer.WriteEndElement();
IEnumerable<LevelObject> nodes = m_LevelObjects.Values.Where(obj0 => (obj0.m_Type) == 2);
writer.WriteStartElement("Nodes");
for (int j = obj.Parameters[0]; j < (obj.Parameters[0] + obj.Parameters[1]); j++)
{
WritePathNodeObjectToXML(writer, (PathPointObject)nodes.ElementAt(j), j);
}
writer.WriteEndElement();
writer.WriteEndElement();
}
// Add an object to this path.
private void AddPathObject(PathObject obj)
{
if( null == actualFigure ) {
actualFigure = new PathFigure();
pathFigures.Add( actualFigure );
}
actualFigure.AddPathObject( obj );
this.AddPathPoints( obj.GetPathPoints() );
}
public void AddPathObject(PathObject obj)
{
pathObjs.Add( obj );
}
// Use this for initialization
void Awake () {
host = gameObject;
follower = transform.GetChild (0).GetComponent<Follower>();
pathObject = transform.GetChild (1).GetComponent<PathObject>();
}
