C# enthält keine Definition für und keine Erweiterungsmethode

Question

mein Code:

using UnityEngine; 
using System.Collections; 

[RequireComponent(typeof(Controller2D))] 
public class Player : MonoBehaviour 
{ 

    public float jumpHeight = 4; 
    public float timeToJumpApex = .4f; 
    float accelerationTimeAirborne = .2f; 
    float accelerationTimeGrounded = .1f; 
    float moveSpeed = 6; 

    float gravity; 
    float jumpVelocity; 
    Vector3 velocity; 
    float velocityXSmoothing; 

    Controller2D controller; 

    void Start() 
    { 
     controller = GetComponent<Controller2D>(); 

     gravity = -(2 * jumpHeight)/Mathf.Pow(timeToJumpApex, 2); 
     jumpVelocity = Mathf.Abs(gravity) * timeToJumpApex; 
     print("Gravity: " + gravity + " Jump Velocity: " + jumpVelocity); 
    } 

    void Update() 
    { 

     if (controller.collisions.above || controller.collisions.below) 
     { 
      velocity.y = 0; 
     } 

     Vector2 input = new Vector2(Input.GetAxisRaw("Horizontal"), Input.GetAxisRaw("Vertical")); 

     if (Input.GetKeyDown(KeyCode.Space) && controller.collisions.below) 
     { 
      velocity.y = jumpVelocity; 
     } 

     float targetVelocityX = input.x * moveSpeed; 
     velocity.x = Mathf.SmoothDamp(velocity.x, targetVelocityX, ref velocityXSmoothing, (controller.collisions.below) ? accelerationTimeGrounded : accelerationTimeAirborne); 
     velocity.y += gravity * Time.deltaTime; 
     controller.Move(velocity * Time.deltaTime); 
    } 
} 

Controller2D Code:

UnityEngine verwendet wird; mit System.Collections;

[RequireComponent (typeof (BoxCollider2D))] public class Controller2D: MonoBehaviour {

public LayerMask collisionMask; 

const float skinWidth = .015f; 
public int horizontalRayCount = 4; 
public int verticalRayCount = 4; 

float horizontalRaySpacing; 
float verticalRaySpacing; 

new BoxCollider2D collider; 
RaycastOrigins raycastOrigins; 
internal object collisions; 

void Start() 
{ 
    collider = GetComponent<BoxCollider2D>(); 
    CalculateRaySpacing(); 
} 

public void Move(Vector3 velocity) 
{ 
    UpdateRaycastOrigins(); 
    if (velocity.x != 0) 
    { 
     HorizontalCollisions(ref velocity); 
    } 
    if (velocity.y != 0) 
    { 
     VerticalCollisions(ref velocity); 
    } 

    transform.Translate(velocity); 
} 

void HorizontalCollisions(ref Vector3 velocity) 
{ 
    float directionX = Mathf.Sign(velocity.x); 
    float rayLength = Mathf.Abs(velocity.x) + skinWidth; 

    for (int i = 0; i < horizontalRayCount; i++) 
    { 
     Vector2 rayOrigin = (directionX == -1) ? raycastOrigins.bottomLeft : raycastOrigins.bottomRight; 
     rayOrigin += Vector2.up * (horizontalRaySpacing * i); 
     RaycastHit2D hit = Physics2D.Raycast(rayOrigin, Vector2.right * directionX, rayLength, collisionMask); 

     Debug.DrawRay(rayOrigin, Vector2.right * directionX * rayLength, Color.red); 

     if (hit) 
     { 
      velocity.x = (hit.distance - skinWidth) * directionX; 
      rayLength = hit.distance; 
     } 
    } 
} 

void VerticalCollisions(ref Vector3 velocity) 
{ 
    float directionY = Mathf.Sign(velocity.y); 
    float rayLength = Mathf.Abs(velocity.y) + skinWidth; 

    for (int i = 0; i < verticalRayCount; i++) 
    { 
     Vector2 rayOrigin = (directionY == -1) ? raycastOrigins.bottomLeft : raycastOrigins.topLeft; 
     rayOrigin += Vector2.right * (verticalRaySpacing * i + velocity.x); 
     RaycastHit2D hit = Physics2D.Raycast(rayOrigin, Vector2.up * directionY, rayLength, collisionMask); 

     Debug.DrawRay(rayOrigin, Vector2.up * directionY * rayLength, Color.red); 

     if (hit) 
     { 
      velocity.y = (hit.distance - skinWidth) * directionY; 
      rayLength = hit.distance; 
     } 
    } 
} 

void UpdateRaycastOrigins() 
{ 
    Bounds bounds = collider.bounds; 
    bounds.Expand(skinWidth * -2); 

    raycastOrigins.bottomLeft = new Vector2(bounds.min.x, bounds.min.y); 
    raycastOrigins.bottomRight = new Vector2(bounds.max.x, bounds.min.y); 
    raycastOrigins.topLeft = new Vector2(bounds.min.x, bounds.max.y); 
    raycastOrigins.topRight = new Vector2(bounds.max.x, bounds.max.y); 
} 

void CalculateRaySpacing() 
{ 
    Bounds bounds = collider.bounds; 
    bounds.Expand(skinWidth * -2); 

    horizontalRayCount = Mathf.Clamp(horizontalRayCount, 2, int.MaxValue); 
    verticalRayCount = Mathf.Clamp(verticalRayCount, 2, int.MaxValue); 

    horizontalRaySpacing = bounds.size.y/(horizontalRayCount - 1); 
    verticalRaySpacing = bounds.size.x/(verticalRayCount - 1); 
} 

struct RaycastOrigins 
{ 
    public Vector2 topLeft, topRight; 
    public Vector2 bottomLeft, bottomRight; 
} 

}

Wenn ich über "oben" schweben und "unter" den Fehler geben Sie mir

C# enthält keine Definition und keine Erweiterungsmethode,

kann jemand sehen, was ich falsch gemacht habe?

Vielen Dank im Voraus!

Answer 1

internal object collisions; 

Hier definieren Sie Kollisionen als Objekt. Dies bedeutet, dass es nicht über oder unter booleschen Eigenschaften verfügt.
Vielleicht müssen Sie eine neue Struktur oder Klasse namens Kollisionen definieren und interne oder öffentliche Boolean-Eigenschaften oben und unten definieren.