【Unity3D】射箭打靶游戏（简单工厂+物理引擎编程）

最新推荐文章于 2024-05-13 09:35:29 发布
最新推荐文章于 2024-05-13 09:35:29 发布
阅读量546 收藏 2
点赞数 1
文章标签： 游戏 ui
原文链接：http://www.cnblogs.com/xieyuanzhen-Feather/p/6666586.html
版权

打靶游戏：

    1.靶对象为 5 环，按环计分；
    2.箭对象，射中后要插在靶上；
    3.游戏仅一轮，无限 trials；

增强要求：

 添加一个风向和强度标志，提高难度

 

游戏成品图：

 

 

UML图：

 

 

游戏设计思路&大致过程&核心代码
游戏对象主要由三个，靶、弓和箭，射出去的箭可以复用（利用简单工厂），将箭从弓的位置加上常力向某个方向射出。最后实现增强功能——添加常力作为风向并且在界面中显示出风向（只设置了界面上的左右两个不同方向）以及风力（0~50）。

1.首先设置游戏对象——靶子、弓和箭。
    为了实现识别不同的环，通过五个共圆心的圆柱体（高度不同——通过设置Transform）来识别箭首先碰到的环（小环厚度较大）。

 

    游戏的弓和箭——刚开始用圆柱体（箭身）+胶囊（箭头）实现箭，在后来进行界面优化时下载了模型。将模型直接作为预制即可。

 

2.大致明确类——建立在之前实验的基础上

         2.1复用之前的类：不需要修改

SSDirector，Singleton，动作类——CCSequenceAction，SSAction，SSActionEvetType，SSActionManager

         2.2需要修改的类：CCActionManager，FirstController，SceneController，UserGUI

 

3.设计基本UML图，调试好基本代码，只有空函数——不具体实现。

 

4.根据课堂实验5实现自由移动弓

         在Bow的预制对象上挂上下述代码即可。利用方向控制键（键盘）可以控制弓的移动。

5.实现UI界面

 

6.实现箭的工厂类

 

 7.实现射出箭的动作

 

 

 

8.实现箭插在靶上和分数识别计算

9.添加风力和风的方向

关键设置——在上述的第8点算是这次实验的一大难点，其余的基本在之前的实验都已经实现过类似的操作。

 

 

详细代码：

SSDirector.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using Com.Mygame;

public class SSDirector : System.Object {
    private static SSDirector _instance;
    
    public ISceneController currentSceneController { get; set; }
    public bool running{ get; set; }

    public static SSDirector getInstance() {
        if (_instance == null) {
            _instance = new SSDirector ();
        }
        return _instance;
    }

    public int getFPS() {
        return Application.targetFrameRate;
    }

    public void setFPS(int fps) {
        Application.targetFrameRate = fps;
    }
}

FirstController.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using Com.Mygame;
    public class FirstController : MonoBehaviour, ISceneController, IUserAction {
        public IshootArrow actionManager {get; set;}
        public ArrowFactory arrowfactory {get; set;}
        public GameObject Arrow;
        public GameObject Bow;
        public Text ScoreText;  // 显示得分

        public int score;
        void Awake() {
            SSDirector director = SSDirector.getInstance ();
            director.setFPS (60);
            director.currentSceneController = this;
            director.currentSceneController.LoadResources ();
            actionManager = gameObject.AddComponent<CCActionManager>();
            arrowfactory = gameObject.AddComponent<ArrowFactory>();
        }
        public void hit(Vector3 dir) {
            actionManager.playArrow(Bow.transform.position);
        }
        void Update() {
            ScoreText.text = "Score:" + score.ToString();
        }
        public float getWindforce() {
            return actionManager.getforce();
        }
        public void StartGame() {
            //
        }
        public void ShowDetail() {
            GUI.Label(new Rect(220, 50, 350, 250), "you can controll the bow and click mouse to emit arrow"); 
        }
        // 接口具体实现--------------------------------------------------------------------
        public void LoadResources() {
            Debug.Log ("load...\n");
            Instantiate(Resources.Load("prefabs/Target"));
            Bow = Instantiate(Resources.Load("prefabs/Bow")) as GameObject; 
            Arrow.transform.position = Bow.transform.position;
        }
        public void Pause(){
        }
        public void Resume(){
        }
    }

SceneController.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using Com.Mygame;

namespace Com.Mygame {
    public interface ISceneController {
        void LoadResources ();
        float getWindforce();
    }
    public interface IUserAction {
        void ShowDetail();
        void StartGame();
        void hit(Vector3 dir);
    }
        
}

UserGUI.cs

using UnityEngine;
using UnityEngine.UI;
using System.Collections;
using Com.Mygame;

public class UserGUI : MonoBehaviour {

    private IUserAction action;     // 用户动作接口
    private ISceneController queryInt;   // 场景接口
    public bool isButtonDown = false;
    public Camera camera;

    public Text WindForce;
    public Text WindDirection;
    void Start() {
        // 实例化对象
        action = SSDirector.getInstance().currentSceneController as IUserAction;
        queryInt = SSDirector.getInstance().currentSceneController as ISceneController;
    }
    void Update() {
        float force = queryInt.getWindforce ();
        if (force < 0) {
            WindDirection.text = "Wind Direction : Left";
        } else if (force > 0) {
            WindDirection.text = "Wind Direction : Right";
        } else {
            WindDirection.text = "Wind Direction : No Wind";
        }
        WindForce.text = "Wind Force : " + queryInt.getWindforce(); //显示风力
    }
    void OnGUI() {
        GUIStyle fontstyle1 = new GUIStyle();
        fontstyle1.fontSize = 50;
        fontstyle1.normal.textColor = new Color(255, 255, 255);
        if (GUI.RepeatButton(new Rect(0, 0, 120, 40), "Rule")) {
            action.ShowDetail();
        }
        if (GUI.Button(new Rect(0, 60, 120, 40), "Start")) {  
            action.StartGame();
        }
        if (Input.GetMouseButtonDown(0) && !isButtonDown) {
            Ray mouseRay = camera.ScreenPointToRay (Input.mousePosition);
            Debug.Log("RayDir = " + mouseRay.direction);
            action.hit(mouseRay.direction);
            isButtonDown = true;
        }
        else if(Input.GetMouseButtonDown(0) && isButtonDown) {  
            isButtonDown = false;
        }
    }
}

Singleton.cs

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

public class Singleton<T> where T: MonoBehaviour {
    // 单例模式，可以在任何代码中轻松获取到单例对象
    
    private static T instance;

    public static T Instance {
        get {
            if (instance == null) {
                instance = (T)Object.FindObjectOfType(typeof(T));
                if (instance == null) {
                    Debug.LogError("Cant find instance of "+typeof(T));
                }
            }
            return instance;
        }
    }
}

Data.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
[System.Serializable]
public class Data : MonoBehaviour {
    public Vector3 size;
    public Color color = Color.red;
    public float speed = 5f;
    public Vector3 director;
    public play Action;
    public bool hit;
}

ArrowFactory.cs

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

public class ArrowFactory : MonoBehaviour {
    private static ArrowFactory _instance;
    private List<GameObject> freeArrow; // 空闲的箭头
    private List<GameObject> usedArrow;
    private GameObject arrowTemplate;

    public FirstController sceneControler { get; set; }

    void Awake() {
        if (_instance == null) {
            _instance = Singleton<ArrowFactory>.Instance;
            _instance.usedArrow = new List<GameObject>();
            _instance.freeArrow = new List<GameObject>();
        }
    }

    public GameObject GetArrow1() {  
        GameObject newArrow;  
        if (freeArrow.Count == 0) {
            newArrow = GameObject.Instantiate(Resources.Load("Prefabs/arrow")) as GameObject;  
        } else {
            newArrow = freeArrow[0];
            freeArrow.Remove(freeArrow[0]);
        }
        
        newArrow.transform.position = arrowTemplate.transform.position;
        newArrow.transform.localEulerAngles = new Vector3(90, 0, 0);
        usedArrow.Add(newArrow);
        return newArrow;
    }  
    public void FreeArrow1(GameObject arrow1) {
        for (int i = 0; i < usedArrow.Count; i++) {
            if (usedArrow[i] == arrow1) {
                usedArrow.Remove(arrow1);
                arrow1.SetActive(true);
                freeArrow.Add(arrow1);
            }
        }
        return;
    }
    // Use this for initialization
    void Start () {
        sceneControler = (FirstController)SSDirector.getInstance().currentSceneController;  
        sceneControler.arrowfactory = this;  
        arrowTemplate = Instantiate(Resources.Load("prefabs/arrow")) as GameObject;
        arrowTemplate.SetActive (false);
        //arrowTemplate.transform.parent = sceneControler.Bow.transform;  
        arrowTemplate.transform.localEulerAngles = new Vector3(90, 0, 0);  
        freeArrow.Add(sceneControler.Arrow);  
    }
    
    // Update is called once per frame
    void Update () {
        
    }
}

joystick.cs

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

public class joystick : MonoBehaviour {
    public float speedY = 10.0F;
    public float speedX = 10.0F;
    //public GameObject cam;

    // Use this for initialization
    void Start () {
        
    }
    
    // Update is called once per frame
    void Update () {
        //Debug.Log("p");
        float translationY = Input.GetAxis("Vertical")*speedY;
        float translationX = Input.GetAxis("Horizontal")*speedX;
        translationY *= Time.deltaTime;
        translationX *= Time.deltaTime;
        transform.Translate(0, translationY, 0);
        transform.Translate(translationX, 0, 0);
        /*if (Input.GetButtonDown("Fire1")) {
            Debug.Log("Fired Pressed");
            Debug.Log(Input.mousePosition);

            Vector3 mp = Input.mousePosition;

            //Camera ca = cam.GetComponent<Camera>();
            Ray ray = ca.ScreenPointToRay(Input.mousePosition);

            RaycastHit hit;
            if (Physics.Raycast(ray, out hit)) {
                print(hit.transform.gameObject.name);
                if (hit.collider.gameObject.tag.Contains("Finish")) {
                    Debug.Log("hit "+hit.collider.gameObject.name+"!");
                }
            }
        }*/
    }
}

target.cs

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

public class Target : MonoBehaviour {
    public int num;//每个靶都有特定的分数
    public play EmitDisk;
    public FirstController sceneController;//场记
    //private ScoreRecorder recorder;
    public void Start() {
        Debug.Log("target");
        sceneController = (FirstController)SSDirector.getInstance().currentSceneController;
    }
    void OnTriggerEnter(Collider other) {
        Debug.Log("jizhong");
        Debug.Log(other.gameObject);
        if (other.gameObject.tag == "Arrow") {
            if (!other.gameObject.GetComponent<Data>().hit) {
               other.gameObject.GetComponent<Data>().hit = true;
                Debug.Log(num);
                sceneController.score += num;//加分
            }
            EmitDisk = (play)other.gameObject.GetComponent<Data>().Action;
            other.gameObject.GetComponent<Rigidbody>().velocity = Vector3.zero;//插在箭靶上  
            EmitDisk.Destory();//动作完成
        }

    }
}

Aciton(动作类代码)

CCActionManager.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using Com.Mygame;
public class CCActionManager : SSActionManager, ISSActionCallback, IshootArrow {

    public FirstController sceneController;
    public ArrowFactory arrowFactory;
    public play EmitArrow;
    public GameObject Arrow;
    public float force = 0f;
    int count = 0;
    //public CCMoveToAction moveToA, moveToB, moveToC, moveToD;

    // Use this for initialization
    protected new void Start () {
        sceneController = (FirstController)SSDirector.getInstance().currentSceneController;
        sceneController.actionManager = this;
        arrowFactory = sceneController.arrowfactory;
    }
    
    // Update is called once per frame
    protected new void Update () {
        base.Update();
    }
    public float getforce() {
        return force;
    }
    public void playArrow(Vector3 dir) {
        force = Random.Range(-50,50); //获取随机的风力
        EmitArrow = play.GetSSAction();
        //force = play.getWindForce();
        //Debug.Log("play");
        Arrow = arrowFactory.GetArrow1();
        //Arrow.transform.position = new Vector3(0, 2, 0);
        Arrow.transform.position = dir;
        Arrow.GetComponent<Rigidbody>().AddForce(new Vector3(force, 0.3f, 2), ForceMode.Impulse);
        this.RunAction(Arrow, EmitArrow, this);
        Arrow.GetComponent<Data>().Action = EmitArrow;
    }

    //
    public void SSActionEvent(SSAction source, SSActionEventType events = SSActionEventType.Competeted,
        int intParam = 0, string strParam = null, Object objectParam = null) {
        arrowFactory.FreeArrow1(source.gameobject);  
        Debug.Log("free");
        source.gameobject.GetComponent<Data>().hit = false;
    }
}

CCSequenceAction.cs

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

public class CCSequenceAction : SSAction, ISSActionCallback {
    public List<SSAction> sequence;
    public int repeat = -1;
    public int start = 0;

    public static CCSequenceAction GetSSAction(int repeat, int start, List<SSAction> sequence) {
        CCSequenceAction action = ScriptableObject.CreateInstance<CCSequenceAction>();
        action.repeat = repeat;
        action.sequence = sequence;
        action.start = start;
        return action;
    }

    public override void Update() {
        if (sequence.Count == 0) return;
        if (start < sequence.Count) {
            sequence [start].Update();
        }
    }

    // Use this for initialization
    public override void Start () {
        foreach (SSAction action in sequence) {
            action.gameobject = this.gameobject;
            action.transform = this.transform;
            action.callback = this;
            action.Start();
        }
    }

    void OnDestory() {
        //
    }

    public void SSActionEvent(SSAction source, SSActionEventType events = SSActionEventType.Competeted, 
        int intParam = 0, string strParam = null, Object objectParam = null) {
        source.destroy = false;
        this.start++;
        if (this.start >= sequence.Count) {
            this.start = 0;
            if (repeat > 0) repeat--;
            if (repeat == 0) {
                this.destroy = true;
                this.callback.SSActionEvent(this);
            }
        }
    } 
    
}

IshootArrow.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using Com.Mygame;
public interface IshootArrow {
    void playArrow(Vector3 dir);
    float getforce();
}

play.cs

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

public class play : SSAction {  
    int count = 0;  
    bool enableEmit = true;  
    Vector3 force;

    public FirstController sceneControler = (FirstController)SSDirector.getInstance().currentSceneController;  
    public static play GetSSAction() {
        play action = ScriptableObject.CreateInstance<play>();  
        return action;  
    }
    // Use this for initialization  
    public override void Start() {
        force = new Vector3(0, 0.3f, 2);
    }

    // Update is called once per frame  
    public override void Update() {
        gameobject.GetComponent<Rigidbody>().velocity = Vector3.zero;  
        gameobject.GetComponent<Rigidbody>().AddForce(force, ForceMode.Impulse);
    }

    public void Destory() {  
        this.destroy = true;
        this.callback.SSActionEvent(this);
        Destroy(gameobject.GetComponent<BoxCollider>());
    }
}

SSAction.cs

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

public class SSAction : ScriptableObject {
    public bool enable = true;
    public bool destroy = false;

    public GameObject gameobject { get; set; }
    public Transform transform {get; set;}
    public ISSActionCallback callback {get; set;}
    protected SSAction() {}
    public virtual void Start() {
        throw new System.NotImplementedException();
    }
    public virtual void Update() {  
        throw new System.NotImplementedException();
    }
    public virtual void FixedUpdate() {
        throw new System.NotImplementedException();
    }
}

SSActionEventType.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public enum SSActionEventType:int {Started, Competeted}
public interface ISSActionCallback {
    void SSActionEvent(SSAction source, SSActionEventType events = SSActionEventType.Competeted, 
        int intParam = 0, string strParam = null, Object objectParam = null);
}

SSActionManager.cs

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

public class SSActionManager : MonoBehaviour {

    private Dictionary <int, SSAction> actions = new Dictionary <int, SSAction>();
    private List<SSAction> waitingAdd = new List<SSAction>();
    private List<int> waitingDelete = new List<int> ();

    // Use this for initialization
    protected void Start () {
        
    }
    
    // Update is called once per frame
    protected void Update () {
        foreach (SSAction ac in waitingAdd) actions [ac.GetInstanceID()] = ac;
        waitingAdd.Clear();

        foreach (KeyValuePair <int, SSAction> kv in actions) {
            SSAction ac = kv.Value;
            if (ac.destroy) {
                waitingDelete.Add(ac.GetInstanceID());
            } else if (ac.enable) {
                ac.Update();
            }
        }

        foreach (int key in waitingDelete) {
            SSAction ac = actions[key];
            actions.Remove(key);
            DestroyObject(ac);
        }
        waitingDelete.Clear();
    }

    public void RunAction(GameObject gameobject, SSAction action, ISSActionCallback manager) {
        action.gameobject = gameobject;
        action.transform = gameobject.transform;
        action.callback = manager;
        waitingAdd.Add(action);
        action.Start();
    }
}

 

转载于:https://www.cnblogs.com/xieyuanzhen-Feather/p/6666586.html

aisuzhong3709
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
U3D 打靶游戏 demo 要源代码 可以联系我
09-25
打靶游戏
【Unity3D】打靶游戏
Khynnn的博客
11-11 572
作业
Unity3d--打靶游戏
TempterCyn的博客
10-16 1058
游戏内容要求： 1.靶对象为 5 环，按环计分； 2.箭对象，射中后要插在靶上 增强要求：射中后，箭对象产生颤抖效果，到下一次射击 或 1秒以后 3.游戏仅一轮，无限 trials； 增强要求：添加一个风向和强度标志，提高难度 游戏规则 1.按空格键取箭，然后按住鼠标左键同时移动鼠标，箭头会跟着鼠标移动，此时松开左键，箭就会射出。射中后箭体会进行抖动。 2.靶上一共有5环，击中n环加n分，...
Unity3D作业六：打靶游戏
weixin_43977005的博客
12-08 1273
作业六：打靶游戏1：游戏要求：1.1游戏内容要求：1.2游戏编程要求2：游戏对象预制：2.1：靶子Target：2.2：箭Arrow：2.3： 弓bow：3：编程：3.1 Adapter模式：1：基类SSAction2：箭的射击动作 ArrowShootAction.cs3：ArrowTrembleAction 箭的颤抖动作：4：SSActionManage统一的动作管理接口：5:ArrowShootActionManager,提供一个接口用于执行箭的射击动作；3.2 SSDirector 导演类3.3：A
Unity3D项目七：简单打靶
Tifinity的博客
10-18 824
简单打靶 文章目录简单打靶游戏规则与要求项目地址与演示视频具体实现总结参考资料 游戏规则与要求 游戏内容要求： 靶对象为 5 环，按环计分； 箭对象，射中后要插在靶上 增强要求：射中后，箭对象产生颤抖效果，到下一次射击 或 1秒以后 游戏仅一轮，无限 trials； 增强要求：添加一个风向和强度标志，提高难度 项目地址与演示视频 项目地址 -> 传送门???? 视频连...
unity3d射箭模拟小游戏
timeyy44的博客
10-14 2956
射箭小游戏制作过程介绍项目总览注意箭矢（Arrow）箭矢跟随鼠标旋转箭矢中靶的事件响应箭矢碰撞处理中靶计分箭矢控制类（ArrowController）箭矢回收箭矢创建箭矢运动键盘按下蓄力箭矢驱动场景控制类（SceneController） 该博客是继上次打飞碟小游戏的另一次尝试，且此次设计过程是在上次的经验上完全的由自己完成，因此尽管经历了更多的弯折和死路，但终究也获得了更多。 项目的代码已经上传...
【前端素材】小游戏-3d射箭打靶游戏.zip
04-04
JavaScript，是一种轻量级的解释型编程语言； jQuery，使用户能更方便地处理HTML documents、events、实现动画效果，并且方便地为网站提供AJAX交互； Bootstrap 是快速开发 Web 应用程序的前端工具包。它是一个 CSS...
3D游戏编程与设计-射箭游戏
12-31
https://www.bilibili.com/video/BV12G411i75d/?vd_source=14378af7f4852f61077710556012ba42 实机视频 https://www.bilibili.com/read/cv28196752/ 博客
Archery Clash 射箭比赛Unity射箭3d游戏项目源码C#
02-05
那些想要创建射箭游戏的人那么这个资源适合您。 尝试用弓箭击落所有灯笼和花瓶。您必须击中所有标有大红点的项目。探索各种日式花园，花点时间拉紧弓弦，做好完美拍摄的准备。如果目标距离很远，请尝试瞄准红点上方...
Archery Blast 射箭爆炸Unity休闲射击游戏项目源码C#
02-12
Archery Blast 射箭爆炸Unity休闲射击游戏项目源码C# 商品描述 支持Unity版本2018.2.0f2及以上 弓箭手……向你鞠躬！在《Archery Blast》中，您是一名有抱负的弓箭手，接受更疯狂的挑战！这次有60个挑战等着你！您将...
unity小型第一人称射击游戏
05-09
通过本次实验，了解Unity中编程的基本操作与流程，掌握基本的生命周期函数和合理控制游戏的逻辑。对于Unity中的基本概念（游戏物体、组件、父子关系）有更加深入的理解和应用，学会如何在开发中自由的获取物体与组件...
Unity3DGame学习笔记：打靶游戏(homework6)
ygtrece的博客
04-05 2053
UML图： 规则说明： 靶分为6环，由内而外射中得分分别为10，8，6，4，2，1 游戏仅一轮，可无限射箭 仅在左右方向上具有风力 实现效果： 大致思路： 与飞碟游戏很相似，仅是增添了箭和靶子的碰撞，并在箭射中靶子时将其刚体属性去除实现箭插在靶子上 UserGUI类： 该类中主要负责检测鼠标的点击，根据鼠标点击得到射线确认箭射出去的方向 using System.C
【Unity3d学习】使用物理引擎——打飞碟游戏的物理引擎改进与射箭游戏设计
JKJKL1的博客
10-18 591
写在前面 Unity3d学习制作的实验资料都在老师的课程网站上：传送门 本次实验的项目有两部分，打飞碟的物理引擎改进以及射箭游戏的设计在Github上：传送门 视频链接：打飞碟（与上一个项目的演示没什么太大区别）、射箭游戏 此次打飞碟游戏的改进是在上一次实验的基础上进行的（上一次的博客地址） HitUFO的物理引擎改进版本 回看内容要求： 游戏内容要求： 游戏有 n 个 round，每个 ...
力扣HOT100 - 55. 跳跃游戏
qq_61504864的博客
05-12 123
【代码】力扣HOT100 - 55. 跳跃游戏。
2024OD机试卷-虚拟理财游戏 (java)
WRJ_Jack的博客
05-12 61
在一款虚拟游戏中生活，你必须进行投资以增强在虚拟游戏中的资产以免被淘汰出局。 现有一家Bank，它提供有若干理财产品 m 个，风险及投资回报不同，你有 N（元）进行投资，能接收的总风险值为X。 你要在可接受范围内选择最优的投资方式获得最大回报。 备注： 在虚拟游戏中，每项投资风险值相加为总风险值； 在虚拟游戏中，最多只能投资2个理财产品； 在虚拟游戏中，最小单位为整数，不能拆分为小数； 投资额*回报率=投资回报
【unity小技巧】减少Unity中的构建打包大小
最新发布
向宇
05-13 319
一位在小公司默默奋斗的开发者，出于兴趣爱好，最近开始自学unity，闲暇之余，边学习边记录分享，站在巨人的肩膀上，通过学习前辈们的经验总是会给我很多帮助和启发！如果你遇到任何问题，也欢迎你评论私信找我， 虽然有些问题我也不一定会，但是我会查阅各方资料，争取给出最好的建议，希望可以帮助更多想学编程的人，共勉~让我们从压缩项日中的图像资源开始，这些资源通常是最消耗空间的资源复制要压缩的图像的名称，比如这个。我们可以降低图像的分辨率，如果你觉得图像的分辨率太大，请选择较低的分辨率。，也欢迎评论私信告诉我哦！
ssm115乐购游戏商城系统+vue
hjjshua的博客
05-09 503
如今社会上各行各业，都喜欢用自己行业的专属软件工作，互联网发展到这个时候，人们已经发现离不开了互联网。新技术的产生，往往能解决一些老技术的弊端问题。因为传统毕业生学历信息管理难度大，容错率低，管理人员处理数据费工费时，所以专门为解决这个难题开发了一个毕业生学历证明系统，可以解决许多问题。 毕业生学历证明系统实现的功能包括管理用户的签约单位信息，管理用户的学历信息，管理用户的转接地信息，管理基础数据，其中基础信息管理包括部门管理，职位管理，班级管理，成分管理，学习形式管理，学制管理，专业管理，学历性质管理，
Cocos creator实现《战机长空》关卡本地存储功能
一名开发者
05-10 367
Cocos creator实现《战机长空》关卡本地存储功能Cocos creator在开放小游戏过程中，经常会出现设置关卡，这里记录一下关卡数据本地存储功能。
unity实现3d射箭小游戏
05-27
1. 创建一个射箭场景，包含箭和靶子模型，以及一个射箭起点。 2. 给箭添加一个刚体组件，并通过脚本控制箭的发射方向和速度。 3. 给靶子添加一个刚体组件，并设置靶子的碰撞器。 4. 创建一个UI界面，包含一个计分...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值