Unity类银河战士恶魔城学习总结(P103之前 Skill相关,技能和技能控制器)

关于类银河战士恶魔城游戏中角色控制的简单实现(unity) 1.类银河战士恶魔城游戏类型简述 类银河战士恶魔城游戏采用的是2D的表现手法,这种融合了2D横版过关、探索、解谜、RPG等等元素组合成的游戏品类,它与普通的2D横版卷轴向的游戏最大的区别在于类银河战士恶魔城的游戏进程属于非线性的,玩家会在同一个时间点会有许多不同的区域可以探索。 2.场景 在unity中,我们可以采用2D或者3D的形式来搭建场景; 2D或者是3D各有各的好处,但如果使用3D场景来做,要注意角色和物品的碰撞器和刚体组件等需采用2D的,为的是减少后续bug的产生。 3.角色移动 阅读详情

【Unity教程】从0编程制作类银河恶魔城游戏_哔哩哔哩_bilibili

教程源地址:https://www.udemy.com/course/2d-rpg-alexdev/

udemy的Alex银河战士恶魔城,记录我自己的学习,代码会逐渐每一p更新,仅供参考学习

Skill

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

public class Skill : MonoBehaviour
{
    [SerializeField] protected float cooldown;
    protected float cooldownTimer;

    protected Player player;

    protected virtual void Start()
    {
        player = PlayerManager.instance.player;
    }

    protected virtual void Update()
    {
        cooldownTimer -= Time.deltaTime;
    }

    public virtual bool CanUseSkill()
    {
        if (cooldownTimer < 0)
        {
            UseSkill();
            cooldownTimer = cooldown;
            return true;
        }
        else
        {
            Debug.Log("Skill is on cooldown");
            return false;
        }
    }

    public virtual void UseSkill()
    {
        //放技能
    }

    protected virtual Transform FindClosesetEnemy(Transform _checkTransform)//寻找附近的敌人,返回最近的敌人
    {

        Collider2D[] colliders = Physics2D.OverlapCircleAll(_checkTransform.position, 25);//碰撞体检测周围的敌人

        float closestDistance = Mathf.Infinity;
        Transform closestEnemy = null;

        foreach (var hit in colliders)
        {
            if (hit.GetComponent<Enemy>() != null)
            {
                float distanceToEnemy = Vector2.Distance(_checkTransform.position, hit.transform.position);

                if (distanceToEnemy < closestDistance)
                {
                    closestDistance = distanceToEnemy;
                    closestEnemy = hit.transform;
                }
            }
        }

        return closestEnemy;
    }

}

SkillManager

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

public class SkillManager : MonoBehaviour
{
    public static SkillManager instance;

    public Dash_Skill dash{ get; private set; }
    public Clone_Skill clone { get; private set; }
    public Sword_Skill sword { get; private set; }
    public Blackhole_Skill blackhole { get; private set; }
    public Crystal_Skill crystal { get; private set; }    

    private void Awake()
    {
        if (instance != null)
            Destroy(instance.gameObject);
        else
            instance = this;
    }

    private void Start()
    {
        dash = GetComponent<Dash_Skill>();
        clone = GetComponent<Clone_Skill>();
        sword = GetComponent<Sword_Skill>();
        blackhole = GetComponent<Blackhole_Skill>();
        crystal = GetComponent<Crystal_Skill>();//获取组件才能发挥功能啊
    }
}

Dash_Skill冲刺技能

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

public class Dash_Skill : Skill
{
    public override void UseSkill()
    {
        base.UseSkill();

        Debug.Log("clone");
    }
}

Clone克隆技能

Clone_Skill

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

public class Clone_Skill : Skill
{
    [Header("Clone Info")]
    [SerializeField] private GameObject clonePrefab;//克隆原型
    [SerializeField] private float cloneDuration;//克隆持续时间
    [SerializeField] private bool canAttack;// 判断是否可以攻击

    [SerializeField] private bool createCloneOnDashStart;//在冲刺开始时创建克隆
    [SerializeField] private bool createCloneOnDashOver;//在冲刺结束时创建克隆
    [SerializeField] private bool canCreateCloneOnCounterAttack;

    [Header("Clone can Duplicate")]
    [SerializeField] private bool canDuplicateClone;//可以重复clone
    [SerializeField] private float chanceToDuplicate;//重复clone的几率
    [Header("Crystal instead of clone")]
    public bool crystalInsteadOfClone;//是否使用水晶代替克隆


    public void CreateClone(Transform _clonePosition,Vector3 _offset)//传入克隆位置
    {
        

        if(crystalInsteadOfClone)//克隆转换成水晶
        {
            SkillManager.instance.crystal.CreateCrystal();
            SkillManager.instance.crystal.CurrentCrystalChooseRandomTarget();
            return;
        }


        GameObject newClone = Instantiate(clonePrefab);//创建新的克隆//克隆 original 对象并返回克隆对象。
                                                       

        newClone.GetComponent<Clone_Skill_Controller>().
            SetupClone(_clonePosition, cloneDuration, canAttack,_offset,FindClosesetEnemy(newClone.transform),canDuplicateClone, chanceToDuplicate,player);
        
    }

    public void CreateCloneOnDashStart()
    {
        if(createCloneOnDashStart)
            CreateClone(player.transform, Vector3.zero);
    }

    public void CreateCloneOnDashOver()
    {
        if (createCloneOnDashOver)
            CreateClone(player.transform, Vector3.zero);
    }
    
    public void CreateCloneOnCounterAttack(Transform _enemyTransform)
    {
        if(canCreateCloneOnCounterAttack)
            StartCoroutine(CreateCloneWithDelay(_enemyTransform, new Vector3(2 * player.facingDir, 0)));
    }

    private IEnumerator CreateCloneWithDelay(Transform _transform,Vector3 _offset)
    {
        yield return new WaitForSeconds(.4f);
            CreateClone(_transform, _offset);
    }

}

Clone_Skill_Controller

using UnityEngine;

//P65克隆控制

public class Clone_Skill_Controller : MonoBehaviour
{
    private Player player;
    private SpriteRenderer sr;
    private Animator anim;
    [SerializeField] private float cloneLosingSpeed;//加速消失时间

    private float cloneTimer;
    [SerializeField] private Transform attackCheck;
    [SerializeField] private float attackCheckRadius = .8f;
    private Transform closestEnemy;
    private int facingDir=1;
    private bool canDuplicateClone;
    private float chanceToDuplicate;



    private void Awake()
    {
        sr = GetComponent<SpriteRenderer>();
        anim = GetComponent<Animator>();
    }


    private void Update()
    {
        cloneTimer -= Time.deltaTime;

        if (cloneTimer < 0)
        {
            sr.color = new Color(1, 1, 1, sr.color.a - (Time.deltaTime * cloneLosingSpeed));//逐渐消失

            if (sr.color.a < 0)
                Destroy(gameObject);//当透明度小于等于0时销毁克隆体
        }
    }


    public void SetupClone(Transform _newTransform, float _cloneDuration, bool _canAttack, Vector3 _offset, Transform _closetEnemy,bool _canDuplicate,float _chanceToDuplicate,Player _player)
    {
        if (_canAttack)
        {
            anim.SetInteger("AttackNumber", Random.Range(1, 3));//随机clone攻击的动画
        }

        //Debug.Log($"Setting clone position to: {_newTransform.position}");

        player = _player;
        transform.position = _newTransform.position + _offset;//将克隆体的位置设置为传入的位置
        cloneTimer = _cloneDuration;//设置克隆体的持续时间

        closestEnemy = _closetEnemy;
        canDuplicateClone = _canDuplicate;
        chanceToDuplicate = _chanceToDuplicate;
        FaceClosestTarget();
    }


    private void AnimationTrigger()
    {
        cloneTimer = -.1f;
    }

    private void AttackTrigger()//攻击碰撞触发函数
    {
        Collider2D[] colliders = Physics2D.OverlapCircleAll(attackCheck.position, attackCheckRadius);//这行代码在 Unity 中用于检测一个圆形区域内的所有碰撞体,并返回它们的数组。

        foreach (var hit in colliders)//for循环遍历碰撞体数组
        {
            if (hit.GetComponent<Enemy>() != null)
            {
                player.stats.DoDamage(hit.GetComponent<CharacterStats>());

                //hit.GetComponent<Enemy>().DamageImpact();

                if (canDuplicateClone)//如果可以多重影分身
                {
                    if (Random.Range(0, 100) <= chanceToDuplicate)
                    {
                        SkillManager.instance.clone.CreateClone(hit.transform,new Vector3(.5f*facingDir,0));//在敌人身上创建克隆
                    }
                }
            }
        }
    }

    private void FaceClosestTarget()//面对最近的目标函数
    {

        if (closestEnemy != null)
        {
            if (transform.position.x > closestEnemy.position.x)
            {
                facingDir = -1;
                transform.Rotate(0, 180, 0);
            }
        }

    }
}

SwordSkill仍刀技能组

Sword_Skill

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
//P67仍刀技能

public enum SwordType//刀的类型,枚举(enum)是一种特殊的数据类型,它允许你为一组相关的常量赋予有意义的名称。这样可以提高代码的可读性和可维护性。
{
    Regular,//常规
    Bounce,//反弹
    Pierce,//穿透
    Spin//旋转
}



public class Sword_Skill : Skill
{
    public SwordType swordType = SwordType.Regular;//刀的类型

    [Header("Bounce info")]
    [SerializeField] private int bounceAmount;//反弹次数
    [SerializeField] private float bounceGravity;//反弹速度
    [SerializeField] private float bounceSpeed;

    [Header("Peirce info")]
    [SerializeField] private int pierceAmount;//穿透次数
    [SerializeField] private float pierceGravity;//穿透速度

    [Header("Spin info")]
    [SerializeField] private float hitCooldown = .35f;//击中冷却
    [SerializeField] private float maxTravelDistance = 7;//最大旋转距离
    [SerializeField] private float spinDuration = 2;//旋转持续时间
    [SerializeField] private float spinGravity = 1;//旋转重力

    [Header("Skill info")]
    [SerializeField] private GameObject swordPrefab;//飞行物体
    [SerializeField] private Vector2 launchForce;//飞行方向
    [SerializeField] private float swordGravity;//飞行重力
    [SerializeField] private float freezeTimeDuration;//冻结时间
    [SerializeField] private float returnSpeed ;


    private Vector2 finalDir;

    [Header("Anim dots")]
    [SerializeField] private int numberOfDots;
    [SerializeField] private float spaceBetweenDots;
    [SerializeField] private GameObject dotPrefab;
    [SerializeField] private Transform dotsParent;

    private GameObject[] dots;

    protected override void Start()
    {
        base.Start();

        GenerateDots();

        SetupGravity();
    }

    public void SetupGravity()
    {
        if (swordType == SwordType.Bounce)
            swordGravity = bounceGravity;
        else if (swordType == SwordType.Pierce)
            swordGravity = pierceGravity;
        else if (swordType == SwordType.Spin)
            swordGravity = spinGravity;

    }




    protected override void Update()
    {
        if (Input.GetKeyUp(KeyCode.Mouse1))
            finalDir = new Vector2(AimDirection().normalized.x * launchForce.x, AimDirection().normalized.y * launchForce.y);

        if (Input.GetKey(KeyCode.Mouse1))
        {
            for (int i = 0; i < dots.Length; i++)
            {

                dots[i].transform.position = DotsPosition(i * spaceBetweenDots);
            }
        }
    }


    public void CreateSword()
    {
        GameObject newSword = Instantiate(swordPrefab, player.transform.position, transform.rotation);//获取物体,位置,旋转,它可以根据现有的预制件(Prefab)、场景中的对象或其他资源来生成新的实例
        Sword_Skill_Controller newSwordScript = newSword.GetComponent<Sword_Skill_Controller>();


        if (swordType == SwordType.Bounce)
            newSwordScript.SetupBounce(true, bounceAmount, bounceSpeed);
        else if (swordType == SwordType.Pierce)
            newSwordScript.SetupPierce(pierceAmount);
        else if (swordType == SwordType.Spin)
            newSwordScript.SetupSpin(true, maxTravelDistance, spinDuration, hitCooldown);





        newSwordScript.SetupSword(finalDir, swordGravity, player,freezeTimeDuration, returnSpeed);

        player.AssignNewSword(newSword);

        DotsActive(false);
    }


    #region Aim region
    public Vector2 AimDirection()//瞄准方向
    {
        Vector2 playerPosition = player.transform.position;
        Vector2 mousePosition = Camera.main.ScreenToWorldPoint(Input.mousePosition);
        Vector2 direction = mousePosition - playerPosition;//两者相减就是瞄准方向

        return direction;

    }

    public void DotsActive(bool _isActive)
    {
        for (int i = 0; i < dots.Length; i++)
        {
            dots[i].SetActive(_isActive);
        }
    }

    private void GenerateDots()
    {
        dots = new GameObject[numberOfDots];
        for (int i = 0; i < numberOfDots; i++)
        {
            dots[i] = Instantiate(dotPrefab, player.transform.position, Quaternion.identity, dotsParent);
            dots[i].SetActive(false);
        }
    }

    private Vector2 DotsPosition(float t)//传入顺序相关的点间距
    {
        Vector2 position = (Vector2)player.transform.position + new Vector2
            (AimDirection().normalized.x * launchForce.x,
             AimDirection().normalized.y * launchForce.y) * t + .5f * (Physics2D.gravity * swordGravity) * (t * t);
        //t是控制之间点间距的
        return position;//返回位置
    }//设置点间距函数
    #endregion
}

Sword_Skill_Controller

using System.Collections.Generic;
using UnityEngine;

public class Sword_Skill_Controller : MonoBehaviour
{
    
    private Animator anim;
    private Rigidbody2D rb;
    private CircleCollider2D cd;
    private Player player;

    private bool canRotate = true;
    private bool isReturning;

    private float freezeTimeDUration;
    private float returnSpeed = 12;


    [Header("Pierce info")]
    [SerializeField] private int pierceAmount;



    [Header("Bounce info")]
    private float bounceSpeed;// 想通过函数传递删除SerializeField
    private bool isBouncing; // 是否可以反弹
    private int bounceAmount;// 反弹次数
    private List<Transform> enemyTarget;//敌人目标
    private int targetIndex = 0;//目标索引

    [Header("Spin info")]
    private float maxTravelDistance;//最大旋转距离
    private float spinDuration;//旋转持续时间
    private float spinTimer;//旋转计时器
    private bool wasStopped;//是否停止
    private bool isSpinning;//是否旋转

    private float hitTimer;
    private float hitCooldown;

    private float spinDirection;//旋转方向

    //Awake在脚本实例化时立即调用。它在所有对象的Awake方法都被调用完毕后,才会开始调用Start方法。而Start在第一次更新循环之前调用。
    private void Awake()
    {
        anim = GetComponentInChildren<Animator>();
        rb = GetComponent<Rigidbody2D>();
        cd = GetComponent<CircleCollider2D>();
    }

    private void DestroyMe()
    {
        Destroy(gameObject);
    }

    //以下四个函数都是把局部变量传递给全局变量
    public void SetupSword(Vector2 _dir, float _gravityScale, Player _player,float _freezeTimeDUration,float _returnSpeed) //设置飞行物体
    {
        player = _player;
        freezeTimeDUration = _freezeTimeDUration;
        returnSpeed = _returnSpeed;


        rb.velocity = _dir;
        rb.gravityScale = _gravityScale;


        if (pierceAmount <= 0)
            anim.SetBool("Rotation", true);

        spinDirection = Mathf.Clamp(rb.velocity.x, -1, 1);//限制旋转方向在-1到1之间

        Invoke("DestroyMe", 7);//Invoke 是 Unity 中 MonoBehaviour 类的一部分,用于在指定的延迟时间后调用某个方法
    }


    public void SetupBounce(bool _isBouncing, int _amountOfBounces, float _bounceSpeed)//设置反弹
    {
        isBouncing = _isBouncing;
        bounceAmount = _amountOfBounces;
        bounceSpeed = _bounceSpeed;


        enemyTarget = new List<Transform>();//当把上面的public改成private时,系统就不会创建一个空的列表
    }

    public void SetupPierce(int _pierceAmount)//int _pierceAmoun:方法参数
    {
        pierceAmount = _pierceAmount;
    }

    public void SetupSpin(bool _isSpinning, float _maxTravelDistance, float _spinDuration, float _hitCooldown)//设置旋转
    {
        isSpinning = _isSpinning;
        maxTravelDistance = _maxTravelDistance;
        spinDuration = _spinDuration;//,_spinDuration 是一个形式参数
        hitCooldown = _hitCooldown;
    }
    

    public void ReturnSword()
    {
        rb.constraints = RigidbodyConstraints2D.FreezeAll;// 冻结刚体的所有约束
        //rb.isKinematic = false;
        transform.parent = null;
        isReturning = true;
    }




    private void Update()
    {
        if (canRotate)//如果可以旋转
            transform.right = rb.velocity;//设置旋转方向

        if (isReturning)
        {
            transform.position = Vector2.MoveTowards(transform.position, player.transform.position, returnSpeed * Time.deltaTime);//返回到玩家手上

            if (Vector2.Distance(transform.position, player.transform.position) < 1)
                player.CatchTheSword();
        }

        BounceLogic();//反弹逻辑
        SpinLogic();//旋转逻辑
    }

    private void SpinLogic()
    {
        if (isSpinning)
        {
            if (Vector2.Distance(transform.position, player.transform.position) > maxTravelDistance && !wasStopped)//如果距离大于最大旋转距离并且没有停止
            {
                StopWhenSpinning();
            }

            if (wasStopped)//如果停止
            {
                spinTimer -= Time.deltaTime;//计时器减去时间

                transform.position = Vector2.MoveTowards(transform.position,
                                                        new Vector2(transform.position.x + spinDirection, transform.position.y), 1.5f * Time.deltaTime);//移动到旋转方向

                if (spinTimer < 0)
                {
                    isReturning = true;
                    isSpinning = false;
                }

                hitTimer -= Time.deltaTime;

                if (hitTimer < 0)
                {
                    hitTimer = hitCooldown;

                    Collider2D[] colliders = Physics2D.OverlapCircleAll(transform.position, 1);

                    foreach (var hit in colliders)
                    {
                        if (hit.GetComponent<Enemy>() != null)
                        {
                           SwordSkillDamage(hit.GetComponent<Enemy>());
                        }
                    }
                }
            }
        }
    }




    private void StopWhenSpinning()//旋转时候停止
    {
        wasStopped = true;
        rb.constraints = RigidbodyConstraints2D.FreezeAll;
        spinTimer = spinDuration;//旋转计时器
    }

    private void BounceLogic()
    {
        if (isBouncing && enemyTarget.Count > 0)//如果可以反弹并且敌人目标数量大于0
        {
            transform.position = Vector2.MoveTowards(transform.position, enemyTarget[targetIndex].position, bounceSpeed * Time.deltaTime);//移动到敌人

            if (Vector2.Distance(transform.position, enemyTarget[targetIndex].position) < 0.1f)//如果距离小于0.1
            {

                SwordSkillDamage(enemyTarget[targetIndex].GetComponent<Enemy>());//敌人受到伤害
                //enemyTarget[targetIndex].GetComponent<Enemy>().Damage();  
                //enemyTarget[targetIndex].GetComponent<Enemy>().StartCoroutine("FreezeTimerFor", freezeTimeDUration);

                targetIndex++; //敌人目标的索引,攻击了这个敌人就攻击下一个敌人
                bounceAmount--;

                if (bounceAmount <= 0)
                {
                    isBouncing = false;
                    isReturning = true;
                }

                if (targetIndex >= enemyTarget.Count) //如果目标索引大于等于敌人目标数量
                {
                    targetIndex = 0;
                }
            }
        }
    }

    private void OnTriggerEnter2D(Collider2D collision)//Sword碰到敌人时候的处理
    {

        if (isReturning)
            return;//后面的就不会再触发,sword可以返回时候攻击到敌人,并且返回到手上


        if(collision.GetComponent<Enemy>() != null)//如果碰到敌人
        {
            Enemy enemy = collision.GetComponent<Enemy>();//获取敌人
            SwordSkillDamage(enemy);
        }


        SetupTargetsForBounce(collision);

        StuckInto(collision);

    }

    private void SwordSkillDamage(Enemy enemy)
    {
        //enemy.DamageEffect();
        player.stats.DoDamage(enemy.GetComponent<CharacterStats>());
        enemy.StartCoroutine("FreezeTimerFor", freezeTimeDUration);
    }


    private void SetupTargetsForBounce(Collider2D collision)
    {
        if (collision.GetComponent<Enemy>() != null)//碰到敌人
        {
            if (isBouncing && enemyTarget.Count <= 0)//如果可以反弹并且敌人目标数量小于等于0
            {
                Collider2D[] colliders = Physics2D.OverlapCircleAll(transform.position, 10);//获取周围敌人的碰撞体

                foreach (var hit in colliders)//遍历周围敌人的碰撞体
                {
                    if (hit.GetComponent<Enemy>() != null)//如果碰到的是敌人
                    {
                        enemyTarget.Add(hit.transform);//添加到敌人目标
                    }
                }
            }
        }
    }


    private void StuckInto(Collider2D collision)//碰撞时候的处理
    {
        if (pierceAmount > 0 && collision.GetComponent<Enemy>() != null)//如果可以穿透并且碰到敌人
        {
            pierceAmount--;
            return;
        }

        if (isSpinning)
        {
            StopWhenSpinning();//注释掉经过敌人不会停止
            return;
        }

        canRotate = false; // 停止旋转
        cd.enabled = false;// 禁用碰撞体

        rb.isKinematic = true;// 设置刚体为运动学模式
        rb.constraints = RigidbodyConstraints2D.FreezeAll;// 冻结刚体的所有约束

        if (isBouncing && enemyTarget.Count > 0)  // 如果可以反弹并且敌人目标数量大于0
            return;


        anim.SetBool("Rotation", false);
        transform.parent = collision.transform;// 将当前物体设为碰撞对象的子对象,即粘在敌人身上
    }
}

Blackhole黑洞技能

Blackhole_Skill

using UnityEngine;

public class Blackhole_Skill : Skill
{
    [SerializeField] private int amountOfAttacks;
    [SerializeField] private float cloneCooldown;
    [SerializeField] private float blackholeDuration;
    [Space]
    [SerializeField] private GameObject blackHolePrefab;
    [SerializeField] private float maxSize;
    [SerializeField] private float growSpeed;
    [SerializeField] private float shrinkSpeed;

    BlackHole_Skill_Controller currentBlackhole;//当前的黑洞


    public override bool CanUseSkill()
    {
        return base.CanUseSkill();
    }

    public override void UseSkill()
    {
        base.UseSkill();//调用了基类 Skill中的 UseSkill 方法

        GameObject newBlackHole = Instantiate(blackHolePrefab, player.transform.position, Quaternion.identity); //这行代码使用 Instantiate 方法在玩家当前位置生成一个新的黑洞对象

        currentBlackhole = newBlackHole.GetComponent<BlackHole_Skill_Controller>();

        currentBlackhole.SetupBlackhole(maxSize, growSpeed, shrinkSpeed, amountOfAttacks, cloneCooldown,blackholeDuration);//调用SetupBlackhole,传递一系列参数来配置黑洞的行为,包括最大尺寸、增长速度、缩小速度、攻击次数和克隆冷却时间
    }

    protected override void Start()
    {
        base.Start();
    }

    protected override void Update()
    {
        base.Update();
    }

    public bool SkillCompeleted()
    {
        if(!currentBlackhole)
        {
            return false;
        }

        if (currentBlackhole.playerCanExitState)
        {
            currentBlackhole = null;
            return true;
        }

        return false;
    }

    public float GetBlackholeRadius()//解决水晶黑洞的攻击范围问题
    {
        return maxSize / 2;
    }
}

BlackHole_Skill_Controller

using System.Collections.Generic;
using UnityEngine;



//2024年10月22日
public class BlackHole_Skill_Controller : MonoBehaviour
{
    [SerializeField] private GameObject hotkeyPrefab;
    [SerializeField] private List<KeyCode> keyCodeList;

    private float maxSize;
    private float growSpeed;
    private float shrinkSpeed;
    private float blackholeTimer;


    private bool canGrow = true;//换成private进行传递
    private bool canShrink;//= false保险起见我自己添加的
    private bool canCreateHotkeys = true;
    private bool cloneAttackReleased;
    private bool playerCanDisapear = true;//产生黑洞玩家默认消失


    private int amountOfAttacks = 4;
    private float cloneAttackCooldown = .3f;
    private float cloneAttackTimer;


    private List<Transform> targets = new List<Transform>();
    private List<GameObject> createdHotKey = new List<GameObject>();

    public bool playerCanExitState { get; private set; }

    public void SetupBlackhole(float _maxSize, float _growSpeed, float _shrinkSpeed, int _amountOfAttacks, float _cloneAttackCooldown, float _blackholeDuration)
    {
        maxSize = _maxSize;
        growSpeed = _growSpeed;
        shrinkSpeed = _shrinkSpeed;
        amountOfAttacks = _amountOfAttacks;
        cloneAttackCooldown = _cloneAttackCooldown;

        blackholeTimer = _blackholeDuration;

        if (SkillManager.instance.clone.crystalInsteadOfClone)
            playerCanDisapear = false;
    }


    private void Update()
    {
        cloneAttackTimer -= Time.deltaTime;// 修正了这里的时间减少方式
        blackholeTimer -= Time.deltaTime;

        if (blackholeTimer < 0)
        {
            blackholeTimer = Mathf.Infinity;

            if (targets.Count > 0)
                RealseCloneAttack();
            else
                FinishBlackHoleAbility();

        }



        if (Input.GetKeyDown(KeyCode.R))
        {
            RealseCloneAttack();
        }

        CloneAttackLogic();

        if (canGrow && !canShrink)//变大函数
        {
            transform.localScale = Vector2.Lerp(transform.localScale, new Vector2(maxSize, maxSize), growSpeed * Time.deltaTime);//Vector2.Lerp 是 Unity 中的一个插值函数,用于在两个 Vector2 之间进行线性插值。
        }

        if (canShrink)
        {
            transform.localScale = Vector2.Lerp(transform.localScale, new Vector2(-1, 1), shrinkSpeed * Time.deltaTime);

            if (transform.localScale.x < 0)
                Destroy(gameObject);
        }
    }


    private void RealseCloneAttack()
    {
        if (targets.Count <= 0)
            return;

        DestroyHotKeys();
        cloneAttackReleased = true;
        canCreateHotkeys = false;

        if (playerCanDisapear)
        {
            playerCanDisapear = false;
            PlayerManager.instance.player.fx.MakeTransprent(true);
        }
    }

    private void CloneAttackLogic()
    {
        if (cloneAttackTimer < 0 && cloneAttackReleased && amountOfAttacks > 0)//如果时间小于0并且克隆攻击释放并且攻击次数大于0
        {
            cloneAttackTimer = cloneAttackCooldown;

            int randomIndex = Random.Range(0, targets.Count);//随机选择一个敌人

            float xOffset;//随机选择一个偏移量

            if (Random.Range(0, 100) > 50)
                xOffset = 2;
            else
                xOffset = -2;


            if (SkillManager.instance.clone.crystalInsteadOfClone)//如果选择了水晶代替克隆
            {
                SkillManager.instance.crystal.CreateCrystal();
                SkillManager.instance.crystal.CurrentCrystalChooseRandomTarget();//随机选择敌人
            }
            else
            {
                SkillManager.instance.clone.CreateClone(targets[randomIndex], new Vector3(xOffset, 0, 0));
            }

            amountOfAttacks--;

            if (amountOfAttacks <= 0)
            {
                Invoke("FinishBlackHoleAbility", .5f);//延时调用
            }
        }
    }

    private void FinishBlackHoleAbility()
    {
        DestroyHotKeys();
        playerCanExitState = true;
        canShrink = true;
        cloneAttackReleased = false;
    }



    private void OnTriggerEnter2D(Collider2D collision)//碰到敌人把他们加入到targets中
    {
        if (collision.GetComponent<Enemy>() != null)
        {
            collision.GetComponent<Enemy>().FreezeTime(true);

            CreatHotKey(collision);

        }
    }

    private void OnTriggerExit2D(Collider2D collision)//private void ontriggerexit2d(collider2d collision) => collision.getcomponent<enemy>()?.freezetime(false);
    {
        if (collision.GetComponent<Enemy>() != null)
            collision.GetComponent<Enemy>().FreezeTime(false);
    }




    private void CreatHotKey(Collider2D collision)
    {
        if (keyCodeList.Count <= 0)
        {
            Debug.LogWarning("Not enough hot keys");
            return;
        }

        if (!canCreateHotkeys)
            return;

        GameObject newHotKey = Instantiate(hotkeyPrefab, collision.transform.position + new Vector3(0, 2), Quaternion.identity);
        createdHotKey.Add(newHotKey);

        //随机KeyCode传给HotKey,并且传过去一个毁掉一个
        KeyCode choosenKey = keyCodeList[Random.Range(0, keyCodeList.Count)];

        keyCodeList.Remove(choosenKey);


        Blackhole_HotKey_Controller newHotKeyScript = newHotKey.GetComponent<Blackhole_HotKey_Controller>();


        newHotKeyScript.SetupHotKey(choosenKey, collision.transform, this);
    }

    public void AddEnemyToList(Transform _enemyTransform) => targets.Add(_enemyTransform);

    private void DestroyHotKeys()
    {
        if (createdHotKey.Count <= 0)
            return;

        for (int i = 0; i < createdHotKey.Count; i++)
        {
            Destroy(createdHotKey[i]);
        }
    }
}

Blackhole_HotKey_Controller

using TMPro;
using UnityEngine;

//TextMeshPro 是 Unity 中一个高级文本渲染插件,提供了比 Unity 内置的 UI.Text 更强大的文本渲染功能。它主要用于在游戏和应用程序中显示高质量的文本
public class Blackhole_HotKey_Controller : MonoBehaviour
{
    private SpriteRenderer sr;
    private KeyCode myHotKey;
    private TextMeshProUGUI myText;

    private Transform myEnemy;
    private BlackHole_Skill_Controller blackHole;//

    public void SetupHotKey(KeyCode _myNewHotKey, Transform _myEnemy, BlackHole_Skill_Controller _myBlackHole)
    {
        sr = GetComponent<SpriteRenderer>();
        myText = GetComponentInChildren<TextMeshProUGUI>();

        myEnemy = _myEnemy;
        blackHole = _myBlackHole;


        myHotKey = _myNewHotKey;
        myText.text = _myNewHotKey.ToString();//将按键转换为字符串

    }

    private void Update()
    {
        if (Input.GetKeyDown(myHotKey))
        {
            blackHole.AddEnemyToList(myEnemy);

            myText.color = Color.clear;
            sr.color = Color.clear;
        }
    }
}

Crystal水晶技能

Crystal_Skill

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


//10月25日,有一个使用多重水晶无法进入冷却的Bug
public class Crystal_Skill : Skill   //放在技能控制器里面
{
    [SerializeField] private float crystalDuration;
    [SerializeField] private GameObject crystalPrefab;
    private GameObject currentCrystal;//预制件创建得临时水晶

    [Header("Crystal mirage")]
    [SerializeField] private bool cloneInsteadOfCrystal;//克隆代替水晶


    [Header("Explosive crystal")]
    [SerializeField] private bool canExplode;

    [Header("Moving crystal")]
    [SerializeField] private bool canMoveToEnemy;
    [SerializeField] private float moveSpeed;


    [Header("Multi stacking crystal")]//水晶堆栈
    [SerializeField] private bool canUseMultiStacks;
    [SerializeField] private int amountOfStacks;
    [SerializeField] private float multiStackCooldown;
    [SerializeField] private float useTimerWindow;
    [SerializeField] private List<GameObject> crystalLeft = new List<GameObject>(); //堆栈使用的列表



    public override bool CanUseSkill()
    {
        return base.CanUseSkill();
    }


    public override void UseSkill()
    {
        base.UseSkill();


        if (CanUseMultiStack())
            return;


        if (currentCrystal == null)//如果没有水晶
        {
            CreateCrystal();
        }
        else
        {
            if (canMoveToEnemy)//有水晶的情况下,如果可以移动到敌人
                return;

            Vector2 playerPos = player.transform.position;//先保存玩家位置
            player.transform.position = currentCrystal.transform.position;//飞雷神之术
            currentCrystal.transform.position = playerPos;//位置互换


            if(cloneInsteadOfCrystal)//如果是克隆代替水晶
            {
                SkillManager.instance.clone.CreateClone(currentCrystal.transform, Vector3.zero);
                Destroy(currentCrystal);
            }
            else
            {
                currentCrystal.GetComponent<Crystal_Skill_Controller>().FinishCrystal();
            }
        }
    }

    public void CreateCrystal()
    {
        currentCrystal = Instantiate(crystalPrefab, player.transform.position, Quaternion.identity);//运行技能如果水晶没有那就创建一个
        Crystal_Skill_Controller currentCysalScrit = currentCrystal.GetComponent<Crystal_Skill_Controller>();//获得控制器中的组件

        currentCysalScrit.SetupCrystal(crystalDuration, canExplode, canMoveToEnemy, moveSpeed, FindClosesetEnemy(currentCrystal.transform), player);//设置水晶函数

        //currentCysalScrit.ChooseRandomEnemy();

    }


    public void CurrentCrystalChooseRandomTarget() => currentCrystal.GetComponent<Crystal_Skill_Controller>().ChooseRandomEnemy();






    private bool CanUseMultiStack()//是否可以使用多个水晶
    {
        if (canUseMultiStacks)
        {
            if(crystalLeft.Count > 0 )
            {
                if(crystalLeft.Count == amountOfStacks)
                    Invoke("ResetAbility", useTimerWindow);

                cooldown = 0;
                GameObject crystalToSpawn = crystalLeft[crystalLeft.Count - 1];//在列表中找到最后一个水晶
                GameObject newCrystal = Instantiate(crystalToSpawn, player.transform.position, Quaternion.identity);//创建一个新的水晶

                crystalLeft.Remove(crystalToSpawn);

                newCrystal.GetComponent<Crystal_Skill_Controller>().
                    SetupCrystal(crystalDuration, canExplode, canMoveToEnemy, moveSpeed, FindClosesetEnemy(newCrystal.transform), player);//调用放置函数

                if(crystalLeft.Count <= 0)
                {
                    
                    cooldownTimer = multiStackCooldown;
                    RefilCrystal();
                }

            return true;

            }
        }

        return false;
    }


    private void RefilCrystal()//重新填充水晶函数
    {
        int amountToAdd = amountOfStacks - crystalLeft.Count;

        for (int i = 0; i < amountToAdd; i++)//总是补充到3个
        {
                crystalLeft.Add(crystalPrefab);
        }
    }

    private void ResetAbility()
    {
        if (cooldownTimer > 0)
            return;

        cooldownTimer = multiStackCooldown;
        RefilCrystal();
    }
}

Crystal_Skill_Controller

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

public class Crystal_Skill_Controller : MonoBehaviour  //放在水晶得预制件里面
{
    private Animator anim => GetComponent<Animator>(); //引用是为了在更新中使用SetTrigger
    private CircleCollider2D cd => GetComponent<CircleCollider2D>();//为了完成爆炸伤害
    private Player player;// 2024年10月30日,给技能加上伤害

    private float crystalExistTimer;//消失计时器

    private bool canExplode ;//是否可以爆炸
    private bool canMove;
    private float moveSpeed;
    
    private bool canGrow;
    private float growSpeed = 5;

    private Transform closetTarget;
    [SerializeField] private LayerMask whatIsEnemy;

    public void SetupCrystal(float _crystalDuration,bool _canExplode,bool _canMove,float _moveSpeed,Transform _closetTarget,Player _player)
    {
        player = _player;
        crystalExistTimer = _crystalDuration;//放置水晶,然后开始计时
        canExplode = _canExplode;
        canMove = _canMove;
        moveSpeed = _moveSpeed;
        closetTarget=_closetTarget;
    }

    public void ChooseRandomEnemy()
    {
        float radius = SkillManager.instance.blackhole.GetBlackholeRadius();//从黑洞控制器中获取黑洞半径

        Collider2D[] colliders = Physics2D.OverlapCircleAll(transform.position, radius, whatIsEnemy);//选取周围所有的碰撞体

        if(colliders.Length > 0)
            closetTarget = colliders[Random.Range(0, colliders.Length)].transform;//随机选取一个敌人
    }



    private void Update()
    {
        crystalExistTimer -= Time.deltaTime;//控制器起码能控制时间吧

        if (crystalExistTimer < 0)
        {
            //Destroy(gameObject);   新增的功能,水晶消失后可以爆炸,所以检查是否可以爆炸
            FinishCrystal();
        }

        if (canMove)//移动到敌人的逻辑函数
        {
            transform.position = Vector2.MoveTowards(transform.position, closetTarget.position, moveSpeed * Time.deltaTime);//水晶移动到敌人位置(这里是最近敌人位置)

            if (Vector2.Distance(transform.position, closetTarget.position) < .5f)//如果水晶到达敌人位置
            {
                FinishCrystal();
                canMove = false;
            }
        }


        if (canGrow)//和上面函数优先级?
            transform.localScale = Vector2.Lerp(transform.localScale, new Vector2(3,3), growSpeed * Time.deltaTime);//水晶变大
    }

    private void AnimationExplodeEvent()//可以放在动画触发器里面
    {
        Collider2D[] colliders = Physics2D.OverlapCircleAll(transform.position, cd.radius);//从克隆控制器粘贴上的

        foreach (var hit in colliders)
        {
            if (hit.GetComponent<Enemy>() != null)
                player.stats.DoMagicDamage(hit.GetComponent<CharacterStats>());//加上魔法伤害
        }
    }



    public void FinishCrystal()
    {
        if (canExplode)
        {
            canGrow = true;
            anim.SetTrigger("Explode");
        }
        else
            SelfDestroy();
    }

    public void SelfDestroy() => Destroy(gameObject);
}

ShockStrike雷击技能

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

public class ShockStrike_Controller : MonoBehaviour
{
    [SerializeField] private CharacterStats targetStats;
    [SerializeField] private float speed;
    private int damage;


    private Animator anim;
    private bool triggered;



    void Start()
    {
        anim=GetComponentInChildren<Animator>();
    }

    public void Setup(int _damage,CharacterStats _targetStats)
    {
        damage = _damage;
        targetStats = _targetStats; 
    }



    
    void Update()
    {
        if (!targetStats)//没有目标数据就不会发挥作用
            return;


        if (triggered)
            return;


        transform.position = Vector2.MoveTowards(transform.position, targetStats.transform.position, speed * Time.deltaTime);//移动到目标位置
        transform.right = transform.position - targetStats.transform.position;//面向目标位置

        if (Vector2.Distance(transform.position, targetStats.transform.position) < .1f)//碰到敌人
        {
            anim.transform.localPosition = new Vector3(0, .5f);
            anim.transform.localRotation = Quaternion.identity;//  Quaternion.identity 表示没有旋转


            transform.localRotation = Quaternion.identity;
            transform.localScale = new Vector3(3, 3);//缩放



            Invoke("DamageAndSelfDestroy", .2f);    
            triggered = true;
            anim.SetTrigger("Hit");
            
        }
    }


    private void DamageAndSelfDestroy()
    {
        targetStats.ApplyShock(true);
        targetStats.TakeDamage(1);
        Destroy(gameObject, .4f);
    }


}

论文学习地图 Day 03|同一张图换一批,BN 的输出为什么会变?从训练统计到 INT8 量化 BN 让网络在训练时根据批次统计进行标准化,并学习每个通道的缩放和平移。常规推理使用固定统计量,因此可以将 BN 折叠到卷积中。折叠改变了权重和偏置的数值范围,这些范围与量化粒度、尺度及整数表示共同决定部署误差。;。 阅读详情

相关推荐

标准工时精益化管理:理论、方法与技巧

ECRS工时分析软件是一款综合性软件,包含了IE软件、IE改善软件、工业工程软件、作业改善/业务改善软件、动作分析软件、作业分析软件、ECRS分析法、ECRS改善手法、时间测量软件、工时测量软件、标准工时计算软件等功能。理论上,标准工时是指在标准的工作环境下,完成一道加工工序所需要花费的人工时间。不同企业、不同工序需要的辅助作业时间和损耗时间各不相同,因此企业需要灵活运用标准工时公式进行计算。总之,标准工时的制定需要综合考虑多种因素,企业可以灵活运用本文介绍的方法和技巧来优化制定流程。

VIOOVI_ECRS的博客 849

2.Unity2D类银河恶魔城学习开发

创建Player脚本并添加到Player上。

m0_74047484的博客 2151

matlab 三维绘图 抛光,瓷砖抛光过程建模与仿真

:瓷砖抛 光过程 建模与仿真朱 成 就(广 东工业大学 机 电工程 学院, 广东广州 )摘要 :瓷砖的抛磨影响 因素众 多 ,实际磨削加工时容易出现漏抛 、返抛现象 。对陶瓷抛光机磨头进行运动学分析 ,并基于不 同粒度号 的磨 粒在一定压力下的加工深度模型 ,探讨抛光机磨 头转 速 、横梁摆动频率 、传送速度对瓷砖抛光加工表 面均匀性 的影响,然 后结合 磨削机理使 用 对陶瓷抛光过程进行仿真 ...

weixin_36331058的博客 750

从零开始制作类银河恶魔城的2d游戏之P65

类银河恶魔城游戏的clone实现

2401_85579382的博客 1510

医学图像中的小目标病灶检测难题:我的硕士研究总结与思考

医学图像中的小目标检测和分割,主要指在CT、MRI、超声等医学影像中识别和分割微小病灶或细小结构。这些小目标通常体积小、边界模糊、特征不明显,却往往是关键病灶,例如肺部小结节、脑微出血、乳腺微钙化等。

weixin_45638136的博客 2373

UFS电源管理实战:如何优化手机存储的功耗与性能(附实测数据)

本文深入探讨了UFS电源管理的实战优化策略,旨在平衡手机存储的功耗与性能。通过解析UFS核心电压域与工作状态,重点介绍了通过动态调整bActiveICCLevel(活动电流等级)来实现精细控制,并结合实测数据与场景驱动的智能策略,为Android系统与硬件工程师提供了降低功耗、提升流畅度的有效方法。

weixin_29214559的博客 508

Unity类银河战士恶魔城学习总结(P134 Merge skill tree with Crystal skill把技能树和格挡技能相组合)

本章节把做到技能树里面多重爆炸。

suzh1qian的博客 572

显著性算法 + 伪彩变换

利用opencv得到显著图和伪彩图

正在挣扎中的人 2301

LangChain入门学习(四)

RAG(检索增强生成)通过结合外部知识库与大模型生成能力,提升问答准确性。其流程分为离线索引与在线检索生成两阶段:先将多源文档(如PDF、Word、Markdown)加载并切分,经嵌入后存入向量库;用户提问时,系统检索相关文本块,结合上下文生成答案。关键工具包括LangChain文档加载器及MinerU,后者支持复杂格式文件的结构化解析,显著提升非结构化数据处理效率。

kevin_org 103

2025年数学建模国赛高教社杯A题、B题、C题、D题、E题详细思路和代码 模型||插值与拟合

核心思想:构造一个精确通过所有已知离散数据点(xi, yi)的函数y = f(x),并以此函数来估算或预测未知点的值。基本假设:我们认为已知的数据点是100%精确、无误差的(或者误差可忽略不计),比如理论计算值、高精度仪器测量值等。我们的目标是“还原”或“重建”出点与点之间的真实函数关系。关键特征精确性:曲线或曲面必须穿过每一个样本点。局部性:插值结果严重依赖于局部数据点的分布和数值。用途:用于“补全”数据、填充缺失值、进行函数近似等。常见方法多项式插值:拉格朗日插值、牛顿插值。

2201_76125261的博客 804

威纶通触摸屏与S7-1200以太网通信的具体方法和步骤(非常详细)

威纶通触摸屏与S7-1200以太网通信的具体方法和步骤(非常详细)

Robot_PLC_HMI_Automation 1万+

TC264核心板高效布线技巧全解析学习笔记

为TC264核心板PCB布线,优化铺铜规则:焊盘发散线宽与间距设为0,自动适配大小焊盘,兼顾散热与防吸热。过孔默认24/12mil,布线模式设为阻挡,确保导线与铺铜安全避让。走线间距6mil,BGA扇出由内向外,优先连至排针;电源/GND就近打孔连内层,缩短环路。关键模拟/时钟电路紧贴芯片,走线短且独立。顶层用于长距离IO,底层用于局部连接,内层为电源地平面。电源去耦电容就近布局,减小噪声。底层铺铜后通过过孔连接顶层GND。删除排针丝印,添加3D丝印,完成整体布局。

comyccccc的博客 223

2025实战|C#上位机+STM32实现LED串灯控制:串口通信+PWM调光+自定义帧协议(附上下位机源码)

粘包:一次收到“BRIGHT:50LED_OFF”,解析完全错乱;乱码:串口波特率/编码不匹配,指令变成“??H??50”;丢帧:数据传输中少字符,比如“BRIGHT:5”,解析出亮度5而非50。因此我们设计字节级自定义帧协议协议先行:无论简单还是复杂场景,先定义清晰的帧协议,避免数据错乱;串口稳字当头:下位机用环形缓冲区接收,上位机加锁发送,避免丢包/粘包;跨线程必处理:C#上位机所有UI更新必须用Invoke,否则必崩溃;硬件是基础:接线、供电、共地这些细节,比代码更易出问题;

这里只有干货:从 Modbus 通信到 MES 对接,从 YOLO 训练到工控机部署,带你搞定工业软件开发全流程。 761

Zig 设计哲学与核心特性 · 0.17 学习手册

本文为Zig 0.17完整学习手册,基于B站19讲视频整理,全面适配Zig 0.17.1版本。涵盖设计哲学(如“一切可见”、显式内存分配)、核心特性(?T、错误即值、comptime、SIMD)及工程实践(Allocator心智模型、零堆分配、Async I/O)。所有代码经实测通过,标注过时写法并提供迁移指南,附30个可运行示例与附录索引,助力开发者从入门迈向系统级编程。

代码过客 171

ET2012新版免狗免安装绿色软件

ET2012新版免狗免安祖昂绿色软件。,新界面,新视觉,

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

[LangChain] 学习笔记(004):嵌入模型——让机器第一次「算得出」两句话有多像

前三篇我们一直在跟「聊天」打交道:给一句话,模型回一段话。如果你想让机器判断「这两句话意思像不像」,它怎么判断?机器只认数字。你给它「我喜欢猫」和「我爱猫咪」,它看到的只是两串字符——比不了大小,也算不了距离。搭这座桥的东西,就叫嵌入。

一名在 Linux 与 C/C++ 世界里打怪升级的开发者。持续输出系统编程、网络编程、数据结构与算法的高质量学习笔记与实战总结 448

IEM模型,地表粗糙度模拟

利用微波反演土壤水分时候,利用IEM模型可以实现对随机地表的模拟

大模型学习25 -- Web服务 -- FastAPI

大模型学习25 -- Web服务 -- FastAPI

kyrie_sakura的博客 226

win10 跳过U8环境检测的IE WebControls.rar

win10 安装u8的时候 提示IE WebControls 不通过,这个工具可以欺骗u8的检查。 跳过U8环境检测的IE WebControls。提示导入失败后,重新检测通过。

Halcon学习--(16) 深度学习总览与通用工作流

刚上手 HALCON 深度学习,最容易卡在这一步:照着示例敲了一行调用,去手册里搜却搜不到。原因是示例里的调用混了三类不同性质的东西。分不清会怎样:把 当算子去手册里搜,搜不到;以为 HALCON 版本不对,实际它是 里定义的一个过程。判断方法很简单——算子在 目录有独立 html 页,其余都没有。本篇后面凡写到签名,都会标明是算子还是过程。26.05 的 下共 35 个 hdev 示例,分在 10 个子目录里。按能力归类:各能力的完整示例清单见第九章。能力之间有交叉(边缘提取归在 Segmenta

weixin_45114627的博客 621

云原生运维学习笔记:Kubernetes 集群手动安装与资源管理实战

本文详细记录了Kubernetes v1.30.2集群的手动安装与资源管理全过程。基于Ubuntu系统,通过netplan配置三台节点(1控制平面+2工作节点),完成主机名与静态网络设置。使用kubeadm config images pull预拉取镜像,避免初始化失败;随后执行kubeadm init,指定Pod网段为10.224.0.0/16,部署Calico网络插件。成功后,通过kubectl管理命名空间与上下文,实现资源隔离与环境切换。操作逻辑清晰,适用于生产环境搭建与故障排查参考。

2604_96593683的博客 428

eMMC5.1协议中文学习讲解(6.6.23~6.6.29.2)

eMMC协议中文学习讲解,按协议手册从头到尾的顺序进行讲解

Gary移动存储固件 311

基于SpringBoot青少年法律学习宣传平台-附源码

为加强青少年法治教育,普及基础法律知识,传统线下普法讲座、纸质宣传手册形式存在传播范围有限、学习时间不灵活、学习效果难以跟踪等问题。本系统面向青少年、普法教师以及平台管理员开发线上法律学习宣传平台。青少年用户可以浏览普法文章、观看法治微课、完成法律知识习题、参与线上答题、留言咨询法律相关问题;教师可以上传普法学习资料、发布知识问卷、查看学生学习记录;管理员负责管理普法资源、审核留言、管理用户信息、统计学习数据。

专注于大学生项目实战开发,讲解,毕业答疑辅导,java就业辅导,高校老师/讲师/同行合作。以及产品测评宣传、工具推广等合作。全网粉丝10w+,平台优质java、小程序创作者。 243

应急救护实训室:双师模式打造专家级智慧学习

急救教育正从“有无课程”转向“训练质量”,面临师资短缺与教学效率瓶颈。南京恒点推出AI赋能的双师模式,以3D交互系统实现伤情可视化,AI导师承担标准化示范与纠错,真人教师聚焦决策判断与经验传授,重构教学注意力分配,推动急救教育向“理解为何做”升级。

恒点虚拟仿真官方博客 194

计算机视觉学习资源推荐:书籍、课程、开源项目精选

学习计算机视觉,选对资源就成功了一半。网络上关于CV的学习资料浩如烟海,但质量参差不齐。对于初学者来说,如何在信息的海洋中找到真正有价值的内容,是一个不小的挑战。书中包含大量实际项目,学习曲线平缓,适合零基础入门。这是构建CV知识体系的最佳方式。全文依次讲解书籍推荐:从入门到精通、在线课程推荐、开源项目推荐、论文阅读指南、学习社区与平台、资源使用策略等内容。

2602_96795563的博客 429

Blockchain 区块链安全(CTF 方向)学习提纲

本文系统梳理CTF Blockchain方向学习路径,涵盖EVM基础、常见漏洞(如重入、delegatecall、权限绕过)与题型,强调“看懂状态、理清调用、算清收益”的解题思维。结合Remix、Foundry等工具链,推荐从Ethernaut到Damn Vulnerable DeFi的阶梯练习,并提供标准化解题流程与自查清单,助力高效攻防实战。

2601_95623860的博客 587

DeepSeek学习设计模式设计定制柜

DeepDraw AI设计新架构引入“设计模式”概念,突破AI在美学与创意上的局限。人类设计师日常多依赖成熟设计模式,90%场景可套用。该系统通过明确规则、边界与生活经验,指导AI精准套用模式,结合用户需求(如多挂衣、多抽屉),生成符合常识的3D模型。流程清晰:选模式→AI生成方案→程序落地建模,有效避免“床头对窗”等常识错误。涵盖卧室、厨房、卫生间等六大核心场景,实现高效人机协作,显著提升设计准确性与实用性。

weixin_42377388的博客 208

学习日记63:TRANSFUSION

Transfusion的核心目标是构建单一统一 Transformer 模型,同时处理离散文本(自回归下一词预测)与连续图像(扩散模型去噪),实现文本、图像的理解与生成,避免将图像离散化为 token 带来的信息损失。多模态生成模型需要感知、处理、生成离散内容(文本、代码)和连续内容(图像、音频、视频)。以下一个 token 预测为目标的语言模型,在离散模态上很强;但扩散模型是连续模态生成的 SOTA。

weixin_56653612的博客 167

51 单片机学习笔记:LCD1602、独立按键、I2C 与 AT24C02 掉电存储(江科大课程小白笔记)

本文为江科大51单片机课程的学习笔记,专为C语言基础薄弱、首次接触单片机的“代码小白”设计。内容涵盖LCD1602显示、独立按键、I2C通信及AT24C02 EEPROM存储等核心模块,通过“人话”解析代码逻辑,重点讲解sbit位定义、数据类型差异、命令与数据写入流程、按键消抖、I2C起始/停止时序、字节收发及应答机制等关键概念,强调模块化编程与实际动手结合,帮助初学者理解底层原理,快速上手开发。

2301_81429079的博客 340
上一篇: Unity类银河战士恶魔城学习总结(P103之前 Enemy相关 , 骷髅战士,状态机,敌人状态,)
下一篇: Unity类银河战士恶魔城学习总结(P103之前 Entity相关,人物实体,背景,闪光特效,玩家管理器)
suzh1qian
博客等级 码龄5年 838粉丝 80原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值
⌂ 换网址