作业五

最新推荐文章于 2024-06-21 19:20:27 发布
最新推荐文章于 2024-06-21 19:20:27 发布
阅读量137 收藏
点赞数
文章标签： 3d游戏
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kjhmh2/article/details/102469450
版权

作业五

打飞碟

编写一个简单的鼠标打飞碟（Hit UFO）游戏

要求

  • 游戏有 n 个 round，每个 round 都包括10 次 trial
  1. 每个 trial 的飞碟的色彩、大小、发射位置、速度、角度、同时出现的个数都可能不同。它们由该 round 的 ruler 控制；
  2. 每个 trial 的飞碟有随机性，总体难度随 round 上升；
  3. 鼠标点中得分，得分规则按色彩、大小、速度不同计算，规则可自由设定。
  • 使用带缓存的工厂模式管理不同飞碟的生产与回收，该工厂必须是场景单实例的！
  • 近可能使用前面 MVC 结构实现人机交互与游戏模型分离

代码结构

还是采用MVC结构，具体可参考牧师与魔鬼的制作，本次主要是利用工厂模式完成不同飞碟的生产和回收。
在这里插入图片描述

代码说明

本次的核心代码主要是Disk和DiskFactory两部分，利用工厂模式来控制物体的产生和复用
对于Disk的实现，我们主要是定义其的属性以及相对应的get和set方法：

public class Disk : MonoBehaviour
{
    public Vector3 StartPoint
    {
        get
        {
            return gameObject.transform.position;
        }
        set
        {
            gameObject.transform.position = value;
        }
    }

    public Vector3 Direction
    {
        get
        {
            return Direction;
        }
        set
        {
            gameObject.transform.Rotate(value);
        }
    }

    public Color color
    {
        get
        {
            return gameObject.GetComponent<Renderer>().material.color;
        }
        set
        {
            gameObject.GetComponent<Renderer>().material.color = value;
        }
    }

    public float speed { get; set; }
}

对于DiskFactory，也就是Disk的制造工厂，屏蔽了生产和销毁的业务逻辑，只讲使用的结构提供给用户，使程序易于扩展。在代码中，我们还让DiskFactory负责在生产Disk时随机指定起始位置，方向，速度，颜色

public class DiskFactory
{
    public GameObject diskPrefab;
    public static DiskFactory DF = new DiskFactory();

    private Dictionary<int, Disk> used = new Dictionary<int, Disk>();
    private List<Disk> free = new List<Disk>();

    private DiskFactory()
    {
        diskPrefab = GameObject.Instantiate<GameObject>(Resources.Load<GameObject>("Prefabs/Disk"));
        diskPrefab.AddComponent<Disk>();
        diskPrefab.SetActive(false);
    }

    public void FreeDisk()
    {
        foreach (Disk x in used.Values)
        {
            if (x.gameObject.activeSelf == false)
            {
                free.Add(x);
                used.Remove(x.GetInstanceID());
                return;
            }
        }
    }

    public Disk GetDisk(int round)
    {

        FreeDisk();
        GameObject newObject = null;
        Disk newDisk;
        if (free.Count > 0)
        {
            newObject = free[0].gameObject;
            free.Remove(free[0]);
        }
        else
            newObject = GameObject.Instantiate<GameObject>(diskPrefab, Vector3.zero, Quaternion.identity);
        newObject.SetActive(true);
        newDisk = newObject.AddComponent<Disk>();

        int swith;


        float s;
        if (round == 1)
        {
            swith = Random.Range(0, 3);
            s = Random.Range(30, 40);
        }
        else if (round == 2)
        {
            swith = Random.Range(0, 4);
            s = Random.Range(40, 50);
        }
        else
        {
            swith = Random.Range(0, 6);
            s = Random.Range(50, 60);
        }

        float PointX = UnityEngine.Random.Range(-1f, 1f) < 0 ? -1 : 1;
        newDisk.Direction = new Vector3(PointX, 1, 0);
        switch (swith)
        {
            case 0:
                newDisk.color = Color.yellow;
                newDisk.speed = s;
                newDisk.StartPoint = new Vector3(Random.Range(-130, -110), Random.Range(30, 90), Random.Range(110, 140));
                break;
            case 1:
                // ...
            case 2:
                // ...
            case 3:
                // ...
            case 4:
                // ...
            case 5:
                // ...
        }
        used.Add(newDisk.GetInstanceID(), newDisk);
        newDisk.name = newDisk.GetInstanceID().ToString();
        return newDisk;
    }
}

在运动分离部分，主要的修改就是重写CCMoveToAction，不同于牧师和魔鬼的上船下船，这里的运动更加简单，只需要让Disk做类似有水平初速自由落体的运动即可。

public class CCMoveToAction : SSAction
{
    public float speedx;
    public float speedy = 0;

    private CCMoveToAction() {}

    public static CCMoveToAction getAction(float speedx)
    {
        CCMoveToAction action = CreateInstance<CCMoveToAction>();
        action.speedx = speedx;
        return action;
    }

    public override void Start() {}

    public override void Update()
    {
        this.transform.position += new Vector3(speedx * Time.deltaTime, -speedy * Time.deltaTime + (float)-0.5 * 10 * Time.deltaTime * Time.deltaTime, 0);
        speedy += 10 * Time.deltaTime;
        if (transform.position.z == -1)
        {
            Debug.Log("Hit");
            destroy = true;
            CallBack.SSActionCallback(this, true);
        }
        else if (transform.position.y <= -45)
        {
            Debug.Log("Missing");
            destroy = true;
            CallBack.SSActionCallback(this, false);
        }
    }
}

运动管理类CCActionManager：

public class CCActionManager : SSActionManager, SSActionCallback
{
    int count = 0;
    public SSActionEventType Complete = SSActionEventType.Completed;
    UserAction UserActionController;

    public void MoveDisk(Disk Disk)
    {
        count ++;
        Complete = SSActionEventType.Started;
        CCMoveToAction action = CCMoveToAction.getAction(Disk.speed);
        addAction(Disk.gameObject, action, this);
    }

    public void SSActionCallback(SSAction source, bool isHit)
    {
        count --;
        Complete = SSActionEventType.Completed;
        UserActionController = SSDirector.getInstance().currentScenceController as UserAction;
        if (!isHit)
        {
            UserActionController.ReduceHealth();
        }
        source.gameObject.SetActive(false);
    }

    public bool IsAllFinished()
    {
        Debug.Log("isALLFInished");
        if (count == 0)
            return true;
        else return false;
    }
}

在SSAction类中，还是和牧师与魔鬼差不多的写法：

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

    public GameObject gameObject;
    public Transform transform;
    public SSActionCallback CallBack;

    public virtual void Start()
    {
        throw new System.NotImplementedException();
    }

    public virtual void Update()
    {
        throw new System.NotImplementedException();
    }
}

在SSActionManager类中，我们需要注意的是，一次性可能会有很多个飞碟在一起移动，所以我们实现了三个数据结构，一个等待的队列让每个新飞碟动作等待被调用，一个字典让每个飞碟运动的id和对应的action进行对应，每次进行遍历来调用其中的update函数实现飞碟的运动。最后是等待被删除的队列，当飞碟被击中或者移动出边界我们就让这个飞碟入队，等待执行销毁。至于判断游戏结束以及游戏结束之后的处理，我们下面再讲述。

public class SSActionManager : MonoBehaviour
{
    private Dictionary<int, SSAction> actions = new Dictionary<int, SSAction>();
    private List<SSAction> waitingToAdd = new List<SSAction>();
    private List<int> watingToDelete = new List<int>();
    UserAction UserActionController;

    private void Start()
    {
        UserActionController = SSDirector.getInstance().currentScenceController as UserAction;
    }

    protected void Update()
    {
        if (UserActionController.GetHealth() <= 0)
        {
            foreach (KeyValuePair<int, SSAction> kv in actions)
            {
                SSAction ac = kv.Value;
                ac.gameObject.transform.position = new Vector3(0, -5, 0);
                watingToDelete.Add(ac.GetInstanceID());
            }
            foreach (int key in watingToDelete)
            {
                SSAction ac = actions[key];
                actions.Remove(key);
                Object.Destroy(ac);
            }
            watingToDelete.Clear();
            return;
        }

        foreach (SSAction ac in waitingToAdd)
        {
            actions[ac.GetInstanceID()] = ac;
        }
        waitingToAdd.Clear();

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

        foreach (int key in watingToDelete)
        {
            SSAction ac = actions[key];
            actions.Remove(key);
            Object.Destroy(ac);
        }
        watingToDelete.Clear();
    }

    public void addAction(GameObject gameObject, SSAction action, SSActionCallback ICallBack)
    {
        action.gameObject = gameObject;
        action.transform = gameObject.transform;
        action.CallBack = ICallBack;
        waitingToAdd.Add(action);
        action.Start();
    }
}

接口空间如下所示：

namespace Interfaces
{
    public interface ISceneController
    {
        void LoadResources();
    }

    public interface UserAction
    {
        void Hit(Vector3 pos);
        int GetScore();
        int GetRound();
        int GetHealth();
        void ReduceHealth();
        void GameOver();
        bool RoundStop();
        void Restart();
    }

    public enum SSActionEventType : int { Started, Completed }

    public interface SSActionCallback
    {
        void SSActionCallback(SSAction source, bool isHit);
    }
}

最后我们重写场记，导演和之前是一样的，可以参考牧师与魔鬼的导演，这里就不再列出。

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

public class FirstSceneController : MonoBehaviour, ISceneController, UserAction
{
    int score = 0;
    int round = 1;
    int tral = 0;
    int health = 5;
    bool start = false;
    bool gameOver = false;
    CCActionManager Manager;
    DiskFactory DF;

    void Awake()
    {
        SSDirector director = SSDirector.getInstance();
        director.currentScenceController = this;
        DF = DiskFactory.DF;
        Manager = GetComponent<CCActionManager>();
    }

    // Use this for initialization
    void Start()
    {

    }

    // Update is called once per frame
    int count = 0;
    void Update()
    {
        if (health <= 0)
            gameOver = true;
        if (gameOver)
            return;
        if (start == true)
        {
            count ++;
            if (count >= 80)
            {
                count = 0;

                if (DF == null)
                {
                    Debug.LogWarning("DF is NUll!");
                    return;
                }
                tral ++;
                Disk d = DF.GetDisk(round);
                Manager.MoveDisk(d);
                if (tral == 10)
                {
                    round ++;
                    tral = 0;
                }
            }
        }
    }

    public void LoadResources()
    {

    }

    public void Hit(Vector3 pos)
    {
        Ray ray = Camera.main.ScreenPointToRay(pos);
        RaycastHit[] hits;
        hits = Physics.RaycastAll(ray);
        for (int i = 0; i < hits.Length; i ++)
        {
            RaycastHit hit = hits[i];

            if (hit.collider.gameObject.GetComponent<Disk>() != null)
            {
                Color c = hit.collider.gameObject.GetComponent<Renderer>().material.color;
                if (c == Color.yellow)
                    score += 1;
                if (c == Color.red)
                    score += 2;
                if (c == Color.black)
                    score += 3;
                GameObject explosion = Instantiate(Resources.Load<GameObject>("Prefabs/ParticleSystem"), hit.collider.gameObject.transform.position, Quaternion.identity);
                explosion.GetComponent<ParticleSystem>().Play();
                Object.Destroy(explosion, 0.1f);
                hit.collider.gameObject.transform.position = new Vector3(0, -400, -1);
            }
        }
    }

    public int GetScore()
    {
        return score;
    }

    public int GetRound()
    {
        return round;
    }

    public int GetHealth()
    {
        return health;
    }

    public void ReduceHealth()
    {
        health -= 1;
        if (health < 0)
            health = 0;
    }

    public void GameOver()
    {
        gameOver = true;
    }

    public bool RoundStop()
    {
        if (round > 3 || health <= 0)
        {
            start = false;
            return Manager.IsAllFinished();
        }
        else
            return false;
    }

    public void Restart()
    {
        score = 0;
        round = 1;
        health = 5;
        start = true;
        gameOver = false;
    }
}

还有一个比较细节的部分是，当生命值为0了之后，此时屏幕上可能还会有正在移动的飞碟，如果我们不对它们进行处理，可能会影响到下一句的游戏，这不是我们所希望的。所以我们判断到游戏结束之后，要在SSActionManager类中将所有飞碟移出屏幕并且清空其动作。再次重新开始游戏的时候就不会影响到下一局的游戏了。
在界面交互部分。可以根据自己的喜爱进行调整：

public class InterfaceGUI : MonoBehaviour
{
    UserAction UserActionController;
    public GameObject t;
    bool isStart = false;
    bool gameOver = false;
    float S;
    float Now;
    int round = 1;

    // Use this for initialization
    void Start()
    {
        UserActionController = SSDirector.getInstance().currentScenceController as UserAction;
        S = Time.time;
    }

    private void OnGUI()
    {
        if (gameOver)
        {
            isStart = false;
            GUI.Label(new Rect(Screen.width / 2 - 30, Screen.height / 2 - 50, 100, 20), "GameOver!");
            if (GUI.Button(new Rect(Screen.width / 2 - 50, Screen.height / 2 - 30, 100, 50), "Confirm"))
            {
                gameOver = false;
                return;
            }
            return;
        }

        if (!isStart)
            S = Time.time;
        GUI.Label(new Rect(10, 10, 200, 20), "Time:  " + ((int)(Time.time - S)).ToString());
        GUI.Label(new Rect(10, 30, 200, 20), "Round:  " + round);
        GUI.Label(new Rect(10, 50, 200, 20), "Score: " + UserActionController.GetScore().ToString());
        GUI.Label(new Rect(10, 70, 200, 20), "Health:  " + UserActionController.GetHealth().ToString());

        if (!isStart && GUI.Button(new Rect(Screen.width / 2 - 50, Screen.height / 2 - 30, 100, 50), "Start"))
        {
            S = Time.time;
            isStart = true;
            UserActionController.Restart();
        }

        if (isStart)
        {
            round = UserActionController.GetRound();
            if (Input.GetButtonDown("Fire1"))
            {
                Vector3 pos = Input.mousePosition;
                UserActionController.Hit(pos);
            }
            if (round > 3)
            {
                round = 3;
                if (UserActionController.RoundStop())
                {
                    isStart = false;
                }
            }
        }

        if (isStart && UserActionController.GetHealth() == 0)
        {
            gameOver = true;
        }
    }
}

实现效果

我们为了效果好看，也加入了天空盒。
在这里插入图片描述
我们还利用了粒子效果模拟打中飞碟之后的爆炸效果，这需要我们预制一个Particle System，在GameObject -> Effects里进行添加，然后设置粒子的数量以及容器的模样，并在代码中设置0.1s之后自动销毁：

GameObject explosion = Instantiate(Resources.Load<GameObject>("Prefabs/ParticleSystem"), hit.collider.gameObject.transform.position, Quaternion.identity);
explosion.GetComponent<ParticleSystem>().Play();
Object.Destroy(explosion, 0.1f);

最终的效果如下：
在这里插入图片描述

在这里插入图片描述

编写一个简单的自定义组件

用自定义组件定义几种飞碟，做成预制：
第一种比较简单的方法是直接将属性设置成public，然后就可以在菜单中找到对应的，比如官方文档给的一个例子：

using UnityEngine;
using System.Collections;

// This is not an editor script.
public class MyPlayer : MonoBehaviour
{
    public int armor = 75;
    public int damage = 25;
    public GameObject gun;

    void Update()
    {
        // Update logic here...
    }
}

这样我们就能够直接在菜单中设置armor，damage，gun三种属性了：
在这里插入图片描述
这里也可以使用Editor的方式，比如将飞碟的颜色属性加入到组件里面去：

using UnityEngine;
using UnityEditor;
using System.Collections;

[CustomEditor(typeof(Disk))]
public class DiskEditor : Editor
{
    private Disk _target { get { return target as Disk; } }

    public override void OnInspectorGUI()
    {
        _target.color = EditorGUILayout.ColorField(new GUIContent("ColorValue"), _target.color);
    }
}

一个比较全面的属性设置如下所示。
我们定义的变量类型可以如下：

public int intValue;
public float floatValue;
public string stringValue;
public bool boolValue;
public Vector3  vector3Value; 
public Course enumValue = Course.Chinese;
public Color colorValue = Color.white;
public Texture textureValue;

在Editor文件中，各种类型的变量添加组件的方式：

_target.intValue = EditorGUILayout.IntField("IntValue", _target.intValue);
_target.floatValue = EditorGUILayout.FloatField("FloatValue", _target.floatValue);
_target.stringValue = EditorGUILayout.TextField("StringValue", _target.stringValue);
_target.boolValue = EditorGUILayout.Toggle("BoolValue", _target.boolValue);
_target.vector3Value = EditorGUILayout.Vector3Field("Vector3Value", _target.vector3Value);
_target.enumValue = (Course)EditorGUILayout.EnumPopup("EnumValue", (Course)_target.enumValue);
_target.colorValue = EditorGUILayout.ColorField(new GUIContent("ColorValue"), _target.colorValue);
_target.textureValue = (Texture)EditorGUILayout.ObjectField("TextureValue", _target.textureValue, typeof(Texture), true);
kjhmh2
关注
课后作业5：进程的同步与互斥
Junds0的博客
05-25 1231
第1关：生产者与消费者问题 本关任务：程序 4-1.c 模拟了 1 个生产者和 1 个消费者，请改写该程序，模拟 5 个生产者和 5 个消费者，它们共享一个包含 8 个缓冲区的缓冲池。产品以 4 位编号，最高位表示生产者编号、其他表示该生产者的产品号 #include <stdio.h> #include <stdlib.h> #include <time.h> #include <unistd.h> #include <pthread.
Games101：作业5解析
Q_pril的博客
03-29 5486
目录 作业要求 Render() rayTriangleIntersect() 参考链接 作业要求 在这部分的课程中，我们将专注于使用光线追踪来渲染图像。在光线追踪中最重要的操作之一就是找到光线与物体的交点。一旦找到光线与物体的交点，就可以执行着色并返回像素颜色。在这次作业中，我们需要实现两个部分：光线的生成和光线与三角的相交。 本次代码框架的工作流程为： 1. 从 main 函数开始。我们定义场景的参数，添加物体（球体或三角形）到场景中，并设置其材...
GAMES101:作业5
qq_41765657的博客
12-09 3939
games101 作业5 ray tracing 光线追踪 - 这里的过程实际上相当于把屏幕空间先缩小到左下角为0，0的2*2格子里，然后移动到0，0处。 - 和框架规定有关，作业一直有上下颠倒的问题，这里面可以在y填一个负号来解决。 - 最后乘的系数是生成图片的大小
李宏毅2021年机器学习作业5（Seq2seq）实验记录
求算法实习
11-18 2753
李宏毅2021年机器学习作业5学习笔记前言一、问题描述二、实验过程2.1 基于RNN2.2 基于Transformer三、总结 前言 声明：本文参考了李宏毅机器学习2021年作业例程，开发平台是colab。 一、问题描述 机器翻译 B站作业讲解视频 Colab地址 二、实验过程 2.1 基于RNN 操作：直接跑原代码就可以 中途意外：跑程序时中途断开连接了，再跑就分配不到GPU了。 训练时间：6小时 2.2 基于Transformer 操作：在代码里把Transformer部分注释取消注释，然后
李宏毅2021春机器学习作业5代码理解
liushaozhuanyong的博客
10-07 956
李宏毅2021春机器学习作业5代码理解
操作系统第五次作业
weixin_51061782的博客
11-04 3573
I/O通道控制通道控制进一步减轻了CPU的工作负担，增加了计算机系统的并行工作程度。把CPU从繁琐的输入/输出操作中解放出来。采用通道技术后，不仅能实现CPU和通道的并行操作，而且通道与通道之间也能实现并行操作，各通道上的外设也能实现并行操作，从而可提高整个系统的效率。静态分配：对独占型设备一般采用静态分配，即在作业级进行的分配，当一个作业运行之前由系统一次分配满足需要的全部设备，这些设备一直为该作业占用，直到作业撤消。这种分配不会出现死锁，但设备的利用效率较低。
一个简单的网页设计HTML5作业
好好读书
06-26 9万+
简单的html设计作业，初次学习，希望指正！
作业管理系统
热门推荐
WEN38306482的博客
06-21 10万+
随着网络的发展，信息化时代的到来，在教学工作的过程中作用越来越明显，作业的及时发布，学生的及时提交，以及通过网上的批改和评分，都大大促进教学质量的发展，充分的利用网络来加强管理，扩展教育模式，增强作业的教学价值，是信息化教学的重大进步，在实际工作中有着重大的现实意义。学生作业管理系统将作业的上交、作业的下载、作业的发布、作业的查询以及信息的维护集于一体，使学校的学生作业管理更加规范化。教师登录系统后，可以对首页、学生管理、教师管理、班级管理、课程管理、题库管理、作业管理等功能进行相应操作，如图5-2所示。
自考java分数比_自考成绩作业5是什么意思每个考生的分数都是这样吗
weixin_30172941的博客
02-28 1701
如今大家把自己的学历看得越来越重，只有自己的学历够高才能有晋升的资格，知识永远是学不完的，不要沾沾自喜目前已有的水平，这还不足以支撑我们走的更远。有很多考生在参加了自学考试之后查询成绩的时候发现有个作业5，这时大家就疑惑了，这个分数是每个考生都有的吗？自考成绩作业5是指平时的作业分，但是这并不是说每个考生都有这个成绩，只有些特殊的专业，学校会步骤课后作业的考生才能有这部分的成绩，因此和其他的考生是...
Python第五章作业
m0_70456205的博客
04-05 2万+
【代码】Python第五章作业。第1关回文素；第2关反素数；...第16关单词个数
作业5
03-14
作业5
网页制作的期末作业 五个静态页面
06-19
在这个案例中，学生提交的作业包含了五个静态页面，这意味着他们可能已经学习了网页设计的基本概念，并尝试将这些知识应用到实际项目中。下面我们将深入探讨这些关键知识点。 1. HTML（HyperText Markup Language）...
五年级暑假作业布置.pdf
09-26
针对五年级的学生，暑假作业的布置旨在巩固已学知识，预习新学期的内容，同时培养良好的学习习惯和兴趣。以下是五年级暑假作业的具体内容和相关知识点的详细说明： 一、语文 1. 《窦桂梅教你阅读》：这本书是提高...
设计模式期末作业（要求5个以上的设计模式的模拟系统）
01-24
这是我的设计模式作业：运用5个以上的设计模式创建一个系统。其中包括：1.单例模式 2.原型模式 3.抽象工厂模式+模板方法模式 4.代理模式 5.策略模式 详见博文：...
MiniGui业务开发基础培训-htk
最新发布
11-11
MiniGui业务开发基础培训-htk
com.harmonyos.exception.DiskReadWriteException(解决方案).md
11-11
鸿蒙开发中碰到的报错，问题已解决，写个文档记录一下这个问题及解决方案
网络分析-Wireshark数据包筛选技巧详解及应用实例
11-11
内容概要：本文档详细介绍了Wireshark软件中各种数据包筛选规则，主要包括协议、IP地址、端口号、包长以及MAC地址等多个维度的具体筛选方法。同时提供了大量实用案例供读者学习，涵盖HTTP协议相关命令和逻辑条件的综合使用方式。 适合人群：对网络安全或数据分析有一定兴趣的研究者，熟悉基本网络概念和技术的专业人士。 使用场景及目标：适用于需要快速准确捕获特定类型网络流量的情况；如网络安全检测、性能优化分析、教学演示等多种实际应用场景。 阅读建议：本资料侧重于实操技能提升，在学习时最好配合实际操作练习效果更佳。注意掌握不同类型条件组合的高级用法，增强问题解决能力。
com.harmonyos.exception.BatteryOverheatException(解决方案).md
11-11
鸿蒙开发中碰到的报错，问题已解决，写个文档记录一下这个问题及解决方案
com.harmonyos.exception.ServiceUnavailableException(解决方案).md
11-11
鸿蒙开发中碰到的报错，问题已解决，写个文档记录一下这个问题及解决方案
使用python中streamlit包报错2023-05-31 12:29:06.534 Warning: to view this Streamlit app on a browser, run it with the following command: streamlit run D:/BaiduNetdiskDownload/BaiduNetdiskDownload/数据可视化课/作业567/作业五/作业5.py [ARGUMENTS]
06-01
streamlit run D:/BaiduNetdiskDownload/BaiduNetdiskDownload/数据可视化课/作业567/作业五/作业5.py [ARGUMENTS] ``` 其中，`D:/BaiduNetdiskDownload/BaiduNetdiskDownload/数据可视化课/作业567/作业五/作业5....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值