java万能战车合金弹头合金弹头载具模型

转载

mob64ca1409970a 2024-05-10 23:16:52

文章标签 java万能战车合金弹头 Time 渲染器自增 文章分类 Java 后端开发

新建工程

导入资源导入NGUI3.6.8

声音转化为2D声音，apply一下

1，选中图片>右键NGUI>Open Atlas Maker>点击>Create创建图集放在文件夹下面.

NGUI>Open>Prefab Toolbar>拖一个background到Hierarchy视图中>切换到2D模式>用W工具>将 BackGround删除

2，选择UI Root>在Scene中右键Create创建Sprite>在Atlas中选择图集，讲图片调整成背景大小>将Anchors的Type设置为Unified,调整上下左右的距离为0；

把摄像机调小:选Gizmos>调整3D Gizmos的大小

创建一个空的GameObject下可以放置图片集

Play按钮，在Scene中右击选Attach>boxCollider;再Attach>Button Script;在UIButton的Sprites中的pressed中选择按下之后的图片效果

写switch方法的时候连按两下tap键，然后输入对应的枚举对象，按下回车键，编辑器会自动帮我们写出所有的case；

///游戏主菜单控制
public class GameMenuController : MonoBehaviour {
public GameObject menuPanel;
    public GameObject operationPanel;
public GameObject diffcultyPanel;
public GameObject characterSelectPanel;
public Color operationPanelColor;
 
    public void OnMenuPlay() {
        menuPanel.SetActive(false);
        operationPanel.SetActive(true);
    }
    public void OnOperationPlay() {
        operationPanel.GetComponent<UISprite>().color = operationPanelColor;
        diffcultyPanel.SetActive(true);
    }
public void OnDiffcultyClick() {
        operationPanel.SetActive(false);
        diffcultyPanel.SetActive(false);
        characterSelectPanel.SetActive(true);
    }
public void OnCharacterSelect() {
 Application.LoadLevel(1);
    }
}
 
给背景分一下层，下面的层最先显示
卡车：将图片设置为2D精灵
选择一个图片精灵>在属性中点击Sprite Editor进行编辑
 
动画中两张精灵的位置有偏差可以通过修改精灵中心点的位置
 
///汽车的运动
public class Car : MonoBehaviour {
public Vector3 targetPos;
public Vector3 endTargetPos;
public int smoothing = 2;
public Wheel[] wheelArray;//三个车轮
public Damper damper;//门板转动
private bool isReaching = false;//表示是否达到目标位置
 
void Start() {
        Invoke("PlaySound", 0.3f);
    }
void Update () {
        transform.position = Vector3.Lerp(transform.position, targetPos, smoothing * Time.deltaTime);
if (isReaching == false) {
            if (Vector3.Distance(transform.position, targetPos) < 0.4f) {
                isReaching = true;
                OnReach();//达到目标位置之后，进行的操作
            }
        }
    }
void PlaySound() {
        audio.Play();
    }
void OnReach() {
        foreach (Wheel w in wheelArray) {
            w.Stop();
        }
        damper.StartRotate();
//放下主角 TODO
//把车子开走
        Invoke("GoOut", 1f);
    }
void GoOut() {
        targetPos = endTargetPos;
foreach (Wheel w in wheelArray) {
            w.Start();
        }
        Destroy(this.gameObject, 1f);
    }
}
 
///车轮旋转
public class Wheel : MonoBehaviour {
public float speed = 200;
private bool isRotate = true;
void Update () {
if(isRotate)
            transform.Rotate(-Vector3.forward * speed * Time.deltaTime); 
    }
public void Stop() {
        isRotate = false;
    }
public void Start() {
        isRotate = true;
    }
}
 
///门板的旋转
public class Damper : MonoBehaviour {
public float speed = 120;
private bool isRotate = false;
private float angle = 0;
void Update () {
if (isRotate) {
            angle += speed * Time.deltaTime;
            transform.Rotate(Vector3.forward * speed * Time.deltaTime);
if (angle > 135) {
                isRotate = false;
            }
        }
    }
public void StartRotate() {
        isRotate = true;
    }
}
 
///角色在地面上的行走射击和蹲下行走射击共用一套代码
using UnityEngine;
using System.Collections;
 
public enum AnimStatus {
    Idle,
    Walk
}
public class PlayerGround : MonoBehaviour {
 
public float animSpeed = 10;//1秒播放10帧图片
    private float animTimeInterval = 0;
public AnimStatus status = AnimStatus.Idle;//表示主角当前的状态
 
public SpriteRenderer upRenderer;//上半身的渲染器
public SpriteRenderer downRenderer;//下半身的渲染器
 
public Sprite[] idleUpSpriteArray;
    private int idleUpIndex = 0;
    private int idleUpLength = 0;
    private float idleUpTimer = 0;
public Sprite idleDownSprite;
 
public Sprite[] walkUpSpriteArray;
private int walkUpIndex = 0;
private int walkUpLength = 0;
private float walkUpTimer = 0;
 
public Sprite[] walkDownSpriteArray;
private int walkDownIndex = 0;
private int walkDownLength = 0;
private float walkDownTimer = 0;
 
 
// Use this for initialization
void Start () {
        animTimeInterval = 1 / animSpeed;//得到每一帧的时间间隔
        idleUpLength = idleUpSpriteArray.Length;//上身动画精灵数
        walkUpLength = walkUpSpriteArray.Length;
        walkDownLength = walkDownSpriteArray.Length;
    }
   
void Update () {
        //判断主角的状态以及播放动画
switch (status) {
case AnimStatus.Idle:
                idleUpTimer += Time.deltaTime;
                if (idleUpTimer > animTimeInterval) {
                    idleUpTimer -= animTimeInterval;//当计时器减去一个周期的时间
                    idleUpIndex++;//当帧数自增（播放下一帧）
                    idleUpIndex %= idleUpLength;//(判断是否到达最大帧数)
                    upRenderer.sprite = idleUpSpriteArray[idleUpIndex];
                }
                downRenderer.sprite = idleDownSprite;
break;
case AnimStatus.Walk:
                walkUpTimer += Time.deltaTime;
if (walkUpTimer > animTimeInterval) {
                    walkUpTimer -= animTimeInterval;
                    walkUpIndex++;
                    walkUpIndex %= walkUpLength;
                    upRenderer.sprite = walkUpSpriteArray[walkUpIndex];
                }
                walkDownTimer += Time.deltaTime;
if (walkDownTimer > animTimeInterval) {
                    walkDownTimer -= animTimeInterval;
                    walkDownIndex++;
                    walkDownIndex %= walkDownLength;
                    downRenderer.sprite = walkDownSpriteArray[walkDownIndex];
                }
break;
        }
    }
public void Shoot(float v_h, bool isTopKeyDown, bool isBottomKeyDown) {
    }
}
 
///角色的跳跃和射击动作
public class PlayerJump : MonoBehaviour {
 
public float animSpeed = 10;//1秒播放10帧图片
private float animTimeInterval = 0;
public AnimStatus status = AnimStatus.Idle;//表示主角当前的状态
public SpriteRenderer upRenderer;//上半身的渲染器
public SpriteRenderer downRenderer;//下半身的渲染器
public Sprite[] idleUpSpriteArray;
private int idleUpIndex = 0;
private int idleUpLength = 0;
private float idleUpTimer = 0;
public Sprite[] idleDownSpriteArray;
private int idleDownIndex = 0;
private int idleDownLength = 0;
private float idleDownTimer = 0;
public Sprite shootUpSprite;
public Sprite shootHorizontalSprite;
private bool shoot = false;
private ShootDir shootDir;//射击的方向
public GameObject projectilePrefab;
public Transform shootupPos;//射击的位置
public Transform shoothorizontalPos;
 
void Start() {
        animTimeInterval = 1 / animSpeed;//得到每一帧的时间间隔
        idleUpLength = idleUpSpriteArray.Length;
        idleDownLength = idleDownSpriteArray.Length;
    }
 
void Update() {
switch (status) {
case AnimStatus.Idle:
                idleUpTimer += Time.deltaTime;
if (idleUpTimer > animTimeInterval) {//播放下一帧
                    idleUpTimer -= animTimeInterval;//当计时器减去一个周期的时间
                    idleUpIndex++;//当帧数自增（播放下一帧）
                    idleUpIndex %= idleUpLength;//(判断是否到达最大帧数)
                    upRenderer.sprite = idleUpSpriteArray[idleUpIndex];
                }
                idleDownTimer += Time.deltaTime;
if (idleDownTimer > animTimeInterval) {//播放下一帧
                    idleDownTimer -= animTimeInterval;//当计时器减去一个周期的时间
                    idleDownIndex++;//当帧数自增（播放下一帧）
                    idleDownIndex %= idleDownLength;//(判断是否到达最大帧数)
                    downRenderer.sprite = idleDownSpriteArray[idleDownIndex];
                }
break;  
        }
    }
 
void LateUpdate() {
if (shoot) {
            shoot = false;
//进行射击//判断射击的位置
            Vector3 pos = Vector3.zero;
if(shootDir==ShootDir.Top){
                pos = shootupPos.position;
            }
else if(shootDir==ShootDir.Left||shootDir==ShootDir.Right){
                pos = shoothorizontalPos.position;
            }
            //判断射击的方向
int z_rotation=0;
switch (shootDir)
            {
case ShootDir.Left:
                    upRenderer.sprite = shootHorizontalSprite;
                    z_rotation=180;
break;
case ShootDir.Right:
                upRenderer.sprite = shootHorizontalSprite;
                    z_rotation=0;
break;
case ShootDir.Top:
                 upRenderer.sprite = shootUpSprite;
                    z_rotation=90;
break;
case ShootDir.Down:
                    z_rotation=270;
break;
default:
break;
            }
            GameObject.Instantiate(projectilePrefab, pos, Quaternion.Euler(0, 0, z_rotation));
        }
    }
//射击的方法
public void Shoot(float v_h, bool isTopKeyDown, bool isBottomKeyDown) {
        shoot = true;
//得到射击的方向
if (isTopKeyDown == false && isBottomKeyDown == false) {
            if (transform.localScale.x == 1) {
                shootDir = ShootDir.Left;
            } else if (transform.localScale.x == -1) {
                shootDir = ShootDir.Right;
            }
          } 
else {
if (isTopKeyDown) {
                    shootDir = ShootDir.Top;
            } 
else if (isBottomKeyDown) {
                    shootDir = ShootDir.Down;
            }
        }
    }
}
 
//子弹
public class PlayerProjectile : MonoBehaviour {
public float speed = 10;
void Start() {
        Destroy(this.gameObject, 3);
    }
void Update () {
        transform.Translate(Vector3.right * speed * Time.deltaTime);
    }
}
 
///进行射击
using UnityEngine;
using System.Collections;
 
public enum ShootDir{
    Left,
    Right,
    Top,
    Down
}
 
public class PlayerShoot : MonoBehaviour {
public int shootRate = 7;//代表每秒可以射击的次数
public PlayerGround playerGround;
public PlayerDown playerDown;
public PlayerJump playerJump;
private float shootTimeInterval = 0;
private float timer = 0;
private bool canShoot = true;
private PlayerMove playerMove;
private bool isTopKeyDown = false;
private bool isBottomKeyDown = false;
 
void Start() {
        shootTimeInterval = 1f / shootRate;
        playerMove = this.GetComponent<PlayerMove>();
    }
    void Update () {
        if (canShoot == false) {
            timer += Time.deltaTime;
            if (timer >= shootTimeInterval) {
                canShoot = true;
                timer -= shootTimeInterval;
            }
        }
 
if (Input.GetKeyDown(KeyCode.W)) {
            isTopKeyDown = true;
        }
if (Input.GetKeyUp(KeyCode.W)) {
            isTopKeyDown = false;
        }
if (Input.GetKeyDown(KeyCode.S)) {
            isBottomKeyDown = true;
        }
        if (Input.GetKeyUp(KeyCode.S)) {
            isBottomKeyDown = false;
        }
if (canShoot && Input.GetKeyDown(KeyCode.J)) {
//进行射击的操作
            audio.Play();
switch (playerMove.state) {
case PlayerState.PlayerGround:
                    playerGround.Shoot(rigidbody.velocity.x, isTopKeyDown, isBottomKeyDown);
break;
case PlayerState.PlayerDown:
                    playerDown.Shoot(rigidbody.velocity.x, isTopKeyDown, isBottomKeyDown);
break;
case PlayerState.PlayerJump:
                    playerJump.Shoot(rigidbody.velocity.x, isTopKeyDown, isBottomKeyDown);
break;
            }
        }
    }
}
 
///角色的移动
using UnityEngine;
using System.Collections;
 
public enum PlayerState {
    PlayerGround,
    PlayerDown,
    PlayerJump
}
 
public class PlayerMove : MonoBehaviour {
public float speed = 3;
public float jumpSpeed = 3;
public PlayerState state = PlayerState.PlayerJump;
private bool isGround = false;
private int groundLayerMask;
private bool isBottomKeyClick = false;
public PlayerGround playerGround;
public PlayerDown playerDown;
public PlayerJump playerJump;
void Start() {
        groundLayerMask = LayerMask.GetMask("Ground");
    }
void Update () {
if (Input.GetKeyDown(KeyCode.S)) {
            isBottomKeyClick = true;
        }
if (Input.GetKeyUp(KeyCode.S)) {
            isBottomKeyClick = false;
        }
float h = Input.GetAxis("Horizontal");
        Vector3 v = rigidbody.velocity;
        rigidbody.velocity = new Vector3(h * speed, v.y, v.z);
        v = rigidbody.velocity;
        RaycastHit hitinfo;
        isGround = Physics.Raycast(transform.position + Vector3.up * 0.1f, Vector3.down, out hitinfo, 0.2f, groundLayerMask);
//判断当前主角的状态 跳起 蹲下 正常
if (isGround == false) {
            state = PlayerState.PlayerJump;
        } else {
if (isBottomKeyClick) {
                state = PlayerState.PlayerDown;
            } else {
                state = PlayerState.PlayerGround;
            }
        }
 
//控制主角的跳跃
 if (isGround && Input.GetKeyDown(KeyCode.K)) {
            rigidbody.velocity = new Vector3(v.x, jumpSpeed, v.z);
        }
//根据状态来判定启用哪一个游戏状态
switch (state) {
case PlayerState.PlayerDown:
                playerDown.gameObject.SetActive(true);
                playerJump.gameObject.SetActive(false);
                playerGround.gameObject.SetActive(false);
break;
case PlayerState.PlayerGround:
                playerDown.gameObject.SetActive(false);
                playerJump.gameObject.SetActive(false);
                playerGround.gameObject.SetActive(true);
break;
case PlayerState.PlayerJump:
                playerDown.gameObject.SetActive(false);
                playerJump.gameObject.SetActive(true);
                playerGround.gameObject.SetActive(false);
break;
        }
 
//控制主角的朝向
float x = 1;
 if (rigidbody.velocity.x > 0.05f) {
            x = -1;
        } else if (rigidbody.velocity.x < -0.05f) {
            x = 1;
        } else {
            x = 0;
        }
if (x != 0) {
            playerGround.transform.localScale= new Vector3(x, 1, 1);
            playerJump.transform.localScale = new Vector3(x, 1, 1);
            playerDown.transform.localScale = new Vector3(x, 1, 1);
        }
 
        //控制主角在idle和walk状态的切换
        if (Mathf.Abs(rigidbody.velocity.x) > 0.05f) {
            playerGround.status = AnimStatus.Walk;
            playerDown.status = AnimStatus.Walk;
        } else {
            playerGround.status = AnimStatus.Idle;
            playerDown.status = AnimStatus.Idle;
        }
if (Mathf.Abs(rigidbody.velocity.x) > 0.05f)
        {
            playerGround.status = AnimStatus.Walk;
            playerDown.status = AnimStatus.Walk;
        }
else
        {
            playerGround.status = AnimStatus.Idle;
            playerDown.status = AnimStatus.Idle;
        }
    }
}

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。