//private bool PointOnWall(Point p, WallData wall)
//{
// return PointOnWall(p.pos, wall);
//}
private bool PointOnWall(Vector2 v2, WallData wall)
{
float wallLen = Vector2.Distance(wall.point1.pos, wall.point2.pos);
float len1 = Vector2.Distance(wall.point1.pos, v2);
float len2 = Vector2.Distance(wall.point2.pos, v2);
if (len1 + len2 - wallLen > 0.01f)
{
return false;
}
return true;
}
public void GetPrefab_LevelElementIsWallData_ReturnWallPrefab()
{
// Arrange
WallData wallData = Substitute.For <WallData>(dummyPos);
// Act
GameObject actualResult = prefabTable.GetPrefab(wallData);
// Assert
NUnit.Framework.Assert.IsNotNull(actualResult);
NUnit.Framework.Assert.AreEqual(prefabTable.wallPrefab, actualResult);
}
public void SetWallText(GameObject wall, string text, bool is_correct, int index)
{
WallData c = wall.AddComponent <WallData>();
c.correct = is_correct;
c.index = index;
Vector3 pos = wall.transform.position + new Vector3(0, 0, -1.1f);
GameObject txt = Instantiate(text_prefab, pos, Quaternion.Euler(0, 0, 0));
txt.GetComponent <TextMeshPro>().SetText(text);
txt.GetComponent <TextMeshPro>().alignment = (TextAlignmentOptions.Center);
}
public Vector3 GetPos(WallSideData wallside)
{
WallData wall = wallside.targetWall;
List <Vector2> v2s = GetWallVerticesPos(wall);
Vector2 v21 = wallside.forward == true ? v2s[1] : v2s[4];
Vector2 v22 = wallside.forward == true ? v2s[2] : v2s[5];
float c = wallside.forward == true ? wall.c5 : wall.c6;
Vector3 v2start = linefunc.GetDisPoint(wall.a, wall.b, c, v21.x, v21.y);
Vector3 v2end = linefunc.GetDisPoint(wall.a, wall.b, c, v22.x, v22.y);
return((v2start + v2end) / 2);
}
private void StreightAndCurvedWallsTest()
{
var nextWall = WallData.CreateStreight(new Vector2(0f, 0f), new Vector2(0f, 2f), 0.2f, 2f);
var prevWall = WallData.CreateStreight(new Vector2(3f, 2f), new Vector2(3f, 0f), 0.1f, 2f);
var curvedWall1 = WallData.CreateCurved(
new Vector2(3f, 0f),
new Vector2(1.5f, -1.5f),
new Vector2(0f, 0f),
0.15f,
2f,
new[]
{
new OpeningData(OpeningType.Outer, CreateBezierHoleShape(), 0.05f),
new OpeningData(OpeningType.Inner, CreateRectHoleShape())
});
var curvedWall2 = curvedWall1.Reverse();
/* var curvedWall2 = WallData.CreateCurved (
* new Vector2 (3f, 0f),
* new Vector2 (1.5f, -1.5f),
* new Vector2 (0f, 0f),
* 0.15f,
* 2f,
* new[]
* {
* new OpeningData (OpeningType.Through, CreateBezierHoleShape (), 0.05f),
* new OpeningData (OpeningType.Through, CreateRectHoleShape ())
* });*/
var matrix = Matrix3x2.CreateTranslation(0f, 3f);
var streightWall = WallData.CreateStreight(
new Vector2(3f, 0f),
new Vector2(0f, 0f),
0.3f,
2f,
new[]
{
new OpeningData(OpeningType.Through, CreateBezierHoleShape()),
new OpeningData(OpeningType.Through, CreateRectHoleShape())
});
RoomMeshesGenerator.CreateWallMeshes(curvedWall1, null, null);
// SingleWallTest (streightWall.Transform (matrix), nextWall.Transform (matrix), prevWall.Transform (matrix));
RoomMeshesGenerator.CreateWallMeshes(streightWall.Transform(matrix), nextWall.Transform(matrix), null);
matrix = Matrix3x2.CreateTranslation(0f, -3f);
RoomMeshesGenerator.CreateWallMeshes(
curvedWall2.Transform(matrix),
prevWall.Reverse().Transform(matrix),
nextWall.Reverse().Transform(matrix));
}
public WallSpawner(
BuildingList buildingList,
BuildingMapMatrixUpdater buildingMapMatrixUpdater,
WallData wallData,
MapLayerMatrixManager mapLayerMatrixManager,
MapLayerMatrix mapLayerMatrixWalls
) : base(buildingList, buildingMapMatrixUpdater)
{
_wallData = wallData;
_mapLayerMatrixManager = mapLayerMatrixManager;
_mapLayerMatrixWalls = mapLayerMatrixWalls;
}
void AddAngle(int _id)
{
GameObject go = Instantiate(placedPrefab);
go.transform.SetParent(container);
WallData wallData = new WallData();
wallData.anglesGO = go;
wallData.id = _id;
walls.Add(wallData);
}
private void finishDrawingWall()
{
CurrentlyDrawnWall.RemoveLastPoint();
if (CurrentlyDrawnWall.anchors.Count <= 1)
{
FurnitureList.Remove(CurrentlyDrawnWall);
listBox1.Refresh();
}
CurrentlyDrawnWall = null;
SelectButton(WallButton);
DrawDesign();
}
/// <summary>
/// Create wall data from list.
/// </summary>
/// <returns>List of LevelElementData.</returns>
private List <LevelElementData> GetAdditionalWallData()
{
List <LevelElementData> walls = new List <LevelElementData>();
foreach (JsonWallStructure wallStructure in wallElements)
{
WallData data = new WallData(new Vector2Int(wallStructure.Position.x, wallStructure.Position.y));
walls.Add(data);
}
return(walls);
}
public void AddWall(WallData wall, bool whithoutChange = false)
{
//Debug.LogWarning("addWall " + wall.point1To2Data.id + " " + wall.point2To1Data.id);
if (whithoutChange == false)
{
wall.point1To2Data.targetWall = wall;
wall.point2To1Data.targetWall = wall;
wall.point1To2Data.materialData = new MaterialData(-1, "3D/texture2D/wall3d.assetbundle");
wall.point2To1Data.materialData = new MaterialData(-1, "3D/texture2D/wall3d.assetbundle");
//Debug.LogWarning("AddWall " + wall.point1.guid+ " " + wall.point2.guid);
}
wallList.Add(wall);
}
private static OpeningPoint2D ProjectOpeningPoint(
Vector2 openingPoint,
WallData wall,
UnfoldedCurve unfoldedWall,
UnfoldedCurve unfoldedWallSide,
Func <WallPointNormals, Vector2> normalGetter)
{
/* Debug.Log (
* $"unwrappedWall {string.Join (",", Array.ConvertAll (unwrappedWall.UnwrappedPoints, x => x.ToString ()))}");
*
* Debug.Log (
* $"unwrappedWallSide {string.Join (",", Array.ConvertAll (unwrappedWallSide.UnwrappedPoints, x => x.ToString ()))}");*/
var wallPoints = wall.Points;
for (int i = 1; i < wallPoints.Length; i++)
{
if (openingPoint.x > unfoldedWall.UnfoldedPoints[i].X)
{
continue;
}
var normals = wall.Normals.Value;
var normal = normalGetter(normals[i]);
var prevNormal = normalGetter(normals[i - 1]);
var averageNormal = normal + prevNormal;
var unwrapped = unfoldedWall
.Unfold(new Vector2(openingPoint.x, 0f))
.ToUnityVector2();
// var unwrappedDebug = new Vector3 (unwrapped.x, openingPoint.y, unwrapped.y);
var unwrappedOnSide = unwrapped.TransposePoint(averageNormal, wall.Width / 2f);
var wrappedOnSide = unfoldedWallSide.Fold(unwrappedOnSide);
var result = new Vector2(wrappedOnSide.x, openingPoint.y);
// var unwrappedOnSideDebug = new Vector3 (unwrappedOnSide.x, openingPoint.y, unwrappedOnSide.y);
// Debug.DrawLine(unwrappedDebug, unwrappedOnSideDebug, color, float.MaxValue);
// Debug.DrawLine(unwrappedDebug, unwrappedOnSideDebug + new Vector3(normal.x, 0f, normal.y), Color.yellow, float.MaxValue);
/*
* Debug.Log (
* $"openingPoint {openingPoint} unwrapped {unwrapped} unwrappedOnSide {unwrappedOnSide} wrappedOnSide {wrappedOnSide} result {result}");
*/
return(new OpeningPoint2D(result, -averageNormal));
}
throw new NotImplementedException();
}
public WallData GetHelpWallData(Point pointFrom, Point pointTo)
{
WallData wallData = null;
for (int i = 0; i < helperData.helpLineList.Count; i++)
{
WallData item = data.wallList[i];
if (item.equle(pointFrom, pointTo))
{
wallData = item;
}
}
return(wallData);
}
private Vector3 calculateRotation(WallData data)
{
switch (data.wall) {
case HallNode.Wall.RIGHT:
return new Vector3 (0f, 90f, 0f);
case HallNode.Wall.LEFT:
return new Vector3 (0f, -90f, 0f);
case HallNode.Wall.TOP:
return new Vector3 (0f, 0f, 0f);
case HallNode.Wall.BOTTOM:
return new Vector3 (0f, 180f, 0f);
}
return new Vector3 (0f, 0f, 0f);
}
public List <WallData> GetWallList(Point target)
{
List <WallData> list = new List <WallData>();
for (int i = 0; i < data.wallList.Count; i++)
{
WallData item = data.wallList[i];
if (item.Contines(target))
{
list.Add(item);
}
}
return(list);
}
public void Load(int id)
{
if (File.Exists(Application.persistentDataPath + "/" + roomScript.GetSaveFolderName() + "/wall" + id.ToString() + ".dat"))
{
BinaryFormatter binary = new BinaryFormatter();
FileStream file = File.Open(Application.persistentDataPath + "/" + roomScript.GetSaveFolderName() + "/wall" + id.ToString() + ".dat", FileMode.Open);
WallData dat = (WallData)binary.Deserialize(file);
file.Close();
transform.localRotation = new Quaternion(dat.rx, dat.ry, dat.rz, dat.rw);
transform.localScale = new Vector3(dat.sx, dat.sy, dat.sz);
transform.position = new Vector3(dat.px, dat.py, dat.pz);
transform.SetSiblingIndex(dat.siblingIndex);
}
}
public float GetSideLength(WallSideData wallside)
{
WallData wall = wallside.targetWall;
List <Vector2> v2s = GetWallVerticesPos(wall);
Vector2 v21 = wallside.forward == true ? v2s[1] : v2s[4];
Vector2 v22 = wallside.forward == true ? v2s[2] : v2s[5];
float c = wallside.forward == true ? wall.c5 : wall.c6;
Vector3 v2start = linefunc.GetDisPoint(wall.a, wall.b, c, v21.x, v21.y);
Vector3 v2end = linefunc.GetDisPoint(wall.a, wall.b, c, v22.x, v22.y);
float angle = linefunc.GetAngle(v2end - v2start);
float dis = Mathf.RoundToInt(Vector2.Distance(v2start, v2end) * 1000);
dis = dis * (int)defaultSettings.DefaultUnit / 1000;
return(dis);
}
private bool CheckRemove(Point pointF, Point ifRemove, Point pointT)
{
WallData wallF = data.GetWall(pointF, ifRemove);
WallData wallT = data.GetWall(pointT, ifRemove);
bool isParallel = wallfunc.IsParallel(wallF, wallT);
if (isParallel == true)
{
data.AddWall(pointF, pointT, wallF.height, wallF.width);
data.RemoveWall(wallF);
data.RemoveWall(wallT);
data.RemovePoint(ifRemove);
}
return(isParallel);
}
private void WallsTest()
{
var walls = new Walls();
walls.AddWallData(WallData.CreateCurved(-2f, -2f, -4f, -0f, -2, 2, 0.3f, 2f));
walls.AddWallData(
WallData.CreateStreight(-2f, 2f, 0f, 2f, 0.4f, 2f, null, WidthChangeType.Type2));
walls.AddWallData(WallData.CreateStreight(0f, 2f, 2f, 2f, 0.1f, 1f));
walls.AddWallData(WallData.CreateStreight(2f, 2f, 2f, -2f, 0.2f, 2f));
walls.AddWallData(WallData.CreateStreight(2f, -2f, -2f, -2f, 0.5f, 2f));
// var walls = new Dictionary<Vector2, List<WallData>> ();
/* var walls = new[]
* {
* // BaseWallData.CreateStreight (new Vector2 (-2, -2), new Vector2 (-2, 2), 0.2f, 2f),
* WallData.CreateCurved (new Vector2 (-2, -2), new Vector2 (-4, -0), new Vector2 (-2, 2), 0.3f, 2f),
* WallData.CreateStreight (new Vector2 (-2, 2), new Vector2 (0, 2), 0.4f, 2f, null, WidthChangeType.Type2),
* WallData.CreateStreight (new Vector2 (0, 2), new Vector2 (2, 2), 0.1f, 1f),
* WallData.CreateStreight (new Vector2 (2, 2), new Vector2 (2, -2), 0.2f, 2f),
* WallData.CreateStreight (new Vector2 (2, -2), new Vector2 (-2, -2), 0.5f, 2f)
* };*/
/* var walls = new[]
* {
* WallData.CreateStreight (new Vector2 (0, -2), new Vector2 (-2, 0), 0.2f, 2f),
* WallData.CreateStreight (new Vector2 (-2, 0), new Vector2 (0, 2), 0.2f, 2f),
* WallData.CreateStreight (new Vector2 (0, 2), new Vector2 (2, 0), 0.2f, 2f),
* WallData.CreateStreight (new Vector2 (2, 0), new Vector2 (0, -2), 0.2f, 2f)
* };*/
/* var wallsCount = walls.Count;
* for (int i = 0; i < wallsCount; i++) {
* var prevIndex = (i - 1 + wallsCount) % wallsCount;
* var nextIndex = (i + 1) % wallsCount;
*
* var meshes = WallMeshesGenerator.GetWallMeshes (walls[prevIndex], walls[i], walls[nextIndex]);
* var parent = new GameObject ($"Wall {i}").transform;
* for (int j = 0; j < meshes.Length; j++) {
* var mesh = meshes[j];
* MeshGenerator
* .CreateGameObject (mesh.name, mesh)
* .transform
* .SetParent (parent, false);
* }
* }*/
}
private void OpenDisInput()
{
minDis = float.MaxValue;
Vector2 pos = GetV2WithoutY(target.position);
minPos = pos;
WallData wall = disView.data;
int sidetype = lineFunc.Clockwise(pos, wall.point1.pos, wall.point2.pos);
if (sidetype == 0)
{
sidetype = 1;
}
for (int i = 0; i < vertexs.Count; i++)
{
Vector2 vertexspos = vertexs[i];
float dis = wall.GetDis(vertexspos);
int sidetypei = lineFunc.Clockwise(vertexspos, wall.point1.pos, wall.point2.pos);
if (sidetypei == 0)
{
dis = 0;
}
else if (sidetypei != sidetype)
{
dis = -dis;
}
dis -= wall.width / 2;
if (dis < minDis)
{
minDis = dis;
minPos = vertexspos;
}
else if (dis == minDis)
{
if (vertexspos.x < minPos.x || vertexspos.y < minPos.y)
{
minPos = vertexspos;
}
}
}
UITool.SetActionTrue(obj);
Cancel();
optionsPage.inputUnit.onClick.AddListener(onOpenInput);
optionsPage.ok.onClick.AddListener(Ok);
optionsPage.cancel.onClick.AddListener(Cancel);
}
private List <WallData> GetWallsData()
{
List <WallData> _wallsData = new List <WallData>();
foreach (Transform _wall in walls.transform)
{
WallData _wallData = new WallData()
{
position = _wall.position,
rotation = new RotationData(_wall.rotation),
size = _wall.localScale
};
_wallsData.Add(_wallData);
}
return(_wallsData);
}
public WallSideData getSideById(int id, OriginalInputData inputdata)
{
for (int i = 0; i < inputdata.wallList.Count; i++)
{
WallData wall = inputdata.wallList[i];
if (wall.point1To2Data.guid == id)
{
return(wall.point1To2Data);
}
if (wall.point2To1Data.guid == id)
{
return(wall.point2To1Data);
}
}
return(null);
}
/// <summary>
/// 找到walls围成的房间
/// </summary>
public RoomData GetRoom(List <WallData> walls)
{
if (walls.Count == 0 || walls == null)
{
return(null);
}
getroomhelp.Clear();
getroomhelp.InsertRange(0, walls);
WallData wall0 = getroomhelp[0];
RoomData room1 = data.GetRoom(wall0.point1, wall0.point2);
RoomData room2 = data.GetRoom(wall0.point2, wall0.point1);
bool isRoom1 = room1 != null ? true : false;
bool isRoom2 = room2 != null ? true : false;
if (isRoom1 == false && isRoom2 == false)
{
return(null);
}
for (int k = 0; k < getroomhelp.Count; k++)
{
WallData wallk = getroomhelp[k];
RoomData roomk1 = data.GetRoom(wallk.point1, wallk.point2);
RoomData roomk2 = data.GetRoom(wallk.point2, wallk.point1);
if (isRoom1 == true)
{
isRoom1 = roomk1 == room1 || roomk2 == room1;
}
if (isRoom2 == true)
{
isRoom2 = roomk1 == room2 || roomk2 == room2;
}
if (isRoom1 == false && isRoom2 == false)
{
return(null);
}
}
if (isRoom1)
{
return(room1);
}
if (isRoom2)
{
return(room2);
}
return(null);
}
public bool OnMaxAngleRoom(WallData walldata)
{
for (int i = 0; i < maxAngleRooms.Count; i++)
{
RoomData room = maxAngleRooms[i];
if (room.sideList.Contains(walldata.point1To2Data))
{
return(true);
}
if (room.sideList.Contains(walldata.point2To1Data))
{
return(true);
}
}
return(false);
}
private async Task <bool> ProcessContactFeeds(List <FeedOperationDetails> fodList)
{
List <WallService.WallRequestData> requestData = new List <WallService.WallRequestData>();
using (List <FeedOperationDetails> .Enumerator enumerator = fodList.GetEnumerator())
{
while (enumerator.MoveNext())
{
FeedOperationDetails current = enumerator.Current;
requestData.Add(new WallService.WallRequestData()
{
UserId = RemoteIdHelper.GetItemIdByRemoteId(current.OwnerRemoteId),
Offset = this.GetRequiredOffset(current),
Count = current.ItemCount
});
}
}
BackendResult <List <WallData>, ResultCode> res = await WallService.Current.GetWallForManyUsers(requestData);
if (res.ResultCode != ResultCode.Succeeded)
{
return(false);
}
for (int i = 0; i < fodList.Count && i < res.ResultData.Count; ++i)
{
FeedOperationDetails fod = fodList[i];
WallData currentWallData = res.ResultData[i];
int nextOffset = this.GetRequiredOffset(fod) + currentWallData.wall.Count;
Feed feed = await SocialManager.OpenContactFeedAsync(fod);
foreach (WallPost wallPost in currentWallData.wall)
{
FeedItem feedItem = this.CreateFeedItem(wallPost, currentWallData.groups, currentWallData.profiles, true);
if (feedItem != null)
{
this.SetRequiredOffset(feedItem, nextOffset);
((ICollection <FeedItem>)feed.Items).Add(feedItem);
}
}
await feed.SaveAsync();
currentWallData = null;
}
return(true);
}
public override void mPhoneUpdate()
{
base.mPhoneUpdate();
if (uguiHitUI.uiHited == true || Input.touchCount != 1)
{
return;
}
Touch touch = Input.GetTouch(0);
Vector2 inputPos = GetScreenToWorldPos(touch.position);
if (lastMousePos == inputPos && touch.phase != TouchPhase.Ended && touch.phase != TouchPhase.Canceled)
{
return;
}
lastMousePos = inputPos;
targetWall = null;
float Angle = targetObj.transform.rotation.eulerAngles.z;
Vector3 world2d = inputCamera.ScreenToWorldPoint(touch.position);
for (int i = 0; i < data.wallList.Count; i++)
{
if (targetVO.type != 2)
{
GoodsOnWall(data.wallList[i], ref world2d, ref Angle);
}
else
{
GoodsInWall(data.wallList[i], ref world2d, ref Angle);
}
}
world2d.z = -5 - targetProduct.defaultHeight;
targetObj.transform.position = world2d;
if (touch.phase == TouchPhase.Ended || touch.phase == TouchPhase.Canceled)
{
undoHelper.save();
Vector3 angle = targetObj.transform.rotation.eulerAngles;
Vector3 world3d = world2d.x * Vector3.right + world2d.y * Vector3.forward;
Product product = mainpagedata.getProduct(targetVO.seekId);
ProductData productData = data.AddProduct(targetVO.id, world3d, angle.z, product, targetWall, targetVO.type);
RefreshView();
ToSelectGoodsState(productData);
}
}
private void RoomsFinderTest()
{
var walls = new Walls();
walls.AddWallData(WallData.CreateStreight(1f, 2f, 0f, 3f, 0.1f, 2f));
walls.AddWallData(WallData.CreateStreight(0f, 2f, 0f, 3f, 0.1f, 2f));
walls.AddWallData(WallData.CreateStreight(1f, 1f, 0.5f, 0.5f, 0.1f, 2f));
walls.AddWallData(WallData.CreateStreight(0f, 0f, 0f, 2f, 0.1f, 2f));
walls.AddWallData(WallData.CreateStreight(0f, 2f, 1f, 2f, 0.1f, 2f));
walls.AddWallData(WallData.CreateStreight(1f, 2f, 1f, 3f, 0.1f, 2f));
walls.AddWallData(WallData.CreateStreight(1f, 3f, 4f, 3f, 0.1f, 2f));
walls.AddWallData(WallData.CreateStreight(4f, 3f, 2f, 2f, 0.1f, 2f));
walls.AddWallData(WallData.CreateStreight(2f, 2f, 1f, 2f, 0.1f, 2f));
walls.AddWallData(WallData.CreateStreight(2f, 2f, 2f, 0f, 0.1f, 2f));
walls.AddWallData(WallData.CreateStreight(2f, 0f, 0f, 0f, 0.1f, 2f));
walls.AddWallData(WallData.CreateStreight(1f, 2f, 1f, 1f, 0.1f, 2f));
walls.AddWallData(WallData.CreateStreight(2f, 0f, 1.5f, 0.5f, 0.1f, 2f));
walls.AddWallData(WallData.CreateStreight(1.5f, 0.5f, 1.5f, 1f, 0.1f, 2f));
walls.AddWallData(WallData.CreateStreight(1.5f, 1f, 1f, 1f, 0.1f, 2f));
walls.AddWallData(WallData.CreateStreight(10f, 10f, 10f, 15f, 0.1f, 2f));
walls.AddWallData(WallData.CreateStreight(10f, 15f, 15f, 15f, 0.1f, 2f));
walls.AddWallData(WallData.CreateStreight(15f, 15f, 15f, 10f, 0.1f, 2f));
walls.AddWallData(WallData.CreateStreight(15f, 10f, 10f, 10f, 0.1f, 2f));
walls.AddWallData(WallData.CreateStreight(11f, 11f, 11f, 13f, 0.1f, 2f));
walls.AddWallData(WallData.CreateStreight(11f, 13f, 13f, 13f, 0.1f, 2f));
walls.AddWallData(WallData.CreateStreight(13f, 13f, 13f, 11f, 0.1f, 2f));
walls.AddWallData(WallData.CreateStreight(13f, 11f, 11f, 11f, 0.1f, 2f));
/* walls.AddWallData (WallData.CreateStreight (0f, 0f, 0f, 2f, 0.1f, 2f));
* walls.AddWallData (WallData.CreateStreight (0f, 2f, 2f, 2f, 0.1f, 2f));
* walls.AddWallData (WallData.CreateStreight (2f, 2f, 2f, 0f, 0.1f, 2f));
* walls.AddWallData (WallData.CreateStreight (0f, 0f, 2f, 0f, 0.1f, 2f));*/
/* walls.AddWallData (WallData.CreateStreight (2f, 2f, 3f, 2f, 0.1f, 2f));
* walls.AddWallData (WallData.CreateStreight (3f, 2f, 3f, 0f, 0.1f, 2f));
* walls.AddWallData (WallData.CreateStreight (3f, 0f, 2f, 0f, 0.1f, 2f));*/
RoomMeshesGenerator.CreateRoomMeshes(walls);
}
private WallData[] GetNearestWall(Point point, Point other)
{
float maxAngle = -1;
float minAngle = 361;
WallData maxAngleWall = null;
WallData minAngleWall = null;
List <Point> list = data.GetNearestPoints(point);
for (int i = 0; i < list.Count; i++)
{
Point item = list[i];
if (item == other)
{
continue;
}
WallData temp = GetWallData(point, item);
if (temp == null)
{
Debug.LogWarning("GetWallData(point, wallData.point2) == null; i = " + i);
continue;
}
float angle = GetAngle(other, point, temp);
if (angle > maxAngle)
{
maxAngleWall = temp;
maxAngle = angle;
}
if (angle < minAngle)
{
minAngleWall = temp;
minAngle = angle;
}
}
if (minAngleWall == maxAngleWall && maxAngleWall == null)
{
//没有相临墙
return(null);
}
return(new WallData[2] {
minAngleWall, maxAngleWall
});
}
void OnCollisionEnter(Collision collision)
{
if (collision.gameObject.name.Equals("boop"))
{
WallData hit_wall = collision.collider.GetComponent <WallData>();
if (is_left[hit_wall.index] == true)
{
Destroy(left_walls[hit_wall.index].gameObject, 5);
Destroy(right_walls[hit_wall.index].gameObject.GetComponent <BoxCollider>());
}
else
{
Destroy(left_walls[hit_wall.index].gameObject.GetComponent <BoxCollider>());
Destroy(right_walls[hit_wall.index].gameObject, 5);
}
print(String.Format("boopest {0} {1}", hit_wall.correct, hit_wall.index));
num_answered = num_answered + 1;
int remaining = problemset_len - num_answered;
//SetWallsRemaining(remaining);
if (remaining <= 0)
{
StartCoroutine(GameOverDelay(3));
}
else
{
SetTargetText(hit_wall.index + 1);
}
if (hit_wall.correct)
{
print("correct");
score = score + 1;
ChangeSpeed(3);
SetWallsRemaining(score);
}
else
{
print("wrong");
ChangeSpeed(-3);
}
left_walls[hit_wall.index].gameObject.name = "answered";
right_walls[hit_wall.index].gameObject.name = "answered";
}
}
/// <summary>
/// Creates wall objects based on the stored data
/// </summary>
/// <param name="wallsParent">Transform that will serve as the parent for the new walls</param>
/// <param name="wallPrefab">Prefab of a wall</param>
public static void LoadWalls(Transform wallsParent, GameObject wallPrefab)
{
// Get the amount of walls
ChildAmountData wallAmData = SaveSystem.LoadWallAmount();
int amountWalls = wallAmData.GetChildAmount();
// Load each wall
for (int i = 0; i < amountWalls; ++i)
{
// Get the data for the wall
WallData wallData = SaveSystem.LoadWall(i);
// Create the new wall as a child of the wall parent
GameObject wallObj = Object.Instantiate(wallPrefab, wallsParent);
// Set its transform components
wallObj.transform.position = wallData.GetPosition();
}
}
private float GetAngle(Point end, Point start, WallData temp)
{
float angle1 = linefunc.GetAngle(end.pos - start.pos);
Point tempEnd = temp.point1;
if (tempEnd == start)
{
tempEnd = temp.point2;
}
float angle2 = linefunc.GetAngle(tempEnd.pos - start.pos);
float angle = angle2 - angle1;
if (angle < 0)
{
angle += 360;
}
return(angle);
}
void OnAddAngle(UnityEngine.XR.ARSubsystems.TrackableId trackeableID, Vector3 pos, Quaternion rot)
{
WallData wallData = GetWallData(trackeableID);
GameObject go = Instantiate(placedPrefab);
go.transform.SetParent(container);
go.transform.position = pos;
go.transform.rotation = rot;
if (wallData == null)
{
wallData = new WallData();
wallData.anglesGO = new List <GameObject>();
wallData.trackeableID = trackeableID;
walls.Add(wallData);
}
wallData.anglesGO.Add(go);
}
private Vector3 calculatePosition(WallData data)
{
float offset = ((data.afterLenght + data.beforeLenght + 1f) / 2) - data.beforeLenght - 0.5f;
Vector3 pos;
switch (data.wall) {
case HallNode.Wall.TOP:
pos = new Vector3 (data.position.x + offset, 0f, -data.position.y + 0.5f) * scale.getHallWidth ();
break;
case HallNode.Wall.BOTTOM:
pos = new Vector3 (data.position.x + offset, 0f, -data.position.y - 0.5f) * scale.getHallWidth ();
break;
case HallNode.Wall.LEFT:
pos = new Vector3 (data.position.x - 0.5f, 0f, -data.position.y - offset) * scale.getHallWidth ();;
break;
default:
pos = new Vector3 (data.position.x + 0.5f, 0f, -data.position.y - offset) * scale.getHallWidth ();;
break;
}
pos.y = scale.getHallHeight () / 2f;
return pos;
}
private void generateWallData(int i, int j, Vector2 offset, HallNode.Wall wall)
{
if(hall.hasWallAt(i, j, wall)){
string key = i+","+j;
string keyPos1 = (i+offset.x)+","+(j+offset.y);
string keyPos2 = (i-offset.x)+","+(j-offset.y);
if(hallWalls.ContainsKey(keyPos1) && hallWalls[keyPos1].ContainsKey(wall)){
hallWalls[keyPos1][wall].beforeLenght++;
if(hallWalls.ContainsKey(key)){
hallWalls[key].Add(wall, hallWalls[keyPos1][wall]);
}
else{
hallWalls.Add(key, new Dictionary<HallNode.Wall, WallData>());
hallWalls[key].Add(wall, hallWalls[keyPos1][wall]);
//walls.Add(hallWalls[key][wall]);
}
}
else if(hallWalls.ContainsKey(keyPos2) && hallWalls[keyPos2].ContainsKey(wall)){
hallWalls[keyPos2][wall].afterLenght++;
if(hallWalls.ContainsKey(key)){
hallWalls[key].Add(wall, hallWalls[keyPos2][wall]);
}
else{
hallWalls.Add(key, new Dictionary<HallNode.Wall, WallData>());
hallWalls[key].Add(wall, hallWalls[keyPos2][wall]);
//walls.Add(hallWalls[key][wall]);
}
}
else{
WallData wallData = new WallData(i, j, wall);
if(hallWalls.ContainsKey(key)){
hallWalls[key].Add(wall, wallData);
}
else{
Dictionary<HallNode.Wall, WallData> dic = new Dictionary<HallNode.Wall, WallData>();
dic.Add(wall, wallData);
hallWalls.Add(key, dic);
}
walls.Add(wallData);
}
}
}
private void generateWallMesh(WallData data)
{
//GameObject cube = GameObject.CreatePrimitive(PrimitiveType.Cube);
GameObject cube = wallBuilder.generateWall (data.afterLenght + data.beforeLenght + 1, 1);
cube.name = "Wall (" + data.position.x + "," + data.position.y + ") " + data.wall.ToString ();
Transform parent = GameObject.Find ("Hall").transform;
//cube.GetComponent<MeshRenderer> ().material = Game.GetInstance ().roomMaterial.wallMaterial;
cube.transform.parent = parent;
cube.transform.position = calculatePosition(data);
cube.transform.localScale = new Vector3 (scale.getHallWidth(), scale.getHallHeight(), 1f);
cube.transform.Rotate (calculateRotation(data));
}
