void GetUI(out TokenNode intToken1, out TokenNode intToken2, out TokenNode stringToken1, out TokenNode stringToken2,
out IHighlightable intField, out IHighlightable stringField)
{
intToken1 = m_IntTokenModel1.GetUI <TokenNode>(GraphView);
Assert.IsNotNull(intToken1);
intToken2 = m_IntTokenModel2.GetUI <TokenNode>(GraphView);
Assert.IsNotNull(intToken2);
stringToken1 = m_StringTokenModel1.GetUI <TokenNode>(GraphView);
Assert.IsNotNull(stringToken1);
stringToken2 = m_StringTokenModel2.GetUI <TokenNode>(GraphView);
Assert.IsNotNull(stringToken2);
intField = null;
stringField = null;
intField = GraphView.GetBlackboard().Highlightables.FirstOrDefault(gv =>
ReferenceEquals((gv as BlackboardField)?.Model, m_IntVariableModel));
Assert.IsNotNull(intField);
stringField = GraphView.GetBlackboard().Highlightables.FirstOrDefault(gv =>
ReferenceEquals((gv as BlackboardField)?.Model, m_StringVariableModel));
Assert.IsNotNull(stringField);
}
public Cuboid(Bounds bounds)
{
float minX = bounds.min.x;
float minY = bounds.min.y;
float minZ = bounds.min.z;
float maxX = bounds.max.x;
float maxY = bounds.max.y;
float maxZ = bounds.max.z;
float midX = (minX + maxX) / 2;
float midY = (minY + maxY) / 2;
float midZ = (minZ + maxZ) / 2;
var p0 = new Vector3(maxX, maxY, maxZ);
var p1 = new Vector3(maxX, maxY, minZ);
var p2 = new Vector3(maxX, minY, minZ);
var p3 = new Vector3(maxX, minY, maxZ);
var p4 = new Vector3(minX, minY, maxZ);
var p5 = new Vector3(minX, minY, minZ);
var p6 = new Vector3(minX, maxY, minZ);
var p7 = new Vector3(minX, maxY, maxZ);
m_CornerPoints = new Vector3[] { p0, p1, p2, p3, p4, p5, p6, p7 };
Pivot = new Vector3(midX, midY, midZ);
Faces = new Face[6];
Faces[0] = new Face(p0, p1, p2, p3, Pivot, Pivot, maxX - minX, this);
Faces[1] = new Face(p4, p5, p6, p7, Pivot, Pivot, maxX - minX, this);
Faces[2] = new Face(p2, p3, p4, p5, Pivot, Pivot, maxY - minY, this);
Faces[3] = new Face(p6, p7, p0, p1, Pivot, Pivot, maxY - minY, this);
Faces[4] = new Face(p1, p2, p5, p6, Pivot, Pivot, maxZ - minZ, this);
Faces[5] = new Face(p0, p3, p4, p7, Pivot, Pivot, maxZ - minZ, this);
m_Target = null;
}
public void Interact()
{
if (isOpened == false)
{
if (playerCollectables.KeysAmount > 0)
{
StartCoroutine(open());
highlightningBehaviour = GetComponent <HighlightningBehaviour>();
if (highlightningBehaviour)
{
IHighlightable ih = highlightningBehaviour.GetComponent <IHighlightable>();
if (ih != null)
{
ih.Unhighlight();
}
Destroy(highlightningBehaviour);
}
playerCollectables.IncreaseKeysAmount(-1);
}
else
{
AudioManager.instance.PlaySound("LockedChest");
cameraShake.Shake(0.015f, 0.017f);
}
}
}
public Cuboid(Vector3[] edgePoints, IHighlightable target, Vector3?pivot = null)
{
m_CornerPoints = new Vector3[8];
Faces = new Face[6];
///0, 1, 3, 2
///4, 5, 7, 6
///2, 3, 7, 6
///0, 1, 5, 4
///1, 5, 7, 3
///0, 4, 6, 2
m_CornerPoints = edgePoints;
Vector3 center = Vector3.zero;
for (int i = 0; i < m_CornerPoints.Length; i++)
{
center += m_CornerPoints[i];
}
center /= m_CornerPoints.Length;
Pivot = pivot.HasValue ? pivot.Value : center;
float xDepth = ((edgePoints[0] + edgePoints[1] + edgePoints[3] + edgePoints[2]) / 4 - (edgePoints[4] + edgePoints[5] + edgePoints[7] + edgePoints[6]) / 4).magnitude;
float yDepth = ((edgePoints[2] + edgePoints[3] + edgePoints[7] + edgePoints[6]) / 4 - (edgePoints[0] + edgePoints[1] + edgePoints[5] + edgePoints[4]) / 4).magnitude;
float zDepth = ((edgePoints[1] + edgePoints[5] + edgePoints[7] + edgePoints[3]) / 4 - (edgePoints[0] + edgePoints[4] + edgePoints[6] + edgePoints[2]) / 4).magnitude;
Faces[0] = new Face(edgePoints[0], edgePoints[1], edgePoints[3], edgePoints[2], center, Pivot, xDepth, this);
Faces[1] = new Face(edgePoints[4], edgePoints[5], edgePoints[7], edgePoints[6], center, Pivot, xDepth, this);
Faces[2] = new Face(edgePoints[2], edgePoints[3], edgePoints[7], edgePoints[6], center, Pivot, yDepth, this);
Faces[3] = new Face(edgePoints[0], edgePoints[1], edgePoints[5], edgePoints[4], center, Pivot, yDepth, this);
Faces[4] = new Face(edgePoints[1], edgePoints[5], edgePoints[7], edgePoints[3], center, Pivot, zDepth, this);
Faces[5] = new Face(edgePoints[0], edgePoints[4], edgePoints[6], edgePoints[2], center, Pivot, zDepth, this);
m_Target = target;
}
/// <summary>
/// Stops the any highlighting item and starts highlighting current item
/// </summary>
/// <param name="sceneItem">Item to highlight</param>
/// <param name="interval">Higligh for X milliseconds</param>
protected void HiglightThisItem(IHighlightable sceneItem, double interval, PracticeItemResult itemResult = PracticeItemResult.Default)
{
if (sceneItem != null)
{
StopHighlight();
var highlightItem = HighlightItem;
//Setting the isHiglighting to true to help Stop highlighting
isHighlighting = true;
if (highlightItem != null)
{
lastHighlighted = sceneItem;
highlightItem(this, new HighlightItemEventArgs(sceneItem, itemResult));
//Timer will automatically stop the highlighting item after specific time and disposes itself.
Timer timer = new Timer(interval);
timer.Elapsed += (s, e) =>
{
timer.Stop();
StopHighlight();
timer.Dispose();
};
timer.Enabled = true;
timer.Start();
highlightTimer = timer;
}
}
else
{
throw new Exception("SceneItem cannot be null");
}
}
private static ContextMenu CreateUserContextMenu(UserMentionEntity entity, IHighlightable item)
{
var menu = new ContextMenu();
menu.Items.Add(new MenuItem
{
Header = Strings.MuteUser,
CommandParameter = $"@{entity.ScreenName}",
Command = GlobalCommands.CreateMuteCommand
});
menu.Items.Add(new Separator());
menu.Items.Add(new MenuItem
{
Header = Strings.Block,
Command = item.BlockUserCommand,
CommandParameter = entity.Id
});
menu.Items.Add(new MenuItem
{
Header = Strings.ReportSpam,
Command = item.ReportSpamCommand,
CommandParameter = entity.Id
});
return(menu);
}
private void Update()
{
if (!_interactionEnabled)
{
return;
}
var transformUnderCoursor = _camera.GetTransformUnderCoursor2D();
var highlightable = transformUnderCoursor?.GetComponent <IHighlightable>();
if (highlightable != null)
{
if (_lastHighlightable != null)
{
_lastHighlightable.CancelHighlight();
}
highlightable.Highlight();
_lastHighlightable = highlightable;
UpdateCursor(transformUnderCoursor, true);
CheckInteraction(transformUnderCoursor);
}
else
{
UpdateCursor(null, false);
if (_lastHighlightable != null)
{
_lastHighlightable.CancelHighlight();
_lastHighlightable = null;
}
}
}
public void TryHighlight(IHighlightable unit)
{
var list = new List <IHighlightable>();
if (unit != null)
{
list.Add(unit);
}
TryHighlight(list);
}
public void Deselect()
{
if (currentHighlight != null)
{
currentHighlight.Dehighlight();
}
infoBar.Hide();
currentHighlight = null;
currentlySelectedRoom = null;
Basement.instance.DehighlightFreeRooms();
}
private static void UnHighlight(IMapNode node)
{
if (node is IHighlightable)
{
IHighlightable tile = (IHighlightable)node;
tile.UnHighlight();
}
else
{
throw new System.Exception("I don't know how to unhighlight this");
}
}
public void Select(RoomInfo room, IHighlightable highlightable)
{
if (currentHighlight != null)
{
Deselect();
}
//todo: fix
currentHighlight = highlightable;
currentlySelectedRoom = room;
infoBar.Show(room);
Basement.instance.HighlightFreeRooms(room.size);
}
private static void Highlight(IMapNode node, Color color)
{
if (node is IHighlightable)
{
IHighlightable tile = (IHighlightable)node;
tile.Highlight(color);
}
else
{
throw new System.Exception("I don't know how to highlight this");
}
}
private static void OnHighlightedItemChanged(object sender, DependencyPropertyChangedEventArgs args)
{
ResultBox resultBox = (ResultBox)sender;
IHighlightable oldItem = resultBox.ItemContainerGenerator.ContainerFromItem(args.OldValue) as IHighlightable;
if (oldItem != null)
{
oldItem.IsHighlighted = false;
}
IHighlightable newItem = resultBox.ItemContainerGenerator.ContainerFromItem(args.NewValue) as IHighlightable;
if (newItem != null)
{
resultBox.ignoreHighlightNotification = true;
newItem.IsHighlighted = true;
resultBox.ignoreHighlightNotification = false;
}
resultBox.HighlightedIndex = resultBox.Items.IndexOf(args.NewValue);
}
/// <summary>
/// Generates an inline from a mention entity.
/// </summary>
/// <param name="entity"> The entity to generate the inline from. </param>
/// <param name="item"></param>
/// <returns> The generated inline. </returns>
private static Inline GenerateMention(UserMentionEntity entity, IHighlightable item)
{
Hyperlink link = new Hyperlink();
link.Inlines.Add(Constants.Twitter.Mention + entity.ScreenName);
link.SetResourceReference(TextElement.ForegroundProperty, "MentionBrush");
link.TextDecorations = null;
link.Command = GlobalCommands.OpenProfileCommand;
if (entity.Id == 0)
{
link.CommandParameter = entity.ScreenName;
}
else
{
link.CommandParameter = entity.Id;
}
link.ContextMenu = CreateUserContextMenu(entity, item);
return(link);
}
public Cuboid(float[] extendsLimits, IHighlightable target, Vector3?pivot = null)
{
m_CornerPoints = new Vector3[8];
Faces = new Face[6];
float minX = extendsLimits[0];
float maxX = extendsLimits[1];
float minY = extendsLimits[2];
float maxY = extendsLimits[3];
float minZ = extendsLimits[4];
float maxZ = extendsLimits[5];
float midX = (minX + maxX) / 2;
float midY = (minY + maxY) / 2;
float midZ = (minZ + maxZ) / 2;
///0, 1, 2, 3
///4, 5, 6, 7
///2, 3, 4, 5
///6, 7, 0, 1
///1, 2, 5, 6
///0, 3, 4, 7
var p0 = new Vector3(maxX, maxY, maxZ);
var p1 = new Vector3(maxX, maxY, minZ);
var p2 = new Vector3(maxX, minY, minZ);
var p3 = new Vector3(maxX, minY, maxZ);
var p4 = new Vector3(minX, minY, maxZ);
var p5 = new Vector3(minX, minY, minZ);
var p6 = new Vector3(minX, maxY, minZ);
var p7 = new Vector3(minX, maxY, maxZ);
m_CornerPoints = new Vector3[] { p0, p1, p2, p3, p4, p5, p6, p7 };
var c = new Vector3(midX, midY, midZ);
Pivot = pivot.HasValue ? pivot.Value : c;
Faces[0] = new Face(p0, p1, p2, p3, c, Pivot, maxX - minX, this);
Faces[1] = new Face(p4, p5, p6, p7, c, Pivot, maxX - minX, this);
Faces[2] = new Face(p2, p3, p4, p5, c, Pivot, maxY - minY, this);
Faces[3] = new Face(p6, p7, p0, p1, c, Pivot, maxY - minY, this);
Faces[4] = new Face(p1, p2, p5, p6, c, Pivot, maxZ - minZ, this);
Faces[5] = new Face(p0, p3, p4, p7, c, Pivot, maxZ - minZ, this);
m_Target = target;
}
public void Highlight(Collider[] colliders)
{
//get highlightable objects from colliders
List <IHighlightable> highlightables = GetComponentsFromColliders <IHighlightable>(colliders, GameObjectExtensions.SearchModes.Parents);
//check list of currently highlighted objects
for (int i = CurrentHighlights.Count - 1; i >= 0; i--)
{
IHighlightable highlightable = CurrentHighlights[i];
//remove any highlightables that have been destroyed
if (highlightable == null || highlightable.Equals(null))
{
CurrentHighlights.RemoveAt(i);
continue;
}
//stop highlighting any objects that aren't being 'selected' anymore
if (!highlightables.Contains(highlightable))
{
highlightable.EndHighlight();
CurrentHighlights.RemoveAt(i);
}
}
//highlight any newly 'selected' objects
for (int i = 0; i < highlightables.Count; i++)
{
IHighlightable highlightable = highlightables[i];
//skip if this object is already being highlighted
if (CurrentHighlights.Contains(highlightable))
{
continue;
}
//highlight this object
highlightable.StartHighlight(this);
CurrentHighlights.Add(highlightable);
}
}
/// <summary>
/// Generates a collection of inlines from a tweet.
/// </summary>
/// <param name="item"> The tweet to generate inlines from. </param>
/// <returns> The generated inlines. </returns>
private IEnumerable <Inline> GenerateInlines(IHighlightable item)
{
var allEntities = ExtractEntities(item).ToArray();
if (allEntities.Any())
{
int lastEnd = 0;
foreach (EntityBase entity in allEntities)
{
if (entity.Start > lastEnd)
{
string text = item.Text.Substring(lastEnd, entity.Start - lastEnd);
yield return(new Run(PrepareText(text)));
}
var tagEntity = entity as HashTagEntity;
if (tagEntity != null)
{
yield return(GenerateHashTag(tagEntity));
}
else if (entity is UrlEntity)
{
if (entity is MediaEntity)
{
if (!Config.Visual.InlineMedia)
{
MediaEntity mediaEnttiy = entity as MediaEntity;
yield return(GenerateMedia(mediaEnttiy));
}
}
else
{
UrlEntity urlEntity = entity as UrlEntity;
var url = urlEntity.ExpandedUrl;
if (!TwitterHelper.IsTweetUrl(url) &&
(!Config.Visual.InlineMedia || !ExtractorRepo.CanExtract(url)))
{
yield return(GenerateLink(urlEntity));
}
}
}
else if (entity is UserMentionEntity)
{
yield return(GenerateMention((UserMentionEntity)entity, item));
}
lastEnd = entity.End;
}
if (lastEnd < item.Text.Length)
{
yield return(new Run(PrepareText(item.Text.Substring(lastEnd))));
}
}
else
{
yield return(new Run(PrepareText(item.Text)));
}
}
private void Awake()
{
highligther = GetComponentInChildren <IHighlightable>();
}
private IEnumerable <EntityBase> ExtractEntities(IHighlightable item)
{
if (item.Text == null)
{
return(Enumerable.Empty <EntityBase>());
}
var hashTags = item.Entities?.HashTagEntities ?? Enumerable.Empty <EntityBase>();
var medias = item.Entities?.MediaEntities ?? Enumerable.Empty <EntityBase>();
var urls = item.Entities?.UrlEntities ?? Enumerable.Empty <UrlEntity>();
var mentions = item.Entities?.UserMentionEntities ?? Enumerable.Empty <EntityBase>();
var entities = hashTags.Distinct(this)
.Concat(medias.Distinct(this))
.Concat(RemoveExtendedTweetUrl(urls).Distinct(this))
.Concat(mentions.Distinct(this));
//IEnumerable<EntityBase> entities = item.Entities?.HashTagEntities ?? Enumerable.Empty<EntityBase>();
//entities = entities.Concat( item.Entities?.MediaEntities ?? Enumerable.Empty<EntityBase>() );
//entities = entities.Concat( item.Entities?.UrlEntities ?? Enumerable.Empty<EntityBase>() );
//entities = entities.Concat( item.Entities?.UserMentionEntities ?? Enumerable.Empty<EntityBase>() );
var tweetText = TwitterHelper.NormalizeText(item.Text);
var allEntities = entities.ToArray();
foreach (var entity in allEntities)
{
int length = entity.End - entity.Start - 1;
List <string> extractedTextVersions = new List <string>
{
ExtractEntityText(entity)
};
if (entity is UserMentionEntity)
{
extractedTextVersions.Add(AlternativeAtSign + extractedTextVersions[0].Substring(1));
}
else if (entity is HashTagEntity)
{
extractedTextVersions.Add(AlternativeHashtagSign + extractedTextVersions[0].Substring(1));
}
var actualText = tweetText.Substring(entity.Start, length);
bool found = false;
foreach (var extractedText in extractedTextVersions)
{
// When the tweet contains emojis, the twitter API returns wrong indices for entities
if (extractedText != actualText)
{
var newIndex = tweetText.IndexOf(extractedText, entity.Start, StringComparison.Ordinal);
if (newIndex == -1)
{
newIndex = tweetText.IndexOf(extractedText, entity.Start, StringComparison.OrdinalIgnoreCase);
}
if (newIndex == -1)
{
continue;
}
found = true;
entity.Start = newIndex;
entity.End = entity.Start + length + 1;
}
}
Debug.Assert(found);
}
var ordered = allEntities.OrderBy(e => e.Start).ToList();
for (int i = ordered.Count - 1; i > 0; --i)
{
var current = ordered[i];
var next = ordered[i - 1];
if (current.Start == next.Start && current.End == next.End)
{
ordered.RemoveAt(i);
}
}
return(ordered);
}
public HighlightItemEventArgs(IHighlightable highlightableItem, PracticeItemResult practiceItemResult = PracticeItemResult.Default)
{
HighlightableItem = highlightableItem;
PracticeItemResult = practiceItemResult;
}
// Start is called before the first frame update
void Awake()
{
highlightable = GetComponent <IHighlightable>();
}
public void Subscribe(IHighlightable h)
{
Highlitables.Add(h);
}
public void Unsubscribe(IHighlightable h)
{
Highlitables.Remove(h);
}
void Update()
{
//Goes through each touch
foreach (Touch t in Input.touches)
{
//If any are over UI, then return
if (EventSystem.current.IsPointerOverGameObject(t.fingerId))
{
return;
}
}
//Returns out if a slider is being dragged
if (UIManager.Instance.sliderIsBeingDragged)
{
return;
}
if (inputPhase == InputPhase.Placing)
{
//If the player is selecting
if (inputType.IsHovering())
{
//Stores the data from the raycast
TrackableHit trackableHit;
//Shoots a ray that can only hit within the bounds of a tracked plane, and if it hits:
if (Frame.Raycast(inputType.GetCursorPosition().x, inputType.GetCursorPosition().y, TrackableHitFlags.PlaneWithinBounds, out trackableHit))
{
//Create an anchor at the hitPoint
Anchor anchor = Session.CreateAnchor(trackableHit.Pose);
//Instantiates the chessboard at the hitpoint, as a prefab of the anchor
chessBoard = Instantiate(chessBoardPrefab, trackableHit.Pose.position, Quaternion.identity, anchor.transform).transform;
//Face chessboard to player
chessBoard.LookAt(transform);
chessBoard.rotation = Quaternion.Euler(new Vector3(0, chessBoard.rotation.y, 0));
//Changes the input phase after the board is placed
inputPhase = InputPhase.Playing;
//Hides the tracked planes
showTrackedPlanes = false;
//Sets the move board button to interactable
UIManager.Instance.moveBoardButton.interactable = true;
}
}
return;
}
else if (inputPhase == InputPhase.Playing)
{
//Cast a ray from its mouse position
Ray ray = cam.ScreenPointToRay(inputType.GetCursorPosition());
//Temp variable
RaycastHit hit;
//If the ray hits
if (Physics.Raycast(ray, out hit))
{
//If it hits a square
if (hit.collider.tag == "Square")
{
Square selectedSquare = hit.transform.GetComponent <Square>();
if (selectedObject != null && inputType.IsSelecting())
{
//Get the piece script
Piece selectedPiece = selectedObject.GetComponent <Piece>();
//If the piece is on the team whose turn it is, and it can move to the spot
if (selectedPiece.team == TeamManager.Instance.currentPlayingTeam && selectedPiece.Move(selectedSquare.boardPosition))
{
//Resets the selected piece
selectedPiece.UnHighlight();
selectedObject = null;
hoveredObject = null;
return;
}
}
//If the square has a piece
if (selectedSquare.currentPiece != null)
{
Piece selectedPiece = selectedSquare.currentPiece;
//If the player is selecting
if (inputType.IsSelecting())
{
//If the piece belongs to the team whose turn it is
if (selectedPiece.team == TeamManager.Instance.currentPlayingTeam)
{
//If the selected piece is a new piece
if (selectedPiece.gameObject != selectedObject && selectedObject != null)
{
//Unhighlights the old object
selectedObject.GetComponent <Piece>().UnHighlight();
}
//Set as selected object
selectedObject = selectedPiece.gameObject;
//Highlight the squares it can move to
selectedPiece.HighlightAllPossibleMoves();
//Selects the piece graphically
selectedPiece.Select();
}
}
//If the player is hovering and the piece isn't already selected
else if (inputType.IsHovering() && !selectedPiece.selected)
{
if (selectedPiece != (Object)hoveredObject)
{
if (hoveredObject != null && !hoveredObject.selected)
{
hoveredObject.UnHighlight();
}
}
hoveredObject = selectedPiece;
hoveredObject.Highlight(Piece.hoverMagnitude);
}
}
else
{
if (inputType.IsHovering() && !selectedSquare.selected)
{
if (selectedSquare != (Object)hoveredObject)
{
if (hoveredObject != null && !hoveredObject.selected)
{
hoveredObject.UnHighlight();
}
}
hoveredObject = selectedSquare;
hoveredObject.Highlight(Square.hoverHighlightMagnitude);
}
}
}
}
}
else if (inputPhase == InputPhase.Moving)
{
//If there are 2 fingers on the screen
if (Input.touchCount > 1)
{
//Gets both of the touches
Touch touch1 = Input.GetTouch(0);
Touch touch2 = Input.GetTouch(1);
//Gets the positions of the touches last frame
Vector2 previousPos1 = touch1.position - touch1.deltaPosition;
Vector2 previousPos2 = touch2.position - touch2.deltaPosition;
//Gets the distance between both fingers last frame
float previousDistance = (previousPos1 - previousPos2).magnitude;
//Gets the distance between both fingers this frame
float currentDistance = (touch1.position - touch2.position).magnitude;
//Gets the change in distance between the 2 fingers in this frame
float distanceMagnitude = (currentDistance - previousDistance);
//Multiplies it with scaleSpeed
float changeAmount = distanceMagnitude * scaleSpeed;
//What the new scale of the board will be
Vector3 newScale = chessBoard.localScale + new Vector3(changeAmount, changeAmount, changeAmount);
//If the new scale is bigger than the max scale, set the scale to the max scale
if (newScale.x > maxBoardSize)
{
chessBoard.transform.localScale = new Vector3(maxBoardSize, maxBoardSize, maxBoardSize);
}
//If the new scale is smaller than the min scale, set the scale to the min scale
else if (newScale.x < minimumBoardSize)
{
chessBoard.transform.localScale = new Vector3(minimumBoardSize, minimumBoardSize, minimumBoardSize);
}
//If the new scale is within the set bounds, set it to the new scale
else
{
chessBoard.transform.localScale = newScale;
}
}
//If the player is selecting
else if (inputType.IsHovering())
{
//Stores the data from the raycast
TrackableHit trackableHit;
//Shoots a ray that can only hit within the bounds of a tracked plane, and if it hits:
if (Frame.Raycast(inputType.GetCursorPosition().x, inputType.GetCursorPosition().y, TrackableHitFlags.PlaneWithinBounds, out trackableHit))
{
//Moves the chessboard to the selected point
chessBoard.position = trackableHit.Pose.position;
}
}
}
debugText.text = UIManager.Instance.sliderIsBeingDragged.ToString();
}
