Player | FEP

PHOTO

Wed Mar 30 2022 10:02:30 GMT+0000 (Coordinated Universal Time)

Saved by @BiscuitTinx #c#

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class Player : MonoBehaviour
{
    [Header("Movement")]
    private float moveSpeed;
    private float desiredMoveSpeed;
    private float lastDesiredMoveSpeed;
    public float walkSpeed;
    public float sprintSpeed;
    public float slideSpeed;
    public float wallrunSpeed;

    public float speedIncreaseMultiplier;
    public float slopeIncreaseMultiplier;

    public float groundDrag;

    [Header("Jumping")]
    public float jumpForce;
    public float jumpCooldown;
    public float airMultiplier;
    bool readyToJump;

    [Header("Crouching")]
    public float crouchSpeed;
    public float crouchYScale;
    private float startYScale;

    [Header("Keybinds")]
    public KeyCode jumpKey = KeyCode.Space;
    public KeyCode sprintKey = KeyCode.LeftShift;
    public KeyCode crouchKey = KeyCode.LeftControl;

    [Header("Ground Check")]
    public float playerHeight;
    public LayerMask whatIsGround;
    bool grounded;

    [Header("Slope Handling")]
    public float maxSlopeAngle;
    private RaycastHit slopeHit;
    private bool exitingSlope;

    [Header("Respawn")]
    public Transform spawnPoint;
    public float respawnHeight = 20f;

    [Header("Important")]
    public Transform orientation;

    float horizontalInput;
    float verticalInput;

    Vector3 moveDirection;

    Rigidbody rb;

    public MovementState state;
    public enum MovementState
    {
        walking,
        sprinting,
        wallrunning,
        crouching,
        sliding,
        air
    }

    public bool sliding;
    public bool crouching;
    public bool wallrunning;

    private void Start()
    {
        rb = GetComponent<Rigidbody>();
        rb.freezeRotation = true;

        readyToJump = true;

        startYScale = transform.localScale.y;
    }

    private void Update()
    {
        // ground check
        grounded = Physics.Raycast(transform.position, Vector3.down, playerHeight * 0.5f + 0.2f, whatIsGround);

        MyInput();
        SpeedControl();
        StateHandler();

        // handle drag
        if (grounded)
            rb.drag = groundDrag;
        else
            rb.drag = 0;

        if(gameObject.transform.position.y < -respawnHeight)
        {
            Respawn();
        }
    }

    private void FixedUpdate()
    {
        MovePlayer();
    }

    private void MyInput()
    {
        horizontalInput = Input.GetAxisRaw("Horizontal");
        verticalInput = Input.GetAxisRaw("Vertical");

        // when to jump
        if (Input.GetKey(jumpKey) && readyToJump && grounded)
        {
            readyToJump = false;

            Jump();

            Invoke(nameof(ResetJump), jumpCooldown);
        }

        // start crouch
        if (Input.GetKeyDown(crouchKey))
        {
            transform.localScale = new Vector3(transform.localScale.x, crouchYScale, transform.localScale.z);
            rb.AddForce(Vector3.down * 5f, ForceMode.Impulse);
        }

        // stop crouch
        if (Input.GetKeyUp(crouchKey))
        {
            transform.localScale = new Vector3(transform.localScale.x, startYScale, transform.localScale.z);
        }
    }

    private void StateHandler()
    {
        // Mode - Wallrunning
        if (wallrunning)
        {
            state = MovementState.wallrunning;
            // if you dont have desiredMoveSpeed you can use > moveSpeed = wallrunSpeed;
            desiredMoveSpeed = wallrunSpeed;
        }

        // Mode - Sliding
        if (sliding)
        {
            state = MovementState.sliding;

            if (OnSlope() && rb.velocity.y < 0.1f)
                desiredMoveSpeed = slideSpeed;

            else
                desiredMoveSpeed = sprintSpeed;
        }

        // Mode - Crouching
        else if (Input.GetKey(crouchKey))
        {
            state = MovementState.crouching;
            desiredMoveSpeed = crouchSpeed;
        }

        // Mode - Sprinting
        else if (grounded && Input.GetKey(sprintKey))
        {
            state = MovementState.sprinting;
            desiredMoveSpeed = sprintSpeed;
        }

        // Mode - Walking
        else if (grounded)
        {
            state = MovementState.walking;
            desiredMoveSpeed = walkSpeed;
        }

        // Mode - Air
        else
        {
            state = MovementState.air;
        }

        // check if desiredMoveSpeed has changed drastically
        if (Mathf.Abs(desiredMoveSpeed - lastDesiredMoveSpeed) > 4f && moveSpeed != 0)
        {
            StopAllCoroutines();
            StartCoroutine(SmoothlyLerpMoveSpeed());
        }
        else
        {
            moveSpeed = desiredMoveSpeed;
        }

        lastDesiredMoveSpeed = desiredMoveSpeed;
    }

    private IEnumerator SmoothlyLerpMoveSpeed()
    {
        // smoothly lerp movementSpeed to desired value
        float time = 0;
        float difference = Mathf.Abs(desiredMoveSpeed - moveSpeed);
        float startValue = moveSpeed;

        while (time < difference)
        {
            moveSpeed = Mathf.Lerp(startValue, desiredMoveSpeed, time / difference);

            if (OnSlope())
            {
                float slopeAngle = Vector3.Angle(Vector3.up, slopeHit.normal);
                float slopeAngleIncrease = 1 + (slopeAngle / 90f);

                time += Time.deltaTime * speedIncreaseMultiplier * slopeIncreaseMultiplier * slopeAngleIncrease;
            }
            else
                time += Time.deltaTime * speedIncreaseMultiplier;

            yield return null;
        }

        moveSpeed = desiredMoveSpeed;
    }

    private void MovePlayer()
    {
        // calculate movement direction
        moveDirection = orientation.forward * verticalInput + orientation.right * horizontalInput;

        // on slope
        if (OnSlope() && !exitingSlope)
        {
            rb.AddForce(GetSlopeMoveDirection(moveDirection) * moveSpeed * 20f, ForceMode.Force);

            if (rb.velocity.y > 0)
                rb.AddForce(Vector3.down * 80f, ForceMode.Force);
        }

        // on ground
        else if (grounded)
            rb.AddForce(moveDirection.normalized * moveSpeed * 10f, ForceMode.Force);

        // in air
        else if (!grounded)
            rb.AddForce(moveDirection.normalized * moveSpeed * 10f * airMultiplier, ForceMode.Force);

        // turn gravity off while on slope
        if(!wallrunning)rb.useGravity = !OnSlope();
    }

    private void SpeedControl()
    {
        // limiting speed on slope
        if (OnSlope() && !exitingSlope)
        {
            if (rb.velocity.magnitude > moveSpeed)
                rb.velocity = rb.velocity.normalized * moveSpeed;
        }

        // limiting speed on ground or in air
        else
        {
            Vector3 flatVel = new Vector3(rb.velocity.x, 0f, rb.velocity.z);

            // limit velocity if needed
            if (flatVel.magnitude > moveSpeed)
            {
                Vector3 limitedVel = flatVel.normalized * moveSpeed;
                rb.velocity = new Vector3(limitedVel.x, rb.velocity.y, limitedVel.z);
            }
        }
    }

    private void Jump()
    {
        exitingSlope = true;

        // reset y velocity
        rb.velocity = new Vector3(rb.velocity.x, 0f, rb.velocity.z);

        rb.AddForce(transform.up * jumpForce, ForceMode.Impulse);
    }
    private void ResetJump()
    {
        readyToJump = true;

        exitingSlope = false;
    }

    public bool OnSlope()
    {
        if (Physics.Raycast(transform.position, Vector3.down, out slopeHit, playerHeight * 0.5f + 0.3f))
        {
            float angle = Vector3.Angle(Vector3.up, slopeHit.normal);
            return angle < maxSlopeAngle && angle != 0;
        }

        return false;
    }

    public Vector3 GetSlopeMoveDirection(Vector3 direction)
    {
        return Vector3.ProjectOnPlane(direction, slopeHit.normal).normalized;
    }

    public void Respawn()
    {
        gameObject.transform.position = spawnPoint.transform.position;
    }
}

Save snippets that work from anywhere online with our extensions

Available in the Chrome Web Store

Get Firefox Add-on

Get VS Code extension

Comments

More like this

FEP

@BiscuitTinx

Player | FEP PlayerCamera | FEP Sliding | FEP CameraMovement | FEP MoveCamera | FEP WallRunning | FEP WallRunning | FEP GrapplingGun | FEP GrappleGunRotation | FEP Ai | FEP ProjectileGun | FEP CustomBullet | FEP LevelLoader | FEP

Player

@BiscuitTinx

Player | FEP PlayerCamera | FEP Sliding | FEP WallRunning | FEP WallRunning | FEP GrapplingGun | FEP

#blazor #c# #html

[SOLVED] - Blazor onchange event with select dropdown

@inject HttpClient httpClient

@if (States != null)
{

<select id="SearchStateId" name="stateId" @onchange="DoStuff" class="form-control1">
    <option>@InitialText</option>
    @foreach (var state in States)
    {
        <option value="@state.Name">@state.Name</option>
    }
</select>
}


@code {
[Parameter] public string InitialText { get; set; } = "Select State";
private KeyValue[] States;
private string selectedString { get; set; }
protected override async Task OnInitializedAsync()
{
    States = await httpClient.GetJsonAsync<KeyValue[]>("/sample-data/State.json");
}

private void DoStuff(ChangeEventArgs e)
{
    selectedString = e.Value.ToString();
    Console.WriteLine("It is definitely: " + selectedString);
}

public class KeyValue
{
    public int Id { get; set; }

    public string Name { get; set; }
}
}

Unity Convert LocalSpace to WorldSpace

//You need this because ur velocity is in localSpace
//This works if you start the game at 0,0,0 rotation,
//what if you start the game at 0,180,0 rotation?  
//Then your up arrow will move you backwards.


//Get inputs
float horzInput = Input.GetAxis("Horizontal");
float vertInput = Input.GetAxis("Vertical");

//Calc Velocity
Vector3 direction = new Vector3(horzInput, 0.0f, vertInput);
Vector3 velocity = direction * _speed;

//Gravity
velocity.y -= _gravity;

//Convert localSpace velocity to worldSpace
velocity = transform.transform.TransformDirection(velocity); //<-Weimberger's way
velocity = transform.TransformDirection(velocity); //<-myWay

//Move
_controller.Move(velocity * Time.deltaTime);

Unity (C#) equivalent of SetInterval()

void Start(){ 
  StartCoroutine(SpawnObject()); 
}

IEnumerator SpawnObject(){
  while (true){
    yield return new WaitForSeconds(1.0f); // every 1 second
    Instantiate(objectToSpawn);
  }
}

I want Input text file in sap using c#

   foreach (string line in lines)
            {
                string[] a = line.Split('|');
                oDocumentSQ.DocNum = Convert.ToInt32(a[0]);
                oDocumentSQ.CardCode = a[1];
                oDocumentSQ.NumAtCard = a[2];
                oDocumentSQ.DocDate = Convert.ToDateTime(a[3]);

                oDocumentSQ.Lines.ItemCode = a[4];
                oDocumentSQ.Lines.UnitPrice = Convert.ToDouble(a[5]);
                oDocumentSQ.Lines.Quantity = Convert.ToInt32(a[6]);
                oDocumentSQ.Lines.VatGroup = a[7];
                oDocumentSQ.Lines.Add();             
            }

#C# #c# #array #dictionary

How to clear item not input when count frequency use Dictionary C#

for (int i = 0; i < n; i++)
{
    if (valCount.ContainsKey(x))
        valCount[x]++;
    else
        valCount[x] = 1;
}

NuGet Gallery | DocumentFormat.OpenXml 2.11.0

Install-Package DocumentFormat.OpenXml -Version 2.11.0

How to initialize a dictionary with a collection initializer - C# Programming Guide | Microsoft Docs

public class HowToDictionaryInitializer
{
    class StudentName
    {
        public string FirstName { get; set; }
        public string LastName { get; set; }
        public int ID { get; set; }
    }

    public static void Main()
    {
        var students = new Dictionary<int, StudentName>()
        {
            { 111, new StudentName { FirstName="Sachin", LastName="Karnik", ID=211 } },
            { 112, new StudentName { FirstName="Dina", LastName="Salimzianova", ID=317 } },
            { 113, new StudentName { FirstName="Andy", LastName="Ruth", ID=198 } }
        };

        foreach(var index in Enumerable.Range(111, 3))
        {
            Console.WriteLine($"Student {index} is {students[index].FirstName} {students[index].LastName}");
        }
        Console.WriteLine();		

        var students2 = new Dictionary<int, StudentName>()
        {
            [111] = new StudentName { FirstName="Sachin", LastName="Karnik", ID=211 },
            [112] = new StudentName { FirstName="Dina", LastName="Salimzianova", ID=317 } ,
            [113] = new StudentName { FirstName="Andy", LastName="Ruth", ID=198 }
        };

        foreach (var index in Enumerable.Range(111, 3))
        {
            Console.WriteLine($"Student {index} is {students2[index].FirstName} {students2[index].LastName}");
        }
    }
}

public int Id { get; set; }

        [Required]
        public string Klant { get; set; }

        [DataType(DataType.EmailAddress)]
        public string Email { get; set; }

        [DataType(DataType.PhoneNumber)]
        public string Telefoonnummer { get; set; }

        [Required]
        public int Aantalpersonen { get; set; }

        [Required]
        [DataType(DataType.Date)]
        public DateTime Datum { get; set; }

        [Required]
        [DataType(DataType.Time)]
        public DateTime Begintijd { get; set; }

        [Required]
        [DataType(DataType.Time)]
        public DateTime Eindtijd { get; set; }

        [DataType(DataType.MultilineText)]
        public string Opmerkingen { get; set; }
        public string Medewerker { get; set; }
        public DateTime AanmaakDatum { get; set; }

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace GoodTimes.Models
{
    public class Bon
    {
        public int Id { get; set; }
        public int Tafelnr { get; set; }
        public DateTime Bezoek { get; set; }
        public string Medewerker { get; set; }
        public int Bonnummer { get; set; }

        public List<BonRegel> BonRegels { get; set; }

        public List<Bestelling> Bestellings { get; set; }
    }
}

Class Reserveren

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Threading.Tasks;

namespace GoodTimes.Models
{
    public class Reserveren
    {
        public int Id { get; set; }

        [Required]
        public string Klant { get; set; }

        [DataType(DataType.EmailAddress)]
        public string Email { get; set; }

        [DataType(DataType.PhoneNumber)]
        public string Telefoonnummer { get; set; }

        [Required]
        public int Aantalpersonen { get; set; }

        [Required]
        [DataType(DataType.Date)]
        public DateTime Datum { get; set; }

        [Required]
        [DataType(DataType.Time)]
        public DateTime Begintijd { get; set; }

        [Required]
        [DataType(DataType.Time)]
        public DateTime Eindtijd { get; set; }

        [DataType(DataType.MultilineText)]
        public string Opmerkingen { get; set; }
        public string Medewerker { get; set; }
        public DateTime AanmaakDatum { get; set; }
    }
}

ApplicationDbContext

using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.AspNetCore.Identity.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore;
using GoodTimes.Models;

namespace GoodTimes.Data
{
    public class ApplicationDbContext : IdentityDbContext
    {
        public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options)
            : base(options)
        {
        }
        public DbSet<GoodTimes.Models.Reserveren> Reserveren { get; set; }
        public DbSet<GoodTimes.Models.Menukaart> Menukaart { get; set; }
        public DbSet<GoodTimes.Models.Categorie> Categorie { get; set; }
        public DbSet<GoodTimes.Models.Product> Product { get; set; }

        protected override void OnModelCreating(ModelBuilder builder)
        {
            base.OnModelCreating(builder);
            builder.Entity<Menukaart>().HasData(
                new Menukaart
                {
                    Id = 1,
                    Naam = "Lunchkaart"
                },
                new Menukaart
                {
                    Id = 2,
                    Naam = "Dinerkaart"
                },
                new Menukaart
                {
                    Id = 3,
                    Naam = "Drankenkaart"
                }
            );
        }

        public DbSet<GoodTimes.Models.Bestelling> Bestelling { get; set; }

        //public DbSet<GoodTimes.Models.Bon> Bon { get; set; }

        //public DbSet<GoodTimes.Models.BonRegel> BonRegel { get; set; }
    }
}

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Threading.Tasks;

namespace GoodTimes.Models
{
    public class Bestelling
    {
        public int Id { get; set; }
        public int Tafelnummer { get; set; }
        public int Aantal { get; set; }
        [DataType(DataType.MultilineText)]
        public string Opmerkingen { get; set; }
        public string Medewerker { get; set; }
        public DateTime Plaatsing { get; set; }
        public bool IsGereed { get; set; }

        //public List<BonRegel> BonRegels { get; set; }

        //public int BonId { get; set; }
        //public Bon Bon { get; set; }
    }
}

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Threading.Tasks;

namespace GoodTimes.Models
{
    public class Categorie
    {
        public int Id { get; set; }
        [Required]
        public string Naam { get; set; }
        public int Volgorde { get; set; }

        public int MenukaartId { get; set; }
        public Menukaart Menukaart { get; set; }

        public List<Product> products { get; set; }
    }
}

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Threading.Tasks;

namespace GoodTimes.Models
{
    public class Product
    {
        public int Id { get; set; }
        [Required]
        public string Naam { get; set; }
        [Required]
        [DataType(DataType.MultilineText)]
        public string Omschrijving { get; set; }
        [Required]
        public double Prijs { get; set; }
        public int Volgorde { get; set; }

        public int CategorieId { get; set; }
        public Categorie categorie { get; set; }
    }
}

#c# #loops #for

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace StarPattern
{
class Program
{
static void Main(string[] args)
{
int x, y, z;
for (x =6; x >= 1; x--)
{
for (y = 1; y < x; y++)
{
Console.Write(" ");
}
for (z = 6; z >= x; z--)
{
Console.Write("*");
}
Console.WriteLine();
}
Console.ReadLine();
}
}
}

Browse more snippets >>