Shawn的代码日常

基于Unity引擎的RPG3D项目开发笔录

RPG游戏开发笔录

文章目录

RPG游戏开发笔录
- 1.将普通3D项目升级为RPG渲染管线
- 2.导入素材（人物，场景，天空盒）
- 3.第三人称自由视角与移动
- 4.切换鼠标指针
- 5.遮挡剔除实现
- 6.敌人的创建，站岗，追逐
- 7.人物基本数值实现
- 8.攻击功能的实现（重难）
- 9.泛型单例模式以及怪物获胜通知
- 10.模板生成更多Enemy
- 11.拓展方法实现怪物的攻击范围限制
- 12.血条UI的设计
- 13.玩家升级系统
- 14.玩家的血条UI
- 15.传送门（切换关卡）
- 16.保存数据
- 17.主菜单的制作
- 18.场景转场

1.将普通3D项目升级为RPG渲染管线

1.Package Manager 搜索 Universal RP进行安装
2.创建通用渲染管线 Rendering--->URP Assets(with Universal Renderer)
3.进入Project Settings--->Graphics，选中刚创建的渲染管线
4.进入Quality中同样上述操作
5.进入渲染管线，修改Shadows-->Max Distance，以减小渲染时带给显卡的压力
6.修改默认渲染方式为GPU，并可修改GPU类型和烘焙渲染：

2.导入素材（人物，场景，天空盒）

更新渲染：
Windows--->Rendering-->Render Pipeline Converter--->Built-in to URP--->全部勾选--->Initialize Converters--->Convert Assets

3.第三人称自由视角与移动

1.Input Manager–>复制粘贴 Horizontal和Vertical 并修改其为第四，第五坐标轴，命名为 Camera Rate X & Camera Rate Y
2.给摄像机设置父节点 Photographer，使其能绕着父物体移动

相机脚本：

public class Photographer : MonoBehaviour
{
    //相机抬升（绕X轴）
    public float Pitch { get; private set; }
    //相机水平角度（绕Y轴）
    public float Yaw { get; private set; }

    //鼠标灵敏度
    public float mouseSensitivity = 5;
    //摄像机旋转速度
    public float cameraRotatingSpeed = 80;
    public float cameraYSpeed = 5;

    //相机跟随目标
    private Transform followTarget;


    public void InitCamera(Transform target)
    {
        followTarget = target;
        transform.position = target.position;
    }

    private void Update()
    {
        UpdateRotation();
        UpdatePosition();
    }

    private void UpdateRotation()
    {
        Yaw += Input.GetAxis("Mouse X") * mouseSensitivity;
        Yaw += Input.GetAxis("CameraRateX") * cameraRotatingSpeed * Time.deltaTime ;
        //Debug.Log(Yaw);
        Pitch += Input.GetAxis("Mouse Y") * mouseSensitivity;
        Pitch += Input.GetAxis("CameraRateY") * cameraRotatingSpeed * Time.deltaTime;
        //限制抬升角度
        Pitch = Mathf.Clamp(Pitch, -90, 90);
        //Debug.Log(Pitch);

        transform.rotation = Quaternion.Euler(Pitch, Yaw, 0);
    }

    private void UpdatePosition()
    {
        Vector3 position = followTarget.position;
        float newY = Mathf.Lerp(transform.position.y, position.y, Time.deltaTime * cameraYSpeed);
        transform.position = new Vector3(position.x,newY,position.z);
    }
}

人物移动脚本（通用）：

[RequireComponent(typeof(Rigidbody))]
public class CharacterMove : MonoBehaviour
{
    //刚体组件
    [Header("组件")]
    private Rigidbody rb;
    
    public Vector3 CurrentInput { get; private set; }

    public float MaxWalkSpeed = 5;


    void Awake()
    {
        rb = GetComponent<Rigidbody>();
    }


    private void FixedUpdate()
    {
        rb.MovePosition(rb.position + CurrentInput * MaxWalkSpeed * Time.fixedDeltaTime);
        //rb.MoveRotation(Quaternion.LookRotation(CurrentInput * MaxWalkSpeed * Time.fixedDeltaTime));
        //rb.rotation = Quaternion.LookRotation(CurrentInput * MaxWalkSpeed * Time.fixedDeltaTime);
        //目标旋转角度
        Quaternion quaternion = Quaternion.LookRotation(CurrentInput * MaxWalkSpeed * Time.fixedDeltaTime);
        //平滑过渡，deltaTime为每帧渲染的时间
        transform.localRotation = Quaternion.Lerp(transform.localRotation, quaternion, Time.deltaTime * 10f);

    }

    public void SetMovementInput(Vector3 input)
    {
        
        CurrentInput = Vector3.ClampMagnitude(input, 1);
    }

玩家移动脚本：

[RequireComponent(typeof(Rigidbody))]
public class PlayerLogic : MonoBehaviour
{
    [Header("组件")]
    //刚体组件
    private Rigidbody rb;
    //动画组件
    private Animator anim;
    //移动组件
    private CharacterMove characterMove;
    //摄像机组件
    public Photographer photographer;

    //摄像机的根位置
    public Transform followTarget;

    //附加项
    public float jumpForce = 10f;


    [Header("人物信息")]
    //人物移动方向
    private bool isForward, isBack, isLeft, isRight,isFall;


    void Awake()
    {
        rb = GetComponent<Rigidbody>();
        anim = GetComponent<Animator>();
        characterMove = GetComponent<CharacterMove>();
        photographer.InitCamera(followTarget);
    }
    
    void Update()
    {
        UpdateMovementInput();
        //Jump();
        AttackAnim();
        SwitchAnim();
    }

    //动画变量同步
    private void SwitchAnim()
    {
        anim.SetBool("Forward", isForward);
        anim.SetBool("Back", isBack);
        anim.SetBool("Left", isLeft);
        anim.SetBool("Right", isRight);
        anim.SetBool("Fall", isFall);
    }

    #region 玩家移动
    //人物移动函数
    private void UpdateMovementInput()
    {
        /*
         * TODO:添加人物死亡条件限制
         */
        float ad = Input.GetAxis("Horizontal");
        //Debug.Log("ad值为：" + ad);
        float ws = Input.GetAxis("Vertical");
        //Debug.Log("ws值为：" + ws);

        Quaternion rot = Quaternion.Euler(0, photographer.Yaw, 0);
        characterMove.SetMovementInput(rot * Vector3.forward * ws + 
                                       rot * Vector3.right * ad);

        if (ad != 0 || ws != 0)
        {
            /*//目标旋转角度
            Quaternion quaternion = Quaternion.LookRotation(new Vector3(ad, 0, ws));
            //平滑过渡，deltaTime为每帧渲染的时间
            transform.localRotation = Quaternion.Lerp(transform.localRotation, quaternion, Time.deltaTime * 10f);*/


            //动画状态切换
            if (ad > 0.1)
            {
                isRight = true;

            }else if (ad < -0.1)
            {
                isLeft = true;
            }else
            {
                isRight = false;
                isLeft = false;
            }

            if (ws > 0.1)
            {
                isForward = true;
            }
            else if (ws < -0.1)
            {
                isBack = true;
            }
            else
            {
                isForward = false;
                isBack = false;
            }
        }

        //添加速度
        //rb.velocity = new Vector3(ad * moveSpeed, 0, ws * moveSpeed);
    }
    #endregion 

    #region 玩家跳跃
    //跳跃函数
    private void Jump()
    {
        if (Input.GetKeyDown(KeyCode.Space) && isFall)
        {
            anim.SetTrigger("Jump");
            rb.velocity = new Vector3(rb.velocity.x, jumpForce,rb.velocity.z);
            isFall = false;
        }     
    }

    private void OnTriggerEnter(Collider other)
    {
        if (other.gameObject.CompareTag("Ground"))
        {
            Debug.Log("触发到地面了");
            isFall = true;
        }
    }

    #endregion

    #region 玩家攻击
    private void AttackAnim()
    {
        this.transform.LookAt(this.transform);
        if (Input.GetMouseButtonDown(0))
        {
            anim.SetTrigger("Attack");
        }else if (Input.GetMouseButtonDown(1))
        {
            anim.SetTrigger("Ability");
        }
    }

    #endregion
}

4.切换鼠标指针

切换鼠标指针：

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

[RequireComponent(typeof(Rigidbody))]
public class CharacterMove : MonoBehaviour
{    
    [Header("人物攻击模块")]
    //鼠标图标
    public Texture2D target, attack;
    RaycastHit hitInfo;


    void Awake()
    {
        rb = GetComponent<Rigidbody>();
    }

    void Update()
    {
        SetCursorTexture();  
    }
    
    //设置鼠标指针
    void SetCursorTexture()
    {
        Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);

        if (Physics.Raycast(ray,out hitInfo))
        {
            switch (hitInfo.collider.gameObject.tag)
            {
                case "Ground":
                    Cursor.SetCursor(target, new Vector2(16, 16), CursorMode.Auto);
                    break;
                case "Enemy":
                    Cursor.SetCursor(attack, new Vector2(16, 16), CursorMode.Auto);
                    break;
            }
        }
    }

5.遮挡剔除实现

1.create-->Shader Graph--> URP--->Unit Shader Graph，并起名为 Occlusion Shader。
2.基于它创建材质Occlusion放回meterials文件夹
编辑Occlusion Shader为如下参考：

材质参数参考：

URP参数参考：

遮挡剔除实现完成！

6.敌人的创建，站岗，追逐

1.导入素材，设置基本状态信息（Idle,Chase,Guard,Dead）
2.敌人的状态切换，追逐玩家以及切换动画：

using UnityEngine;
using UnityEngine.AI;

public enum EnemyStates { GUARD,PATROL,CHASE,DEAD }

[RequireComponent(typeof(NavMeshAgent))]
public class EnemyController : MonoBehaviour
{
    [Header("组件")]
    private NavMeshAgent agent;
    private Animator anim;

    [Header("状态变量")]
    private EnemyStates enemyStates;

    [Header("敌人基础设置")]
    //敌人可视范围
    public float sightRadius;
    //敌人的类型
    public bool isGuard;
    //敌人攻击目标
    private GameObject AttackTarget;
    //记录敌人初始站岗位置
    private Vector3 GuardPos;

    //敌人状态
    bool isWalk,isDead;

	//脱战观望时间
	public float remainLookatTime = 3f;
    //脱战停留计时器
    private float remainTimer;

    private void Awake()
    {
        agent = GetComponent<NavMeshAgent>();
        anim = GetComponent<Animator>();
    }

void Start()
    {
        //给敌人初始位置赋值
        GuardPos = transform.position;
    }
    
    void Update()
    {
        SwitchStates();
        SwitchAnimation();
    }

    //切换动画
    void SwitchAnimation()
    {
        anim.SetBool("Chase", isChase);
        anim.SetBool("Walk", isWalk);
        anim.SetBool("Dead", isDead);
    }

    void SwitchStates()
    {
        //如果发现玩家，切换到Chase
        if (FoundPlayer())
        {
            enemyStates = EnemyStates.CHASE;
            Debug.Log("发现玩家");
        }

        switch (enemyStates)
        {
            case EnemyStates.GUARD:
            	Guard();
                break;
            case EnemyStates.PATROL:
                break;
            case EnemyStates.CHASE:
                ChasePlayer();
                break;
            case EnemyStates.DEAD:
                break;
        }
    }

    //是否发现玩家
    bool FoundPlayer()
    {
        //拿到检测到对应范围内的所以碰撞体
        var hitColliders = Physics.OverlapSphere(this.transform.position, sightRadius);

        //检测其中是否存在Player
        foreach(var target in hitColliders)
        {
            if (target.gameObject.CompareTag("Player"))
            {
                AttackTarget = target.gameObject;
                return true;
            }
        }
        //脱离目标
        AttackTarget = null;
        return false;
    }

    //追逐玩家函数
    void ChasePlayer()
    {
        //脱战逻辑
        if (!FoundPlayer())
        {
            if (remainTimer > 0)
            {
                //观望战立状态
                agent.destination = transform.position;
                remainTimer -= Time.deltaTime;
                isWalk = false;
            }
            else
            {
                
                //回到上一个状态(巡逻或者站立)
                enemyStates = isGuard ? EnemyStates.GUARD : EnemyStates.PATROL;
            }

        }
        else
        {
            agent.isStopped = false;
            isWalk = true;
            //刷新观望时间计时器
            remainTimer = remainLookatTime;
            //当距离小于攻击距离时，开始攻击
            if (Vector3.Distance(transform.position, AttackTarget.transform.position) < characterStats.AttackData.attackRange)
            {
                isWalk = false;
                agent.isStopped = true;
                anim.SetTrigger("Attack");
            }
            else
            {
                
                //追击Player
                agent.destination = AttackTarget.transform.position;
            }

        }
        

    }
    //怪物返回出生点以及站岗逻辑
    void Guard()
    {
        //判断怪物是否返回出生点
        if (Vector3.Distance(transform.position,GuardPos) <= 3)
        {
            isWalk = false;
        }
        else
        {
            isWalk = true;
            agent.destination = GuardPos;
        }
        
    }
}

7.人物基本数值实现

1.给文件夹分好类，分别创建 MonoBehavior和ScriptableObject文件夹。
2.创建第一个ScriptableObject脚本文件，命名为 CharacterData_SO。
3.编写人物应有的通用属性，并在专门的数据文件夹下创建出数据文件。

数据模板写法：

[CreateAssetMenu(fileName ="New Data",menuName = "Character Stats/Data")]
public class CharacterData_SO : ScriptableObject
{
    [Header("Stats Info")]
    //最大生命值
    public int maxHealth;
    //当前生命值
    public int currentHealth;
    //基础防御力
    public int baseDefence;
    //当前防御力
    public int currentDefence;
}

数据操作写法：

public class CharacterStats : MonoBehaviour
{
    public CharacterData_SO characterData;

    #region Read from Data_SO
    public int MaxHealth 
    {
        get
        {
            return characterData != null ? characterData.maxHealth : 0;
        }
        set
        {
            characterData.maxHealth = value;
        }
    }

    public int CurrentHealth
    {
        get
        {
            return characterData != null ? characterData.currentHealth : 0;
        }
        set
        {
            characterData.currentHealth = value;
        }
    }

    public int BaseDefence
    {
        get
        {
            return characterData != null ? characterData.baseDefence : 0;
        }
        set
        {
            characterData.baseDefence = value;
        }
    }

    public int CurrentDefence
    {
        get
        {
            return characterData != null ? characterData.currentDefence : 0;
        }
        set
        {
            characterData.currentDefence = value;
        }
    }
    #endregion
}

4.将数据操作脚本 CharacterStats挂载到Player和Enemy上，并拖入对应数据文件。
5.在玩家控制脚本中获取到数据文件，并获取到操作该数据的方法。
6.同样方式实现攻击数值的基本书写：

[CreateAssetMenu(fileName = "New Attack",menuName = "Attack/Data")]
public class AttackData_SO : ScriptableObject
{
    //攻击距离
    public float attackRange;
    //技能距离
    public float skillRange;
    //冷却时间
    public float coolDown;
    //基础伤害范围
    public int minDamage;
    public int maxDamage;

    //暴击倍率（伤害）
    public float criticalMultiplier;
    //暴击率
    public float criticalChance;
}

8.攻击功能的实现（重难）

1.创建攻击数据脚本：包括玩家和怪物
给出参考：Player Attack Data_SO

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

[CreateAssetMenu(fileName = "New Attack",menuName = "Attack/Data")]
public class AttackData_SO : ScriptableObject
{
    //攻击距离
    public float attackRange;
    //技能距离
    public float skillRange;
    //冷却时间
    public float coolDown;
    //基础伤害范围
    public int minDamage;
    public int maxDamage;

    //暴击倍率（伤害）
    public float criticalMultiplier;
    //暴击率
    public float criticalChance;
}

玩家攻击脚本面板参考：

2.在角色数据操作脚本中引入攻击脚本：并写出伤害计算逻辑

public class CharacterStats : MonoBehaviour
{
    public CharacterData_SO characterData;

    public AttackData_SO AttackData;

    #region 攻击模块
    public void TakeDamage(CharacterStats attacker,CharacterStats defencer)
    {
        //计算一次攻击的伤害
        float coreDamage = UnityEngine.Random.Range(attacker.AttackData.minDamage, attacker.AttackData.maxDamage);

        //控制最低伤害为1
        int damage = Mathf.Max((int)coreDamage - defencer.CurrentDefence,1);
        
        //控制血量最低为0
        CurrentHealth = Mathf.Max(CurrentHealth - damage, 0);
        //更新 UI
        
    }
    #endregion
}

由于这里攻击函数是玩家和怪物通用的，所以后续只需要传入攻击者和受击者即可正常完成伤害计算并扣血。其次，怪物的进攻逻辑是AI操控，只需要在追踪玩家时，吧玩家对象传入怪物的攻击目标变量即可。但玩家的攻击目标选择却成了问题，这里采用类似怪物发现玩家的方式，采用一个圆形探测范围（该范围阈值即为玩家的攻击范围），当玩家进行攻击操作时，只需要检测怪物是否在范围检测距离内，如果在距离内，则正常调用TakeDamage()，如果不在，则视为空刀。缺点是实际攻击范围（以玩家为圆心，以攻击距离为半径的圆形内）与动画攻击范围（人物的前方扇形区域）不符合。后续有待改进…此外，暴击功能较为繁琐，目前未实现。以下为判断暴击的常用方法之一，仅供参考：

//设置全局变量，判断是否暴击
characterStats.isCritical = UnityEngine.Random.value < characterStats.attackData.criticalChance;

3.怪物的攻击逻辑：(将其挂载到怪物攻击动画的某一帧上)

	//引入数值组件
	private CharacterStats characterStats;

	//给组件赋值
	private void Awake()
	{
		characterStats = GetComponent<CharacterStats>();
	}
	
	//每次游戏开始给怪物重置生命值
	void Start()
	{
		//刷新初始生命值
        characterStats.CurrentHealth = characterStats.MaxHealth;
	}

//怪物攻击的出伤害事件
    void Hit()
    {
        if (AttackTarget != null)
        {
            //拿到受害者的属性信息
            var targetStats = AttackTarget.GetComponent<CharacterStats>();
            //造成伤害
            targetStats.TakeDamage(characterStats, targetStats);
        }
    }

4.玩家的攻击逻辑

//引入数值组件
//Awake初始化数值组件
//初始化生命值

#region 玩家攻击
    public void AttackAnim()
    {
        if (Input.GetMouseButtonDown(0))
        {
            anim.SetTrigger("Attack");
        }else if (Input.GetMouseButtonDown(1))
        {
            anim.SetTrigger("Ability");
        }
    }

    //范围检测
    private bool AttackRangeTest()
    {
        Debug.Log(characterStats.AttackData.attackRange);
        //拿到检测到对应范围内的所有碰撞体
        Collider[] hitColliders = Physics.OverlapSphere(transform.position, characterStats.AttackData.attackRange);
        foreach (Collider collider in hitColliders)
        {
            if (collider.gameObject.CompareTag("Enemy"))
            {
                AttackTarget = collider.gameObject;
                return true;
            }
        }
        return false;
    }

    //玩家的出伤害逻辑
    void Hit()
    {
        if (AttackRangeTest())
        {
            CharacterStats targetStats = AttackTarget.GetComponent<CharacterStats>();
            targetStats.TakeDamage(characterStats, targetStats);
        }
        else
        {
            Debug.Log("空刀！");
        }
    }
#endregion

5.死亡的判断
思路：死亡判断直接在Update()函数中逐帧判断当前生命值是否为0即可：
玩家死亡：

//引入变量
	bool isDead;
	void Update()
    {
        if (characterStats.CurrentHealth != 0)
        {
            UpdateMovementInput();
            Jump();
            AttackAnim();
            
        }
        else
        {
            isDead = true;
            rb.constraints = RigidbodyConstraints.FreezePosition;
            rb.constraints = RigidbodyConstraints.FreezeRotation;
        }
        SwitchAnim();

    }

怪物死亡：

	void Update()
    {
        if (characterStats.CurrentHealth != 0)
        {
            SwitchStates();
        }
        else
        {
            isDead = true;
            enemyStates = EnemyStates.DEAD;
        }
        
        SwitchAnimation();
    }

9.泛型单例模式以及怪物获胜通知

1.写一个管理单例模式的基类( Tools/Singleton )：

//管理类的基类
//泛型单例模式

public class Singleton<T> : MonoBehaviour where T:Singleton<T>
{
    private static T instance;

    //外部可访问的函数
    public static T Instance
    {
        get { return instance; }
    }

    //可继承可重写的Awake方法
    protected virtual void Awake()
    {
        if (instance != null)
        {
            Destroy(gameObject);
        }
        else
        {
            instance = (T)this;
        }
    }

    public static bool IsInitialized
    {
        get { return instance != null; }
    }

    protected virtual void OnDestroy() 
    { 
        if (instance == this)
        {
            instance = null;
        }    
    }
}

2.写一个发放广播的接口 IEndGameObserver

public interface IEndGameObserver 
{
    void EndNotify();
}

3.写一个游戏管理类继承管理基类 ( Manages/GameManager )

public class GameManager : Singleton<GameManager>
{
    public CharacterStats playerStats;


    //收集所有需要接收广播的对象
    List<IEndGameObserver> endGameObservers = new List<IEndGameObserver>();

	//在游戏开始时将玩家信息注册到管理类
    public void RigisterPlayer(CharacterStats player)
    {
        playerStats = player;
    }

	//在游戏开始时，将怪物信息（被通知者）录入通知对象
    public void AddObserver(IEndGameObserver observer)
    {
        endGameObservers.Add(observer);
    }

	//怪物被消灭时，清理通知对象
    public void RemoveObserver(IEndGameObserver observer)
    {
        endGameObservers.Remove(observer);
    }

	//通知逻辑
    public void NotifyObservers()
    {
        foreach(var observer in endGameObservers)
        {
            observer.EndNotify();
        }
    }
}

4.在玩家逻辑中添加注册信息到管理类
PlayerLogic:

void Start()
    {
        //利用单例模式调用注册玩家信息
        GameManager.Instance.RigisterPlayer(characterStats);
    }

5.在怪物逻辑中添加注册和销毁通知，以及通知内容的具体实现
EnemyController:

//首先让其实现IEndGameObserver接口
public class EnemyController : MonoBehaviour,IEndGameObserver
{
	private void OnEnable()
    {
        GameManager.Instance.AddObserver(this);
    }

    private void OnDisable()
    {
    	if (!GameManager.IsInitialized) return;
        GameManager.Instance.RemoveObserver(this);
    }
}

	public void EndNotify()
    {
        //获胜动画
        //停止所有移动
        //停止Agent
        isWalk = false;
        AttackTarget = null;
        isVictory = true;
    }

报错总结：此处在GameManager的实例化阶段一直报 空引用异常，后来发现自己没有创建 Game Manager 的结点，并挂载GameManager的脚本。此外，还需注意 Onable函数是场景初始化时被创建，此处不涉及场景切换，故，需将其暂时写在Start方法中，后续再更改。

10.模板生成更多Enemy

1.由于之前写法会使多个复制出来的怪物属性共享，这显然不是我们需要的功能，故我们需要创建一个属性模板，让其新生成的怪物以该模板生成对应的数值。
Character Stats中：

public class CharacterStats : MonoBehaviour
{
	public CharacterData_SO templateData;

    public CharacterData_SO characterData;

	void Awake()
    {
        if (templateData != null)
        {
            characterData = Instantiate(templateData);
        }    
    }
}

2.引入新怪物的美术模型资源，添加必要组件EnemyController，NavMesh Agent以及基本碰撞体，别忘了将其标签改为Enemy，并创建对应的数据文件。
3.在重置新类型敌人的动画信息时，可直接创建一个 Override Animators，可十分便利的重置怪物动画。

11.拓展方法实现怪物的攻击范围限制

由于之前只要怪物发动攻击动画，玩家必掉血。这是极度不合理的，我们希望玩家有一定的闪避空间或容错，故我们采用 拓展方法 Extension Method 来对其攻击范围做一个限制。

1.写一个 Extension Method脚本：

public static class ExtensionMethod 
{

    //确保怪物攻击在正前方[-60°,60°]之间范围攻击有效
    private const float dotThreshold = 0.5f;

    public static bool IsFacingTarget(this Transform transform, Transform target)
    {
        //计算出目标物对于攻击者正前方的相对位置并取单位向量
        var vectorToTarget = target.position - transform.position;
        vectorToTarget.Normalize();

        float dot = Vector3.Dot(transform.forward, vectorToTarget);

        return dot >= dotThreshold;
    }
}

2.并在怪物的攻击动画事件中加上限制条件：
EnemyController:

//怪物攻击的出伤害事件
    void Hit()
    {
        if (AttackTarget != null && transform.IsFacingTarget(AttackTarget.transform))
        {
            //拿到受害者的属性信息
            var targetStats = AttackTarget.GetComponent<CharacterStats>();
            //造成伤害
            targetStats.TakeDamage(characterStats, targetStats);
        }
    }

3.给Boss的基础攻击增加击退效果

但暂时有点问题，无法正常击退玩家。后续再改BUG。

public class Boss_Rock : EnemyController
{
    //击飞玩家的力
    public float kickForce = 25f;

    public void KickOff()
    {
        if (AttackTarget != null && transform.IsFacingTarget(AttackTarget.transform))
        {
            Debug.Log("被踢开了");
            //拿到受害者的属性信息
            var targetStats = AttackTarget.GetComponent<CharacterStats>();

            //计算击飞方向(问题)
            //FIXME:有待修改
            Vector3 direction = (AttackTarget.transform.position - transform.position).normalized;
            AttackTarget.GetComponent<Rigidbody>().velocity = direction * kickForce;
            
            //造成伤害
            targetStats.TakeDamage(characterStats, targetStats);
        }
    }
}

4.设置石头人可投掷物

– 1.拖入石头的素材，添加必要组件：RigidBody，Mesh Collider（勾选第一项），脚本Rock.cs

public class Rock : MonoBehaviour
{
	private Rigidbody rb;
	
	[Header("Basic Settings")]
	public float force;

	public GameObject target;
	private Vector3 direction;

	void Start()
	{
		rb = GetComponent<Rigidbody>();
		FlyToTarget();	
	}

	public void FlyToTarget()
	{
		//预防石头生成瞬间玩家脱离范围
		if (target == null)
		{
			target = FindObjectOfType<PlayerController>().gameObject;
		}
		direction = (target.transform.position - transform.position + Vector3.up).normalized;
		rb.AddForce(direction * force, ForceMode.Impulse);
	}
}

– 2.修改石头人生成石头代码：

public class Boss_Rock : EnemyController
{
	//扔出的石头的预制体
	public GameObject rockPrefab;
	//出手点的坐标
	public Transform handPos;

	//投掷石头的逻辑
	public void ThrowRock()
	{
		if (AttackTarget != null)
		{
			var rock = Instantiate(rockPrefab,handPos.position,Quaternion.identify);
			rock.GetComponent<Rock>().target = AttackTarget;
		}
	}
}

– 3.将ThrowRock方法添加到动画对应帧数上。

– 4.设置石头的状态：在被投掷出的时候能对敌人以及玩家造成伤害，但落地以后无法对玩家或敌人造成伤害。

public class Rock : MonoBehaviour
{
	public enum RockStates { HitPlayer,HitEnemy,HitNothing };
	//石头的伤害值
    public int damage = 8;
    //石头的状态
    public RockStates rockStates;

	void Start()
    {
        rb = GetComponent<Rigidbody>();
        //为了防止石头刚一出来就被判断为hitNothing
        rb.velocity = Vector3.one;
        //初始化石头的状态
        rockStates = RockStates.HitPlayer;
        //石头被生成的时候就自动飞向目标
        FlyToTarget();
        //石头扔出三秒后延迟销毁
        Destroy(this.gameObject, 3);
    }
	//逐帧判断，当石头几乎静止时变得不再有威胁
	void FixedUpdate()
    {
        Debug.Log(rb.velocity.sqrMagnitude);
        if (rb.velocity.sqrMagnitude < 1)
        {
            rockStates = RockStates.HitNothing;
        }    
    }

	void OnCollisionEnter(Collision collision)
    {
        
        switch (rockStates)
        {
            case RockStates.HitPlayer:
                if (collision.gameObject.CompareTag("Player"))
                {
                    CharacterStats characterStats = collision.gameObject.GetComponent<CharacterStats>();
                    //碰到玩家了，造成伤害，并对玩家播放受击动画（TakeDamage的函数重载）
                    characterStats.TakeDamage(damage,characterStats);
                    collision.gameObject.GetComponent<Animator>().SetTrigger("Hit");

                    rockStates = RockStates.HitNothing;
                }
                break;

            case RockStates.HitEnemy:
                if (collision.gameObject.CompareTag("Enemy"))
                {
                    var EnemyStats = collision.gameObject.GetComponent<CharacterStats>();
                    EnemyStats.TakeDamage(damage, EnemyStats);
                    //攻击到敌人以后，也将其设为无危胁状态
                    
                }
                break;
        }    
    }
}

– 5.函数重载TakeDamage()方法，让石头也能造成伤害：

	public void TakeDamage(int damage,CharacterStats defencer)
    {
        int finalDamage = Mathf.Max(damage - defencer.CurrentDefence, 1);
        CurrentHealth = Mathf.Max(CurrentHealth - finalDamage, 0);
    }

– 6.修改玩家的攻击逻辑，使其攻击石头也具有一定逻辑：

//范围检测
    private bool AttackRangeTest()
    {
        //Debug.Log(characterStats.AttackData.attackRange);
        //拿到检测到对应范围内的所有碰撞体
        Collider[] hitColliders = Physics.OverlapSphere(transform.position, characterStats.AttackData.attackRange);
        foreach (Collider collider in hitColliders)
        {
        	//有限判断敌人，如果不存在敌人，则判断是否有可攻击物
            if (collider.gameObject.CompareTag("Enemy") 
             || collider.gameObject.CompareTag("Attackable"))
            {
                AttackTarget = collider.gameObject;
                return true;
            }
        }
        return false;
    }

    //玩家的出伤害逻辑
    void Hit()
    {
        
        if (AttackRangeTest())
        {
            if (AttackTarget.CompareTag("Attackable"))
            {
                //进一步判断是石头
                if (AttackTarget.GetComponent<Rock>())
                {
                    AttackTarget.GetComponent<Rock>().rockStates = Rock.RockStates.HitEnemy;
                    AttackTarget.GetComponent<Rigidbody>().velocity = Vector3.one;
                    AttackTarget.GetComponent<Rigidbody>().AddForce(transform.forward * 20, ForceMode.Impulse);
                }
            }else if (AttackTarget.CompareTag("Enemy"))
            {
                CharacterStats targetStats = AttackTarget.GetComponent<CharacterStats>();
                targetStats.TakeDamage(characterStats, targetStats);
            }
            
        }
    }

12.血条UI的设计

1.创建一个Canvas命名为 HealthBarCanvas,修改Canvas的 UI Scale Mode改为 World Space，并设置相机Camera。创建一个子物体UI image，命名 Bar Holder。
2.对UI界面的位置信息进行调整，修改长3和高0.25（参考值）。
3.在Package Manager中引入 3D sprite，创建一个2D Object–>Square，找到其基础的文件，复制一份图片另存起来。将其拖入到Bar Holder的Source Image中，并可修改其颜色（血条底色）。
4.继续创建Bar Health的子节点Image，尺寸参数与父节点保持一致，拖入Source Image，修改颜色（血条上层色），并将其改为滑动条的形式进行显示。
5.写UI脚本操控血条的变化。

public class HealthBarUI : MonoBehaviour
{
    //血条预制体
    public GameObject healthBarPrefab;

    //血条位置
    public Transform barPoint;

    //是否让血条持续显示
    public bool alwaysVisible;
    //血条被唤醒后显示的时间
    public float visibleTime;

    //血量滑动条
    Image healthSlider;
    Transform UIBar;

    //摄像机的位置（保证始终正对摄像机）
    Transform camera;

    //拿到当前目标的血量信息
    private CharacterStats currentStats;

    void Start()
    {
        currentStats = GetComponent<CharacterStats>();
    }

    void OnEnable()
    {
        camera = Camera.main.transform;
        
        foreach (Canvas canvas in FindObjectsOfType<Canvas>())
        {
            if (canvas.renderMode == RenderMode.WorldSpace)
            {
                UIBar = Instantiate(healthBarPrefab, canvas.transform).transform;
                healthSlider = UIBar.GetChild(0).GetComponent<Image>();
                UIBar.gameObject.SetActive(alwaysVisible);
            }
        }
    }

    //血条跟随敌人
    void LateUpdate()
    {
        if (UIBar != null)
        {
            UIBar.position = barPoint.position;

            UIBar.forward = -camera.forward;
            
        }
    }

    void Update()
    {
        
        UpdateHealthBar(currentStats.CurrentHealth, currentStats.MaxHealth);
    }

    private void UpdateHealthBar(int currentHealth, int maxHealth) 
    {
        if (currentHealth <= 0)
        {
            if (UIBar != null)
            {
                Destroy(UIBar.gameObject);
            }

        }
        else
        {
            UIBar.gameObject.SetActive(true);

            float sliderPercent = (float)currentHealth / maxHealth;
            //Debug.Log("当前血量仅剩：" + sliderPercent);
            healthSlider.fillAmount = sliderPercent;
        }
        
    }

    
}

总结：该套程序采用逐帧检测血条变化，相对来说效率较差，优化可以让角色攻击时计算一次血条变化。后续会优化！！！

13.玩家升级系统

1.先添加一下玩家的属性
Character_SO：

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

[CreateAssetMenu(fileName ="New Data",menuName = "Character Stats/Data")]
public class CharacterData_SO : ScriptableObject
{
    [Header("Stats Info")]
    //基础生命值
    public float baseHealth;
    //最大生命值
    public float maxHealth;
    //当前生命值
    public float currentHealth;
    //基础防御力
    public int baseDefence;
    //当前防御力
    public int currentDefence;

    [Header("击杀敌人获得的经验值")]
    public int killExp;

    [Header("玩家升级系统")]
    //当前等级
    public int currentLevel;
    //最大等级
    public int maxLevel;
    //升级所需基础经验值
    public int baseExp;
    //当前经验值
    public int currentExp;
    //升级经验提高值
    public int ExpIncrement;
    //升级属性加权
    public float levelBuff;

    //更新经验值函数
    public void UpdateExp(int Exp)
    {
        currentExp += Exp;

        if (currentExp >= baseExp)
        {
            LevelUp();
        }
    }

    private void LevelUp()
    {
        //提高等级(将当前等级限制在[0,maxLevel之间])
        currentLevel = Mathf.Clamp(currentLevel + 1, 0, maxLevel);
        //升级所需的经验值也随之提高
        baseExp += ExpIncrement;
        //血量提高5％
        maxHealth = baseHealth * (levelBuff * currentLevel + 1);
        currentHealth = maxHealth;
        Debug.Log("LevelUP，当前血量为" + currentHealth);
    }
}

暂时为了学习升级逻辑的构思以及数值的模范书写，后续功能有待优化！
2.在造成伤害界面添加击杀增加经验的判断：
CharacterStats:

 public void TakeDamage(CharacterStats attacker,CharacterStats defencer)
    {
        //计算一次攻击的伤害
        float coreDamage = UnityEngine.Random.Range(attacker.AttackData.minDamage, attacker.AttackData.maxDamage);

        //控制最低伤害为1
        int damage = Mathf.Max((int)coreDamage - defencer.CurrentDefence,1);
        
        //控制血量最低为0
        CurrentHealth = Mathf.Max(CurrentHealth - damage, 0);
        //更新 UI
        //经验值update
        if (CurrentHealth == 0)
        {
            attacker.characterData.UpdateExp(defencer.characterData.killExp);
        }
    }

14.玩家的血条UI

1.同样优先创建一个Canvas，设置参考如下：

做出如下效果的UI界面：

并在其父节点下嵌入以下脚本以控制血条的变化：
PlayerHealthUI:

using UnityEngine.UI;

public class PlayerHealthUI : MonoBehaviour
{
    Text levelText;

    Image healthSlider;

    Image expSlider;

    void Awake()
    {
        //拿到文本子节点
        levelText = transform.GetChild(2).GetComponent<Text>();
        healthSlider = transform.GetChild(0).GetChild(0).GetComponent<Image>();
        expSlider = transform.GetChild(1).GetChild(0).GetComponent<Image>();
    }

    void Update()
    {
        levelText.text = "level " + GameManager.Instance.playerStats.characterData.currentLevel.ToString("00");
        UpdateHealth();
        UpdateExp();
    }

    void UpdateHealth()
    {
        float sliderPercent = (float)GameManager.Instance.playerStats.CurrentHealth / GameManager.Instance.playerStats.MaxHealth;
        healthSlider.fillAmount = sliderPercent;
    }

    void UpdateExp()
    {
        float sliderPercent = (float)GameManager.Instance.playerStats.characterData.currentExp / GameManager.Instance.playerStats.characterData.baseExp;
        expSlider.fillAmount = sliderPercent;
    }
}

15.传送门（切换关卡）

场景内传送：

1.在之前Shader Graph目录下继续创建Shader，参数参考如下：
2.利用创建的Shader的基础上创建一个Meterial，并调参数。
3.在层级窗口中创建一个Quad，并添加以上材质，在其下创建一个子节点 DestinationPoint 作为被传送点。
4.创建 TransitionPoint.cs脚本控制传送点：（挂载在传送门父类上）

public class TransitionPoint : MonoBehaviour
{
    //传送类型(同场景，不同场景)
    public enum TransitionType
    {
        SameScene,DifferentScene
    }

    [Header("info")]
    //场景名字（如果同场景则可以不填）
    public string sceneName;
    //传送类型
    public TransitionType type;

    //传送到的目的地点
    public TransitionDestination.DestinationTags destinationTag;

    //只有该属性触发了才会传送
    private bool canTrans;

    void Update()
    {
        if (Input.GetKeyDown(KeyCode.F) && canTrans)
        {
            //场景传送
            SceneController.Instance.TransitionToDestination(this);
        }    
    }


    void OnTriggerStay(Collider other)
    {
        if (other.CompareTag("Player"))
        {
            canTrans = true;
        }
    }

    void OnTriggerExit(Collider other)
    {
        if (other.CompareTag("Player"))
        {
            canTrans = false ;
        }
    }
}

5.创建传送目标点脚本 TransitionDestination.cs:

public class TransitionDestination : MonoBehaviour
{
    public enum DestinationTags
    {
        ENTRE,A,B,C
    }

    public DestinationTags destinationTag;
}

6.写场景控制脚本实现同场景传送逻辑：SceneController.cs：

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

public class SceneController : Singleton<SceneController>
{
    Transform player;
    //玩家的预制体(加载新场景时引入)
    public GameObject playerPrefab;

    protected override void Awake()
    {
        base.Awake();
        DontDestroyOnLoad(this);
    }

    public void TransitionToDestination(TransitionPoint transitionPoint)
    {
        switch (transitionPoint.type) 
        {
            case TransitionPoint.TransitionType.SameScene:
                StartCoroutine(Transition(SceneManager.GetActiveScene().name, transitionPoint.destinationTag));
                break;
            case TransitionPoint.TransitionType.DifferentScene:
                StartCoroutine(Transition(transitionPoint.sceneName, transitionPoint.destinationTag));
                break;
        
        }

    }

    //使用携程异步加载场景
    IEnumerator Transition(string sceneName , TransitionDestination.DestinationTags destinationTag)
    {
        //TODO：保存数据

        //判断是相同场景还是不同场景
        if (SceneManager.GetActiveScene().name != sceneName)
        {
            //等待return值完成后再执行其他代码（异步加载）
            yield return SceneManager.LoadSceneAsync(sceneName);
            yield return Instantiate(playerPrefab, GetDestination(destinationTag).transform.position,GetDestination(destinationTag).transform.rotation);
            //中断携程
            yield break;
        }
        else
        {
            player = GameManager.Instance.playerStats.transform;
            player.SetPositionAndRotation(GetDestination(destinationTag).transform.position, GetDestination(destinationTag).transform.rotation);
            yield return null;
        }     
    }


    //在全部传送门中查找传送标签一样的传送门
    private TransitionDestination GetDestination(TransitionDestination.DestinationTags destinationTag)
    {
        var entrances = Resources.FindObjectsOfTypeAll<TransitionDestination>();
        for (int i = 0; i < entrances.Length; i++)
        {
            if (entrances[i].destinationTag == destinationTag)
            {
                return entrances[i];
            }
        }

        return null;
    }
}

以上代码遇到的问题：

1.切换到新场景后，管理类代码全部消失，导致游戏无法正常运行，解决方法：在Manage相关代码前都加上重写的Awake()方法即可：

protected override void Awake()
{
    base.Awake();
    //意为该Manage脚本不会被销毁
    DontDestroyOnLoad(this);
}

2.注意在切换至新场景之前，一定要在新场景安置自己写的 PhotoGrapher 结点，并且在PlayerLogic初始化的时候找到摄像机别赋值完整：

	void Awake()
    {
        photographer = FindObjectOfType<Photographer>();
        rb = GetComponent<Rigidbody>();
        anim = GetComponent<Animator>();
        characterMove = GetComponent<CharacterMove>();
        photographer.InitCamera(followTarget);
        characterStats = GetComponent<CharacterStats>();
        audio = photographer.GetComponent<AudioSource>();
    }

3.这样改完以后从第二场景重新返回第一场景时，会出现两个人物，并且人物在半空中。（埋个伏笔）

16.保存数据

1.使用JSON保存游戏数据，在切换场景时调用保存函数与读取函数：
2.新建一个结点 SaveManager并创建脚本 SaveManager.cs挂载到结点上：

public class SaveManager : Singleton<SaveManager>
{
    protected override void Awake()
    {
        base.Awake();
        DontDestroyOnLoad(this);
    }

    //封装保存和读取玩家信息的函数
    public void SavePlayerData()
    {
        Save(GameManager.Instance.playerStats.characterData, GameManager.Instance.playerStats.characterData.name);
    }

    public void LoadPlayerData()
    {
        Load(GameManager.Instance.playerStats.characterData, GameManager.Instance.playerStats.characterData.name);
    }


    //存储数据
    public void Save(Object data,string key)
    {
        //将要存储的数值转化为JSON
        var jsonData = JsonUtility.ToJson(data,true);
        //将数据以键值对的形式保存
        PlayerPrefs.SetString(key, jsonData);
        PlayerPrefs.Save();
    }

    //加载数据
    public void Load(Object data, string key)
    {
        if (PlayerPrefs.HasKey(key))
        {
            JsonUtility.FromJsonOverwrite(PlayerPrefs.GetString(key), data);
        }
    }
}

3.在切换场景时调用这个两个函数即可完成对玩家数据的保存：
SceneController.cs：

//使用携程异步加载场景
    IEnumerator Transition(string sceneName , TransitionDestination.DestinationTags destinationTag)
    {
        //TODO：保存数据
        SaveManager.Instance.SavePlayerData();

        //判断是相同场景还是不同场景
        if (SceneManager.GetActiveScene().name != sceneName)
        {
            //等待return值完成后再执行其他代码（异步加载）
            yield return SceneManager.LoadSceneAsync(sceneName);
            yield return Instantiate(playerPrefab, GetDestination(destinationTag).transform.position,GetDestination(destinationTag).transform.rotation);
            //读取数据
            SaveManager.Instance.LoadPlayerData();

            //中断携程
            yield break;
        }
        else
        {
            player = GameManager.Instance.playerStats.transform;
            player.SetPositionAndRotation(GetDestination(destinationTag).transform.position, GetDestination(destinationTag).transform.rotation);
            yield return null;
        }     
    }

4.切记勿忘在新场景创建角色UI。

17.主菜单的制作

1.制作UI，按钮，标题，背景等等
2.分别实现退出游戏，新的游戏和继续游戏的脚本功能：
– 1.退出游戏

public class MainManu : MonoBehaviour
{
    Button quitBtn;

    void Awake()
    {
        quitBtn = transform.GetChild(3).GetComponent<Button>();

        quitBtn.onClick.AddListener(QuitGame);
    }

    void QuitGame()
    {
        Application.Quit();
        Debug.Log("退出游戏");
    }
}

– 2.新的游戏：
1).清除之前的数据
2).在游戏控制中添加寻找全图起点的方法：
GameManager.cs:

 //寻找入口的函数
    public Transform GetEntrance()
    {
        foreach (var item in FindObjectsOfType<TransitionDestination>())
        {
            if (item.destinationTag == TransitionDestination.DestinationTags.ENTRE)
            {
                return item.transform;
            }
        }
        return null;
    }

2).切换到第一场景的某点（在场景控制中使用携程切换场景）

public void TransitionToFirstLevel()
    {
        StartCoroutine(LoadLevel("City"));
    }

    IEnumerator LoadLevel(string scene)
    {
        if (scene != "")
        {
            yield return SceneManager.LoadSceneAsync(scene);
            yield return player = Instantiate(playerPrefab, GameManager.Instance.GetEntrance().position, GameManager.Instance.GetEntrance().rotation).transform;

            //保存数据
            SaveManager.Instance.SavePlayerData();
            yield break;
        }
        
    }

– 3.继续游戏的实现：
1).在保存函数里加入保存当前地图逻辑

public class SaveManager : Singleton<SaveManager>
{
    //当前所在的场景
    private string sceneName = "";

    public string SneceName { get { return PlayerPrefs.GetString(sceneName); } }

    protected override void Awake()
    {
        base.Awake();
        DontDestroyOnLoad(this);
    }

    //封装保存和读取玩家信息的函数
    public void SavePlayerData()
    {
        Save(GameManager.Instance.playerStats.characterData, GameManager.Instance.playerStats.characterData.name);
    }

    public void LoadPlayerData()
    {
        Load(GameManager.Instance.playerStats.characterData, GameManager.Instance.playerStats.characterData.name);
    }


    //存储数据
    public void Save(Object data,string key)
    {
        //将要存储的数值转化为JSON
        var jsonData = JsonUtility.ToJson(data,true);
        //将数据以键值对的形式保存
        PlayerPrefs.SetString(key, jsonData);
        PlayerPrefs.SetString(sceneName, SceneManager.GetActiveScene().name);
        PlayerPrefs.Save();
    }

    //加载数据
    public void Load(Object data, string key)
    {
        if (PlayerPrefs.HasKey(key))
        {
            JsonUtility.FromJsonOverwrite(PlayerPrefs.GetString(key), data);
        }
    }
}

2).在场景控制里，调用协程：
SceneController.cs

public void TransitionToLoadGame()
    {
        StartCoroutine(LoadLevel(SaveManager.Instance.SceneName));
    }

3).在玩家生成的生成的时候，就读取一遍玩家数据
PlayerController.cs

	void OnEnable()
    {
        //利用单例模式调用注册玩家信息
        GameManager.Instance.RigisterPlayer(characterStats);
    }

    void Start()
    {
        SaveManager.Instance.LoadPlayerData();
        //初始化攻击冷却计时器(初始状态可攻击)
        AttackCD = -1;
    }

4).给予玩家回到Main的方式：
SceneController.cs：

	public void TransitionToMain()
    {
        StartCoroutine(LoadMain());
    }

	IEnumerator LoadMain()
    {
        yield return SceneManager.LoadSceneAsync("Main");
        yield break;
    }

5).添加补全继续游戏的调用函数
MainMenu.cs:

	void ContinueGame()
    {
        //读取进度
        SceneController.Instance.TransitionToMain();
    }

18.场景转场

1.引入TimeLine窗口：Windows-->Sequencing-->Timeline

你可能感兴趣的:(游戏与梦想,unity,3d,游戏引擎,RPG)

斤斤计较的婚姻到底有多难？白心之岂必有为
很多人私聊我会问到在哪个人群当中斤斤计较的人最多？我都会回答他，一般婚姻出现问题的斤斤计较的人士会非常多，以我多年经验，在婚姻落的一塌糊涂的人当中，斤斤计较的人数占比在20～30%以上，也就是说10个婚姻出现问题的斤斤计较的人有2-3个有多不减。在婚姻出问题当中，有大量的心理不平衡的、尖酸刻薄的怨妇。在婚姻中仅斤斤计较有两种类型：第一种是物质上的，另一种是精神上的。在物质与精神上抠门已经严重的影响
QQ群采集助手，精准引流必备神器 2401_87347160 其他经验分享
功能概述微信群查找与筛选工具是一款专为微信用户设计的辅助工具，它通过关键词搜索功能，帮助用户快速找到相关的微信群，并提供筛选是否需要验证的群组的功能。主要功能关键词搜索：用户可以输入关键词，工具将自动查找包含该关键词的微信群。筛选功能：工具提供筛选机制，用户可以选择是否只显示需要验证或不需要验证的群组。精准引流：通过上述功能，用户可以更精准地找到目标群组，进行有效的引流操作。3.设备需求该工具可以
机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习 python
一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
随笔 | 仙一般的灵气海思沧海
仙岛今天，我看了你全部，似乎已经进入你的世界我不知道，这是否是梦幻，还是你仙一般的灵气吸引了我也许每一个人都要有一份属于自己的追求，这样才能够符合人生的梦想，生活才能够充满着阳光与快乐我不知道，我为什么会这样的感叹，是在感叹自己的人生，还是感叹自己一直没有孜孜不倦的追求只感觉虚度了光阴，每天活在自己的梦中，活在一个不真实的世界是在逃避自己，还是在逃避周围的一切有时候我嘲笑自己，嘲笑自己如此的虚无，
一百九十四章. 自相矛盾巨木擎天
唉！就这么一夜，林子感觉就像过了很多天似的，先是回了阳间家里，遇到了那么多不可思议的事情儿。特别是小伙伴们，第二次与自己见面时，僵硬的表情和恐怖的气氛，让自己如坐针毡，打从心眼里难受！还有东子，他现在还好吗？有没有被人欺负？护城河里的小鱼小虾们，还都在吗？水不会真的干枯了吧？那对相亲相爱漂亮的太平鸟儿，还好吧！春天了，到了做窝、下蛋、喂养小鸟宝宝的时候了，希望它们都能够平安啊！虽然没有看见家人，也
10月|愿你的青春不负梦想-读书笔记-01 Tracy的小书斋
本书的作者是俞敏洪，大家都很熟悉他了吧。俞敏洪老师是我行业的领头羊吧，也是我事业上的偶像。本日摘录他书中第一章中的金句：『一个人如果什么目标都没有，就会浑浑噩噩，感觉生命中缺少能量。能给我们能量的，是对未来的期待。第一件事，我始终为了进步而努力。与其追寻全世界的骏马，不如种植丰美的草原，到时骏马自然会来。第二件事，我始终有阶段性的目标。什么东西能给我能量？答案是对未来的期待。』读到这里的时候，我便
微服务下功能权限与数据权限的设计与实现 nbsaas-boot 微服务 java 架构
在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
学点心理知识，呵护孩子健康静候花开_7090
昨天听了华中师范大学教育管理学系副教授张玲老师的《哪里才是学生心理健康的最后庇护所，超越教育与技术的思考》的讲座。今天又重新学习了一遍，收获匪浅。张玲博士也注意到了当今社会上的孩子由于心理问题导致的自残、自杀及伤害他人等恶性事件。她向我们普及了一个重要的命题，她说心理健康的一些基本命题，我们与我们通常的一些教育命题是不同的，她还举了几个例子，让我们明白我们原来以为的健康并非心理学上的健康。比如如果
2021年12月19日，春蕾教育集团团建活动感受——黄晓丹黄错错加油
感受:1.从陌生到熟悉的过程。游戏环节让我们在轻松的氛围中得到了锻炼，也增长了不少知识。2.游戏过程中，我们贡献的是个人力量，展现的是团队的力量。它磨合的往往不止是工作的熟悉，更是观念上契合度的贴近。3.这和工作是一样的道理。在各自的岗位上，每个人摆正自己的位置、各司其职充分发挥才能，并团结一致劲往一处使，才能实现最大的成功。新知:1.团队精神需要不断地创新。过去，人们把创新看作是冒风险，现在人们
《投行人生》读书笔记小蘑菇的树洞
《投行人生》----作者詹姆斯-A-朗德摩根斯坦利副主席40年的职业洞见-很短小精悍的篇幅，比较适合初入职场的新人。第一部分成功的职业生涯需要规划1.情商归为适应能力分享与协作同理心适应能力，更多的是自我意识，你有能力识别自己的情并分辨这些情绪如何影响你的思想和行为。2.对于初入职场的人的建议，细节，截止日期和数据很重要截止日期，一种有效的方法是请老板为你所有的任务进行优先级排序。和老板喝咖啡的好
Long类型前后端数据不一致 igotyback 前端
响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
店群合一模式下的社区团购新发展——结合链动 2+1 模式、AI 智能名片与 S2B2C 商城小程序源码说私域人工智能小程序
摘要：本文探讨了店群合一的社区团购平台在当今商业环境中的重要性和优势。通过分析店群合一模式如何将互联网社群与线下终端紧密结合，阐述了链动2+1模式、AI智能名片和S2B2C商城小程序源码在这一模式中的应用价值。这些创新元素的结合为社区团购带来了新的机遇，提升了用户信任感、拓展了营销渠道，并实现了线上线下的完美融合。一、引言随着互联网技术的不断发展，社区团购作为一种新兴的商业模式，在满足消费者日常需
2021-08-26 影幽
在生活中，女人与男人的感悟往往有所不同。人生最大的舞台就是生活，大幕随时都可能拉开，关键是你愿不愿意表演都无法躲避。在生活中，遇事不要急躁，不要急于下结论，尤其生气时不要做决断，要学会换位思考，大事化小小事化了，把复杂的事情尽量简单处理，千万不要把简单的事情复杂化。永远不要扭曲，别人善意，无药可救。昨天是张过期的支票，明天是张信用卡，只有今天才是现金，要善加利用！执着的攀登者不必去与别人比较自己的
高级编程--XML+socket练习题 masa010 java 开发语言
1.北京华北2114.8万人上海华东2,500万人广州华南1292.68万人成都华西1417万人（1）使用dom4j将信息存入xml中（2）读取信息，并打印控制台（3）添加一个city节点与子节点（4）使用socketTCP协议编写服务端与客户端，客户端输入城市ID，服务器响应相应城市信息（5）使用socketTCP协议编写服务端与客户端，客户端要求用户输入city对象，服务端接收并使用dom4j
2018-07-23-催眠日作业-#不一样的31天#-66小鹿小鹿_33
预言日：人总是在逃避命运的路上，与之不期而遇。心理学上有个著名的名词，叫做自证预言；经济学上也有一个很著名的定律叫做，墨菲定律；在灵修派上，还有一个很著名的法则，叫做吸引力法则。这3个领域的词，虽然看起来不太一样，但是他们都在告诉人们一个现象：你越担心什么，就越有可能会发生什么。同样的道理，你越想得到什么，就应该要积极地去创造什么。无论是自证预言，墨菲定律还是吸引力法则，对人都有正反2个维度的影响
回溯 Leetcode 332 重新安排行程 mmaerd Leetcode刷题学习记录 leetcode 算法职场和发展
重新安排行程Leetcode332学习记录自代码随想录给你一份航线列表tickets，其中tickets[i]=[fromi,toi]表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。所有这些机票都属于一个从JFK（肯尼迪国际机场）出发的先生，所以该行程必须从JFK开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。例如，行程[“JFK”,“LGA”]与[“JFK”,“LGB
每日一题——第九十题互联网打工人no1 C语言程序设计每日一练 c语言
题目：判断子串是否与主串匹配#include#include#include//////判断子串是否在主串中匹配//////主串///子串///boolisSubstring(constchar*str,constchar*substr){intlenstr=strlen(str);//计算主串的长度intlenSub=strlen(substr);//计算子串的长度//遍历主字符串，对每个可能得
Python数据分析与可视化实战指南 William数据分析 python python 数据
在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
《庄子.达生9》钱江潮369
【原文】孔子观于吕梁，县水三十仞，流沫四十里，鼋鼍鱼鳖之所不能游也。见一丈夫游之，以为有苦而欲死也，使弟子并流而拯之。数百步而出，被发行歌而游于塘下。孔子从而问焉，曰：“吾以子为鬼，察子则人也。请问，‘蹈水有道乎’”曰：“亡，吾无道。吾始乎故，长乎性，成乎命。与齐俱入，与汩偕出，从水之道而不为私焉。此吾所以蹈之也。”孔子曰：“何谓始乎故，长乎性，成乎命？”曰：“吾生于陵而安于陵，故也；长于水而安于
水泥质量纠纷案代理词徐宝峰律师
贵州领航建设有限公司诉贵州纳雍隆庆乌江水泥有限公司产品质量纠纷案代理词尊敬的审判长、审判员：贵州千里律师事务所接受被告贵州纳雍隆庆乌江水泥有限公司的委托，指派我担任其诉讼代理人，参加本案的诉讼活动。下面，我结合本案事实和相关法律规定发表如下代理意见，供合议庭评议案件时参考：原告应当举证证明其遭受的损失与被告生产的水泥质量的因果关系。首先水泥是一种粉状水硬性无机胶凝材料。加水搅拌后成浆体，能在空气中
Goolge earth studio 进阶4——路径修改与平滑陟彼高冈yu Google earth studio 进阶教程旅游
如果我们希望在大约中途时获得更多的城市鸟瞰视角。可以将相机拖动到这里并创建一个新的关键帧。camera_target_clip_7EarthStudio会自动平滑我们的路径，所以当我们通过这个关键帧时，不是一个生硬的角度，而是一个平滑的曲线。camera_target_clip_8路径上有贝塞尔控制手柄，允许我们调整路径的形状。右键单击，我们可以选择“平滑路径”，这是默认的自动平滑算法，或者我们可
从鸡肉高汤到记忆的魔法再到有效提示的艺术步子哥人工智能
还记得小时候那些天马行空的白日梦吗？也许只要按下键盘上的某个神奇组合，电脑就会发出滴滴的声响，一个隐藏的世界突然在你眼前展开，让你获得超凡的能力，摆脱平凡的生活。这听起来像是玩过太多电子游戏的幻想，但实际上，间隔重复系统给人的感觉惊人地相似。在最佳状态下，这些系统就像魔法一样神奇。本文将以一个看似平凡的鸡肉高汤食谱为例，深入浅出地探讨如何编写有效的间隔重复提示，让你像掌握烹饪技巧一样轻松地掌握记忆
18-115 一切思考不能有效转化为行动，都TM是扯淡！成长时间线
7月25号写了一篇关于为什么会断更如此严重的反思，然而，之后日更仅仅维持了一周，又出现了这次更严重的现象。从8月2号到昨天8月6号，5天！又是5天没有更文！虽然这次断更时间和上次一样，那为什么说这次更严重？因为上次之后就分析了问题的原因，以及应该如何解决，按理说应该会好转，然而，没过几天严重断更的现象再次出现，想想，经过反思，问题依然没有解决与改变，这让我有些担忧。到底是哪里出了问题，难道我就真的
山东大学小树林支教调研团青青仓木队——翟晓楠山东大学青青仓木队
过了半年，又一次启程，又一次回到支教的初心之地。比起上一次的试探与不安，我更多了一丝稳重与熟练。心境、处境也都随着半个学期的过去而变得不同，半个学期中，身体上的，心理上的，太多的逆境让我变得步履维艰，曲曲折折，弯弯绕绕，我仿佛打不起精神，没有胃口，没有动力。感觉走的不顺畅的时候，支教这个旅程，给了我力量。自告奋勇承担起队长这一职务的我，从组织时的复杂和困难的经历，协调各种问题，从无到有，和校长和队
直返最高等级与直返APP：无需邀请码的返利新体验古楼
随着互联网的普及和电商的兴起，直返模式逐渐成为一种流行的商业模式。在这种模式下，消费者通过购买产品或服务，获得一定的返利，并可以分享给更多的人。其中，直返最高等级和直返APP是直返模式中的重要概念和工具。本文将详细介绍直返最高等级的概念、直返APP的使用以及与邀请码的关系。【高省】APP（高佣金领导者）是一个自用省钱佣金高，分享推广赚钱多的平台，百度有几百万篇报道，运行三年，稳定可靠。高省APP，
DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计网页设计期末网页作业 html静态网页 html5期末大作业网页设计 web大作业
️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
2020-04-12每天三百字之连接与替代冷眼看潮
不知道是不是好为人师，有时候还真想和别人分享一下我对某些现象的看法或者解释。人类社会不断发展进步的过程，就是不断连接与替代的过程。人类发现了火并应用火以后，告别了茹毛饮血的野兽般的原始生活（火烧、烹饪替代了生食）人类用石器代替了完全手工，工具的使用使人类进步一大步。类似这样的替代还有很多，随着科技的发展，有更多的原始的事物被替代，代之以更高效、更先进的技术。在近现代，汽车替代了马车，高速公路和铁路
探索OpenAI和LangChain的适配器集成：轻松切换模型提供商 nseejrukjhad langchain easyui 前端 python
#探索OpenAI和LangChain的适配器集成：轻松切换模型提供商##引言在人工智能和自然语言处理的世界中，OpenAI的模型提供了强大的能力。然而，随着技术的发展，许多人开始探索其他模型以满足特定需求。LangChain作为一个强大的工具，集成了多种模型提供商，通过提供适配器，简化了不同模型之间的转换。本篇文章将介绍如何使用LangChain的适配器与OpenAI集成，以便轻松切换模型提供商
利用Requests Toolkit轻松完成HTTP请求 nseejrukjhad http 网络协议网络 python
RequestsToolkit的力量：轻松构建HTTP请求Agent在现代软件开发中，API请求是与外部服务交互的核心。RequestsToolkit提供了一种便捷的方式，帮助开发者构建自动化的HTTP请求Agent。本文旨在详细介绍RequestsToolkit的设置、使用和潜在挑战。引言RequestsToolkit是一个强大的工具包，可用于构建执行HTTP请求的智能代理。这对于想要自动化与外
数组去重好奇的猫猫猫
整理自js中基础数据结构数组去重问题思考？如何去除数组中重复的项例如数组：[1,3,4,3,5]我们在做去重的时候，一开始想到的肯定是，逐个比较，外面一层循环，内层后一个与前一个一比较，如果是久不将当前这一项放进新的数组，挨个比较完之后返回一个新的去过重复的数组不好的实践方式上述方法效率极低，代码量还多，思考？有没有更好的方法这时候不禁一想当然有了！！！hashtable啊，通过对象的hash办法
Spring中@Value注解，需要注意的地方无量 spring bean @Value xml
Spring 3以后,支持@Value注解的方式获取properties文件中的配置值，简化了读取配置文件的复杂操作 1、在applicationContext.xml文件(或引用文件中)中配置properties文件 <bean id="appProperty" class="org.springframework.beans.fac
mongoDB 分片开窍的石头 mongodb
mongoDB的分片。要mongos查询数据时候先查询configsvr看数据在那台shard上，configsvr上边放的是metar信息，指的是那条数据在那个片上。由此可以看出mongo在做分片的时候咱们至少要有一个configsvr,和两个以上的shard（片）信息。第一步启动两台以上的mongo服务 &nb
OVER(PARTITION BY)函数用法 0624chenhong oracle
这篇写得很好，引自 http://www.cnblogs.com/lanzi/archive/2010/10/26/1861338.html OVER(PARTITION BY)函数用法 2010年10月26日 OVER(PARTITION BY)函数介绍开窗函数 &nb
Android开发中，ADB server didn't ACK 解决方法一炮送你回车库 Android开发
首先通知：凡是安装360、豌豆荚、腾讯管家的全部卸载，然后再尝试。一直没搞明白这个问题咋出现的，但今天看到一个方法，搞定了！原来是豌豆荚占用了 5037 端口导致。参见原文章：一个豌豆荚引发的血案——关于ADB server didn't ACK的问题简单来讲，首先将Windows任务进程中的豌豆荚干掉，如果还是不行，再继续按下列步骤排查。 &nb
canvas中的像素绘制问题换个号韩国红果果 JavaScript canvas
pixl的绘制，1.如果绘制点正处于相邻像素交叉线，绘制x像素的线宽，则从交叉线分别向前向后绘制x/2个像素，如果x/2是整数，则刚好填满x个像素，如果是小数，则先把整数格填满，再去绘制剩下的小数部分，绘制时，是将小数部分的颜色用来除以一个像素的宽度，颜色会变淡。所以要用整数坐标来画的话（即绘制点正处于相邻像素交叉线时），线宽必须是2的整数倍。否则会出现不饱满的像素。 2.如果绘制点为一个像素的
编码乱码问题灵静志远 java jvm jsp 编码
1、JVM中单个字符占用的字节长度跟编码方式有关，而默认编码方式又跟平台是一一对应的或说平台决定了默认字符编码方式；2、对于单个字符：ISO-8859-1单字节编码，GBK双字节编码，UTF-8三字节编码；因此中文平台(中文平台默认字符集编码GBK)下一个中文字符占2个字节，而英文平台(英文平台默认字符集编码Cp1252(类似于ISO-8859-1))。 3、getBytes()、getByte
java 求几个月后的日期 darkranger calendar getinstance
Date plandate = planDate.toDate(); SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd"); Calendar cal = Calendar.getInstance(); cal.setTime(plandate); // 取得三个月后时间 cal.add(Calendar.M
数据库设计的三大范式（通俗易懂） aijuans 数据库复习
关系数据库中的关系必须满足一定的要求。满足不同程度要求的为不同范式。数据库的设计范式是数据库设计所需要满足的规范。只有理解数据库的设计范式，才能设计出高效率、优雅的数据库，否则可能会设计出错误的数据库. 目前，主要有六种范式：第一范式、第二范式、第三范式、BC范式、第四范式和第五范式。满足最低要求的叫第一范式，简称1NF。在第一范式基础上进一步满足一些要求的为第二范式，简称2NF。其余依此类推。
想学工作流怎么入手 atongyeye jbpm
工作流在工作中变得越来越重要，很多朋友想学工作流却不知如何入手。很多朋友习惯性的这看一点，那了解一点，既不系统，也容易半途而废。好比学武功，最好的办法是有一本武功秘籍。研究明白，则犹如打通任督二脉。系统学习工作流，很重要的一本书《JBPM工作流开发指南》。本人苦苦学习两个月，基本上可以解决大部分流程问题。整理一下学习思路，有兴趣的朋友可以参考下。 1 首先要
Context和SQLiteOpenHelper创建数据库百合不是茶 android Context创建数据库
一直以为安卓数据库的创建就是使用SQLiteOpenHelper创建,但是最近在android的一本书上看到了Context也可以创建数据库,下面我们一起分析这两种方式创建数据库的方式和区别,重点在SQLiteOpenHelper 一:SQLiteOpenHelper创建数据库: 1,SQLi
浅谈group by和distinct bijian1013 oracle 数据库 group by distinct
group by和distinct只了去重意义一样，但是group by应用范围更广泛些，如分组汇总或者从聚合函数里筛选数据等。譬如：统计每id数并且只显示数大于3 select id ,count(id) from ta
vi opertion 征客丶 mac opration vi
进入 command mode （命令行模式）按 esc 键再按 shift + 冒号注：以下命令中带 $ 【在命令行模式下进行】，不带 $ 【在非命令行模式下进行】一、文件操作 1.1、强制退出不保存 $ q! 1.2、保存 $ w 1.3、保存并退出 $ wq 1.4、刷新或重新加载已打开的文件 $ e 二、光标移动 2.1、跳到指定行数字
【Spark十四】深入Spark RDD第三部分RDD基本API bit1129 spark
对于K/V类型的RDD,如下操作是什么含义？ val rdd = sc.parallelize(List(("A",3),("C",6),("A",1),("B",5)) rdd.reduceByKey(_+_).collect reduceByKey在这里的操作，是把
java类加载机制 BlueSkator java 虚拟机
java类加载机制 1.java类加载器的树状结构引导类加载器 ^ | 扩展类加载器 ^ | 系统类加载器 java使用代理模式来完成类加载，java的类加载器也有类似于继承的关系，引导类是最顶层的加载器，它是所有类的根加载器，它负责加载java核心库。当一个类加载器接到装载类到虚拟机的请求时，通常会代理给父类加载器，若已经是根加载器了，就自己完成加载。虚拟机区分一个Cla
动态添加文本框 BreakingBad 文本框
<script> var num=1; function AddInput() { var str=""; str+="<input
读《研磨设计模式》-代码笔记-单例模式 bylijinnan java 设计模式
声明：本文只为方便我个人查阅和理解，详细的分析以及源代码请移步原作者的博客http://chjavach.iteye.com/ public class Singleton { } /* * 懒汉模式。注意，getInstance如果在多线程环境中调用，需要加上synchronized，否则存在线程不安全问题 */ class LazySingleton
iOS应用打包发布常见问题 chenhbc ios iOS发布 iOS上传 iOS打包
这个月公司安排我一个人做iOS客户端开发，由于急着用，我先发布一个版本，由于第一次发布iOS应用，期间出了不少问题，记录于此。 1、使用Application Loader 发布时报错：Communication error.please use diagnostic mode to check connectivity.you need to have outbound acc
工作流复杂拓扑结构处理新思路 comsci 设计模式工作算法企业应用 OO
我们走的设计路线和国外的产品不太一样，不一样在哪里呢？国外的流程的设计思路是通过事先定义一整套规则(类似XPDL)来约束和控制流程图的复杂度(我对国外的产品了解不够多，仅仅是在有限的了解程度上面提出这样的看法)，从而避免在流程引擎中处理这些复杂的图的问题，而我们却没有通过事先定义这样的复杂的规则来约束和降低用户自定义流程图的灵活性，这样一来，在引擎和流程流转控制这一个层面就会遇到很
oracle 11g新特性Flashback data archive daizj oracle
1. 什么是flashback data archive Flashback data archive是oracle 11g中引入的一个新特性。Flashback archive是一个新的数据库对象，用于存储一个或多表的历史数据。Flashback archive是一个逻辑对象，概念上类似于表空间。实际上flashback archive可以看作是存储一个或多个表的所有事务变化的逻辑空间。
多叉树:2-3-4树 dieslrae 树
平衡树多叉树,每个节点最多有4个子节点和3个数据项,2,3,4的含义是指一个节点可能含有的子节点的个数,效率比红黑树稍差.一般不允许出现重复关键字值.2-3-4树有以下特征: 1、有一个数据项的节点总是有2个子节点(称为2-节点) 2、有两个数据项的节点总是有3个子节点(称为3-节
C语言学习七动态分配 malloc的使用 dcj3sjt126com c language malloc
/* 2013年3月15日15:16:24 malloc 就memory(内存) allocate(分配)的缩写本程序没有实际含义，只是理解使用 */ # include <stdio.h> # include <malloc.h> int main(void) { int i = 5; //分配了4个字节静态分配 int * p
Objective-C编码规范[译] dcj3sjt126com 代码规范
原文链接 : The official raywenderlich.com Objective-C style guide 原文作者 : raywenderlich.com Team 译文出自 : raywenderlich.com Objective-C编码规范译者 : Sam Lau
0.性能优化-目录 frank1234 性能优化
从今天开始笔者陆续发表一些性能测试相关的文章，主要是对自己前段时间学习的总结，由于水平有限，性能测试领域很深，本人理解的也比较浅，欢迎各位大咖批评指正。主要内容包括：一、性能测试指标吞吐量、TPS、响应时间、负载、可扩展性、PV、思考时间 http://frank1234.iteye.com/blog/2180305 二、性能测试策略生产环境相同基准测试预热等 htt
Java父类取得子类传递的泛型参数Class类型 happyqing java 泛型父类子类 Class
import java.lang.reflect.ParameterizedType; import java.lang.reflect.Type; import org.junit.Test; abstract class BaseDao<T> { public void getType() { //Class<E> clazz =
跟我学SpringMVC目录汇总贴、PDF下载、源码下载 jinnianshilongnian springMVC
----广告-------------------------------------------------------------- 网站核心商详页开发掌握Java技术，掌握并发/异步工具使用，熟悉spring、ibatis框架；掌握数据库技术，表设计和索引优化，分库分表/读写分离；了解缓存技术，熟练使用如Redis/Memcached等主流技术；了解Ngin
the HTTP rewrite module requires the PCRE library 流浪鱼 rewrite
./configure: error: the HTTP rewrite module requires the PCRE library. 模块依赖性Nginx需要依赖下面3个包 1. gzip 模块需要 zlib 库 ( 下载: http://www.zlib.net/ ) 2. rewrite 模块需要 pcre 库 ( 下载: http://www.pcre.org/ ) 3. s
第12章 Ajax（中） onestopweb Ajax
index.html <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/
Optimize query with Query Stripping in Web Intelligence blueoxygen BO
http://wiki.sdn.sap.com/wiki/display/BOBJ/Optimize+query+with+Query+Stripping+in+Web+Intelligence and a very straightfoward video http://www.sdn.sap.com/irj/scn/events?rid=/library/uuid/40ec3a0c-936
Java开发者写SQL时常犯的10个错误 tomcat_oracle java sql
1、不用PreparedStatements 　　有意思的是，在JDBC出现了许多年后的今天，这个错误依然出现在博客、论坛和邮件列表中，即便要记住和理解它是一件很简单的事。开发者不使用PreparedStatements的原因可能有如下几个：　　他们对PreparedStatements不了解　　他们认为使用PreparedStatements太慢了　　他们认为写Prepar
世纪互联与结盟有感阿尔萨斯
10月10日，世纪互联与（Foxcon）签约成立合资公司，有感。全球电子制造业巨头（全球500强企业）与世纪互联共同看好IDC、云计算等业务在中国的增长空间，双方迅速果断出手，在资本层面上达成合作，此举体现了全球电子制造业巨头对世纪互联IDC业务的欣赏与信任，另一方面反映出世纪互联目前良好的运营状况与广阔的发展前景。众所周知，精于电子产品制造（世界第一），对于世纪互联而言，能够与结盟