/// <summary>
/// Freeze paddle method
/// </summary>
/// <param name="side"></param>
/// <param name="freezeDuration"></param>
void FreezePaddle(ScreenSide side, float freezeDuration)
{
print("Freeze");
// Handles Left Side Freezing
if (side == ScreenSide.Left && p1IsFrozen == false)
{
freezeTimer.Duration = freezeDuration;
freezeTimer.Run();
p1IsFrozen = true;
}
else
{
freezeTimer.Duration = freezeTimer.Duration + freezeDuration;
freezeTimer.Run();
p1IsFrozen = true;
}
// Handles Right Side Freezing
if (side == ScreenSide.Right && p2IsFrozen == false)
{
freezeTimer.Duration = freezeDuration;
freezeTimer.Run();
p2IsFrozen = true;
}
else if (side == ScreenSide.Right && p2IsFrozen == true)
{
freezeTimer.Duration = freezeTimer.Duration + freezeDuration;
freezeTimer.Run();
p2IsFrozen = true;
}
}
void SpawnStar()
{
//ScreenSide side = (ScreenSide)Random.Range(0, 4);
Vector3 spawnPos;
switch (side)
{
case ScreenSide.TOP:
spawnPos = Camera.main.ScreenToWorldPoint(new Vector3(Random.Range(0, dx), dy + padding, 0f));
break;
case ScreenSide.RIGHT:
spawnPos = Camera.main.ScreenToWorldPoint(new Vector3(dx + padding, Random.Range(0, dy), 0f));
break;
case ScreenSide.BOTTOM:
spawnPos = Camera.main.ScreenToWorldPoint(new Vector3(Random.Range(0, dx), 0 - padding, 0f));
break;
default:
spawnPos = Camera.main.ScreenToWorldPoint(new Vector3(0 - padding, Random.Range(0, dy), 0f));
break;
}
side = (ScreenSide)(((int)side + 1) % 4);
spawnPos.z = 0f;
Instantiate(star, spawnPos, Quaternion.identity);
star.GetComponent <FallingStar>().duration = fallDuration;
}
public List<ChefsController> GetMirrorController(ScreenSide side)
{
if(!_Controllers.ContainsKey(side))
return null;
return _Controllers[side];
}
/// <summary>
/// Returns the reflected coordinate (x or y) based on what side of the screen the entity has passed.
/// </summary>
/// <param name="side">The side of the screen the entity has passed</param>
/// <param name="screenWidth">The width of the screen</param>
/// <param name="screenHeight">The height of the screen</param>
/// <returns>The reflected x or y coordinate</returns>
private float GetReflectCoord(ScreenSide side, float screenWidth, float screenHeight)
{
// Get the side, and return the corresponding x-coordinate
switch (side)
{
//----------------
// X Reflection
case ScreenSide.Right:
return(-EffectiveWidth);
case ScreenSide.Left:
return(screenWidth + EffectiveWidth);
//----------------
//----------------
// Y Reflection
case ScreenSide.Top:
return(screenHeight + EffectiveHeight);
case ScreenSide.Bottom:
return(-EffectiveHeight);
//----------------
// If we got this far, something went horribly wrong
default:
throw new ArgumentException("Invalid side", "side");
}
}
public Vector2 GetNearestOutsidePosition()
{
// Get the nearest border
var newPosition = Position();
ScreenSide side = GetNearestBorder();
switch (side)
{
case ScreenSide.Left:
newPosition.X = -Width();
break;
case ScreenSide.Top:
newPosition.Y = -Height();
break;
case ScreenSide.Right:
newPosition.X = Game.ViewportAdapter.VirtualWidth + Width();
break;
case ScreenSide.Bottom:
newPosition.Y = Game.ViewportAdapter.VirtualHeight + Height();
break;
default:
break;
}
return(newPosition);
}
public Vector3 GetRandomizedOutOfBoundsPosition(
ScreenSide side,
Vector2 size,
float offset = 0)
{
var halfSize = GetHalfSizeFor(side, size) + offset;
var randomComponent = GetRandomComponentFor(side, size);
switch (side)
{
case ScreenSide.Top:
return(new Vector3(randomComponent, _screenSizeModel.HeightExtendUnits + halfSize, 0));
case ScreenSide.Bottom:
return(new Vector3(randomComponent, -(_screenSizeModel.HeightExtendUnits + halfSize), 0));
case ScreenSide.Left:
return(new Vector3(-(_screenSizeModel.WidthExtendUnits + halfSize), randomComponent, 0));
case ScreenSide.Right:
return(new Vector3(_screenSizeModel.WidthExtendUnits + halfSize, randomComponent, 0));
default:
throw new ArgumentOutOfRangeException();
}
}
/*** CONFIG METHODS ***/
private void SetupAmbiLight()
{
dynamic config = JsonConvert.DeserializeObject(File.ReadAllText("config.json"));
bool formIsHidden = config.startsHidden;
double gamma = config.gamma;
AmbiLight.multiThreading = config.multiThreading;
AmbiLight.scanDepth = config.scanDepth;
AmbiLight.pixelsToSkipPerCoordinate = config.pixelsToSkipPerCoordinate;
AmbiLight.delay = config.delay;
AmbiLight.frameTimeout = config.frameTimeout;
AmbiLight.previewMode = config.preview;
HuePorts huePorts = new HuePorts(config.devices.ToObject <Device[]>(), gamma);
ScreenSide right = new ScreenSide(config.ambiLight.right.screenRegions.ToObject <ScreenRegion[]>(), Direction.Right);
ScreenSide left = new ScreenSide(config.ambiLight.left.screenRegions.ToObject <ScreenRegion[]>(), Direction.Left);
ScreenSide top = new ScreenSide(config.ambiLight.top.screenRegions.ToObject <ScreenRegion[]>(), Direction.Top);
ScreenSide bottom = new ScreenSide(config.ambiLight.bottom.screenRegions.ToObject <ScreenRegion[]>(), Direction.Bottom);
ScreenSide[] screenSides = new ScreenSide[] { top, right, bottom, left };
ambiLight = new AmbiLight(screenSides, formIsHidden, huePorts, previewImage);
Logger.Add("Loaded AmbiLight from config.json");
Logger.Add("----------------------------");
}
public float GetRandomOutsideAngle(ScreenSide side, int maxAngle, int?topAngle = null)
{
var randomAngle = Game.GameManager.Random.Next(-maxAngle, maxAngle);
if (topAngle.HasValue)
{
randomAngle -= topAngle.Value;
}
switch (side)
{
case ScreenSide.Left:
randomAngle -= 90;
break;
case ScreenSide.Right:
randomAngle += 90;
break;
case ScreenSide.Bottom:
randomAngle += 180;
break;
default:
break;
}
return(randomAngle);
}
/// <summary>
/// Constructs a button.
/// </summary>
/// <param name="text"></param>
/// <param name="position"></param>
/// <param name="transitionOnTime"></param>
/// <param name="transitionOffTime"></param>
/// <param name="transitionOnSide"></param>
/// <param name="transitionOffSide"></param>
public Button(
string text,
Vector2 position,
Color color,
Color selectedColor,
float scale,
float selectedScale,
double selectionTransitionOnTime,
double selectionTransitionOffTime,
double transitionOnTime,
double transitionOffTime,
ScreenSide transitionOnSide,
ScreenSide transitionOffSide)
: base(transitionOnTime, transitionOffTime, transitionOnSide, transitionOffSide, null, position)
{
this.text = new TextComponent(text, position);
this.color = color;
this.selectedColor = selectedColor;
this.scale = scale;
this.selectedScale = selectedScale;
this.selectionTransition = new Transition(selectionTransitionOnTime, selectionTransitionOffTime);
this.OnSelection += Button_Selection;
this.OnDeselection += Button_Deselection;
this.TabStop = true;
}
private void FillBufferFromScreenWith(ScreenSide screenSide)
{
ScreenRegion currentScreenRegion;
Collection <Point> currentLedCoordinates;
int totalRed;
int totalGreen;
int totalBlue;
int totalCoordinates;
int colorIndex = 0;
for (int regionIndex = 0; regionIndex < screenSide.screenRegions.Length; regionIndex++)
{
currentScreenRegion = screenSide.screenRegions[regionIndex];
currentLedCoordinates = currentScreenRegion.coordinates;
totalRed = totalGreen = totalBlue = 0;
totalCoordinates = currentLedCoordinates.Count;
foreach (Point currentLedCoordinate in currentLedCoordinates)
{
colorIndex = Screen.PrimaryScreen.Bounds.Width * 4 * currentLedCoordinate.Y + currentLedCoordinate.X * 4;
totalBlue += screenBuffer[colorIndex++];
totalGreen += screenBuffer[colorIndex++];
totalRed += screenBuffer[colorIndex++];
}
Color color = Color.FromArgb(totalRed / totalCoordinates, totalGreen / totalCoordinates, totalBlue / totalCoordinates);
foreach (Led currentLed in currentScreenRegion.leds)
{
if (huePorts.huePorts[currentLed.device].isEnabled)
{
huePorts.huePorts[currentLed.device].SetOneLedToColor(currentLed.channel, currentLed.ledIndex, color);
}
}
if (previewMode)
{
switch (screenSide.direction)
{
case Direction.Right:
colorPreview.SetPixel(19, regionIndex + 1, color);
break;
case Direction.Left:
colorPreview.SetPixel(0, regionIndex + 1, color);
break;
case Direction.Top:
colorPreview.SetPixel(regionIndex, 1, color);
break;
default:
colorPreview.SetPixel(regionIndex, 11, color);
break;
}
}
}
}
public float2 GetCurrentEdge(ScreenSide screenSide)
{
switch (screenSide)
{
case ScreenSide.Top:
return(new float2(
0,
CameraPosition.y + HeightExtendUnits));
case ScreenSide.Bottom:
return(new float2(
0,
CameraPosition.y - HeightExtendUnits));
case ScreenSide.Left:
return(new float2(
CameraPosition.x - WidthExtendUnits,
0));
case ScreenSide.Right:
return(new float2(
CameraPosition.x + WidthExtendUnits,
0));
default:
throw new ArgumentOutOfRangeException(nameof(screenSide), screenSide, null);
}
}
// Start is called before the first frame update
void Start()
{
Debug.Log(dx);
Debug.Log(dy);
InvokeRepeating("SpawnStar", 0f, spawnRate);
side = ScreenSide.TOP;
}
public void EndGame(ScreenSide winner)
{
gameOver.Play();
var paddles = GameObject.FindGameObjectsWithTag("Player");
var balls = GameObject.FindGameObjectsWithTag("Ball");
Timer.PauseAll();
foreach (var pad in paddles)
{
pad.GetComponent <Paddle>().Pause();
}
foreach (var ball in balls)
{
ball.GetComponent <Ball>().Freeze();
}
switch (winner)
{
case ScreenSide.Left:
Instantiate(player1Wins);
break;
case ScreenSide.Right:
Instantiate(player2Wins);
break;
}
}
/// <summary>
/// Give more score to each side, called by outside world.
/// </summary>
/// <param name="scoringSide">Which side **scores the point**.</param>
/// <param name="amountAdded">How many points said side gains.</param>
void AddScore(ScreenSide scoringSide, int amountAdded)
{
switch (scoringSide)
{
case ScreenSide.Left:
leftScore += amountAdded;
break;
case ScreenSide.Right:
rightScore += amountAdded;
break;
}
scoreText.text = leftScore.ToString() + " - " + rightScore;
var cam = Camera.main;
Assert.IsNotNull(cam);
if (leftScore >= ConfigurationUtils.PointsToWin)
{
cam.GetComponent <GameOver>()
.EndGame(ScreenSide.Left);
}
else if (rightScore >= ConfigurationUtils.PointsToWin)
{
cam.GetComponent <GameOver>()
.EndGame(ScreenSide.Right);
}
}
public void Init(ScreenSide side)
{
ScreenSide = side;
bool isWide;
bool isNegativeOffset;
Vector2 size;
Vector3 position;
switch (side)
{
case ScreenSide.Top:
isWide = true;
isNegativeOffset = false;
break;
case ScreenSide.Right:
isWide = false;
isNegativeOffset = false;
break;
case ScreenSide.Bottom:
isWide = true;
isNegativeOffset = true;
break;
case ScreenSide.Left:
isWide = false;
isNegativeOffset = true;
break;
default:
throw ExceptionUtil.ArgumentException(() => side);
}
float negativePositionMultiplier = isNegativeOffset ? -1f : 1f;
float positionOffset = ColliderWidth * -0.5f;
if (isWide)
{
size = new Vector2(SpaceUtil.WorldMapSize.x, ColliderWidth);
float y = (SpaceUtil.WorldMap.Top.y - positionOffset) * negativePositionMultiplier;
position = new Vector3(0, y);
}
else
{
size = new Vector2(ColliderWidth, SpaceUtil.WorldMapSize.y);
float x = (SpaceUtil.WorldMap.Right.x - positionOffset) * negativePositionMultiplier;
position = new Vector3(x, 0);
}
var collider = GetComponent <BoxCollider2D>();
collider.size = size;
collider.transform.position = position;
}
void Gameover(ScreenSide side)
{
GameObject instance = Instantiate(Resources.Load("gameovermenu")) as GameObject;
GameOverMessage game = instance.GetComponent <GameOverMessage>();
game.SetWinner(side);
AudioManager.Play(AudioClipName.GameOver);
}
/// <summary>
/// Ends the game and displays the winner message
/// </summary>
/// <param name="winner">winning side</param>
public void EndGame(ScreenSide winner)
{
// instantiate prefab and set score
GameObject gameOverMessage = Instantiate(Resources.Load("GameOverMessage")) as GameObject;
GameOverMessage gameOverMessageScript = gameOverMessage.GetComponent <GameOverMessage>();
gameOverMessageScript.SetWinner(winner);
}
void QueueGameOver(ScreenSide side, int points)
{
//Object.Instantiate(Resources.Load("GameOverMessage"));
GameOverMessage instance = Instantiate(Resources.Load("GameOverMessage", typeof(GameOverMessage))) as GameOverMessage;
instance.SetWinner(side);
AudioManager.Play(AudioClipName.GameOver);
}
public void InvokeFreezeEffect(ScreenSide side)
{
switch (base.GetBallType())
{
case BallType.Freezer:
freezePaddleEvent.Invoke(side, duration);
break;
}
}
/// <summary>
/// Sets the winning side in the message to the given side
/// </summary>
/// <param name="winner">winner</param>
public void SetWinner(ScreenSide winner)
{
if (winner == ScreenSide.Left)
{
messageText.text = "Game Over!\n\nLeft player won!";
}
else
{
messageText.text = "Game Over!\n\nRight player won!";
}
}
/// <summary>
/// Constructs a label.
/// </summary>
/// <param name="text"></param>
/// <param name="position"></param>
/// <param name="transitionOnTime"></param>
/// <param name="transitionOffTime"></param>
/// <param name="transitionOnSide"></param>
/// <param name="transitionOffSide"></param>
public Label(
string text,
Vector2 position,
double transitionOnTime,
double transitionOffTime,
ScreenSide transitionOnSide,
ScreenSide transitionOffSide)
: base(transitionOnTime, transitionOffTime, transitionOnSide, transitionOffSide, null, position)
{
this.text = new TextComponent(text, position);
}
// Private constructor
private GlobalState()
{
ostrichGameComplete = false;
peacockGameComplete = false;
seagullGameComplete = false;
talkedToSeagull = false;
talkedToPenguin = false;
talkedToWhale = false;
staircaseUnlocked = false;
fishingRodGet = false;
exitSide = ScreenSide.NONE;
}
/// <summary>
/// Adds the given points to the given side
/// </summary>
/// <param name="side">screen side</param>
/// <param name="points">points to add</param>
void AddPoints(ScreenSide side, int points)
{
// add points and change text
if (side == ScreenSide.Left)
{
leftScore += points;
}
else
{
rightScore += points;
}
scoreText.text = leftScore + ScoreSeparator + rightScore;
}
//functoin to add the times the ball gets out of the scene
public void AddToScore(int realPoints, ScreenSide scoreSide)
{
if (scoreSide == ScreenSide.Left)
{
LScore += realPoints;
}
else
{
RScore += realPoints;
}
Stext.text = LScore.ToString() + ScoreDash + RScore.ToString();
}
/// <summary>
/// Speedup the specified speedupSide and duration.
/// </summary>
/// <param name="speedupSide">Speedup side.</param>
/// <param name="duration">Duration.</param>
void Speedup(ScreenSide speedupSide, float duration)
{
speedup = true;
if (!speedupTimer.Running)
{
speedupTimer.Duration = duration;
speedupTimer.Run();
}
else
{
speedupTimer.AddTime(duration);
}
}
/// <summary>
/// Used by others to add hits for each side.
/// </summary>
/// <param name="side">Which side gets the hit.</param>
/// <param name="nHitsToAdd">How many hits they get, usually 1.</param>
void AddHits(ScreenSide side, int nHitsToAdd)
{
if (side == ScreenSide.Left)
{
nLeftHits += nHitsToAdd;
leftHitsText.text = "Hits: " + nLeftHits;
}
else if (side == ScreenSide.Right)
{
nRightHits += nHitsToAdd;
rightHitsText.text = "Hits: " + nRightHits;
}
}
//functon to add the time the ball hits
public void AddPoints(int points, ScreenSide DefaultLeft)
{
if (DefaultLeft == ScreenSide.Left)
{
Lbounces += points;
LBouncerCounter.text = ScorePrefix + Lbounces.ToString();
}
else
{
Rbounces += points;
RBouncerCounter.text = ScorePrefix + Rbounces.ToString();
}
}
/// <summary>
/// Add hits for each paddle
/// </summary>
public void AddHits(ScreenSide side, float nHitsToAdd)
{
if (side == ScreenSide.Left)
{
lefth += nHitsToAdd;
leftHits.text = LeftHitsPrefix + lefth.ToString();
}
else if (side == ScreenSide.Right)
{
righth += nHitsToAdd;
rightHits.text = RightHitsPrefix + righth.ToString();
}
}
/// <summary>
/// Does the freeze processing
/// </summary>
public void Freeze(ScreenSide fside, float ftime)
{
// Check which side got frozen
if (side == fside)
{
if (freezerTimer.Running)
{
freezerTimer.FrozenTime = ftime;
}
freezerTimer.Run();
frozen = true;
}
}
static void SpeedUp(ScreenSide s, int t)
{
if (!speedy)
{
speedupTimer.Duration = ConfigurationUtils.SpeedupDuration;
}
else
{
speedupTimer.Duration += ConfigurationUtils.SpeedupDuration;
}
speedy = true;
speedupTimer.Run();
}
/// <summary>
/// Control score of game
/// </summary>
public void AddScore(ScreenSide scoringSide, float amountAdded)
{
switch (scoringSide)
{
case ScreenSide.Left:
lscore += amountAdded;
break;
case ScreenSide.Right:
rscore += amountAdded;
break;
}
scoreText.text = lscore.ToString() + ScorePrefix + rscore;
}
/// <summary>
/// Adds the given hits to the given side
/// </summary>
/// <param name="side">screen side</param>
/// <param name="hits">hits to add</param>
void AddHits(ScreenSide side, int hits)
{
// add hits and change text
if (side == ScreenSide.Left)
{
leftHit += hits;
leftHitText.text = HitsPrefix + leftHit;
}
else
{
rightHit += hits;
rightHitText.text = HitsPrefix + rightHit;
}
}
public Control(
double transitionOnTime,
double transitionOffTime,
ScreenSide transitionOnSide,
ScreenSide transitionOffSide,
TextComponent text,
Vector2 position)
{
transition = new Transition(transitionOnTime, transitionOffTime);
this.transitionOnSide = transitionOnSide;
this.transitionOffSide = transitionOffSide;
this.text = text;
Position = position;
}
/// <summary>
/// To calculate the score
/// </summary>
/// <param name="scoringSide"></param>
/// <param name="amountAdded"></param>
public void AddScore(ScreenSide scoredSide, float amountAdded)
{
if (scoredSide == ScreenSide.Left)
{
scoreLeft += amountAdded;
}
else if (scoredSide == ScreenSide.Right)
{
scoreRight += amountAdded;
}
scoreText.text = scoreLeft.ToString() + ScorePrefix + scoreRight.ToString();
}
// Update is called once per frame.
// public void Update(){
// // Below Debug Log call is to check for random idle timings.
// //UnityEngine.Debug.Log("TIMER COUNT " + releaseWatch.ElapsedMilliseconds);
// //UnityEngine.Debug.Log("idleWatch: " + idleKeyWatch.ElapsedMilliseconds); // + '\n' + "idleTime: " + IDLE_TRIGGER_LIMIT);
//
// }
/// <summary>
/// Update is called once per frame
/// </summary>
public void Update()
{
/*Below Debug Log call is to check for random idle timings*/
// UnityEngine.Debug.Log("TIMER COUNT " + releaseWatch.ElapsedMilliseconds);
//UnityEngine.Debug.Log("idleWatch: " + idleKeyWatch.ElapsedMilliseconds); // + '\n' + "idleTime: " + IDLE_TRIGGER_LIMIT);
//UnityEngine.Debug.Log("SIZE " + Screen.width.ToString() + ", " + Screen.height.ToString());
//if (!touchController.GetLastFingerPosition().Equals(TouchController.NULL_VECTOR))
// {
//UnityEngine.Debug.Log("TYPE " + touchController.ReturnTouchType());
// UnityEngine.Debug.Log("DIST " + Vector2.Distance(touchController.GetLastFingerPosition(), Camera.mainCamera.WorldToScreenPoint(playerObject.transform.position)));
//}
//UnityEngine.Debug.Log("LAST " + justReleasedFingerPos);
//UnityEngine.Debug.Log("ANGLE " + fingerSwipeAngle);
/*if(playerObject){
UnityEngine.Debug.Log("PLAYER " + Camera.mainCamera.WorldToScreenPoint(playerObject.transform.position));
}*/
//UnityEngine.Debug.Log("FINGER POS " + touchController.GetLastFingerPosition());
if(gameStateManagerRef.inGame){
// Initialize any left over managers, objects, refs, etc.
InitRemainingRefs();
// Could have used any of the managers but chose tearManagerRef, but this ensures no code gets executed until
// everything is initialized
if(tearManagerRef){
if(touchController.ReturnTouchType() == TouchType.NONE){
movingTornPiece = false;
currentDirection = ScreenSide.NONE;
}
if(tearManagerRef.HaveTornOnce && !tornPieceInitiated){
tornPiece = GameObject.Find("paper_CuttPieceOfPaper");
tornPieceInitiated = true;
}
// Determine if screen orientation or size has changed and re-assign touch positions/limits.
HandleScreenChanges();
// Sets touch globals such current/previous press state swipe detection and jump detectoin.
SetTouchGlobals();
// Detect first last and in between states/pos' for touch input positions.
DetectFirstInput();
DetectBetweenInput();
DetectLastInput();
// After horizontal and vertical movements are set determine player animation direction
SetPlayerDirection();
if(currPressState == PressState.UP && releaseSet){
ResetTouchFields();
}
// Update idle and keydown watches.
UpdateInputWatches();
// Limits time ellapsed on watches.
LimitWatches();
// Update and set new animations to be played in Animation Manager.
UpdateAnimations();
}
/*else{
UnityEngine.Debug.Log("MANAGERS ARE NULL");
}*/
}
}
/// <summary>
/// Returns true if the player is attempting to move the player left or right on screen
/// </summary>
/// <param name="side"></param>
/// <returns></returns>
private bool PlayerMoveHorizontalTriggered(ScreenSide side)
{
if (gameStateManagerRef.inGame)
{
if (tearScript != null)
{
if (tearScript.GetMovingPiece() || tearScript.GetRotatingPiece())
{
return false;
}
}
}
if((Input.GetKey(moveLeft) && side.Equals(ScreenSide.LEFT)) ||
(Input.GetKey(moveRight) && side.Equals(ScreenSide.RIGHT)))
{
return true;
}
else
{
if(touchController.GetLastFingerPosition().Equals(TouchController.nullVector))
{
return false;
}
else
{
if
// did the player actually trigger a keyboard input
((touchController.ReturnTouchType() == TouchType.TAP ||
touchController.ReturnTouchType() == TouchType.DRAG) &&
// and did the player hit the viable horizontal section of the screen
((side.Equals(ScreenSide.LEFT) &&
touchController.GetLastFingerPosition().x <= leftSideTouchLimitPos) ||
(side.Equals(ScreenSide.RIGHT) &&
touchController.GetLastFingerPosition().x >= rightSideTouchLimitPos)) &&
// and did the player hit the viable vertical section of the screen
touchController.GetLastFingerPosition().y <= bottomTouchLimitPos)
{
//UnityEngine.Debug.Log("MOVING " + side.ToString());
return true;
}
return false;
}
}
}
// Returns true if the player is attempting to move the player left or right on screen.
private bool PlayerMoveHorizontalTriggered(ScreenSide side)
{
if((!tearManagerRef.GetMovingPiece() && fingerGesture == FingerGesture.MOVE &&
!foldRef.currentlyFolding &&
(!tearManagerRef.PlayerCurrentlyTearing
//This selection of code was commented out for controls by Douglas Weller
/*||
!worldCollisionRef.PointInsideObject(paperObject, touchController.GetLastFingerPosition())*/
)) ||
!gameStateManagerRef.OnMobileDevice()){
if((Input.GetKey(wasdLeft) || Input.GetKey(arrowLeft)) ||
(Input.GetKey(wasdRight) || Input.GetKey(arrowRight))){
if(Input.GetKey(wasdLeft) || Input.GetKey(arrowLeft)){
lastKeyboardSide = ScreenSide.RIGHT;
}
else if((Input.GetKey(wasdLeft) && Input.GetKey(wasdRight)) ||
(Input.GetKey(arrowLeft) && Input.GetKey(arrowRight))){
lastKeyboardSide = ScreenSide.RIGHT;
}
else{
lastKeyboardSide = ScreenSide.LEFT;
}
//UnityEngine.Debug.Log("WATCH " + justPressedWatch.ElapsedMilliseconds);
//UnityEngine.Debug.Log("WALK");
//UnityEngine.Debug.Log("TRUE");
return true;
}
else{
if(touchController.GetLastFingerPosition().Equals(TouchController.NULL_VECTOR)){
//UnityEngine.Debug.Log("FALSE");
return false;
}
else{
//if(
// did the player actually trigger a keyboard input
/*(touchController.ReturnTouchType() == TouchType.TAP ||
touchController.ReturnTouchType() == TouchType.DRAG) &&*/
/*
// and did the player hit the viable horizontal section of the screen
((side.Equals(ScreenSide.LEFT) && ReturnSidePressed(touchController.GetLastFingerPosition()) == ScreenSide.LEFT) ||
((side.Equals(ScreenSide.RIGHT) && ReturnSidePressed(touchController.GetLastFingerPosition()) == ScreenSide.RIGHT))) &&
// and did the player hit the viable vertical section of the screen
touchController.GetLastFingerPosition().x <= bottomTouchLimitPos.x &&
touchController.GetLastFingerPosition().y <= bottomTouchLimitPos.y)*/{
lastSidePressed = side;
//UnityEngine.Debug.Log("TRUE");
//UnityEngine.Debug.Log("MOVING " + side.ToString());
return true;
}
//UnityEngine.Debug.Log("FALSE");
return false;
}
}
}
/*else{
UnityEngine.Debug.Log("FALSE");
}*/
return false;
}
/// <summary>
/// Returns the reflected coordinate (x or y) based on what side of the screen the entity has passed.
/// </summary>
/// <param name="side">The side of the screen the entity has passed</param>
/// <param name="screenWidth">The width of the screen</param>
/// <param name="screenHeight">The height of the screen</param>
/// <returns>The reflected x or y coordinate</returns>
private float GetReflectCoord(ScreenSide side, float screenWidth, float screenHeight)
{
// Get the side, and return the corresponding x-coordinate
switch (side)
{
//----------------
// X Reflection
case ScreenSide.Right:
return -EffectiveWidth;
case ScreenSide.Left:
return (screenWidth + EffectiveWidth);
//----------------
//----------------
// Y Reflection
case ScreenSide.Top:
return (screenHeight + EffectiveHeight);
case ScreenSide.Bottom:
return -EffectiveHeight;
//----------------
// If we got this far, something went horribly wrong
default:
throw new ArgumentException("Invalid side", "side");
}
}
// Resets fields used for detecting idle input and differentiating between moving and jumping.
private void ResetTouchFields()
{
if (controllerRef.getGrounded())
{
fingerSwipeAngle = SWIPE_ANGLE_RESET_VALUE;
}
releaseSet = false;
pressSet = false;
lastSidePressed = ScreenSide.NONE;
fingerIdlePos = TouchController.NULL_VECTOR;
justPressedFingerPos = TouchController.NULL_VECTOR;
justReleasedFingerPos = TouchController.NULL_VECTOR;
justPressedSide = ScreenSide.NONE;
justReleasedSide = justPressedSide;
}
// Use this for initialization.
public void Start()
{
// Keeping GameObject component grabbing consistent among classes. - J.T.
GameObject mainObject = GameObject.FindGameObjectsWithTag("MainObject")[0];
if(GameObject.FindGameObjectsWithTag("MainObject").Length > 1){
GameObject[] mainObjectList = GameObject.FindGameObjectsWithTag("MainObject");
for(int i = 0; i < mainObjectList.Length; ++i){
if(mainObjectList[i].GetComponent<GameStateManager>().objectSaved){
mainObject = mainObjectList[i];
}
}
}
gameStateManagerRef = mainObject.GetComponent <GameStateManager>();
gameStateManagerRef.EnsureGameScriptsAdded();
gameStateManagerRef.EnsureCoreScriptsAdded();
screenManagerRef = mainObject.GetComponent<ScreenManager>();
animManagerRef = mainObject.GetComponent<AnimationManager>();
worldCollisionRef = mainObject.GetComponent<WorldCollision>();
touchController = gameObject.GetComponent<TouchController>();
soundManagerRef = gameStateManagerRef.GetSoundManager();
paperObject = GameObject.FindGameObjectWithTag("background");
tearBorder = GameObject.FindGameObjectWithTag("DeadSpace");
foldBorder = GameObject.FindGameObjectWithTag("foldborder");
unfoldBorder = GameObject.FindGameObjectWithTag("unfoldborder");
unfoldBlocker = GameObject.FindGameObjectWithTag("RayTraceBlocker");
moveBorder = GameObject.FindGameObjectWithTag("insideBorder");
menuButton = GameObject.Find("MenuButton_Prefab");
restartButton = GameObject.Find("RestartButton_Prefab");
moveMode = true;
tearMode = false;
foldMode = false;
//Keeping old code here in case something gets broken. - J.T.
// Ensures all necessary scripts are added for the MainObject.
/*
gameStateManagerRef = gameObject.GetComponent<GameStateManager>();
gameStateManagerRef.EnsureCoreScriptsAdded();
gameStateManagerRef.EnsureGameScriptsAdded();
screenManagerRef = gameObject.GetComponent<ScreenManager>();
animManagerRef = gameObject.GetComponent<AnimationManager>();
worldCollisionRef = gameObject.GetComponent<WorldCollision>();
touchController = gameObject.GetComponent<TouchController>();
*/
idleTriggerLimit = Random.Range (1000, 3000);
keyDownWatch = new Stopwatch();
idleKeyWatch = new Stopwatch();
releaseWatch = new Stopwatch();
justPressedWatch = new Stopwatch();
playerBottomCollisionWatch = new Stopwatch();
idlePlayerWatch = new Stopwatch();
watchList.Add(keyDownWatch);
watchList.Add(idleKeyWatch);
watchList.Add(releaseWatch);
watchList.Add(justPressedWatch);
watchList.Add(playerBottomCollisionWatch);
watchList.Add(idlePlayerWatch);
wasdRight = KeyCode.D;
wasdLeft = KeyCode.A;
arrowRight = KeyCode.RightArrow;
arrowLeft = KeyCode.LeftArrow;
keyJump = KeyCode.Space;
hasHorizontalCollision = false;
currentDirection = ScreenSide.NONE;
tornPieceInitiated = false;
movingTornPiece = false;
}
