public bool Move(Rectangle area, float distance, object data, OnMovementFinished onMovementFinished, OnMovementCancelled onMovementCancelled)
{
AbortCurrentMovement();
this.data = data;
this.onMovementFinished = onMovementFinished;
this.onMovementCancelled = onMovementCancelled;
if (area.Contains(representable.getPosition(), 0))
{
if (onMovementFinished != null)
{
onMovementFinished(data);
}
return(true);
}
var accesible = TrajectoryHandler.GetAccessibleTrajectory(representable.getPosition(), FindObjectOfType <SceneMB>().Trajectory);
Vector2[] intersections;
if (TrajectoryHandler.TrajectoryRectangleIntersections(area, accesible, out intersections))
{
var route = accesible.route(representable.getPosition(), intersections);
if (route != null && route.Length > 0)
{
toArea = area;
distanceToArea = distance;
MoveRoute(route);
return(true);
}
}
return(false);
}
public InteractuableResult Interacted(PointerEventData pointerData)
{
InteractuableResult res = InteractuableResult.IGNORES;
switch (SceneData.getType())
{
case GeneralScene.GeneralSceneSceneType.SCENE:
var scene = SceneData as Scene;
if (!Game.Instance.GameState.IsFirstPerson && scene.isAllowPlayerLayer())
{
RaycastHit hitInfo;
background.GetComponent <Collider>().Raycast(Camera.main.ScreenPointToRay(pointerData.position), out hitInfo, float.MaxValue);
var texPos = PixelsSize;
var texCoord = hitInfo.textureCoord;
texCoord.y = 1 - texCoord.y;
texPos.Scale(texCoord);
var positioner = PlayerMB.Instance.GetComponent <ScenePositioner>();
var accesible = TrajectoryHandler.GetAccessibleTrajectory(positioner.Position, trajectoryHandler);
PlayerMB.Instance.GetComponent <Mover>().Move(accesible.closestPoint(texPos));
}
break;
case GeneralScene.GeneralSceneSceneType.SLIDESCENE:
if (ProgressSlide())
{
res = InteractuableResult.REQUIRES_MORE_INTERACTION;
}
else
{
res = FinishCutscene((Cutscene)SceneData);
}
break;
case GeneralScene.GeneralSceneSceneType.VIDEOSCENE:
var videoscene = (Videoscene)SceneData;
if (movieplayer == MovieState.NOT_MOVIE ||
movieplayer == MovieState.STOPPED ||
(movieplayer == MovieState.PLAYING && !movie.isPlaying()) ||
videoscene.isCanSkip())
{
movie.Stop();
movieplayer = MovieState.STOPPED;
if (movieplayer == MovieState.PLAYING)
{
TrackerAsset.Instance.Accessible.Skipped(SceneData.getId(), AccessibleTracker.Accessible.Cutscene);
}
res = FinishCutscene(videoscene);
}
break;
}
return(res);
}
public static TrajectoryHandler GetAccessibleTrajectory(Vector2 position, TrajectoryHandler original)
{
position = original.closestPoint(position);
var line = original.containingLine(position);
if (line == null)
{
// Return empty trajectory
return(new TrajectoryHandler(new Trajectory()));
}
var output = new Trajectory();
var toOpen = new Queue <LineHandler>();
var opened = new Dictionary <LineHandler, bool>();
var added = new Dictionary <string, bool>();
toOpen.Enqueue(line);
while (toOpen.Count != 0)
{
var current = toOpen.Dequeue();
opened[current] = true;
// First we add both nodes and the side
if (!added.ContainsKey(current.start.getID()))
{
output.addNode(current.start.getID(), current.start.getX(), current.start.getY(), current.start.getScale());
added.Add(current.start.getID(), true);
}
if (!added.ContainsKey(current.end.getID()))
{
output.addNode(current.end.getID(), current.end.getX(), current.end.getY(), current.end.getScale());
added.Add(current.end.getID(), true);
}
output.addSide(current.start.getID(), current.end.getID(), (int)current.getDistance());
// Then we add the neightbor lines to expand
foreach (var side in current.getNeighborLines())
{
if (opened.ContainsKey(side) && opened[side])
{
continue;
}
else
{
toOpen.Enqueue(side);
}
}
}
return(new TrajectoryHandler(output));
}
public static Rectangle MoveAreaToTrajectory(this Rectangle area, uAdventure.Runner.TrajectoryHandler trajectory)
{
var points = area.isRectangular() ? area.ToRect().ToPoints() : area.getPoints().ToArray();
var aa = new ActiveArea("aux", false, 0, 0, 0, 0);
var pointsList = aa.getPoints();
var center = points.Aggregate((v1, v2) => v1 + v2) / points.Length;
var adjust = -center + trajectory.closestPoint(center);
foreach (var p in points)
{
pointsList.Add(p + adjust);
}
return(aa);
}
public static bool TrajectoryRectangleIntersections(Rectangle rect, TrajectoryHandler trajectory, out Vector2[] intersections)
{
List <Vector2> intersectionsList = new List <Vector2>();
Vector2[] currentIntersections;
foreach (var side in trajectory.lines)
{
if (LineRectangleIntersections(rect, LineHandler.nodeToVector2(side.start),
LineHandler.nodeToVector2(side.end), out currentIntersections))
{
intersectionsList.AddRange(currentIntersections);
}
}
intersections = intersectionsList.ToArray();
return(intersections.Length > 0);
}
public bool Move(Vector2 point, object data, OnMovementFinished onMovementFinished, OnMovementCancelled onMovementCancelled)
{
AbortCurrentMovement();
this.data = data;
this.onMovementFinished = onMovementFinished;
this.onMovementCancelled = onMovementCancelled;
var accesible = TrajectoryHandler.GetAccessibleTrajectory(representable.getPosition(), FindObjectOfType <SceneMB>().Trajectory);
var route = accesible.route(representable.getPosition(), point);
if (route != null && route.Length > 0)
{
toArea = null;
MoveRoute(route);
return(true);
}
return(false);
}
private void RefreshPlayerAndTrajectory(Scene scene)
{
var playerContext = Game.Instance.GameState.PlayerContext;
//###################### BARRIERS ######################
var barriers = scene.getBarriers().FindAll(b => ConditionChecker.check(b.getConditions())).ToArray();
var trajectory = scene.getTrajectory();
if (trajectory == null)
{
barriers = barriers.ToList().ConvertAll(b =>
{
Barrier r = b.Clone() as Barrier;
r.setValues(r.getX(), 0, r.getWidth(), backgroundTexture.height);
return(r);
}).ToArray();
trajectory = new Trajectory();
var width = backgroundTexture ? backgroundTexture.width : Screen.width;
trajectory.addNode("leftSide", 0, playerContext.getY(), playerContext.Scale);
trajectory.addNode("rightSide", width, playerContext.getY(), playerContext.Scale);
trajectory.addSide("leftSide", "rightSide", width);
}
trajectoryHandler = new TrajectoryHandler(TrajectoryHandler.CreateBlockedTrajectory(trajectory, barriers));
if (!ready)
{
Representable player = GameObject.Instantiate(playerPrefab, referencesHolder).GetComponent <Representable>();
player.Element = Game.Instance.GameState.Player;
player.Context = playerContext;
var scenePositioner = player.gameObject.AddComponent <ScenePositioner>();
scenePositioner.Scene = this;
scenePositioner.Representable = player;
scenePositioner.Context = playerContext;
// Force the start
player.SendMessage("Start");
}
}
public void RenderScene()
{
ready = false;
this.transform.position = new Vector3(0, 0, 0);
LoadParents();
switch (SceneData.getType())
{
default:
Debug.LogError("Wrong scene type: " + SceneData.GetType());
ready = true;
break;
case GeneralScene.GeneralSceneSceneType.VIDEOSCENE:
InventoryManager.Instance.Show = false;
movie = Game.Instance.ResourceManager.getVideo(((Videoscene)SceneData).getResources()[0].getAssetPath(Videoscene.RESOURCE_TYPE_VIDEO));
movieplayer = MovieState.LOADING;
SetBackground(movie.Movie);
break;
case GeneralScene.GeneralSceneSceneType.SCENE:
InventoryManager.Instance.Show = true;
Scene scene = (Scene)SceneData;
Texture2D backgroundTexture = null;
foreach (ResourcesUni sr in scene.getResources())
{
if (ConditionChecker.check(sr.getConditions()))
{
backgroundTexture = Game.Instance.ResourceManager.getImage(sr.getAssetPath(Scene.RESOURCE_TYPE_BACKGROUND));
SetBackground(backgroundTexture);
var foregroundPath = sr.getAssetPath(Scene.RESOURCE_TYPE_FOREGROUND);
if (!string.IsNullOrEmpty(foregroundPath))
{
Texture2D foregroundTexture = Game.Instance.ResourceManager.getImage(foregroundPath);
foreground.GetComponent <Renderer>().material.SetTexture("_MainTex", backgroundTexture);
foreground.GetComponent <Renderer>().material.SetTexture("_AlphaTex", foregroundTexture);
foreground.localScale = background.localScale;
var foreGroundPos = background.localPosition;
foreGroundPos.z = 1;
foreground.localPosition = foreGroundPos;
}
LoadBackgroundMusic(sr);
break;
}
}
LoadZBoundaries();
//###################### REFERENCES ######################
DeleteChilds(referencesHolder);
// Characters
foreach (var context in Game.Instance.GameState
.GetElementReferences(scene.getId())
.Where(tc => !tc.IsRemoved())
.Checked())
{
InstanceElement(context);
}
//###################### ACTIVEAREAS ######################
DeleteChilds(activeAreasHolder);
foreach (var activeArea in scene.getActiveAreas().NotRemoved()
.Where(a => ConditionChecker.check(a.getConditions())))
{
InstanceRectangle <ActiveArea>(activeArea);
}
//###################### EXITS ######################
DeleteChilds(exitsHolder);
foreach (var exit in scene.getExits()
.Where(e => e.isHasNotEffects() || ConditionChecker.check(e.getConditions())))
{
InstanceRectangle <Exit>(exit);
}
if (!Game.Instance.GameState.IsFirstPerson && scene.isAllowPlayerLayer())
{
var playerContext = Game.Instance.GameState.PlayerContext;
//###################### BARRIERS ######################
var barriers = scene.getBarriers().FindAll(b => ConditionChecker.check(b.getConditions())).ToArray();
var trajectory = scene.getTrajectory();
if (trajectory == null)
{
barriers = barriers.ToList().ConvertAll(b => {
Barrier r = b.Clone() as Barrier;
r.setValues(r.getX(), 0, r.getWidth(), backgroundTexture.height);
return(r);
}).ToArray();
trajectory = new Trajectory();
var width = backgroundTexture ? backgroundTexture.width : Screen.width;
trajectory.addNode("leftSide", 0, playerContext.getY(), playerContext.Scale);
trajectory.addNode("rightSide", width, playerContext.getY(), playerContext.Scale);
trajectory.addSide("leftSide", "rightSide", width);
}
trajectoryHandler = new TrajectoryHandler(TrajectoryHandler.CreateBlockedTrajectory(trajectory, barriers));
Representable player = GameObject.Instantiate(playerPrefab, referencesHolder).GetComponent <Representable>();
player.Element = Game.Instance.GameState.Player;
player.Context = playerContext;
var scenePositioner = player.gameObject.AddComponent <ScenePositioner>();
scenePositioner.Scene = this;
scenePositioner.Representable = player;
scenePositioner.Context = playerContext;
// Force the start
player.SendMessage("Start");
ready = true;
}
else
{
ready = true;
}
Camera.main.GetComponent <PlayerFollower>().SettleInstant();
break;
case GeneralScene.GeneralSceneSceneType.SLIDESCENE:
InventoryManager.Instance.Show = false;
Slidescene ssd = (Slidescene)SceneData;
currentSlide = 0;
foreach (ResourcesUni r in ssd.getResources())
{
if (ConditionChecker.check(r.getConditions()))
{
this.slides = Game.Instance.ResourceManager.getAnimation(r.getAssetPath(Slidescene.RESOURCE_TYPE_SLIDES));
SetSlide(0);
LoadBackgroundMusic(r);
ready = true;
break;
}
}
break;
}
firstRender = false;
}
//private SlidesceneResource current_resource;
public void RenderScene()
{
switch (sd.getType())
{
case GeneralScene.GeneralSceneSceneType.VIDEOSCENE:
movie = ResourceManager.Instance.getVideo(((Videoscene)sd).getResources()[0].getAssetPath(Videoscene.RESOURCE_TYPE_VIDEO));
movieplayer = MovieState.LOADING;
this.transform.FindChild("Background").localPosition = new Vector3(40, 30, 20);
break;
case GeneralScene.GeneralSceneSceneType.SCENE:
loadParents();
Scene rsd = (Scene)sd;
foreach (ResourcesUni sr in rsd.getResources())
{
if (ConditionChecker.check(sr.getConditions()))
{
Texture2D tmp = ResourceManager.Instance.getImage(sr.getAssetPath(Scene.RESOURCE_TYPE_BACKGROUND));
Transform background = this.transform.FindChild("Background");
background.GetComponent <Renderer>().material.mainTexture = tmp;
float scale = (tmp.width / (tmp.height / 600f)) / 800f;
this.transform.position = new Vector3(40, 30, 20);
background.localPosition = new Vector3(((80 * scale) - 80) / 2f, 0, 20);
background.transform.localScale = new Vector3(scale * 80, 60, 1);
break;
}
}
//###################### CHARACTERS ######################
deleteChilds(Characters);
foreach (ElementReference context in rsd.getCharacterReferences())
{
instanceElement <NPC>(context);
}
//###################### OBJECTS ######################
deleteChilds(Objects);
foreach (ElementReference context in rsd.getItemReferences())
{
instanceElement <Item>(context);
}
//###################### ATREZZOS ######################
deleteChilds(Atrezzos);
foreach (ElementReference context in rsd.getAtrezzoReferences())
{
instanceElement <Atrezzo>(context);
}
//###################### ACTIVEAREAS ######################
deleteChilds(ActiveAreas);
foreach (ActiveArea ad in rsd.getActiveAreas())
{
if (ConditionChecker.check(ad.getConditions()))
{
instanceRectangle <ActiveArea>(ad);
}
}
//###################### EXITS ######################
deleteChilds(Exits);
foreach (Exit exit in rsd.getExits())
{
if (exit.isHasNotEffects() || ConditionChecker.check(exit.getConditions()))
{
instanceRectangle <Exit>(exit);
}
}
if (!Game.Instance.GameState.isFirstPerson())
{
if (rsd.getTrajectory() == null)
{
break;
}
trajectory = new TrajectoryHandler(rsd.getTrajectory());
if (player_context == null)
{
//Vector2 pos = LineHandler.nodeToVector2 (lines [lines.Count-1].end);
Trajectory.Node pos = trajectory.getLastNode();
player_context = new ElementReference("Player", pos.getX(), pos.getY(), rsd.getPlayerLayer());
player_context.setScale(pos.getScale());
}
/*GameObject.Destroy(this.transform.FindChild ("Player"));*/
var player = GameObject.Instantiate(Player_Prefab).GetComponent <PlayerMB>();
player.transform.parent = Characters;
player.Element = Game.Instance.GameState.getPlayer();
player.Context = player_context;
}
break;
case GeneralScene.GeneralSceneSceneType.SLIDESCENE:
Slidescene ssd = (Slidescene)sd;
foreach (ResourcesUni r in ssd.getResources())
{
if (ConditionChecker.check(r.getConditions()))
{
this.slides = ResourceManager.Instance.getAnimation(r.getAssetPath(Slidescene.RESOURCE_TYPE_SLIDES));
this.transform.FindChild("Background").GetComponent <Renderer>().material.mainTexture = this.slides.frames[0].Image;
this.transform.position = new Vector3(40, 30, 20);
break;
}
}
break;
}
}
