protected override void OneUseDestroy()
{
base.OneUseDestroy();
Scene.Remove(pathRenderer);
pathRenderer = null;
sfx.Stop();
}
// Start is called before the first frame update
private void Awake()
{
pathFinder = GetComponent <PathfinderAStar>();
pathRenderer = GetComponent <PathRenderer>();
pathVisualizer = GetComponent <PathVisualizer>();
unitHandler = GameObject.FindObjectOfType <CurrentUnitHandler>();
}
void FingerGestures_OnFingerDown(int fingerIndex, Vector2 fingerPos)
{
PathRenderer path = paths[fingerIndex];
path.Reset();
path.AddPoint(fingerPos, fingerDownMarkerPrefab);
}
void OnFingerDown(FingerDownEvent e)
{
PathRenderer path = paths[e.Finger.Index];
path.Reset();
path.AddPoint(e.Finger.Position, fingerDownMarkerPrefab);
}
void OnFingerUp(FingerUpEvent e)
{
PathRenderer path = paths[e.Finger.Index];
path.AddPoint(e.Finger.Position, fingerUpMarkerPrefab);
UI.StatusText = "Finger " + e.Finger + " was held down for " + e.TimeHeldDown.ToString("N2") + " seconds";
}
void Update()
{
if (!rendered && Math.Abs(transform.position.x - Player.transform.position.x) <= settings.RenderDistance && Math.Abs(transform.position.y - Player.transform.position.y) <= settings.RenderDistance)
{
GrassRenderer grenderer = this.GetComponent(typeof(GrassRenderer)) as GrassRenderer;
grenderer.Render();
for (int i = 0; i < this.transform.childCount; i++)
{
if (this.transform.GetChild(i).GetComponent(typeof(PathRenderer)) != null)
{
PathRenderer prenderer = this.transform.GetChild(i).GetComponent(typeof(PathRenderer)) as PathRenderer;
prenderer.Render();
}
}
rendered = true;
}
else if (rendered && Math.Abs(transform.position.x - Player.transform.position.x) > settings.RenderDistance && Math.Abs(transform.position.y - Player.transform.position.y) > settings.RenderDistance)
{
GrassRenderer grenderer = this.GetComponent(typeof(GrassRenderer)) as GrassRenderer;
grenderer.UnRender();
for (int i = 0; i < this.transform.childCount; i++)
{
if (this.transform.GetChild(i).GetComponent(typeof(PathRenderer)) != null)
{
PathRenderer prenderer = this.transform.GetChild(i).GetComponent(typeof(PathRenderer)) as PathRenderer;
prenderer.Render();
}
}
rendered = false;
}
}
private void Awake()
{
inputManager = InputManager.instance;
pathRenderer = GetComponent <PathRenderer>();
thisTransform = transform;
isInCameraFocus = false;
}
void FingerGestures_OnFingerUp(int fingerIndex, Vector2 fingerPos, float timeHeldDown)
{
PathRenderer path = paths[fingerIndex];
path.AddPoint(fingerPos, fingerUpMarkerPrefab);
UI.StatusText = "Finger " + fingerIndex + " was held down for " + timeHeldDown.ToString("N2") + " seconds";
}
void FingerGestures_OnFingerMoveEnd(int fingerIndex, Vector2 fingerPos)
{
UI.StatusText = "Stopped moving finger " + fingerIndex;
PathRenderer path = paths[fingerIndex];
path.AddPoint(fingerPos, fingerMoveEndMarkerPrefab);
}
/// <summary>
/// Wait for path to finish
/// </summary>
/// <returns></returns>
private IEnumerator WaitForPathFinish()
{
yield return(null);
yield return(new WaitUntil(() => agent.remainingDistance <= agent.stoppingDistance));
PathRenderer.ResetPath();
}
/// <summary>
/// Puts a path renderer at the back of the list. Evicts the front of the list if at capacity.
/// </summary>
/// <param name="pathRenderer">The path renderer to put at the back of the list.</param>
private void PushBack(PathRenderer pathRenderer)
{
if (pathList.Count >= CAPACITY)
{
pathList.PopFront().SetVisible(false);
}
pathList.PushBack(pathRenderer);
pathRenderer.SetVisible(outlinePath);
}
/// <summary>
/// Checks for changing the displayed line when the player moves forwards.
/// </summary>
/// <param name="player">The player moving forward.</param>
private void CheckForward(Player player)
{
PathRenderer nextLine = pathList.PeekFront().nextLine;
if (nextLine != null && nextLine.GetBackDistance(player) < pathList.PeekBack().GetFrontDistance(player))
{
PushFront(nextLine);
}
}
/// <summary>
/// Checks for changing the displayed line when the player moves backwards.
/// </summary>
/// <param name="player">The player moving backwards.</param>
private void CheckBackward(Player player)
{
PathRenderer prevLine = pathList.PeekBack().prevLine;
if (prevLine != null && prevLine.GetFrontDistance(player) < pathList.PeekFront().GetBackDistance(player))
{
PushBack(prevLine);
}
}
private void Awake()
{
if (!Instance)
{
Instance = this;
}
else
{
Destroy(gameObject);
}
}
private void HidePath()
{
Path[] paths = DemosHoster.GetComponentsInChildren <Path>(true);
foreach (Path path in paths)
{
PathRenderer pathRenderer = path.GetComponent <PathRenderer>();
Destroy(pathRenderer);
LineRenderer lineRenderer = path.GetComponent <LineRenderer>();
Destroy(lineRenderer);
}
}
/// <summary>
/// Draw current agent path
/// </summary>
/// <returns></returns>
private IEnumerator DrawPath()
{
while (true)
{
if (agent.hasPath)
{
PathRenderer.DrawPath(agent.path.corners);
}
yield return(new WaitForSeconds(0.25f));
}
}
protected override void Start()
{
base.Start();
UI.StatusText = "Drag your fingers anywhere on the screen";
// create one PathRenderer per finger
paths = new PathRenderer[FingerGestures.Instance.MaxFingers];
for( int i = 0; i < paths.Length; ++i )
paths[i] = new PathRenderer( i, lineRendererPrefab );
}
private void RenderPathSegList(SvgGraphicsElement element, SvgPathSegList segs)
{
var reenderer = new PathRenderer();
foreach (var seq in segs)
{
seq.Accept(reenderer);
}
var path = reenderer.Path();
this.RenderShapeToCanvas(element, path);
}
public void Render(D2D.RenderTarget renderTarget, FrameworkElement rootElement, FrameworkElement fe)
{
var textBlock = fe as TextBlock;
if (textBlock != null)
{
TextBlockRenderer.Render(this, renderTarget, rootElement, textBlock);
return;
}
var rectangle = fe as Rectangle;
if (rectangle != null)
{
RectangleRenderer.Render(this, renderTarget, rootElement, rectangle);
return;
}
var border = fe as Border;
if (border != null)
{
BorderRenderer.Render(this, renderTarget, rootElement, border);
return;
}
var ellipse = fe as Ellipse;
if (ellipse != null)
{
EllipseRenderer.Render(this, renderTarget, rootElement, ellipse);
return;
}
var line = fe as Line;
if (line != null)
{
LineRenderer.Render(this, renderTarget, rootElement, line);
return;
}
var path = fe as Path;
if (path != null)
{
PathRenderer.Render(this, renderTarget, rootElement, path);
return;
}
FrameworkElementRenderer.Render(this, renderTarget, rootElement, fe);
}
/// <summary>
/// Subscribes to all connectors
/// </summary>
void Start()
{
m_initialPosition = transform.position;
m_rigidbody = GetComponent <Rigidbody2D>();
m_renderer = GetComponent <SpriteRenderer>();
m_pathRenderer = FindObjectOfType <PathRenderer>();
m_defaultLayer = m_renderer.sortingLayerID;
m_fallingLayer = SortingLayer.NameToID("PlayerFalling");
if (m_pathRenderer == null)
{
Debug.LogWarning("WARNING! Player is missing reference to path renderer");
}
}
LineRenderer lineRenderer; // line renderer reference
#endregion
#region //====== MONOBEHAVIOURS ======\\
private void Awake()
{
if (Instance == null)
{
Instance = this;
}
else
{
Destroy(this);
}
lineRenderer = GetComponent <LineRenderer>();
}
protected override void Start()
{
base.Start();
UI.StatusText = "Drag your fingers anywhere on the screen";
// create one PathRenderer per finger
paths = new PathRenderer[FingerGestures.Instance.MaxFingers];
for (int i = 0; i < paths.Length; ++i)
{
paths[i] = new PathRenderer(i, lineRendererPrefab);
}
}
public void UseSource(object source)
{
_source = source as PathRenderer;
Lighting.IsChecked = _source.Scene.LightingEnabled;
Shadows.IsChecked = _source.Scene.ShadowsEnabled;
SoftShadows.IsChecked = _source.Scene.SoftShadows;
AmbientOcclusion.IsChecked = _source.Scene.AmbientOcclusion;
GISamples.Text = _source.Scene.GISamples.ToString();
FOV.Text = _source.MainCamera.FOV.ToString();
CameraDistance.Text = _source.MainCamera.MaxDistance.ToString();
BatchSize.Text = _source.BatchSize.ToString();
}
void PrefetchData()
{
string tmpPath = pathRenderer.pathFile;
bool tmpToggle = pathRenderer.loadItemDataFromTest;
for (int i = 0; i < commands.Length; i++)
{
pathRenderer.pathFile = commands[i].path;
pathRenderer.loadItemDataFromTest = commands[i].testDataToggle;
commands[i].data = PathRenderer.LoadPathFile(commands[i].path);
commands[i].data = PathRenderer.ScalePathData(commands[i].data, pathRenderer.scaleOnLoad, pathRenderer.offsetOnLoad);
}
pathRenderer.pathFile = tmpPath;
pathRenderer.loadItemDataFromTest = tmpToggle;
}
public GameObject GenerateTrialWithPath()
{
GameObject trialObject = new GameObject("TrialWithPath");
Configuration.GenerateTrial().transform.parent = trialObject.transform;
GameObject renderer = GameObject.Instantiate(PathRenderer, trialObject.transform);
PathRenderer r = renderer.GetComponent <PathRenderer>();
r.PathConfiguration = this;
r.GenerateRenderedPath();
return(trialObject);
}
public override void Added(Scene scene)
{
base.Added(scene);
// Offset the points to their position, relative to the room's position.
Rectangle bounds = SceneAs <Level>().Bounds;
Vector2 levelOffset = new Vector2(bounds.Left, bounds.Top);
for (int i = 0; i < originalNodes.Length; i++)
{
targets[i] = originalNodes[i] + levelOffset;
}
// Creating the Path Renderer.
scene.Add(pathRenderer = new PathRenderer(this));
}
void Start()
{
mesh = PathRenderer.Build(count);
Random.InitState(0);
segmentBuffer = new ComputeBuffer(count, Marshal.SizeOf(typeof(Segment_t)));
var segments = new Segment_t[count];
for (int i = 0; i < count; i++)
{
segments[i].position = new Vector3(Random.value - 0.5f, i, Random.value - 0.5f);
}
segmentBuffer.SetData(segments);
vertexBuffer = new ComputeBuffer(count * 2, Marshal.SizeOf(typeof(Vector3)));
vertexBuffer.SetData(new Vector3[vertexBuffer.count]);
}
void OnFingerMove(FingerMotionEvent e)
{
PathRenderer path = paths[e.Finger.Index];
if (e.Phase == FingerMotionPhase.Started)
{
UI.StatusText = "Started moving " + e.Finger;
// path.AddPoint( e.Position, fingerMoveBeginMarkerPrefab );
}
else if (e.Phase == FingerMotionPhase.Updated)
{
path.AddPoint(e.Position);
}
else
{
UI.StatusText = "Stopped moving " + e.Finger;
// path.AddPoint( e.Position, fingerMoveEndMarkerPrefab );
}
}
/// <summary>
/// Fills the path list with the first lines in the path.
/// </summary>
/// <param name="startPath">The start of the path being rendered.</param>
public void Init(PathComponent startPath)
{
if (pathList.Count > 0)
{
foreach (PathRenderer pathRenderer in pathList)
{
pathRenderer.SetVisible(false);
}
pathList.Clear();
}
if (startPath != null)
{
PathRenderer current = startPath.firstLine;
while (pathList.Count < CAPACITY && current != null)
{
PushFront(current);
current = current.nextLine;
}
}
}
public override void OnInspectorGUI()
{
base.OnInspectorGUI();
if (GUILayout.Button("A*"))
{
var controller = (Controller)target;
var nodes = controller.NodesTree
.Select(kdTreeNode => kdTreeNode.Value)
.Where(informer => informer)
.ToList();
var from = nodes.Find(x => x.transform.position == controller.From);
var to = nodes.Find(x => x.transform.position == controller.To);
DebugInformationAlgorithm debugInformation;
controller.AStar(from, to, controller.Radius, true, out debugInformation);
controller.InitializeDebugInfo();
controller.DebugManagerAStar.AddPath(debugInformation);
}
if (GUILayout.Button("Test"))
{
Test();
}
if (GUILayout.Button("Test100"))
{
for (var i = 0; i < 100; i++)
{
Test();
}
}
if (GUILayout.Button("Map update"))
{
var controller = (Controller)target;
controller.RemoveEmpty();
PathRenderer.MapRebuild();
}
}
public override void Awake(Scene scene)
{
/*
* Yes, I'm doing this before base.Awake, because ConnectedSolid will
* change the original width and height of this entity, because
* of how the game handles multiple colliders, and adds them.
*/
scene.Add(path = new PathRenderer(this));
base.Awake(scene);
if (Theme == SwapBlock.Themes.Normal)
{
greenTiles = AutoTile(customGreenTextures ? customGreenEdgeTiles : GreenEdgeTiles, customGreenTextures ? customGreenInnerCornerTiles : GreenInnerCornerTiles, out greenBgTiles, false, false);
redTiles = AutoTile(customRedTextures ? customRedEdgeTiles : RedEdgeTiles, customRedTextures ? customRedInnerCornerTiles : RedInnerCornerTiles, out redBgTiles, false, false);
}
else
{
greenTiles = AutoTile(customGreenTextures ? customGreenEdgeTiles : MoonGreenEdgeTiles, customGreenTextures ? customGreenInnerCornerTiles : MoonGreenInnerCornerTiles, out greenBgTiles, false, false);
redTiles = AutoTile(customRedTextures ? customRedEdgeTiles : MoonRedEdgeTiles, customRedTextures ? customRedInnerCornerTiles : MoonRedInnerCornerTiles, out redBgTiles, false, false);
}
greenTiles.RemoveAll(image => greenBgTiles.Contains(image));
redTiles.RemoveAll(image => redBgTiles.Contains(image));
Add(middleRed);
Add(middleGreen);
// Making the track rectangle always contain the connected swap block, entirely.
int x1 = (int)MathHelper.Min(GroupBoundsMin.X, offset.X + GroupBoundsMin.X);
int y1 = (int)MathHelper.Min(GroupBoundsMin.Y, offset.Y + GroupBoundsMin.Y);
int x2 = (int)MathHelper.Max(GroupBoundsMax.X, offset.X + GroupBoundsMax.X);
int y2 = (int)MathHelper.Max(GroupBoundsMax.Y, offset.Y + GroupBoundsMax.Y);
moveRect = new Rectangle(x1, y1, x2 - x1, y2 - y1);
scene.Add(bgTiles = new ConnectedSwapBlockBGTilesRenderer(this));
}
