/// <summary>
/// Checks if the touch position is in the specified touch zone.
/// </summary>
/// <param name="touchZone">The queried touch zone.</param>
/// <returns>
/// If the touch position is in the specified touch zone.
/// </returns>
public bool IsInZone(ETouchZone touchZone)
{
// Return false if not currently touching the trackpad.
if (!_trackedDevice.GetButton(StylusButton.TouchstripTouch) &&
!_trackedDevice.GetButtonUp(StylusButton.TouchstripTouch))
{
return(false);
}
Update();
TouchZone zone = _touchZones.First(x => x.Zone == touchZone);
if (!_touchZones.Select(x => x.Zone).Contains(touchZone))
{
return(false);
}
float maxX = (zone.Center.x * 2) + (zone.Size.x);
float minX = (zone.Center.x * 2) - (zone.Size.x);
float maxY = (zone.Center.y * 2) + (zone.Size.y);
float minY = (zone.Center.y * 2) - (zone.Size.y);
return(_touchPosition.x <= maxX &&
_touchPosition.x >= minX &&
_touchPosition.y <= maxY &&
_touchPosition.y >= minY);
}
private void InitTouchController()
{
TouchZone pauseZone = this.ctrl.GetZone(ZONE_PAUSE);
TouchZone screenZone = this.ctrl.GetZone(ZONE_SCREEN);
pauseZone.DisableGUI();
screenZone.DisableGUI();
}
public Button(Sprite sprite_, TouchZone zone_)
{
// Button constructor
// ================
m_sprite = sprite_;
m_touchZone = zone_;
m_active = true;
}
// Methods
public Button(Texture2D texture_, Vector2 position_)
{
// Button constructor
// ================
m_sprite = new Sprite(texture_, position_, 0, Vector2.One);
Vector2 halfDim = new Vector2(m_sprite.GetWidth() / 2, m_sprite.GetHeight() / 2);
m_touchZone = new TouchZone(m_sprite.GetPosition() - halfDim, m_sprite.GetPosition() + halfDim);
m_active = true;
}
// got a tip for this from here: https://forum.unity.com/threads/detect-when-mouseposition-in-a-recttransform.500263/
public bool TouchInZone(TouchZone touchZone, int touchCount = 1)
{
if (Input.touchCount >= touchCount || Input.anyKey)
{
RectTransform rect = null;
switch (touchZone)
{
case TouchZone.Engine:
rect = EngineArea;
break;
case TouchZone.Sails:
rect = SailsArea;
break;
case TouchZone.Boost:
rect = BoostArea;
break;
default:
break;
}
switch (touchCount)
{
case 1:
//hacky way of enabling mouse testing:
Vector2 posOne = (Input.touchCount == 1 ? Input.touches[0].position : (Vector2)rect.InverseTransformPoint(Input.mousePosition));
//Vector2 posOne = (Input.touchCount == 1 ? Input.touches[0].position : (Vector2)Input.mousePosition);
return(rect.rect.Contains(posOne));
case 2:
return(rect.rect.Contains(rect.InverseTransformPoint(Input.touches[0].position)) &&
rect.rect.Contains(rect.InverseTransformPoint(Input.touches[1].position)));
default:
return(false);
}
}
return(false);
}
public override void Init()
{
playerObject = GameObject.Find("Player").GetComponent <IPlayer>();
m_touchZone = GameObject.Find("TouchZone").GetComponent <TouchZone>();
}
// ----------------
public void ControlByTouch()
{
if (this.touchCtrl == null)
{
return;
}
// Get controls' references...
TouchStick stickWalk = this.touchCtrl.GetStick(DemoFppGameCS.STICK_WALK);
TouchZone zoneAim = this.touchCtrl.GetZone(DemoFppGameCS.ZONE_AIM);
TouchZone zoneFire = this.touchCtrl.GetZone(DemoFppGameCS.ZONE_FIRE);
TouchZone zoneZoom = this.touchCtrl.GetZone(DemoFppGameCS.ZONE_ZOOM);
TouchZone zoneReload = this.touchCtrl.GetZone(DemoFppGameCS.ZONE_RELOAD);
// If Walk stick is pressed...
if (stickWalk.Pressed())
{
// ... use it's unnormalized direction vector to control walking.
Vector2 moveVec = stickWalk.GetVec();
this.SetWalkSpeed(moveVec.y, moveVec.x);
}
// Stop walking when stick is released...
else
{
this.SetWalkSpeed(0, 0);
}
// Firing...
// Set weapons trigger by getting the Fire zone pressed state
// (include mid-frame press)
this.SetTriggerState(zoneFire.UniPressed(true, false));
// Reload on Reload zone press (including mid-frame press and release situations).
if (zoneReload.JustUniPressed(true, true))
{
this.ReloadWeapon();
}
// Toggle zoom mode, when tapped on zoom-zone...
if (zoneZoom.JustTapped())
{
this.zoomActive = !this.zoomActive;
}
// Zoom dragging...
if (this.zoomActive &&
zoneZoom.UniPressed(false, false))
{
// Store inital zoom factor...
if (!this.isZoomDragging)
{
this.isZoomDragging = true;
this.zoomFactorRaw = this.zoomFactor;
}
// Change zoom factor by RAW vertical unified-touch drag delta
// queried in centimeters and scaled...
this.zoomFactorRaw += (this.zoomFactorPerCm *
zoneZoom.GetUniDragDelta(TouchCoordSys.SCREEN_CM, true).y);
this.zoomFactor = Mathf.Clamp(this.zoomFactorRaw, 0, 1);
}
else
{
this.isZoomDragging = false;
}
// Aim, when either aim or fire zone if pressed by at least one finger
// (ignoring mid-frame presses and releases)...
if (zoneAim.UniPressed(false, false) ||
zoneFire.UniPressed(false, false))
{
// If just started aiming, store initial aim angles...
if (!this.isAiming)
{
this.isAiming = true;
this.aimVertRaw = this.aimVert;
this.aimHorzRaw = this.aimHorz;
}
// Get aim delta adding aim-zone and fire-zone's
// unified-touch RAW drag deltas in centimeters...
Vector2 aimDelta =
zoneAim.GetUniDragDelta(TouchCoordSys.SCREEN_CM, true) +
zoneFire.GetUniDragDelta(TouchCoordSys.SCREEN_CM, true);
// Apply aim-sensitivity and speed...
aimDelta *= Mathf.Lerp(0.1f, 1.0f, this.aimSensitivity);
aimDelta.x *= this.horzAimSpeed;
aimDelta.y *= this.vertAimSpeed;
// Add calculated delta to current our raw, non-clamped aim angles
// and pass them to Aim() function.
// By keeping separate, non-clamped angles we prevent that
// uncomfortable effect when dragging past the limit and back again.
this.aimHorzRaw += aimDelta.x;
this.aimVertRaw += aimDelta.y;
//
this.Aim(this.aimHorzRaw, this.aimVertRaw);
}
else
{
this.isAiming = false;
}
// When double tapped the aim zone - level horizonal aim angle...
if (zoneAim.JustDoubleTapped())
{
this.Aim(this.aimHorz, 0);
}
}
// ----------------
private void Update()
{
if (Input.GetKeyUp(KeyCode.Escape))
{
DemoSwipeMenuCS.LoadMenuScene();
return;
}
// Manually poll and update the controller...
this.ctrl.PollController();
this.ctrl.UpdateController();
// Control and update the player controller...
if (this.player != null)
{
this.player.ControlByTouch(this.ctrl, this);
this.player.UpdateChara();
}
// Popup box update...
if (this.popupBox != null)
{
if (!this.popupBox.IsVisible())
{
if (Input.GetKeyDown(KeyCode.Space))
{
this.popupBox.Show(INSTRUCTIONS_TITLE, INSTRUCTIONS_TEXT,
INSTRUCTIONS_BUTTON_TEXT);
}
}
else
{
if (Input.GetKeyDown(KeyCode.Space))
{
this.popupBox.Hide();
}
}
}
// Control camera...
TouchZone zoneScreen = this.ctrl.GetZone(ZONE_SCREEN);
TouchStick stickWalk = this.ctrl.GetStick(STICK_WALK);
// If screen is pressed by two fingers (excluding mid-frame press and release).
if (zoneScreen.MultiPressed(false, true))
{
if (!this.isMultiTouching)
{
// If we just started multi-touch, store initial zoom factor.
this.pinchStartZoom = this.camZoom;
this.isMultiTouching = true;
// Cancel stick's touch if it's shared with our catch-all zone...
zoneScreen.TakeoverTouches(stickWalk);
}
// If pinching is active...
if (zoneScreen.Pinched())
{
// Get pinch distance delta in centimeters (screen-size independence!),
// then add it to our non-clamped state variable...
this.pinchStartZoom += this.zoomFactorPerCm *
zoneScreen.GetPinchDistDelta(TouchCoordSys.SCREEN_CM);
// ... and pass it to proper function when zoom factor will be clamped.
this.SetZoom(this.pinchStartZoom);
}
}
// If less than two fingers are touching the zone...
else
{
this.isMultiTouching = false;
}
// Update camera...
this.camZoom = Mathf.Clamp01(this.camZoom);
this.camZoomForDisplay = Mathf.SmoothDamp(this.camZoomForDisplay, this.camZoom,
ref this.camZoomVel, this.camSmoothingTime);
// Place camera...
this.PlaceCamera();
}
// ---------------
private void Update()
{
// If controller's layout changed, reset menu's width...
if ((this.ctrl != null) && this.ctrl.LayoutChanged())
{
this.menu.SetWindowSize(Screen.width, this.ctrl.GetDPI());
}
// Fade-in phase...
if (this.fadeInTimer.Enabled)
{
this.fadeInTimer.Update(Time.deltaTime);
if (this.fadeInTimer.Completed)
{
this.fadeInTimer.Disable();
}
}
// Control...
else
{
if (Input.GetKeyUp(KeyCode.Escape))
{
Application.LoadLevel(EXIT_SCREEN_SCENE_NAME);
return;
//Application.Quit();
}
// Get first and the only one touch zone (no need for IDs)...
TouchZone zone = this.ctrl.GetZone(0);
// Handle tap...
if (zone.JustTapped())
{
this.menu.OnTap();
}
// Handle unified-touch press...
if (zone.JustUniPressed())
{
this.menu.OnPress();
}
// If unified-touch moved, use it's drag delta...
if (zone.UniDragged())
{
this.menu.Move(-zone.GetUniDragDelta(TouchCoordSys.SCREEN_PX).x);
}
// On unfied-touch release, get released drag velocity to detect those quick swipes...
else if (zone.JustUniReleased())
{
this.menu.OnRelease(-zone.GetReleasedUniDragVel().x);
}
}
// If swipe-menu completed - go to selected mode...
this.menu.UpdateMenu();
if (this.menu.JustCompleted())
{
switch (this.menu.GetCurItem())
{
case ITEM_FPP:
this.StartDemo(FPP_DEMO_SCENE_NAME);
return;
case ITEM_RPG:
this.StartDemo(RPG_DEMO_SCENE_NAME);
return;
case ITEM_MAP:
this.StartDemo(MAP_DEMO_SCENE_NAME);
return;
case ITEM_DSS:
this.StartDemo(DUAL_STICK_DEMO_SCENE_NAME);
return;
}
}
}
public override void Init()
{
m_touchZone = GameObject.Find("TouchZone").GetComponent <TouchZone>();
ballObject = GameObject.Find("Ball").GetComponent <IBall>();
}
// ---------------------
private void Update()
{
if (Input.GetKeyUp(KeyCode.Escape))
{
DemoSwipeMenuCS.LoadMenuScene();
//DemoMenu.LoadMenuLevel();
return;
}
// Popup box update...
if (this.popupBox != null)
{
if (!this.popupBox.IsVisible())
{
if (Input.GetKeyDown(KeyCode.Space))
{
this.popupBox.Show(
INSTRUCTIONS_TITLE,
INSTRUCTIONS_TEXT,
INSTRUCTIONS_BUTTON_TEXT);
}
}
else
{
if (Input.GetKeyDown(KeyCode.Space))
{
this.popupBox.Hide();
}
}
}
// Touch controls...
// Get first zone, since there's only one...
TouchZone zone = this.touchCtrl.GetZone(0);
// If two fingers are touching, handle twisting and pinching...
if (zone.MultiPressed(false, true))
{
// Get current mulit-touch position (center) as a pivot point for zoom and rotation...
Vector2 pivot = zone.GetMultiPos(TouchCoordSys.SCREEN_PX);
// If pinched, scale map by non-raw relative pinch scale..
if (zone.Pinched())
{
this.ScaleMap(zone.GetPinchRelativeScale(false), pivot);
}
// If twisted, rotate map by this frame's angle delta...
if (zone.Twisted())
{
this.RotateMap(zone.GetTwistDelta(false), pivot);
}
}
// If one finger is touching the screen...
else
{
// Single touch...
if (zone.UniPressed(false, true))
{
if (zone.UniDragged())
{
// Drag the map by this frame's unified touch drag delta...
Vector2 delta = zone.GetUniDragDelta(TouchCoordSys.SCREEN_PX, false);
this.SetMapOffset(this.mapOfs + delta);
}
}
// Double tap with two fingers to zoom-out...
if (zone.JustMultiDoubleTapped())
{
this.ScaleMap(0.5f, zone.GetMultiTapPos(TouchCoordSys.SCREEN_PX));
}
// Double tap with one finger to zoom in...
else if (zone.JustDoubleTapped())
{
this.ScaleMap(2.0f, zone.GetTapPos(TouchCoordSys.SCREEN_PX));
}
}
// Keep map on the screen...
if (this.keepMapInside)
{
this.marginFactor = Mathf.Clamp(this.marginFactor, 0, 0.5f);
Rect safeRect = new Rect(
Screen.width * this.marginFactor,
Screen.height * this.marginFactor,
Screen.width * (1.0f - (2.0f * this.marginFactor)),
Screen.height * (1.0f - (2.0f * this.marginFactor)));
Rect mapRect = this.GetMapBoundingBox();
if (mapRect.xMax < safeRect.xMin)
{
this.mapOfs.x -= (mapRect.xMax - safeRect.xMin);
}
else if (mapRect.xMin > safeRect.xMax)
{
this.mapOfs.x -= (mapRect.xMin - safeRect.xMax);
}
if (mapRect.yMax < safeRect.yMin)
{
this.mapOfs.y -= (mapRect.yMax - safeRect.yMin);
}
else if (mapRect.yMin > safeRect.yMax)
{
this.mapOfs.y -= (mapRect.yMin - safeRect.yMax);
}
}
// Smooth map transform...
if ((Time.deltaTime >= this.smoothingTime))
{
this.SnapDisplayTransform();
}
else
{
float st = (Time.deltaTime / this.smoothingTime);
this.displayOfs = Vector2.Lerp(this.displayOfs, this.mapOfs, st);
this.displayScale = Mathf.Lerp(this.displayScale, this.mapScale, st);
this.displayAngle = Mathf.Lerp(this.displayAngle, this.mapAngle, st);
}
//this.TransformMap();
}
// ----------------
public ControlParams(TouchControllerCodeTemplateGenerator cfg,
TouchZone zone, int id)
{
this.cfg = cfg;
this.zone = zone;
this.stick = null;
this.constVal = id;
this.srcName = zone.name;
this.varName = "";
this.constName = "";
this.prefix = "";
this.GenNames();
}
// ---------------
void Update()
{
// If the game is paused...
if ((this.popupBox != null) && this.popupBox.IsVisible())
{
if (Input.GetKeyUp(KeyCode.Escape))
{
this.popupBox.End();
}
// Unpause...
if (this.popupBox.IsComplete())
{
this.popupBox.Hide();
// Enable controller...
this.ctrl.EnableController();
// Unpause the player...
this.player.OnUnpause();
}
}
// When not paused...
else
{
// Return to Main menu...
if (Input.GetKeyUp(KeyCode.Escape))
{
DemoSwipeMenuCS.LoadMenuScene();
return;
}
// Handle input...
if (this.ctrl)
{
// Get stick and zone references by IDs...
TouchStick
walkStick = this.ctrl.GetStick(STICK_WALK),
fireStick = this.ctrl.GetStick(STICK_FIRE);
TouchZone
//screenZone = this.ctrl.GetZone(ZONE_SCREEN),
pauseZone = this.ctrl.GetZone(ZONE_PAUSE);
// If the PAUSE zone (or SPACEBAR) is released, show info box...
if (pauseZone.JustUniReleased() || Input.GetKeyUp(KeyCode.Space))
{
// Show popup box...
this.popupBox.Show(INFO_TITLE, INFO_BODY, INFO_BUTTON_TEXT);
// Disable controller to stop it from reacting to touch input...
this.ctrl.DisableController();
// Pause the game...
this.player.OnPause();
}
else
{
// Walk when left stick is pressed...
if (walkStick.Pressed())
{
// Use stick's normalized XZ vector and tilt to move...
this.player.Move(walkStick.GetVec3d(true, 0), walkStick.GetTilt());
}
// Stop when stick is released...
else
{
this.player.Move(Vector3.zero, 0);
}
// Shoot when right stick is pressed...
if (fireStick.Pressed())
{
this.player.SetTriggerState(true);
// Get target angle and stick's tilt to determinate turning speed.
this.player.Aim(fireStick.GetAngle(), fireStick.GetTilt());
}
// ...or stop shooting and aiming when right stick is released.
else
{
this.player.SetTriggerState(false);
this.player.Aim(0, 0);
}
}
}
}
// Update character...
this.player.UpdateChara();
// Update camera...
if (this.cam != null)
{
Transform camTf = this.cam.transform;
camTf.position = this.player.transform.position + this.camOfs;
}
}
// --------------
public Finger(TouchZone tzone)
{
this.zone = tzone;
this.Reset();
}
// ----------------------
// Update()
// ----------------------
void Update()
{
if (this.ctrl != null)
{
// ----------------------
// Stick and Zone Variables
// ----------------------
TouchStick walkStick = this.ctrl.GetStick(STICK_WALK);
TouchZone actionZone = this.ctrl.GetZone(ZONE_ACTION);
TouchZone screenZone = this.ctrl.GetZone(ZONE_SCREEN);
// ----------------------
// Input Handling Code
// ----------------------
// ----------------
// Stick 'Walk'...
// ----------------
if (walkStick.Pressed())
{
Vector2 walkVec = walkStick.GetVec();
float walkTilt = walkStick.GetTilt();
float walkAngle = walkStick.GetAngle();
TouchStick.StickDir walkDir = walkStick.GetDigitalDir(true);
Vector3 walkWorldVec = walkStick.GetVec3d(false, 0);
// Your code here.
}
// ----------------
// Zone 'Action'...
// ----------------
if (actionZone.JustUniPressed())
{
Vector2 actionPressStartPos = actionZone.GetUniStartPos(TouchCoordSys.SCREEN_PX);
}
// Uni-touch pressed...
if (actionZone.UniPressed())
{
float actionUniDur = actionZone.GetMultiTouchDuration();
Vector2 actionUniPos = actionZone.GetMultiPos();
Vector2 actionUniDragDelta = actionZone.GetMultiDragDelta();
Vector2 actionUniRawDrawDelta = actionZone.GetMultiDragDelta(true);
}
// Uni-Touch Just Released
if (actionZone.JustUniReleased())
{
Vector2 actionUniRelStartPos = actionZone.GetReleasedUniStartPos();
Vector2 actionUniRelEndPos = actionZone.GetReleasedUniEndPos();
int actionUniRelStartBox = TouchZone.GetBoxPortion(2, 2, actionZone.GetReleasedUniStartPos(TouchCoordSys.SCREEN_NORMALIZED));
int actionUniRelEndBox = TouchZone.GetBoxPortion(2, 2, actionZone.GetReleasedUniEndPos(TouchCoordSys.SCREEN_NORMALIZED));
Vector2 actionUniRelDragVel = actionZone.GetReleasedUniDragVel();
Vector2 actionUniRelDragVec = actionZone.GetReleasedUniDragVec();
}
// ----------------
// Zone 'SCREEN'...
// ----------------
if (screenZone.JustMultiPressed())
{
Vector2 screenMultiPressStartPos = screenZone.GetMultiStartPos(TouchCoordSys.SCREEN_PX);
}
if (screenZone.JustUniPressed())
{
Vector2 screenPressStartPos = screenZone.GetUniStartPos(TouchCoordSys.SCREEN_PX);
}
// Multi-Pressed...
if (screenZone.MultiPressed())
{
float screenMultiDur = screenZone.GetMultiTouchDuration();
Vector2 screenMultiPos = screenZone.GetMultiPos();
Vector2 screenMultiDragDelta = screenZone.GetMultiDragDelta();
Vector2 screenMultiRawDrawDelta = screenZone.GetMultiDragDelta(true);
// Multi-touch drag...
if (screenZone.JustMultiDragged())
{
}
if (screenZone.MultiDragged())
{
}
// Just Twisted...
if (screenZone.JustTwisted())
{
}
// Twisted...
if (screenZone.Twisted())
{
float screenTwistDelta = screenZone.GetTwistDelta();
float screenTwistTotal = screenZone.GetTotalTwist();
}
// Just Pinched...
if (screenZone.JustPinched())
{
}
// Pinched...
if (screenZone.Pinched())
{
float screenPinchRelScale = screenZone.GetPinchRelativeScale();
float screenPinchAbsScale = screenZone.GetPinchScale();
float screenFingerDist = screenZone.GetPinchDist();
}
}
// Uni-touch pressed...
if (screenZone.UniPressed())
{
float screenUniDur = screenZone.GetMultiTouchDuration();
Vector2 screenUniPos = screenZone.GetMultiPos();
Vector2 screenUniDragDelta = screenZone.GetMultiDragDelta();
Vector2 screenUniRawDrawDelta = screenZone.GetMultiDragDelta(true);
// Just Uni-touch dragged...
if (screenZone.JustUniDragged())
{
}
// Uni-Touch drag...
if (screenZone.UniDragged())
{
}
}
// Multi-Touch Just Released
if (screenZone.JustMultiReleased())
{
Vector2 screenMultiRelStartPos = screenZone.GetReleasedMultiStartPos();
Vector2 screenMultiRelEndPos = screenZone.GetReleasedMultiEndPos();
int screenMultiRelStartBox = TouchZone.GetBoxPortion(2, 2, screenZone.GetReleasedMultiStartPos(TouchCoordSys.SCREEN_NORMALIZED));
int screenMultiRelEndBox = TouchZone.GetBoxPortion(2, 2, screenZone.GetReleasedMultiEndPos(TouchCoordSys.SCREEN_NORMALIZED));
Vector2 screenMultiRelDragVel = screenZone.GetReleasedMultiDragVel();
Vector2 screenMultiRelDragVec = screenZone.GetReleasedMultiDragVec();
// Released multi-touch was dragged...
if (screenZone.ReleasedMultiDragged())
{
}
// Released multi-touch was twisted...
if (screenZone.ReleasedTwisted())
{
float screenRelTwistAngle = screenZone.GetReleasedTwistAngle();
float screenRelTwistVel = screenZone.GetReleasedTwistVel();
}
// Released multi-touch was pinched...
if (screenZone.ReleasedPinched())
{
float screenRelPinchStartDist = screenZone.GetReleasedPinchStartDist();
float screenRelPinchEndDist = screenZone.GetReleasedPinchEndDist();
float screenRelPinchScale = screenZone.GetReleasedPinchScale();
}
}
// Uni-Touch Just Released
if (screenZone.JustUniReleased())
{
Vector2 screenUniRelStartPos = screenZone.GetReleasedUniStartPos();
Vector2 screenUniRelEndPos = screenZone.GetReleasedUniEndPos();
int screenUniRelStartBox = TouchZone.GetBoxPortion(2, 2, screenZone.GetReleasedUniStartPos(TouchCoordSys.SCREEN_NORMALIZED));
int screenUniRelEndBox = TouchZone.GetBoxPortion(2, 2, screenZone.GetReleasedUniEndPos(TouchCoordSys.SCREEN_NORMALIZED));
Vector2 screenUniRelDragVel = screenZone.GetReleasedUniDragVel();
Vector2 screenUniRelDragVec = screenZone.GetReleasedUniDragVec();
// Released uni-touch was dragged...
if (screenZone.ReleasedUniDragged())
{
}
}
// Double multi-finger tap...
if (screenZone.JustMultiDoubleTapped())
{
Vector2 screenMultiDblTapPos = screenZone.GetMultiTapPos();
}
else
// Simple multi-finger tap...
if (screenZone.JustMultiTapped())
{
Vector2 screenMultiTapPos = screenZone.GetMultiTapPos();
}
else
// Double one-finger tap...
if (screenZone.JustDoubleTapped())
{
Vector2 screenDblTapPos = screenZone.GetTapPos();
}
else
// Simple one-finger tap...
if (screenZone.JustTapped())
{
Vector2 screenTapPos = screenZone.GetTapPos();
}
}
}
protected void GUI_EditPanel_Zone(TouchZone z)
{
if(z == null)
return;
GUILayout.Label("Layers to test against: ",EditorStyles.boldLabel);
LayerMask newMask = z.layersToTouch;
bool prevStatus = z.layersToTouch == 0;
GUILayout.BeginHorizontal();
bool currStatus = EditorGUILayout.Toggle("Nothing",prevStatus,EditorStyles.toggle);
GUILayout.EndHorizontal();
if(prevStatus != currStatus && prevStatus == false)
{
newMask = 0;
}
prevStatus = z.layersToTouch == -1;
GUILayout.BeginHorizontal();
currStatus = EditorGUILayout.Toggle("Everything",prevStatus,EditorStyles.toggle);
GUILayout.EndHorizontal();
if(prevStatus != currStatus && prevStatus == false)
{
newMask = -1;
}
for (int i=0;i<32;i++) {
string layerName = LayerMask.LayerToName (i);
if (layerName != "") {
prevStatus = (z.layersToTouch == (z.layersToTouch | (1 << i)) || (z.layersToTouch == -1));
GUILayout.BeginHorizontal();
currStatus = EditorGUILayout.Toggle(layerName,prevStatus,EditorStyles.toggle);
GUILayout.EndHorizontal();
if(prevStatus != currStatus)
{
if(prevStatus == false)
{
newMask = newMask | (1 << i);
}
else
{
if(z.layersToTouch == -1)
{
newMask = 1 << i;
newMask = ~newMask;
}
else
{
newMask = newMask & ~(1 << i);;
}
}
}
}
}
if(newMask != z.layersToTouch)
{
z.layersToTouch = newMask;
EditorUtility.SetDirty(z);
}
}
// --------------------
public void ControlByTouch(TouchController ctrl, DemoRpgGameCS game)
{
TouchStick
stickWalk = ctrl.GetStick(DemoRpgGameCS.STICK_WALK);
TouchZone
zoneScreen = ctrl.GetZone(DemoRpgGameCS.ZONE_SCREEN),
zoneAction = ctrl.GetZone(DemoRpgGameCS.ZONE_ACTION),
zoneFire = ctrl.GetZone(DemoRpgGameCS.ZONE_FIRE);
// Get stick's normalized direction in world space relative to camera's angle...
Vector3 moveWorldDir = stickWalk.GetVec3d(TouchStick.Vec3DMode.XZ, true, game.camOrbitalAngle);
// Get stick's angle in world space by adding it to camera's angle..
float stickWorldAngle = stickWalk.GetAngle() + game.camOrbitalAngle;
// Get walking speed from stick's current tilt...
float speed = stickWalk.GetTilt();
// Get gun's trigger state by checking Fire zone's state (including mid-frame press)
bool gunTriggerState = zoneFire.UniPressed(true, false);
// Check if Action should be performed - either by pressing the Action button or
// by tapping on the right side of the screen...
bool performAction =
zoneAction.JustUniPressed(true, true) ||
zoneScreen.JustTapped();
if ((this.charaState == CharaState.IDLE) ||
(this.charaState == CharaState.WALK) ||
(this.charaState == CharaState.RUN))
{
if (speed > this.walkStickThreshold)
{
float moveSpeed = 0;
// Walk...
if (speed < this.runStickThreshold)
{
moveSpeed = this.walkSpeed;
if (this.charaState != CharaState.WALK)
{
this.StartWalking();
}
// Set animation speed...
this.charaAnim[this.ANIM_WALK_F].speed = this.walkAnimSpeed;
}
// Run!
else
{
moveSpeed = this.runSpeed;
if (this.charaState != CharaState.RUN)
{
this.StartRunning();
}
// Set animation speed...
this.charaAnim[this.ANIM_RUN_F].speed = this.runAnimSpeed;
}
// Update player's angle...
this.angle = DampAngle(this.angle, stickWorldAngle, this.angleSmoothingTime, this.turnMaxSpeed, Time.deltaTime);
// Move player's collider...
this.charaCtrl.Move(moveWorldDir * moveSpeed * Time.deltaTime);
}
else if ((this.charaState == CharaState.WALK) || (this.charaState == CharaState.RUN))
{
// Stop...
this.StartIdle();
}
// Perform Action...
if (performAction)
{
this.PerformUseAction();
}
}
// Every other state than USE...
if (this.charaState != CharaState.USE)
{
if (this.gun != null)
{
this.gun.SetTriggerState(gunTriggerState);
}
if (performAction)
{
this.PerformUseAction();
}
}
// USE state updates...
else
{
if (this.gun != null)
{
this.gun.SetTriggerState(false);
}
this.useElapsed += Time.deltaTime;
if (this.useElapsed > this.useAnimDuration)
{
this.StartIdle();
}
}
}
