public override bool GetButton (string name, CrossPlatformInput.ButtonAction action) {
bool containsName = virtualButtons.ContainsKey (name);
if(containsName)
{
switch (action)
{
// virtual buttons are activated by touch or mouse click
case CrossPlatformInput.ButtonAction.GetButton:
return virtualButtons[name].GetButton;
case CrossPlatformInput.ButtonAction.GetButtonDown:
return virtualButtons[name].GetButtonDown;
case CrossPlatformInput.ButtonAction.GetButtonUp:
return virtualButtons[name].GetButtonUp;
}
} else {
// no virtual button with this name, check "real" (input manager) buttons:
switch (action)
{
case CrossPlatformInput.ButtonAction.GetButton:
return Input.GetButton(name);
case CrossPlatformInput.ButtonAction.GetButtonDown:
return Input.GetButtonDown(name);
case CrossPlatformInput.ButtonAction.GetButtonUp:
return Input.GetButtonUp(name);
}
}
return false;
}
public override bool GetButton (string name, CrossPlatformInput.ButtonAction action) {
switch (action) {
case CrossPlatformInput.ButtonAction.GetButton:
return alwaysUseVirtual.Contains (name) ? virtualButtons[name].GetButton : Input.GetButton (name);
case CrossPlatformInput.ButtonAction.GetButtonDown:
return alwaysUseVirtual.Contains (name) ? virtualButtons[name].GetButtonDown : Input.GetButtonDown (name);
case CrossPlatformInput.ButtonAction.GetButtonUp:
return alwaysUseVirtual.Contains (name) ? virtualButtons[name].GetButtonUp : Input.GetButtonUp (name);
default:
throw new Exception("Invalid button action.");
}
}
public override bool GetButton(string name, CrossPlatformInput.ButtonAction action)
{
if (!this.virtualButtons.ContainsKey(name))
{
throw new Exception(" Button " + name + " does not exist");
}
switch (action)
{
case CrossPlatformInput.ButtonAction.GetButtonDown:
return this.virtualButtons[name].GetButtonDown;
case CrossPlatformInput.ButtonAction.GetButtonUp:
return this.virtualButtons[name].GetButtonUp;
case CrossPlatformInput.ButtonAction.GetButton:
return this.virtualButtons[name].GetButton;
default:
throw new Exception("Invalid button action.");
}
}
public void RegisterVirtualAxis(CrossPlatformInput.VirtualAxis axis)
{
// check if we already have an axis with that name and log and error if we do
if (virtualAxes.ContainsKey(axis.name))
{
//Debug.LogError("There is already a virtual axis named " + axis.name + " registered.");
}
else
{
// add any new axes
virtualAxes.Add(axis.name, axis);
// if we dont want to match with the input manager setting then revert to always using virtual
if (!axis.matchWithInputManager)
{
alwaysUseVirtual.Add(axis.name);
}
}
}
public void RegisterVirtualButton(CrossPlatformInput.VirtualButton button)
{
// check if already have a buttin with that name and log an error if we do
if (virtualButtons.ContainsKey(button.name))
{
//Debug.LogError("There is already a virtual button named " + button.name + " registered.");
}
else
{
// add any new buttons
virtualButtons.Add(button.name, button);
// if we dont want to match to the input manager then always use a virtual axis
if (!button.matchWithInputManager)
{
alwaysUseVirtual.Add(button.name);
}
}
}
private static void RegisterVirtualAxis(CrossPlatformInput.VirtualAxis axis)
{
CrossPlatformInput.virtualInput.RegisterVirtualAxis(axis);
}
public VirtualButton(string name, bool matchToInputSettings)
{
this.name = name;
this.matchWithInputManager = matchToInputSettings;
CrossPlatformInput.RegisterVirtualButton(this);
}
public void Remove()
{
CrossPlatformInput.UnRegisterVirtualAxis(this.name);
}
public void FixedUpdate()
{
float speed = runSpeed;
// Read input
#if CROSS_PLATFORM_INPUT
float h = CrossPlatformInput.GetAxis("Horizontal");
float v = CrossPlatformInput.GetAxis("Vertical");
bool jump = CrossPlatformInput.GetButton("Jump");
#else
float h = Input.GetAxis("Horizontal");
float v = Input.GetAxis("Vertical");
bool jump = Input.GetButton("Jump");
#endif
#if !MOBILE_INPUT
// On standalone builds, walk/run speed is modified by a key press.
// We select appropriate speed based on whether we're walking by default, and whether the walk/run toggle button is pressed:
bool walkOrRun = Input.GetKey(KeyCode.LeftShift);
speed = walkByDefault ? (walkOrRun ? runSpeed : walkSpeed) : (walkOrRun ? walkSpeed : runSpeed);
// On mobile, it's controlled in analogue fashion by the v input value, and therefore needs no special handling.
#endif
input = new Vector2(h, v);
// normalize input if it exceeds 1 in combined length:
if (input.sqrMagnitude > 1)
{
input.Normalize();
}
// Get a vector which is desired move as a world-relative direction, including speeds
Vector3 desiredMove = transform.forward * input.y * speed + transform.right * input.x * strafeSpeed;
// preserving current y velocity (for falling, gravity)
float yv = rigidbody.velocity.y;
// add jump power
if (grounded && jump)
{
yv += jumpPower;
grounded = false;
}
// Set the rigidbody's velocity according to the ground angle and desired move
rigidbody.velocity = desiredMove + Vector3.up * yv;
// Use low/high friction depending on whether we're moving or not
if (desiredMove.magnitude > 0 || !grounded)
{
collider.material = advanced.zeroFrictionMaterial;
}
else
{
collider.material = advanced.highFrictionMaterial;
}
// Ground Check:
// Create a ray that points down from the centre of the character.
Ray ray = new Ray(transform.position, -transform.up);
// Raycast slightly further than the capsule (as determined by jumpRayLength)
RaycastHit[] hits = Physics.RaycastAll(ray, capsule.height * jumpRayLength);
System.Array.Sort(hits, rayHitComparer);
if (grounded || rigidbody.velocity.y < jumpPower * .5f)
{
// Default value if nothing is detected:
grounded = false;
// Check every collider hit by the ray
for (int i = 0; i < hits.Length; i++)
{
// Check it's not a trigger
if (!hits[i].collider.isTrigger)
{
// The character is grounded, and we store the ground angle (calculated from the normal)
grounded = true;
// stick to surface - helps character stick to ground - specially when running down slopes
//if (rigidbody.velocity.y <= 0) {
rigidbody.position = Vector3.MoveTowards(rigidbody.position, hits[i].point + Vector3.up * capsule.height * .5f, Time.deltaTime * advanced.groundStickyEffect);
//}
rigidbody.velocity = new Vector3(rigidbody.velocity.x, 0, rigidbody.velocity.z);
break;
}
}
}
Debug.DrawRay(ray.origin, ray.direction * capsule.height * jumpRayLength, grounded ? Color.green : Color.red);
// add extra gravity
rigidbody.AddForce(Physics.gravity * (advanced.gravityMultiplier - 1));
}
public abstract bool GetButton(string name, CrossPlatformInput.ButtonAction action);
private void Update()
{
this.move = new Vector3(CrossPlatformInput.GetAxis("Horizontal"), 0f, CrossPlatformInput.GetAxis("Vertical"));
this.jump = CrossPlatformInput.GetButton("Jump");
}
private static void AddAxes(string name)
{
// we have not registered this button yet so add it, happens in the constructor
CrossPlatformInput.RegisterVirtualAxis(new CrossPlatformInput.VirtualAxis(name));
}
private void Update()
{
this.demoCam.localPosition = Vector3.SmoothDamp(this.demoCam.localPosition, Vector3.forward * (float)(-(float)ParticleSceneControls.selected.camOffset), ref this.camOffsetVelocity, 1f);
if (CrossPlatformInput.GetButtonDown("NextParticleSystem"))
{
ParticleSceneControls.selectedIndex++;
if (ParticleSceneControls.selectedIndex == this.demoParticles.items.Length)
{
ParticleSceneControls.selectedIndex = 0;
}
this.Select(ParticleSceneControls.selectedIndex);
return;
}
if (CrossPlatformInput.GetButtonDown("PreviousParticleSystem"))
{
ParticleSceneControls.selectedIndex--;
if (ParticleSceneControls.selectedIndex == -1)
{
ParticleSceneControls.selectedIndex = this.demoParticles.items.Length - 1;
}
this.Select(ParticleSceneControls.selectedIndex);
return;
}
if (ParticleSceneControls.selected.mode == ParticleSceneControls.Mode.Activate)
{
return;
}
bool flag = Input.GetMouseButtonDown(0) && ParticleSceneControls.selected.mode == ParticleSceneControls.Mode.Instantiate;
bool flag2 = Input.GetMouseButton(0) && ParticleSceneControls.selected.mode == ParticleSceneControls.Mode.Trail;
if (flag || flag2)
{
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
RaycastHit raycastHit;
if (Physics.Raycast(ray, out raycastHit))
{
Quaternion rotation = Quaternion.LookRotation(raycastHit.normal);
if (ParticleSceneControls.selected.align == ParticleSceneControls.AlignMode.Up)
{
rotation = Quaternion.identity;
}
Vector3 vector = raycastHit.point + raycastHit.normal * this.distFromSurface;
if ((vector - this.lastPos).magnitude > ParticleSceneControls.selected.minDist)
{
if (ParticleSceneControls.selected.mode != ParticleSceneControls.Mode.Trail || this.instance == null)
{
this.instance = UnityEngine.Object.Instantiate <Transform>(ParticleSceneControls.selected.transform, vector, rotation);
if (this.particleMultiplier != null)
{
this.instance.GetComponent <ParticleSystemMultiplier>().multiplier = this.multiply;
}
this.currentParticleList.Add(this.instance);
if (ParticleSceneControls.selected.maxCount > 0 && this.currentParticleList.Count > ParticleSceneControls.selected.maxCount)
{
if (this.currentParticleList[0] != null)
{
UnityEngine.Object.Destroy(this.currentParticleList[0].gameObject);
}
this.currentParticleList.RemoveAt(0);
}
}
else
{
this.instance.position = vector;
this.instance.rotation = rotation;
}
if (ParticleSceneControls.selected.mode == ParticleSceneControls.Mode.Trail)
{
this.instance.transform.GetComponent <ParticleSystem>().enableEmission = false;
this.instance.transform.GetComponent <ParticleSystem>().Emit(1);
}
this.instance.parent = raycastHit.transform;
this.lastPos = vector;
}
}
}
}
public static bool GetButtonUp(string name)
{
return(CrossPlatformInput.GetButton(name, CrossPlatformInput.ButtonAction.GetButtonUp));
}
public static float GetAxisRaw(string name)
{
return(CrossPlatformInput.GetAxis(name, true));
}
private void OnEnable()
{
this.axis = (CrossPlatformInput.VirtualAxisReference(this.axisName) ?? new CrossPlatformInput.VirtualAxis(this.axisName));
this.rect = base.GetComponent <GUIElement>().GetScreenRect();
this.FindPairedButton();
}
private static void RegisterVirtualButton(CrossPlatformInput.VirtualButton button)
{
CrossPlatformInput.virtualInput.RegisterVirtualButton(button);
}
private static bool GetButton(string name, CrossPlatformInput.ButtonAction action)
{
return CrossPlatformInput.virtualInput.GetButton(name, action);
}
// Update is called once per frame
void Update()
{
// we make initial calculations from the original local rotation
transform.localRotation = originalRotation;
// read input from mouse or mobile controls
float inputH = 0;
float inputV = 0;
if (relative)
{
inputH = CrossPlatformInput.GetAxis("Mouse X");
inputV = CrossPlatformInput.GetAxis("Mouse Y");
// wrap values to avoid springing quickly the wrong way from positive to negative
if (targetAngles.y > 180)
{
targetAngles.y -= 360; followAngles.y -= 360;
}
if (targetAngles.x > 180)
{
targetAngles.x -= 360; followAngles.x -= 360;
}
if (targetAngles.y < -180)
{
targetAngles.y += 360; followAngles.y += 360;
}
if (targetAngles.x < -180)
{
targetAngles.x += 360; followAngles.x += 360;
}
#if UNITY_IPHONE || UNITY_ANDROID || UNITY_WP8
// on mobile, sometimes we want input mapped directly to tilt value,
// so it springs back automatically when the look input is released.
if (autoZeroHorizontalOnMobile)
{
targetAngles.y = Mathf.Lerp(-rotationRange.y * 0.5f, rotationRange.y * 0.5f, inputH * .5f + .5f);
}
else
{
targetAngles.y += inputH * rotationSpeed;
}
if (autoZeroVerticalOnMobile)
{
targetAngles.x = Mathf.Lerp(-rotationRange.x * 0.5f, rotationRange.x * 0.5f, inputV * .5f + .5f);
}
else
{
targetAngles.x += inputV * rotationSpeed;
}
#else
// with mouse input, we have direct control with no springback required.
targetAngles.y += inputH * rotationSpeed;
targetAngles.x += inputV * rotationSpeed;
#endif
// clamp values to allowed range
targetAngles.y = Mathf.Clamp(targetAngles.y, -rotationRange.y * 0.5f, rotationRange.y * 0.5f);
targetAngles.x = Mathf.Clamp(targetAngles.x, -rotationRange.x * 0.5f, rotationRange.x * 0.5f);
}
else
{
inputH = Input.mousePosition.x;
inputV = Input.mousePosition.y;
// set values to allowed range
targetAngles.y = Mathf.Lerp(-rotationRange.y * 0.5f, rotationRange.y * 0.5f, inputH / Screen.width);
targetAngles.x = Mathf.Lerp(-rotationRange.x * 0.5f, rotationRange.x * 0.5f, inputV / Screen.height);
}
// smoothly interpolate current values to target angles
followAngles = Vector3.SmoothDamp(followAngles, targetAngles, ref followVelocity, dampingTime);
// update the actual gameobject's rotation
transform.localRotation = originalRotation * Quaternion.Euler(-followAngles.x, followAngles.y, 0);
}
void Update()
{
demoCam.localPosition = Vector3.SmoothDamp(demoCam.localPosition, Vector3.forward * -selected.camOffset, ref camOffsetVelocity, 1);
if (CrossPlatformInput.GetButtonDown("NextParticleSystem"))
{
selectedIndex++;
if (selectedIndex == demoParticles.items.Length)
{
selectedIndex = 0;
}
Select(selectedIndex);
return;
}
if (CrossPlatformInput.GetButtonDown("PreviousParticleSystem"))
{
selectedIndex--;
if (selectedIndex == -1)
{
selectedIndex = demoParticles.items.Length - 1;
}
Select(selectedIndex);
return;
}
if (selected.mode == Mode.Activate)
{
// this is for a particle system that just needs activating, and needs no interaction (eg, duststorm)
return;
}
bool oneShotClick = (Input.GetMouseButtonDown(0) && selected.mode == Mode.Instantiate);
bool repeat = (Input.GetMouseButton(0) && selected.mode == Mode.Trail);
if (oneShotClick || repeat)
{
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
RaycastHit hit;
if (Physics.Raycast(ray, out hit))
{
var rot = Quaternion.LookRotation(hit.normal);
if (selected.align == AlignMode.Up)
{
rot = Quaternion.identity;
}
var pos = hit.point + hit.normal * distFromSurface;
if ((pos - lastPos).magnitude > selected.minDist)
{
if (selected.mode != Mode.Trail || instance == null)
{
instance = (Transform)Instantiate(selected.transform, pos, rot);
if (particleMultiplier != null)
{
instance.GetComponent <ParticleSystemMultiplier>().multiplier = multiply;
}
currentParticleList.Add(instance);
if (selected.maxCount > 0 && currentParticleList.Count > selected.maxCount)
{
if (currentParticleList[0] != null)
{
Destroy(currentParticleList[0].gameObject);
}
currentParticleList.RemoveAt(0);
}
}
else
{
instance.position = pos;
instance.rotation = rot;
}
if (selected.mode == Mode.Trail)
{
instance.transform.GetComponent <ParticleSystem>().enableEmission = false;
instance.transform.GetComponent <ParticleSystem>().Emit(1);
}
instance.parent = hit.transform;
lastPos = pos;
}
}
}
}
public void FixedUpdate()
{
// Read input
float h = CrossPlatformInput.GetAxis("Horizontal");
float v = CrossPlatformInput.GetAxis("Vertical");
bool jump = CrossPlatformInput.GetButton("Jump");
input = new Vector2(h, v);
float speed = runSpeed;
#if !(UNITY_IPHONE || UNITY_ANDROID || UNITY_WP8)
// On standalone builds, walk/run speed is modified by a key press.
// We select appropriate speed based on whether we're walking by default, and whether the walk/run toggle button is pressed:
bool walkOrRun = Input.GetKey(KeyCode.LeftShift);
speed = walkByDefault ? (walkOrRun ? runSpeed : walkSpeed) : (walkOrRun ? walkSpeed : runSpeed);
#endif
// On mobile, it's controlled in analogue fashion by the v input value, and therefore needs no special handling.
// Ground Check:
// Create a ray that points down from the centre of the character.
Ray ray = new Ray(transform.position, -transform.up);
// Raycast slightly further than the capsule (as determined by jumpRayLength)
RaycastHit[] hits = Physics.RaycastAll(ray, capsule.height * jumpRayLength);
float nearest = Mathf.Infinity;
if (grounded || rigidbody.velocity.y < 0.1f)
{
// Default value if nothing is detected:
grounded = false;
// Check every collider hit by the ray
for (int i = 0; i < hits.Length; i++)
{
// Check it's not a trigger
if (!hits[i].collider.isTrigger && hits[i].distance < nearest)
{
// The character is grounded, and we store the ground angle (calculated from the normal)
grounded = true;
nearest = hits[i].distance;
//Debug.DrawRay(transform.position, groundAngle * transform.forward, Color.green);
}
}
}
Debug.DrawRay(ray.origin, ray.direction * capsule.height * jumpRayLength, grounded ? Color.green : Color.red);
// normalize input if it exceeds 1 in combined length:
if (input.sqrMagnitude > 1)
{
input.Normalize();
}
// Get a vector which is desired move as a world-relative direction, including speeds
Vector3 desiredMove = transform.forward * input.y * speed + transform.right * input.x * strafeSpeed;
// preserving current y velocity (for falling, gravity)
float yv = rigidbody.velocity.y;
// add jump power
if (grounded && jump)
{
yv += jumpPower;
grounded = false;
}
// Set the rigidbody's velocity according to the ground angle and desired move
rigidbody.velocity = desiredMove + Vector3.up * yv;
// Use low/high friction depending on whether we're moving or not
if (desiredMove.magnitude > 0 || !grounded)
{
collider.material = advanced.zeroFrictionMaterial;
}
else
{
collider.material = advanced.highFrictionMaterial;
}
// add extra gravity
rigidbody.AddForce(Physics.gravity * (advanced.gravityMultiplier - 1));
}
void Update()
{
// Read the jump input in Update so button presses aren't missed.
#if CROSS_PLATFORM_INPUT
if (CrossPlatformInput.GetButtonDown("Jump"))
{
jump = true;
}
#else
// touch = t1.senseTouch();
// if(touch == "SwipeUp")
// jump = true;
// if (touch == "SwipeDown") c = true;
if (Input.GetKey(KeyCode.X))
{
c = true;
}
if (Input.GetKey(KeyCode.Space))
{
jump = true;
}
/////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////Touch Begin////////////////////////////////
if (Input.touchCount == 1)
{
if (Input.GetTouch(0).position.x < Screen.width / 2)
{
if (Input.GetTouch(0).phase == TouchPhase.Began)
{
v2previous = Input.GetTouch(0).position;
}
/////////////////////////Touch Stationary////////////////////////////////
if (Input.GetTouch(0).phase == TouchPhase.Stationary)
{
v2current = Input.GetTouch(0).position;
fTouchDelta = v2current.magnitude - v2previous.magnitude;
if (Mathf.Abs(fTouchDelta) < minSwipeLenght)
{
if (Input.GetTouch(0).tapCount == 1)
{
jump = true;
}
}
}
/////////////////////////Touch End////////////////////////////////
if (Input.GetTouch(0).phase == TouchPhase.Ended)
{
jump = false;
}
}
else
{
if (Input.GetTouch(0).phase == TouchPhase.Began)
{
v2previous = Input.GetTouch(0).position;
}
/////////////////////////Touch Move////////////////////////////////
if (Input.GetTouch(0).phase == TouchPhase.Moved)
{
v2current = Input.GetTouch(0).position;
fTouchDelta = v2current.magnitude - v2previous.magnitude;
if (Mathf.Abs(fTouchDelta) > minSwipeLenght)
{
if (fTouchDelta > 0)
{
// SwipeUp
}
else
{
c = true;
}
}
}
}
}
//////////////////////////////////////////////////////////////////////////////////////////////
#endif
}
void Update()
{
// Get the axis and jump input.
move = new Vector3(CrossPlatformInput.GetAxis("Horizontal"), 0f, CrossPlatformInput.GetAxis("Vertical"));
jump = CrossPlatformInput.GetButton("Jump");
}