internal static void SetAlternateMenuVisibility(Transform rayOrigin, bool visible)
{
Rays.ForEachProxyDevice(deviceData =>
{
foreach (var menu in deviceData.alternateMenus)
{
if (!(menu is IActionsMenu))
{
continue;
}
var menuHideFlags = deviceData.menuHideData;
// Set alternate menu visible on this rayOrigin and hide it on all others
var alternateMenuData = menuHideFlags[menu];
if (deviceData.rayOrigin == rayOrigin && visible)
{
alternateMenuData.hideFlags &= ~MenuHideFlags.Hidden;
}
else
{
alternateMenuData.hideFlags |= MenuHideFlags.Hidden;
}
}
});
}
void Start()
{
nodes = new ArrayList();
rays = Camera.main.GetComponent <Rays> ();
// Using windows
rootPath = "C:\\Users\\Zac\\Documents\\file-browser";
currentDirectory = "C:\\Users\\Zac\\Documents\\file-browser\\HCI Test Moderate";
slash = '\\';
if (!System.IO.Directory.Exists(rootPath))
{
// Using unix
rootPath = "/Users/Zac/Documents/file-browser";
currentDirectory = "/Users/Zac/Documents/file-browser/HCI Test Moderate";
slash = '/';
}
rootPath = PlayerPrefs.GetString("rootPath");
currentDirectory = PlayerPrefs.GetString("currentDirectory");
rootNode = (GameObject)Instantiate(rootFolder.gameObject, new Vector3(0, 0, -5), Quaternion.identity);
rootNode.GetComponent <TreeNode> ().setId(currentDirectory);
rootNode.GetComponent <TreeNode> ().setPath(currentDirectory);
rootNode.GetComponent <TreeNode> ().setFileType(TreeNode.FileType.RootNode);
homeNode = rootNode;
Camera.main.transform.GetComponent <ClickScript> ().homeFolder = homeNode;
Camera.main.transform.GetComponent <ClickScript> ().searchFiles [0] = rootNode;
TraverseTree(currentDirectory);
Camera.main.transform.GetComponent <ClickScript> ().homeFolder = rootNode;
Camera.main.transform.GetComponent <ClickScript> ().nodes = nodes;
}
void OnObjectsDropped(Transform rayOrigin, Transform[] grabbedObjects)
{
Node?node = null;
foreach (var ray in m_Rays)
{
var miniWorldRay = ray.Value;
if (ray.Key == rayOrigin || miniWorldRay.originalRayOrigin == rayOrigin)
{
node = miniWorldRay.node;
break;
}
}
foreach (var ray in m_Rays)
{
var miniWorldRay = ray.Value;
if (miniWorldRay.node == node)
{
miniWorldRay.DropPreviewObjects(this);
miniWorldRay.dragStartedOutside = false;
if (!miniWorldRay.isContained)
{
Rays.UnlockRay(rayOrigin, this);
Rays.ShowRay(rayOrigin, true);
}
}
}
}
static GameObject InstantiateMenuUI(Transform rayOrigin, IMenu prefab)
{
var ui = evr.GetNestedModule <UI>();
GameObject go = null;
Rays.ForEachProxyDevice(deviceData =>
{
var proxy = deviceData.proxy;
var otherRayOrigin = deviceData.rayOrigin;
if (proxy.rayOrigins.ContainsValue(rayOrigin) && otherRayOrigin != rayOrigin)
{
Transform menuOrigin;
if (proxy.menuOrigins.TryGetValue(otherRayOrigin, out menuOrigin))
{
if (deviceData.customMenu == null)
{
go = ui.InstantiateUI(prefab.gameObject, menuOrigin, false);
var customMenu = go.GetComponent <IMenu>();
deviceData.customMenu = customMenu;
deviceData.menuHideData[customMenu] = new MenuHideData {
hideFlags = 0
};
}
}
}
});
return(go);
}
IEnumerator Start()
{
var leftHandFound = false;
var rightHandFound = false;
// Some components depend on both hands existing (e.g. MiniWorldWorkspace), so make sure they exist before restoring
while (!(leftHandFound && rightHandFound))
{
Rays.ForEachProxyDevice(deviceData =>
{
if (deviceData.node == Node.LeftHand)
{
leftHandFound = true;
}
if (deviceData.node == Node.RightHand)
{
rightHandFound = true;
}
});
yield return(null);
}
var viewer = GetNestedModule <Viewer>();
while (!viewer.hmdReady)
{
yield return(null);
}
GetModule <SerializedPreferencesModule>().DeserializePreferences(serializedPreferences);
m_HasDeserialized = true;
}
void OnObjectsDropped(Transform rayOrigin, Transform[] grabbedObjects)
{
var node = Node.None;
foreach (var ray in m_Rays)
{
var miniWorldRay = ray.Value;
if (ray.Key == rayOrigin || miniWorldRay.originalRayOrigin == rayOrigin)
{
node = miniWorldRay.node;
break;
}
}
foreach (var ray in m_Rays)
{
var miniWorldRay = ray.Value;
if (miniWorldRay.node == node)
{
miniWorldRay.DropPreviewObjects(this);
miniWorldRay.dragStartedOutside = false;
if (!miniWorldRay.isContained)
{
Rays.RemoveVisibilitySettings(rayOrigin, this);
}
}
}
}
public ActionResult Save(Rays rays)
{
if (!ModelState.IsValid)
{
var viewModel = new RaysFormViewModel
{
Rays = rays,
RaysType = _raysTypes.GetRecords,
};
return(View("RaysForm", viewModel));
}
if (rays._Id == Guid.Empty)
{
_context.InsertRecord(_table, rays);
}
else
{
return(HttpNotFound());
}
return(RedirectToAction("Index", "Rays"));
}
void UpdateRayContaimnent(DeviceData data)
{
bool wasContained;
var rayOrigin = data.rayOrigin;
m_RayWasContained.TryGetValue(rayOrigin, out wasContained);
var isContained = false;
foreach (var miniWorld in m_Worlds)
{
isContained |= miniWorld.Contains(rayOrigin.position + rayOrigin.forward * DirectSelection.GetPointerLength(rayOrigin));
}
if (isContained && !wasContained)
{
Rays.AddVisibilitySettings(rayOrigin, this, false, true);
}
if (!isContained && wasContained)
{
Rays.RemoveVisibilitySettings(rayOrigin, this);
}
m_RayWasContained[rayOrigin] = isContained;
}
static void ClearToolMenuButtonPreview()
{
Rays.ForEachProxyDevice((deviceData) =>
{
deviceData.ToolsMenu.PreviewToolsMenuButton.previewToolType = null;
});
}
private float[] DrawRays(GamePiece gamePiece)
{
float[] input = new float[numberOfRays];
layerMask = 1 << gamePiece.gameObject.layer;
layerMask = ~layerMask;
Vector2 size = gamePiece.GetComponent <Renderer>().bounds.size;
Vector2 objectPosition = gamePiece.transform.position;
Vector2 topOfObject = new Vector2(objectPosition.x, objectPosition.y + size.y / 2);
Vector2 bottomOfObject = new Vector2(objectPosition.x, objectPosition.y - size.y / 2);
Vector2 leftOfObject = new Vector2(objectPosition.x - size.x / 2, objectPosition.y);
Vector2 rightOfObject = new Vector2(objectPosition.x + size.x / 2, objectPosition.y);
input[0] = Rays.SendRay(topOfObject, Vector2.up, Color.yellow, layerMask);
input[1] = Rays.SendRay(bottomOfObject, Vector2.down, Color.red, layerMask);
input[2] = Rays.SendRay(leftOfObject, Vector2.left, Color.blue, layerMask);
input[3] = Rays.SendRay(rightOfObject, Vector2.right, Color.green, layerMask);
for (int i = 0; i < numberOfRays; i++)
{
if (i <= 2)
{
input[i] = Rays.SendRay(topOfObject, vectors[i], Color.yellow, layerMask);
}
else
{
input[i] = Rays.SendRay(bottomOfObject, vectors[i], Color.red, layerMask);
}
}
return(input);
}
public void ConnectInterface(object target, object userData = null)
{
var rayOrigin = userData as Transform;
var settingsMenuProvider = target as ISettingsMenuProvider;
if (settingsMenuProvider != null)
{
m_SettingsMenuProviders[new KeyValuePair <Type, Transform>(target.GetType(), rayOrigin)] = settingsMenuProvider;
foreach (var kvp in m_MainMenus)
{
if (rayOrigin == null || kvp.Key == rayOrigin)
{
kvp.Value.AddSettingsMenu(settingsMenuProvider);
}
}
}
var settingsMenuItemProvider = target as ISettingsMenuItemProvider;
if (settingsMenuItemProvider != null)
{
m_SettingsMenuItemProviders[new KeyValuePair <Type, Transform>(target.GetType(), rayOrigin)] = settingsMenuItemProvider;
foreach (var kvp in m_MainMenus)
{
if (rayOrigin == null || kvp.Key == rayOrigin)
{
kvp.Value.AddSettingsMenuItem(settingsMenuItemProvider);
}
}
}
var mainMenu = target as IMainMenu;
if (mainMenu != null && rayOrigin != null)
{
mainMenu.menuTools = m_MainMenuTools;
mainMenu.menuWorkspaces = WorkspaceModule.workspaceTypes;
mainMenu.settingsMenuProviders = m_SettingsMenuProviders;
mainMenu.settingsMenuItemProviders = m_SettingsMenuItemProviders;
m_MainMenus[rayOrigin] = mainMenu;
}
var menuOrigins = target as IUsesMenuOrigins;
if (menuOrigins != null)
{
Transform mainMenuOrigin;
var proxy = Rays.GetProxyForRayOrigin(rayOrigin);
if (proxy != null && proxy.menuOrigins.TryGetValue(rayOrigin, out mainMenuOrigin))
{
menuOrigins.menuOrigin = mainMenuOrigin;
Transform alternateMenuOrigin;
if (proxy.alternateMenuOrigins.TryGetValue(rayOrigin, out alternateMenuOrigin))
{
menuOrigins.alternateMenuOrigin = alternateMenuOrigin;
}
}
}
}
internal void UpdateDirectSelection()
{
m_DirectSelections.Clear();
m_ActiveStates.Clear();
var directSelection = objectsGrabber;
Rays.ForEachProxyDevice(deviceData =>
{
var rayOrigin = deviceData.rayOrigin;
var input = deviceData.directSelectInput;
var obj = GetDirectSelectionForRayOrigin(rayOrigin);
if (obj && !obj.CompareTag(k_VRPlayerTag))
{
m_ActiveStates.Add(input);
m_DirectSelections[rayOrigin] = new DirectSelectionData
{
gameObject = obj,
node = deviceData.node,
input = input
};
}
else if (directSelection != null && directSelection.GetHeldObjects(rayOrigin) != null)
{
m_ActiveStates.Add(input);
}
});
foreach (var ray in evr.GetNestedModule <MiniWorlds>().rays)
{
var rayOrigin = ray.Key;
var miniWorldRay = ray.Value;
var input = miniWorldRay.directSelectInput;
var go = GetDirectSelectionForRayOrigin(rayOrigin);
if (go != null)
{
m_ActiveStates.Add(input);
m_DirectSelections[rayOrigin] = new DirectSelectionData
{
gameObject = go,
node = ray.Value.node,
input = input
};
}
else if (miniWorldRay.dragObjects != null ||
(directSelection != null && directSelection.GetHeldObjects(rayOrigin) != null))
{
m_ActiveStates.Add(input);
}
}
// Only activate direct selection input if the cone is inside of an object, so a trigger press can be detected,
// and keep it active if we are dragging
Rays.ForEachProxyDevice(deviceData =>
{
var input = deviceData.directSelectInput;
input.active = m_ActiveStates.Contains(input);
});
}
public void CreatesCorrectBlockedBishopAttacksForSquare(ulong occupied, Square square, ulong expectedAttacks)
{
// Act
var bishopAttacks = Rays.BishopAttacks(square, occupied);
// Assert
Assert.Equal <Bitboard>(expectedAttacks, bishopAttacks);
}
public void CreatesCorrectQueenAttacksForSquare(Square square, ulong expectedAttacks)
{
// Act
var queenAttacks = Rays.QueenAttacks(square);
// Assert
Assert.Equal <Bitboard>(expectedAttacks, queenAttacks);
}
public void CreatesCorrectBishopAttacksForSquare(Square square, ulong expectedAttacks)
{
// Act
var bishopAttacks = Rays.BishopAttacks(square);
// Assert
Assert.Equal <Bitboard>(expectedAttacks, bishopAttacks);
}
public void CreatesCorrectRaysForGivenSquare(Square square, Direction direction, ulong expectedAttacks)
{
// Act
var rayAttacks = Rays.RayAttacks(square, direction);
// Assert
Assert.Equal <Bitboard>(expectedAttacks, rayAttacks);
}
public void CanGetAllQueenAttacks(ulong queens, ulong occupied, ulong expectedAttacks)
{
// Act
var attacks = Rays.AllQueenAttacks(queens, occupied);
// Assert
Assert.Equal <Bitboard>(expectedAttacks, attacks);
}
public void CanGetAllBishopAttacks(ulong bishops, ulong occupied, ulong expectedAttacks)
{
// Act
var attacks = Rays.AllBishopAttacks(bishops, occupied);
// Assert
Assert.Equal <Bitboard>(expectedAttacks, attacks);
}
// Start is called before the first frame update
void Start()
{
_animator = GetComponentInChildren <Animator>();
_rigidbody = GetComponent <Rigidbody2D>();
_crossDetection = GetComponent <Rays>();
_localScale = transform.localScale;
}
private void Start()
{
_rb = GetComponent <Rigidbody2D>();
_crossDetection = GetComponent <Rays>();
_rbStartGravity = _rb.gravityScale;
_coyoteTime = coyoteTimeMax;
_wallCoyoteTime = wallJumpCoyoteTimeMax;
}
private void CalculateVertical(ref Vector2 movement)
{
bool up = movement.y > 0;
float distance = Mathf.Abs(movement.y) + this.Inset;
Vector2 direction, origin;
if (up)
{
direction = Vector2.up;
origin = this.RayData.origins.topLeft;
}
else
{
direction = Vector2.down;
origin = this.RayData.origins.bottomLeft;
}
// raycast from x-pos we will be at (horiz before vert)
origin.x += movement.x;
LayerMask mask = groundMask;
if (!up && !ignorePlatforms)
{
mask |= platformMask;
}
Vector2 ray;
for (int i = 0; i < this.VerticalRays; i++)
{
ray = new Vector2(origin.x + i * this.Spacing.x, origin.y);
Rays.DrawRay(ray, direction, distance, Color.blue);
if (Physics2D.RaycastNonAlloc(ray, direction, this.hit, distance, mask) > 0)
{
movement.y = hit[0].point.y - ray.y;
distance = Mathf.Abs(movement.y);
if (up)
{
movement.y -= this.Inset;
this.state.Above = true;
}
else
{
movement.y += this.Inset;
this.state.Below = true;
}
if (distance < this.Inset + Rays.Precision)
{
break;
}
}
}
}
public void NE_E4_ReturnsF5G6H7()
{
// arrange
var s = new Rays("E4").NE;
var expected = Bitboard.With.F5.G6.H7.Build();
// act
// assert
s.AsBoard.Should().Be(expected);
}
public void NE_H1_ReturnsEmpty()
{
// arrange
var s = new Rays("H1").NE;
var expected = Bitboard.Empty;
// act
// assert
s.AsBoard.Should().Be(expected);
}
public void E_A8_ReturnsB8C8D8E8F8G8H8()
{
// arrange
var s = new Rays("A8").E;
var expected = Bitboard.With.B8.C8.D8.E8.F8.G8.H8.Build();
// act
// assert
s.AsBoard.Should().Be(expected);
}
internal void OnWorkspaceCreated(IWorkspace workspace)
{
var miniWorldWorkspace = workspace as MiniWorldWorkspace;
if (!miniWorldWorkspace)
{
return;
}
miniWorldWorkspace.zoomSliderMax = evr.GetModule <SpatialHashModule>().GetMaxBounds().size.MaxComponent()
/ miniWorldWorkspace.contentBounds.size.MaxComponent();
var miniWorld = miniWorldWorkspace.miniWorld;
m_Worlds.Add(miniWorld);
var intersectionModule = evr.GetModule <IntersectionModule>();
Rays.ForEachProxyDevice(deviceData =>
{
var miniWorldRayOrigin = InstantiateMiniWorldRay();
miniWorldRayOrigin.parent = workspace.transform;
var tester = miniWorldRayOrigin.GetComponentInChildren <IntersectionTester>();
tester.active = false;
m_Rays[miniWorldRayOrigin] = new MiniWorldRay
{
originalRayOrigin = deviceData.rayOrigin,
miniWorld = miniWorld,
proxy = deviceData.proxy,
node = deviceData.node,
directSelectInput = deviceData.directSelectInput,
tester = tester
};
intersectionModule.AddTester(tester);
evr.GetModule <HighlightModule>().AddRayOriginForNode(deviceData.node, miniWorldRayOrigin);
if (deviceData.proxy.active)
{
if (deviceData.node == Node.LeftHand)
{
miniWorldWorkspace.leftRayOrigin = deviceData.rayOrigin;
}
if (deviceData.node == Node.RightHand)
{
miniWorldWorkspace.rightRayOrigin = deviceData.rayOrigin;
}
}
}, false);
}
public void E_H1_ReturnsEmpty()
{
// arrange
Bitboard s = new Rays("H1").E;
Bitboard expected = Bitboard.Empty;
// act
// assert
s.AsBoard.Should().Be(expected);
}
public void NE_A8_ReturnsEmpty()
{
// arrange
Bitboard s = new Rays("A8").NE;
Bitboard expected = Bitboard.Empty;
// act
// assert
s.AsBoard.Should().Be(expected);
}
public void E_E4_ReturnsF4G4H4()
{
// arrange
var s = new Rays("E4").E;
var expected = Bitboard.With.F4.G4.H4.Build();
// act
// assert
s.AsBoard.Should().Be(expected);
}
internal void OnWorkspaceCreated(IWorkspace workspace)
{
var miniWorldWorkspace = workspace as MiniWorldWorkspace;
if (!miniWorldWorkspace)
{
return;
}
miniWorldWorkspace.zoomSliderMax = evr.GetModule <SpatialHashModule>().GetMaxBounds().size.MaxComponent()
/ miniWorldWorkspace.contentBounds.size.MaxComponent();
var miniWorld = miniWorldWorkspace.miniWorld;
var worldID = m_Worlds.Count;
miniWorld.miniWorldTransform.name = string.Format("Miniworld {0}", worldID);
m_Worlds.Add(miniWorld);
var intersectionModule = evr.GetModule <IntersectionModule>();
Rays.ForEachProxyDevice(deviceData =>
{
var node = deviceData.node;
var rayOrigin = deviceData.rayOrigin;
var proxy = deviceData.proxy;
var miniWorldRayOrigin = InstantiateMiniWorldRay();
miniWorldRayOrigin.name = string.Format("{0} Miniworld {1} Ray", node, worldID);
miniWorldRayOrigin.parent = workspace.transform;
var tester = miniWorldRayOrigin.GetComponentInChildren <IntersectionTester>();
tester.active = false;
m_Rays[miniWorldRayOrigin] = new MiniWorldRay(rayOrigin, miniWorld, proxy, node, tester);
intersectionModule.AddTester(tester);
evr.GetModule <HighlightModule>().AddRayOriginForNode(node, miniWorldRayOrigin);
if (proxy.active)
{
if (node == Node.LeftHand)
{
miniWorldWorkspace.leftRayOrigin = rayOrigin;
}
if (node == Node.RightHand)
{
miniWorldWorkspace.rightRayOrigin = rayOrigin;
}
}
}, false);
}
internal static void SetAlternateMenuVisibility(Transform rayOrigin, bool visible)
{
Rays.ForEachProxyDevice(deviceData =>
{
var alternateMenu = deviceData.alternateMenu;
if (alternateMenu != null)
{
var flags = deviceData.menuHideFlags[alternateMenu];
deviceData.menuHideFlags[alternateMenu] = (deviceData.rayOrigin == rayOrigin) && visible ? flags & ~MenuHideFlags.Hidden : flags | MenuHideFlags.Hidden;
}
});
}
public void PlayLandParticles()
{
Bounds bounds = this.collider.bounds;
Vector2 origin = new Vector2(bounds.center.x, bounds.min.y - this.controller.Inset);
Rays.DrawRay(origin, Vector2.down, this.vfx.landParticlePlayDistance, Color.blue);
if (this.shouldPlayLandParticles && this.controller.Velocity.y < 0 &&
Rays.IsHitting(origin, Vector2.down, this.vfx.landParticlePlayDistance, this.controller.GroundOrPlatform))
{
this.vfx.landParticle.Play();
this.shouldPlayLandParticles = false;
}
}
public ActionResult New()
{
var rays = new Rays();
rays.Id = GenerateUniqueID();
var viewModel = new RaysFormViewModel
{
Rays = rays,
RaysType = _raysTypes.GetRecords,
};
return(View("RaysForm", viewModel));
}
static Transform GetCustomAlternateMenuOrigin(Transform rayOrigin)
{
Transform alternateMenuOrigin = null;
var proxy = Rays.GetProxyForRayOrigin(rayOrigin);
if (proxy != null)
{
var alternateMenuOrigins = proxy.alternateMenuOrigins;
if (alternateMenuOrigins.ContainsKey(rayOrigin))
{
alternateMenuOrigin = alternateMenuOrigins[rayOrigin];
}
}
return(alternateMenuOrigin);
}
private bool SpaceToStand()
{
Bounds inset = this.collider.bounds;
Vector2 origin = new Vector2(inset.min.x + this.controller.Inset, inset.max.y - this.controller.Inset);
Vector2 ray;
for (int i = 0; i < this.controller.VerticalRays; i++)
{
ray = new Vector2(origin.x + i * this.controller.Spacing.x, origin.y);
Rays.DrawRay(ray, Vector2.up, this.standRoom, Color.blue);
if (Rays.IsHitting(ray, Vector2.up, this.standRoom, this.controller.Ground))
{
return(false);
}
}
return(true);
}
static Transform GetCustomMenuOrigin(Transform rayOrigin)
{
Transform mainMenuOrigin = null;
var proxy = Rays.GetProxyForRayOrigin(rayOrigin);
if (proxy != null)
{
var menuOrigins = proxy.menuOrigins;
if (menuOrigins.ContainsKey(rayOrigin))
{
mainMenuOrigin = menuOrigins[rayOrigin];
}
}
return(mainMenuOrigin);
}
private void CalculateHorizontal(ref Vector2 movement)
{
bool right = movement.x > 0;
float distance = Mathf.Abs(movement.x) + this.RayData.Inset;
Vector2 direction, origin;
if (right)
{
direction = Vector2.right;
origin = this.RayData.origins.bottomRight;
}
else
{
direction = Vector2.left;
origin = this.RayData.origins.bottomLeft;
}
Vector2 ray;
for (int i = 0; i < this.HorizontalRays; i++)
{
ray = new Vector2(origin.x, origin.y + i * this.Spacing.y);
Rays.DrawRay(ray, direction, distance, Color.blue);
if (Physics2D.RaycastNonAlloc(ray, direction, this.hit, distance, this.groundMask) > 0)
{
movement.x = hit[0].point.x - ray.x;
distance = Mathf.Abs(movement.x);
if (right)
{
movement.x -= this.Inset;
this.state.Right = true;
}
else
{
movement.x += this.Inset;
this.state.Left = true;
}
if (distance < this.Inset + Rays.Precision)
{
break;
}
}
}
}
public override void Trigger()
{
if ( State == ConcealState )
{
if ( !Helper.UnlimitedRays() )
{
if ( Helper.RaysCount() >= Helper.MaxRays() )
{
UpdateState(ModelState.MaxRaysExceed);
return;
}
}
if ( _rays == null )
{
UpdateState(ModelState.LightBoxActivated);
_rays = new Rays(this);
Helper.RaysCreated(_rays);
Index = Helper.RaysCount().ToString();
}
}
}
public void NW_E4_ReturnsD5C6B7A8()
{
// arrange
var s = new Rays("E4").NW;
var expected = Bitboard.With.D5.C6.B7.A8.Build();
// act
// assert
s.AsBoard.Should().Be(expected);
}
public override void Reset()
{
State = ConcealState;
Index = string.Empty;
_rays = null;
}
public void N_E4_ReturnsE5E6E7E8()
{
// arrange
var s = new Rays("E4").N;
var expected = Bitboard.With.E5.E6.E7.E8.Build();
// act
// assert
s.AsBoard.Should().Be(expected);
}
public void SE_E4_ReturnsF3G2H1()
{
// arrange
var s = new Rays("E4").SE;
var expected = Bitboard.With.F3.G2.H1.Build();
// act
// assert
s.AsBoard.Should().Be(expected);
}
public void SE_A8_ReturnsB7C6D5E4F3G2H1()
{
// arrange
var s = new Rays("A8").SE;
var expected = Bitboard.With.B7.C6.D5.E4.F3.G2.H1.Build();
// act
// assert
s.AsBoard.Should().Be(expected);
}
public void SW_E4_ReturnsD3C2B1()
{
// arrange
var s = new Rays("E4").SW;
var expected = Bitboard.With.D3.C2.B1.Build();
// act
// assert
s.AsBoard.Should().Be(expected);
}
public void S_E4_ReturnsE3E2E1()
{
// arrange
var s = new Rays("E4").S;
var expected = Bitboard.With.E3.E2.E1.Build();
// act
// assert
s.AsBoard.Should().Be(expected);
}
public void W_A8_ReturnsEmpty()
{
// arrange
var s = new Rays("A8").W;
var expected = Bitboard.Empty;
// act
// assert
s.AsBoard.Should().Be(expected);
}
public void W_H1_ReturnsG1F1E1D1C1B1A1()
{
// arrange
var s = new Rays("H1").W;
var expected = Bitboard.With.G1.F1.E1.D1.C1.B1.A1.Build();
// act
// assert
s.AsBoard.Should().Be(expected);
}
public void W_E4_ReturnsD4C4B4A4()
{
// arrange
var s = new Rays("E4").W;
var expected = Bitboard.With.D4.C4.B4.A4.Build();
// act
// assert
s.AsBoard.Should().Be(expected);
}
public void NW_H1_ReturnsG2F3E4D5C6B7A8()
{
// arrange
var s = new Rays("H1").NW;
var expected = Bitboard.With.G2.F3.E4.D5.C6.B7.A8.Build();
// act
// assert
s.AsBoard.Should().Be(expected);
}
void Start()
{
nodes = new ArrayList ();
rays = Camera.main.GetComponent<Rays> ();
// Using windows
rootPath = "C:\\Users\\Zac\\Documents\\file-browser";
currentDirectory = "C:\\Users\\Zac\\Documents\\file-browser\\HCI Test Moderate";
slash = '\\';
if (!System.IO.Directory.Exists (rootPath)) {
// Using unix
rootPath = "/Users/Zac/Documents/file-browser";
currentDirectory = "/Users/Zac/Documents/file-browser/HCI Test Moderate";
slash = '/';
}
rootPath = PlayerPrefs.GetString ("rootPath");
currentDirectory = PlayerPrefs.GetString ("currentDirectory");
rootNode = (GameObject)Instantiate (rootFolder.gameObject, new Vector3 (0, 0, -5), Quaternion.identity);
rootNode.GetComponent<TreeNode> ().setId (currentDirectory);
rootNode.GetComponent<TreeNode> ().setPath (currentDirectory);
rootNode.GetComponent<TreeNode> ().setFileType (TreeNode.FileType.RootNode);
homeNode = rootNode;
Camera.main.transform.GetComponent<ClickScript> ().homeFolder = homeNode;
Camera.main.transform.GetComponent<ClickScript> ().searchFiles [0] = rootNode;
TraverseTree (currentDirectory);
Camera.main.transform.GetComponent<ClickScript> ().homeFolder = rootNode;
Camera.main.transform.GetComponent<ClickScript> ().nodes = nodes;
}
