public static Vector3 ReturnMaximalVector(List <Vector3> vectors, Utils.Direction dir)
{
Vector3 maximalVector = Vector3.zero;
bool init = true;
foreach (var v in vectors)
{
if (init)
{
maximalVector = v;
init = false;
continue;
}
if (dir == Left && v.x < maximalVector.x)
{
maximalVector = v;
}
if (dir == Right && v.x > maximalVector.x)
{
maximalVector = v;
}
if (dir == Up && v.z > maximalVector.z)
{
maximalVector = v;
}
if (dir == Down && v.z < maximalVector.z)
{
maximalVector = v;
}
}
return(maximalVector);
}
public Moves Move(Utils.Direction direction, Utils.Quantifier speed)
{
Moves move = Moves.NO_ACTION;
Utils.Quantifier Moving_In_Pretended_Direction;
Moves Move_Direction, Move_Oposite_Direction;
if (direction == Utils.Direction.RIGHT)
{
Moving_In_Pretended_Direction = this.agentStatus.MOVING_RIGHT;
Move_Direction = Moves.MOVE_RIGHT;
Move_Oposite_Direction = Moves.MOVE_LEFT;
}
else
{
Moving_In_Pretended_Direction = this.agentStatus.MOVING_LEFT;
Move_Direction = Moves.MOVE_LEFT;
Move_Oposite_Direction = Moves.MOVE_RIGHT;
}
if (Moving_In_Pretended_Direction == speed + 1) //TODO REDUDANT, NEEDS TO REFACTOR. I JUST COPIED IT FROM CIRCLE XD
{
move = Move_Oposite_Direction;
}
else if (Moving_In_Pretended_Direction <= speed)
{
move = Move_Direction;
}
else
{
move = Move_Oposite_Direction;
}
return(move);
}
public bool CheckWall(Utils.Direction check)
{
bool hit = false;
switch (check)
{
case Utils.Direction.LEFT:
foreach (Transform wallCheck in wallChecksLeft)
{
Debug.DrawLine(transform.position, wallCheck.position);
if (Physics2D.Linecast(transform.position, wallCheck.position, 1 << LayerMask.NameToLayer("Ground")))
{
hit = true;
}
}
break;
case Utils.Direction.RIGHT:
foreach (Transform wallCheck in wallChecksRight)
{
if (Physics2D.Linecast(transform.position, wallCheck.position, 1 << LayerMask.NameToLayer("Ground")))
{
hit = true;
}
}
break;
}
return(hit);
}
private void HandleScrollWheelInput()
{
scrollWheelInput.Update();
if (scrollWheelInput.PressedDown)
{
// Changing the object
if (leftAltInput.PressedDown)
{
objPlacer.ChangeObject(!scrollWheelInput.PositiveAxis);
}
// Turning the object
else if (leftCtrlInput.PressedDown)
{
Utils.Direction direction =
scrollWheelInput.PositiveAxis ? Utils.Direction.Left : Utils.Direction.Right;
objPlacer.ChangeRotationForNextObject(direction);
}
// Changing the height level
else
{
float heightLevelChange = leftShiftInput.PressedDown ? 0.5f : 1f;
heightLevelChange = (scrollWheelInput.PositiveAxis ? 1 : -1) * heightLevelChange;
objPlacer.ChangeHeightLevel(heightLevelChange);
}
}
}
public void setMoveDirection(RaycastHit hit)
{
Vector3 incomingVec = hit.normal - Vector3.up;
if (incomingVec == new Vector3(0, -1, -1))
{
moveDirection = Utils.Direction.South;
}
else if (incomingVec == new Vector3(0, -1, 1))
{
moveDirection = Utils.Direction.North;
}
else if (incomingVec == new Vector3(0, 0, 0))
{
moveDirection = Utils.Direction.Up;
}
else if (incomingVec == new Vector3(1, 1, 1))
{
moveDirection = Utils.Direction.Down;
}
else if (incomingVec == new Vector3(-1, -1, 0))
{
moveDirection = Utils.Direction.West;
}
else if (incomingVec == new Vector3(1, -1, 0))
{
moveDirection = Utils.Direction.East;
}
}
protected void Flip(Utils.Direction dir)
{
if (direction == Utils.Direction.LEFT)
{
Vector3 scale = transform.localScale;
scale.x *= -1;
transform.localScale = scale;
}
}
public bool CanMoveTo(Utils.Direction dir)
{
if (directions[(int)dir] != null)
{
return(true);
}
return(false);
}
/// <summary>
/// Handles user input.
/// </summary>
private void HandleGameInput()
{
HandleCameraInput();
leftShiftInput.Update();
leftCtrlInput.Update();
leftAltInput.Update();
// Changing the object
changeObjInput.Update();
if (changeObjInput.JustPressedDown)
{
objPlacer.ChangeObject(changeObjInput.PositiveAxis);
}
// Turning the object
turnObjInput.Update();
if (turnObjInput.JustPressedDown)
{
Utils.Direction direction =
turnObjInput.PositiveAxis ? Utils.Direction.Right : Utils.Direction.Left;
objPlacer.ChangeRotationForNextObject(direction);
}
showAllInput.Update();
if (showAllInput.JustPressedDown)
{
grid.HideAllObjects(false);
}
if (ui.EditMenuActive)
{
HandleRightClickCancelInput();
}
else if (!objPlacer.MultiSelectionActive)
{
HandleScrollWheelInput();
HandleMouseAndModifierInput();
HandleQuickSettingsInput();
if (ModeButtonHeldDown())
{
UpdateModeHold(settings.EditMode, instant: false);
}
else
{
ResetModeHold();
HandleMultiSelectionInput();
HandleFavoritesInput();
}
}
else
{
HandleMultiSelectionInput();
}
}
public void Flip(Utils.Direction direction)
{
if ((direction == Utils.Direction.LEFT && !facingLeft) || (direction == Utils.Direction.RIGHT && facingLeft))
{
facingLeft = !facingLeft;
Vector3 scale = sprite.transform.localScale;
scale.x *= -1;
sprite.transform.localScale = scale;
}
}
public float GetDistanceUntilCollision(Utils.Direction check, float distance)
{
float distanceHit = 0;
Vector3 baseVector = transform.position;
float i = -0.5f;
int index = 0;
switch (check)
{
case Utils.Direction.LEFT:
distanceHit = distance * -1;
Vector3[] leftVectors = new Vector3[10];
i = -0.5f;
index = 0;
while (i < 0.48f)
{
leftVectors[index] = new Vector3(baseVector.x - distance, baseVector.y + i);
i += 0.1f;
index++;
}
foreach (Vector3 leftVector in leftVectors)
{
RaycastHit2D rc2d = Physics2D.Linecast(new Vector3(baseVector.x, leftVector.y), leftVector, 1 << LayerMask.NameToLayer("Ground"));
if (rc2d)
{
distanceHit = rc2d.distance * -1;
}
}
break;
case Utils.Direction.RIGHT:
distanceHit = distance;
Vector3[] rightVectors = new Vector3[10];
i = -0.5f;
index = 0;
while (i < 0.48f)
{
rightVectors[index] = new Vector3(baseVector.x + distance, baseVector.y + i);
i += 0.1f;
index++;
}
foreach (Vector3 rightVector in rightVectors)
{
RaycastHit2D rc2d = Physics2D.Linecast(new Vector3(baseVector.x, rightVector.y), rightVector, 1 << LayerMask.NameToLayer("Ground"));
if (rc2d)
{
distanceHit = rc2d.distance;
}
}
break;
}
return(distanceHit);
}
public PostOrderAsync(string account, string venue, Stock stock, Fill order, Utils.OrderType orderType)
{
Url = string.Format("https://api.stockfighter.io/ob/api/venues/{0}/stocks/{1}/orders", venue, stock.Symbol);
Account = account;
Venue = venue;
Stock = stock.Symbol;
Price = order.Price;
Quantity = order.Quantity;
_direction = Utils.GetDirection(order.IsBuy);
_orderType = orderType;
}
/// <summary>
/// Determines whether the mouse cursor is near the edge of the screen.
/// </summary>
/// <param name="side">A specific side or None for any</param>
/// <param name="maxDistance">How close to the edge should the cursor be (in pixels)</param>
/// <returns>Is the mouse cursor near the edge of the screen</returns>
private bool MouseCursorNearScreenEdge(Utils.Direction side, float maxDistance)
{
bool up = Input.mousePosition.y >= screenDimensions.y - maxDistance;
bool down = Input.mousePosition.y <= maxDistance;
bool left = Input.mousePosition.x <= maxDistance;
bool right = Input.mousePosition.x >= screenDimensions.x - maxDistance;
switch (side)
{
case Utils.Direction.Up:
return(up);
case Utils.Direction.Down:
return(down);
case Utils.Direction.Left:
return(left);
case Utils.Direction.Right:
return(right);
// Any side
case Utils.Direction.None:
Utils.Direction nearSide = Utils.Direction.None;
if (up)
{
nearSide = Utils.Direction.Up;
}
else if (down)
{
nearSide = Utils.Direction.Down;
}
else if (left)
{
nearSide = Utils.Direction.Left;
}
else if (right)
{
nearSide = Utils.Direction.Right;
}
if (nearSide != Utils.Direction.None)
{
Debug.Log("Mouse cursor near edge: " + nearSide + " " + Input.mousePosition);
return(true);
}
break;
}
return(false);
}
void LeftRightSubdivide(LotInfo lot, Utils.Direction v_dir)
{
if (lot.Frontage < 2.7f)
{
return;
}
LotInfo LotL = SubdivideBlock(lot, Utils.Left, v_dir);
LotInfo LotR = SubdivideBlock(lot, Utils.Right, v_dir);
LeftRightSubdivide(LotL, v_dir);
LeftRightSubdivide(LotR, v_dir);
}
/// <summary>Coroutine for audio fade in/out. fadeTime is true to real seconds.
/// You can use as many AudioSources as possible in one execution, useful for e.g. fading in/out a group of ambisonics sources.
/// </summary>
public static IEnumerator Fade(Utils.Direction direction, float fadeTime, params AudioSource[] audioSources)
{
// IMPORTANT FOR isFading CHECK!! DO NOT REMOVE
yield return(null);
isFadingIn = (direction == Utils.Direction.In) ? true : isFadingIn;
isFadingOut = (direction == Utils.Direction.Out) ? true : isFadingOut;
float startVolume = 0f, endVolume = 1f;
switch (direction)
{
case Utils.Direction.In:
startVolume = (audioSources[0].volume > 0.1f) ? 0f : audioSources[0].volume;
endVolume = 1f;
foreach (AudioSource a in audioSources)
{
a.volume = 0f;
a.Play();
}
break;
case Utils.Direction.Out:
startVolume = (audioSources[0].volume > 0.9f) ? 1f : audioSources[0].volume;
endVolume = 0f;
break;
}
for (float f = 0; f <= fadeTime; f += Time.deltaTime)
{
foreach (AudioSource a in audioSources)
{
a.volume = Mathf.Lerp(startVolume, endVolume, f / fadeTime);
}
yield return(null);
}
isFadingIn = (direction == Utils.Direction.In) ? false : isFadingIn;
isFadingOut = (direction == Utils.Direction.Out) ? false : isFadingOut;
if (direction == Utils.Direction.Out && !isFading)
{
foreach (AudioSource a in audioSources)
{
a.Stop(); a.clip = null;
}
}
}
protected override void Attack()
{
if (!isAttacking && (Utils.GetUnixTime() - cooldownTimer) > cooldown)
{
Collider2D collider = Physics2D.OverlapCircle(transform.position, 7f, 1 << LayerMask.NameToLayer("Player"));
if (collider)
{
float distance = shootStart.position.x - collider.transform.position.x;
if (direction == Utils.Direction.RIGHT && distance > 0)
{
direction = Utils.Direction.LEFT;
}
if (direction == Utils.Direction.LEFT && distance <= 0)
{
direction = Utils.Direction.RIGHT;
}
Flip(direction);
isAttacking = true;
cooldownTimer = Utils.GetUnixTime();
Transform destination = collider.transform;
foreach (float offset in projectileDirectionsOffset)
{
Vector3 vector = destination.position;
vector.y += offset;
GameObject go = UnityEngine.Object.Instantiate(ProjectilePrefab);
IProjectile fb = go.GetComponent <IProjectile>();
fb.start = new Vector3(shootStart.position.x, shootStart.position.y, shootStart.position.z);
fb.end = vector;
fb.source = type;
projectiles.Add(fb);
}
anim.Play("GolemAttack");
timer = new System.Timers.Timer();
timer.Interval = 1000;
timer.Elapsed += StopAttacking;
timer.Enabled = true;
}
}
}
private Moves Roll(Utils.Direction direction, Utils.Quantifier speed)
{
Moves move = Moves.NO_ACTION;
Utils.Quantifier Moving_In_Pretended_Direction;
Moves Roll_Pretended_Direction, Roll_Oposite_Direction;
//Define directions
if (direction == Utils.Direction.RIGHT)
{
Moving_In_Pretended_Direction = this.agentStatus.MOVING_RIGHT;
Roll_Pretended_Direction = Moves.ROLL_RIGHT;
Roll_Oposite_Direction = Moves.ROLL_LEFT;
}
else
{
Moving_In_Pretended_Direction = this.agentStatus.MOVING_LEFT;
Roll_Pretended_Direction = Moves.ROLL_LEFT;
Roll_Oposite_Direction = Moves.ROLL_RIGHT;
}
//Decide action
if (this.predictor != null)
{
//TODO Remove this first condition. This is the same as Else condition
if (Moving_In_Pretended_Direction == speed + 1) //If Agent is moving with a little bit excessive speed
{
Log.LogInformation("SPEED: Good enough - " + Enum.GetName(typeof(Utils.Quantifier), Moving_In_Pretended_Direction).ToString());
//move = Moves.NO_ACTION;
move = Roll_Oposite_Direction;
}
else if (Moving_In_Pretended_Direction <= speed) //When the agent is moving with not enough speed
{
Log.LogInformation("SPEED: Still not enough - " + Enum.GetName(typeof(Utils.Quantifier), Moving_In_Pretended_Direction).ToString());
move = Roll_Pretended_Direction;
}
else //When the agent is moving with too much speed and needs to brake (> speed + 1)
{
Log.LogInformation("SPEED: Too much! Rolling backwards - " + Enum.GetName(typeof(Utils.Quantifier), Moving_In_Pretended_Direction).ToString());
move = Roll_Oposite_Direction;
}
}
return(move);
}
public EntityPlayerMP(Vector2f pos, string _name) : base(pos, new Vector2f(36, 72), "Resources\\Sprites\\Entities\\player.png", EntityName.playerMP)
{
playerName = _name;
Console.WriteLine(_name);
isMoving = false;
moveDir = Utils.Direction.right;
Speed = 0.1f;
animation = new AnimationPlayer(this);
headText = new Text(playerName, Canvas.Instance.font)
{
CharacterSize = 9,
Position = new Vector2f(pos.X, pos.Y - 10)
};
}
protected override void Move()
{
if (!isAttacking)
{
anim.Play("GolemRun");
if (!cc.CheckGround(direction) || cc.CheckWall(direction))
{
direction = (direction == Utils.Direction.RIGHT) ? Utils.Direction.LEFT : Utils.Direction.RIGHT;
}
float walkSpeed = (direction == Utils.Direction.RIGHT) ? speed : speed * -1;
rb2d.velocity = new Vector2(walkSpeed * Time.deltaTime, rb2d.velocity.y);
Flip(direction);
}
else
{
rb2d.velocity = new Vector2(0, 0);
}
}
/// <summary>
/// Determines whether the mouse cursor is near the edge of the screen.
/// </summary>
/// <param name="side">A specific side or None for any</param>
/// <param name="screenSizeRatio">How close to the edge should the cursor be
/// (a percentage of the screen width/height)</param>
/// <returns>Is the mouse cursor near the edge of the screen</returns>
private bool MouseCursorNearScreenEdgePercentage(Utils.Direction side, float screenSizeRatio)
{
screenSizeRatio = Mathf.Clamp01(screenSizeRatio);
float maxDistance = 0f;
switch (side)
{
case Utils.Direction.Up:
case Utils.Direction.Down:
maxDistance = screenSizeRatio * screenDimensions.y;
break;
case Utils.Direction.Left:
case Utils.Direction.Right:
maxDistance = screenSizeRatio * screenDimensions.x;
break;
}
return(MouseCursorNearScreenEdge(side, maxDistance));
}
public bool CheckGround(Utils.Direction check)
{
bool value = false;
switch (check)
{
case Utils.Direction.LEFT:
value = Physics2D.Linecast(transform.position, groundCheckLeft.position, 1 << LayerMask.NameToLayer("Ground"));
break;
case Utils.Direction.RIGHT:
value = Physics2D.Linecast(transform.position, groundCheckRight.position, 1 << LayerMask.NameToLayer("Ground"));
break;
case Utils.Direction.BOTH:
value = (Physics2D.Linecast(transform.position, groundCheckLeft.position, 1 << LayerMask.NameToLayer("Ground")) ||
Physics2D.Linecast(transform.position, groundCheckRight.position, 1 << LayerMask.NameToLayer("Ground")));
break;
}
return(value);
}
public void UpdateEntityByPacket(PacketEntityData packet)
{
string entityID = packet.EntityID;
string entityType = entityID.Split("_")[0];
float posX = packet.PosX;
float posY = packet.PosY;
string addData = packet.AddData;
if (entityType == "player")
{
Console.WriteLine(packet.ToString());
string playerName = addData.Split(".")[0];
bool isMoving = bool.Parse(addData.Split(".")[1]);
Utils.Direction moveDir = (Utils.Direction) int.Parse(addData.Split(".")[2]);
EntityPlayerMP player = GetPlayerAtName(playerName);
if (player != null)
{
player.SetMove(moveDir, isMoving);
player.Pos = new Vector2f(posX, posY);
}
}
}
private void HandleCameraInput()
{
horizontalInput.Update();
verticalInput.Update();
resetCamInput.Update();
if (settings.MouseCameraMoveActive &&
MouseCursorNearScreenEdgePercentage(Utils.Direction.Left, 0.05f))
{
cam.Move(Utils.Direction.Left, 1);
}
else if (settings.MouseCameraMoveActive &&
MouseCursorNearScreenEdgePercentage(Utils.Direction.Right, 0.05f))
{
cam.Move(Utils.Direction.Right, 1);
}
else if (horizontalInput.PressedDown)
{
Utils.Direction direction =
horizontalInput.PositiveAxis ? Utils.Direction.Right : Utils.Direction.Left;
cam.Move(direction, 1);
}
// The camera can zoom in and out regardless of whether it moves horizontally or not
if (verticalInput.PressedDown)
{
Utils.Direction direction =
verticalInput.PositiveAxis ? Utils.Direction.Up : Utils.Direction.Down;
cam.Move(direction, 1);
}
if (resetCamInput.JustPressedDown)
{
cam.ResetCamera();
}
}
private void ObjectsCollided(GameObject obj, GameObject obj2, out CollisionState _state)
{
FloatRect overlap;
obj.HitBox.Rect.Intersects(obj2.HitBox.Rect, out overlap);
float colX = 0;
float colY = 0;
if (overlap.Width < overlap.Height)
{
colX = -1.0f;
if (obj.HitBox.CenterPos.X < obj2.HitBox.CenterPos.X)
{
colX = 1.0f;
}
}
else
{
colY = 1.0f;
if (obj.HitBox.CenterPos.Y > obj2.HitBox.CenterPos.Y)
{
colY = -1.0f;
}
}
Vector2f col = new Vector2f(colX, colY);
float[] angles = Utils.AnalazeVector(col);
Utils.Direction side = (Utils.Direction)Utils.GetMaxIndexInArray(angles);
_state = new CollisionState(true, obj2, side);
obj.CollidedWith(obj2, side);
float dx = 0, dy = 0;
if (obj.ObjectType != GameObject.Type.block)
{
switch (side)
{
case Utils.Direction.top:
dy = -overlap.Height;
break;
case Utils.Direction.bottom:
dy = overlap.Height;
break;
case Utils.Direction.right:
dx = overlap.Width;
break;
case Utils.Direction.left:
dx = -overlap.Width;
break;
}
obj.Pos = new Vector2f(obj.PosX + dx, obj.PosY + dy);
}
}
public CollisionState(bool _isCollided, GameObject _obj = null, Utils.Direction _side = Utils.Direction.right)
{
isCollided = _isCollided;
obj = _obj;
side = _side;
}
// Update is called once per frame
void Update()
{
if (canSelect && Input.GetMouseButtonDown(0))
{
RaycastHit hitInfo = new RaycastHit();
Boolean hitted = false;
if (Physics.Raycast(Camera.main.ScreenPointToRay(Input.mousePosition), out hitInfo))
{
hitted = true;
}
if (hitted && hitInfo.transform.gameObject.tag.Equals("Cube"))
{
CubeSelected cubSel = new CubeSelected();
cubSel.cube = hitInfo.transform.gameObject;
cubSel.hitDirection = utils.getHitDirection(hitInfo);
cubSel.SetColor();
//**********FoundCenter***********//
if (selected.Count == 0)
{
isX = true;
isY = true;
isZ = true;
selected.Add(cubSel);
Utils.Direction dir = cubSel.hitDirection;
switch (utils.getAxisFromDir(dir))
{
case Utils.Axis.X:
isX = false;
break;
case Utils.Axis.Y:
isY = false;
break;
case Utils.Axis.Z:
isZ = false;
break;
}
c0 = (CubeSelected)selected [0];
c0.ChangeColorTo(Color.green);
}
else if (selected.Count == 1)
{
selected.Add(cubSel);
if (cubSel.cube.Equals(((CubeSelected)selected [0]).cube) || !cubSel.hitDirection.Equals(((CubeSelected)selected [0]).hitDirection))
{
ResetSelection();
return; //BUG ripetere selzione 0
}
c1 = cubSel;
c1.SetColor();
c1.ChangeColorTo(Color.green);
float c1xPos = cubSel.cube.transform.position.x;
float c1yPos = cubSel.cube.transform.position.y;
float c1zPos = cubSel.cube.transform.position.z;
float c0xPos = ((CubeSelected)selected [0]).cube.transform.position.x;
float c0yPos = ((CubeSelected)selected [0]).cube.transform.position.y;
float c0zPos = ((CubeSelected)selected [0]).cube.transform.position.z;
int xCor = 100;
int yCor = 100;
int zCor = 100;
if ((!isZ && Math.Round(c1xPos, 0) != Math.Round(c0xPos, 0) && Math.Round(c1yPos, 0) != Math.Round(c0yPos, 0)) ||
(!isY && Math.Round(c1xPos, 0) != Math.Round(c0xPos, 0) && Math.Round(c1zPos, 0) != Math.Round(c0zPos, 0)) ||
(!isX && Math.Round(c1zPos, 0) != Math.Round(c0zPos, 0) && Math.Round(c1yPos, 0) != Math.Round(c0yPos, 0))
)
{
ResetSelection();
return; //BUG ripetere selzione 0
}
Debug.Log("c0xPos: " + Math.Round(c0xPos, 0));
Debug.Log("c0yPos: " + Math.Round(c0yPos, 0));
Debug.Log("c0zPos: " + Math.Round(c0zPos, 0));
Debug.Log("c1xPos: " + Math.Round(c1xPos, 0));
Debug.Log("c1yPos: " + Math.Round(c1yPos, 0));
Debug.Log("c1zPos: " + Math.Round(c1zPos, 0));
if (Math.Round(c1xPos, 0) != Math.Round(c0xPos, 0))
{
isX = false;
}
if (Math.Round(c1yPos, 0) != Math.Round(c0yPos, 0))
{
isY = false;
}
if (Math.Round(c1zPos, 0) != Math.Round(c0zPos, 0))
{
isZ = false;
}
xCor = (int)Mathf.Floor((cubSel.cube.transform.position.x / 2.2f) + 0.1f);
yCor = (int)Math.Floor((cubSel.cube.transform.position.y / 2.2f) + 0.1f);
zCor = (int)Mathf.Floor((cubSel.cube.transform.position.z / 2.2f) + 0.1f);
GameObject[] allcube = GameObject.FindGameObjectsWithTag("Cube");
Vector3 axis = new Vector3();
if (isX)
{
yCor = (int)Mathf.Floor(size / 2);
zCor = (int)Mathf.Floor(size / 2);
rotateCube = GameObject.Find("RotateCenter_" + xCor + yCor + zCor);
foreach (GameObject children in allcube)
{
if (Math.Round(children.transform.position.x, 0) == Math.Round(rotateCube.transform.position.x, 0))
{
children.transform.parent = rotateCube.transform;
}
}
if (c1.hitDirection.Equals(Utils.Direction.North) || c1.hitDirection.Equals(Utils.Direction.Up))
{
if ((Math.Round(c1yPos, 0) > Math.Round(c0yPos, 0) || Math.Round(c1zPos, 0) < Math.Round(c0zPos, 0)))
{
clockWise = -1;
Debug.Log("-X");
}
else
{
clockWise = 1;
Debug.Log("+X");
}
}
else
{
if ((Math.Round(c1yPos, 0) > Math.Round(c0yPos, 0) || Math.Round(c1zPos, 0) < Math.Round(c0zPos, 0)))
{
clockWise = 1;
Debug.Log("+X");
}
else
{
Debug.Log("-X");
clockWise = -1;
}
}
if (rotateCube != null)
{
Quaternion tarRot = Quaternion.Euler(90 * clockWise, 0, 0) * rotateCube.transform.rotation;
rotateCube.GetComponent <Rotate> ().tarRot = tarRot;
rotateCube.GetComponent <Rotate> ().axis = axis;
canSelect = false;
rotateCube.GetComponent <Rotate> ().canRotate = true;
}
}
if (isY)
{
xCor = (int)Mathf.Floor(size / 2);
zCor = (int)Mathf.Floor(size / 2);
rotateCube = GameObject.Find("RotateCenter_" + xCor + yCor + zCor);
foreach (GameObject children in allcube)
{
if (Math.Round(children.transform.position.y) == Math.Round(rotateCube.transform.position.y))
{
children.transform.parent = rotateCube.transform;
}
}
Debug.Log("hitDirection: " + c1.hitDirection);
if (c1.hitDirection.Equals(Utils.Direction.South) || c1.hitDirection.Equals(Utils.Direction.East))
{
if (Math.Round(c1xPos, 0) > Math.Round(c0xPos, 0) || Math.Round(c1zPos, 0) > Math.Round(c0zPos, 0))
{
axis = Vector3.down;
clockWise = -1;
Debug.Log("-Y");
}
else
{
axis = Vector3.up;
Debug.Log("+Y");
clockWise = 1;
}
}
else
{
if (Math.Round(c1xPos, 0) > Math.Round(c0xPos, 0) || Math.Round(c1zPos, 0) > Math.Round(c0zPos, 0))
{
clockWise = 1;
axis = Vector3.up;
Debug.Log("+Y");
}
else
{
Debug.Log("-Y");
axis = Vector3.down;
clockWise = -1;
}
}
if (rotateCube != null)
{
Quaternion tarRot = Quaternion.Euler(0, 90 * clockWise, 0) * rotateCube.transform.rotation;
rotateCube.GetComponent <Rotate> ().tarRot = tarRot;
rotateCube.GetComponent <Rotate> ().axis = axis;
rotateCube.GetComponent <Rotate> ().canRotate = true;
canSelect = false;
}
}
if (isZ)
{
xCor = (int)Mathf.Floor(size / 2);
yCor = (int)Mathf.Floor(size / 2);
rotateCube = GameObject.Find("RotateCenter_" + xCor + yCor + zCor);
foreach (GameObject children in allcube)
{
if (Math.Round(children.transform.position.z) == Math.Round(rotateCube.transform.position.z))
{
children.transform.parent = rotateCube.transform;
}
}
if (c1.hitDirection.Equals(Utils.Direction.Down) || c1.hitDirection.Equals(Utils.Direction.East))
{
if (Math.Round(c1xPos, 0) > Math.Round(c0xPos, 0) || Math.Round(c1yPos, 0) > Math.Round(c0yPos, 0))
{
Debug.Log("+Z");
clockWise = 1;
}
else
{
Debug.Log("-Z");
clockWise = -1;
}
}
else
{
if (Math.Round(c1xPos, 0) > Math.Round(c0xPos, 0) || Math.Round(c1yPos, 0) > Math.Round(c0yPos, 0))
{
clockWise = -1;
Debug.Log("-Z");
}
else
{
clockWise = 1;
Debug.Log("+Z");
}
}
if (rotateCube != null)
{
Quaternion tarRot = Quaternion.Euler(0, 0, 90 * clockWise) * rotateCube.transform.rotation;
rotateCube.GetComponent <Rotate> ().tarRot = tarRot;
rotateCube.GetComponent <Rotate> ().axis = axis;
rotateCube.GetComponent <Rotate> ().canRotate = true;
canSelect = false;
}
}
}
}
}
else if (!canSelect && rotateCube != null)
{
if (!rotateCube.GetComponent <Rotate> ().canRotate)
{
ResetSelection();
Debug.Log("ROTATE END");
canSelect = true;
rotateCube = null;
}
}
}
public virtual void CollidedWith(GameObject obj2, Utils.Direction side)
{
}
public DashObject(Transform transform, Utils.Direction direction)
{
this.transform = transform;
this.direction = direction;
}
void Update()
{
if (Input.GetMouseButtonDown(0) && !spawned)
{
RaycastHit hitInfo = new RaycastHit();
bool hitted = false;
if (Physics.Raycast(Camera.main.ScreenPointToRay(Input.mousePosition), out hitInfo))
{
hitted = true;
}
if (hitted && hitInfo.transform.gameObject.tag.Equals("Cube"))
{
player = (GameObject)Instantiate(Resources.Load("Robot Kyle/Model/RobotKyle"));
CubeSelected cubSel = new CubeSelected();
cubSel.cube = hitInfo.transform.gameObject;
cubSel.hitDirection = utils.getHitDirection(hitInfo);
Utils.Direction dir = cubSel.hitDirection;
player.transform.position = cubSel.cube.transform.position;
switch (dir)
{
case Utils.Direction.North:
player.transform.position = new Vector3(player.transform.position.x, player.transform.position.y, player.transform.position.z + 1.1f);
player.transform.rotation = Quaternion.Euler(90, 0, 0) * player.transform.rotation;
break;
case Utils.Direction.South:
player.transform.position = new Vector3(player.transform.position.x, player.transform.position.y, player.transform.position.z - 1.1f);
player.transform.rotation = Quaternion.Euler(-90, 0, 0) * player.transform.rotation;
break;
case Utils.Direction.West:
player.transform.position = new Vector3(player.transform.position.x - 1.1f, player.transform.position.y, player.transform.position.z);
player.transform.rotation = Quaternion.Euler(0, 0, 90) * player.transform.rotation;
break;
case Utils.Direction.East:
player.transform.position = new Vector3(player.transform.position.x + 1.1f, player.transform.position.y, player.transform.position.z);
player.transform.rotation = Quaternion.Euler(0, 0, -90) * player.transform.rotation;
break;
case Utils.Direction.Up:
player.transform.position = new Vector3(player.transform.position.x, player.transform.position.y + 1.1f, player.transform.position.z);
break;
case Utils.Direction.Down:
player.transform.position = new Vector3(player.transform.position.x, player.transform.position.y - 1.1f, player.transform.position.z);
player.transform.rotation = Quaternion.Euler(180, 0, 0) * player.transform.rotation;
break;
}
player.transform.parent = cubSel.cube.transform;
spawned = true;
}
}
else if (Input.GetKeyDown(KeyCode.R) && spawned)
{
player.transform.rotation = player.transform.rotation * Quaternion.Euler(0, 90, 0);
}
else if (Input.GetKeyDown(KeyCode.V) && spawned)
{
placed = true;
}
else if (placed)
{
selectScript.enabled = true;
this.enabled = false;
}
}
LotInfo SubdivideBlock(LotInfo Lot, Utils.Direction h_dir, Utils.Direction v_dir)
{
List <Vector3> newPoints = new List <Vector3>();
List <Vector3> lotVerts = new List <Vector3>();
lotVerts.AddRange(Lot.LotVerts);
Vector3 rayVectorV = (v_dir == Utils.Up) ? RayVectorV : -RayVectorV;
Vector3 AnchorsH = (h_dir == Utils.Left) ?
Utils.ReturnMaximalVector(BlockRay(Lot.Center, -RayVectorH, vertical: false), Utils.Left):
Utils.ReturnMaximalVector(BlockRay(Lot.Center, RayVectorH, vertical: false), Utils.Right);
Vector3 AnchorsV = (v_dir == Utils.Up) ?
Utils.ReturnMaximalVector(BlockRay(Lot.Center, RayVectorV, vertical: true), Utils.Up) :
Utils.ReturnMaximalVector(BlockRay(Lot.Center, -RayVectorV, vertical: true), Utils.Down);
Vector3 left = (h_dir == Utils.Left) ? Lot.Left : Lot.Center;
Vector3 right = (h_dir == Utils.Right) ? Lot.Right : Lot.Center;
Utils.VectorList(lotVerts, AnchorsH);
Utils.VectorList(lotVerts, AnchorsV);
Utils.VectorList(lotVerts, Lot.Center);
Utils.VectorList(lotVerts, self.shiftedVerts);
// Utils.VectorList(lotVerts, BlockCenter);
Utils.VectorList(newPoints, left);
Utils.VectorList(newPoints, right);
Utils.VectorList(newPoints, Utils.ReturnMaximalVector(BlockRay(left, rayVectorV), v_dir));
Utils.VectorList(newPoints, Utils.ReturnMaximalVector(BlockRay(right, rayVectorV), v_dir));
foreach (var vert in lotVerts)
{
if (h_dir == Utils.Left && vert.x <= Lot.Center.x && vert.x >= (Lot.Left.x - Vector3.Distance(Lot.Center, Lot.Left)))
{
if (v_dir == Utils.Up && vert.z >= Lot.Center.z)
{
Utils.VectorList(newPoints, vert);
}
if (v_dir == Utils.Down && vert.z <= Lot.Center.z)
{
Utils.VectorList(newPoints, vert);
}
}
if (h_dir == Utils.Right && vert.x <= Lot.Right.x + Vector3.Distance(Lot.Center, Lot.Right) && vert.x >= Lot.Center.x)
{
if (v_dir == Utils.Up && vert.z >= Lot.Center.z)
{
Utils.VectorList(newPoints, vert);
}
if (v_dir == Utils.Down && vert.z <= Lot.Center.z)
{
Utils.VectorList(newPoints, vert);
}
}
}
//Debug.Log(newPoints.Count);
LotInfo newLot = new LotInfo(self, newPoints, direction, left: left, right: right, parentLot: Lot);
if (newLot.Frontage < 2.7)
{
GameObject LotObject = (GameObject)Instantiate(Resources.Load("Lot"));
LotObject.GetComponent <Lot>().init(newLot);
LotObject.transform.parent = transform;
}
//Debug.Log(AnchorsH[AnchorsH.Count - 1]);
foreach (var v in newLot.RoadFacingVerts)
{
//Instantiate(redMarker,v,Quaternion.identity,self.transform);
}
return(newLot);
}
public void SetMove(Utils.Direction dir, bool _isMoving)
{
moveDir = dir;
isMoving = _isMoving;
}
