SAIMA/UserSettings/Layouts/default-2021.dwlt

937 lines
23 KiB
Plaintext
Raw Normal View History

2022-07-17 23:29:12 +08:00
%YAML 1.1
%TAG !u! tag:unity3d.com,2011:
--- !u!114 &1
MonoBehaviour:
m_ObjectHideFlags: 52
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 0}
m_Enabled: 1
m_EditorHideFlags: 1
m_Script: {fileID: 12004, guid: 0000000000000000e000000000000000, type: 0}
m_Name:
m_EditorClassIdentifier:
m_PixelRect:
serializedVersion: 2
x: 0
y: 43.2
width: 1536
height: 772.8
2022-07-17 23:29:12 +08:00
m_ShowMode: 4
2022-08-04 17:37:45 +08:00
m_Title: "\u5C42\u7EA7"
m_RootView: {fileID: 2}
2022-07-17 23:29:12 +08:00
m_MinSize: {x: 875, y: 300}
m_MaxSize: {x: 10000, y: 10000}
m_Maximized: 1
2022-07-17 23:29:12 +08:00
--- !u!114 &2
MonoBehaviour:
m_ObjectHideFlags: 52
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 0}
m_Enabled: 1
m_EditorHideFlags: 1
m_Script: {fileID: 12008, guid: 0000000000000000e000000000000000, type: 0}
2022-07-17 23:29:12 +08:00
m_Name:
m_EditorClassIdentifier:
m_Children:
- {fileID: 3}
- {fileID: 5}
任务:搭建基本玩法 1.让马可以跳跃 (1.测试,如果我给马的刚体一个(1,1)的力代表跳跃,是否可行? Good Job!通过测试,可以通过给力的方式使马整体起飞,而且控制点和马蹄都会随之起飞,是理想的状态。 (2.让马并拢每一组腿,当按住某键,使该组腿并拢,也就是消除输入偏差。当松开键,重新设置输入偏差,使双腿分开。 DONE (3.从输入中获取信息,当两腿均并拢,进入跳跃模式,否则离开跳跃模式,在跳跃模式下,如何通过输入计算出应该给出多大、哪个方向的的跳跃力是核心和难点 (4.马脚和马脚的控制点很难控制,数据也经常抖动,我不想通过这两个变量来计算跳跃的力。我打算直接通过输入值判断 (5.尝试:首先,若处于跳跃模式,每帧记录上一帧输入,并计算一个瞬时速度,当瞬时速度的y大于0,也就代表此时腿在上升,在预备,不考虑。若瞬时速度的y小于0,说明腿开始下降,可能会跳起。此时判断此瞬时速度的模长是否大于某个阈值,若是,进入戒备状态,此后的若干帧后,有任何一帧再低于阈值,说明输入结束,输出最后的速度,并给予马刚体。若此时瞬时速度的模长小于阈值 ,说明太慢,不记录。在这个戒备状态中的每一帧,需要记录瞬时速度,并累计影响,最终经过乘以调整值、取反(因为是相对作用)操作,得到需要赋予马的力,然后把力赋给马刚体,完成一次跳跃 (6.Good!初步尝试有效。在马着地后,重置跳跃状态,即可完成循环,开始下一次跳跃。 至此,马基本可以跳跃,但是手感极差,并且键鼠几乎没有操作空间,需要后续进一步优化……
2022-07-26 00:00:56 +08:00
- {fileID: 4}
2022-07-17 23:29:12 +08:00
m_Position:
serializedVersion: 2
x: 0
y: 0
width: 1536
height: 772.8
m_MinSize: {x: 875, y: 300}
m_MaxSize: {x: 10000, y: 10000}
m_UseTopView: 1
m_TopViewHeight: 30
m_UseBottomView: 1
m_BottomViewHeight: 20
2022-07-17 23:29:12 +08:00
--- !u!114 &3
MonoBehaviour:
m_ObjectHideFlags: 52
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 0}
m_Enabled: 1
m_EditorHideFlags: 1
m_Script: {fileID: 12011, guid: 0000000000000000e000000000000000, type: 0}
2022-07-17 23:29:12 +08:00
m_Name:
m_EditorClassIdentifier:
m_Children: []
m_Position:
serializedVersion: 2
x: 0
2022-07-17 23:29:12 +08:00
y: 0
width: 1536
height: 30
m_MinSize: {x: 0, y: 0}
m_MaxSize: {x: 0, y: 0}
m_LastLoadedLayoutName:
2022-07-17 23:29:12 +08:00
--- !u!114 &4
MonoBehaviour:
m_ObjectHideFlags: 52
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 0}
m_Enabled: 1
m_EditorHideFlags: 1
任务:搭建基本玩法 1.让马可以跳跃 (1.测试,如果我给马的刚体一个(1,1)的力代表跳跃,是否可行? Good Job!通过测试,可以通过给力的方式使马整体起飞,而且控制点和马蹄都会随之起飞,是理想的状态。 (2.让马并拢每一组腿,当按住某键,使该组腿并拢,也就是消除输入偏差。当松开键,重新设置输入偏差,使双腿分开。 DONE (3.从输入中获取信息,当两腿均并拢,进入跳跃模式,否则离开跳跃模式,在跳跃模式下,如何通过输入计算出应该给出多大、哪个方向的的跳跃力是核心和难点 (4.马脚和马脚的控制点很难控制,数据也经常抖动,我不想通过这两个变量来计算跳跃的力。我打算直接通过输入值判断 (5.尝试:首先,若处于跳跃模式,每帧记录上一帧输入,并计算一个瞬时速度,当瞬时速度的y大于0,也就代表此时腿在上升,在预备,不考虑。若瞬时速度的y小于0,说明腿开始下降,可能会跳起。此时判断此瞬时速度的模长是否大于某个阈值,若是,进入戒备状态,此后的若干帧后,有任何一帧再低于阈值,说明输入结束,输出最后的速度,并给予马刚体。若此时瞬时速度的模长小于阈值 ,说明太慢,不记录。在这个戒备状态中的每一帧,需要记录瞬时速度,并累计影响,最终经过乘以调整值、取反(因为是相对作用)操作,得到需要赋予马的力,然后把力赋给马刚体,完成一次跳跃 (6.Good!初步尝试有效。在马着地后,重置跳跃状态,即可完成循环,开始下一次跳跃。 至此,马基本可以跳跃,但是手感极差,并且键鼠几乎没有操作空间,需要后续进一步优化……
2022-07-26 00:00:56 +08:00
m_Script: {fileID: 12042, guid: 0000000000000000e000000000000000, type: 0}
2022-07-17 23:29:12 +08:00
m_Name:
m_EditorClassIdentifier:
任务:搭建基本玩法 1.让马可以跳跃 (1.测试,如果我给马的刚体一个(1,1)的力代表跳跃,是否可行? Good Job!通过测试,可以通过给力的方式使马整体起飞,而且控制点和马蹄都会随之起飞,是理想的状态。 (2.让马并拢每一组腿,当按住某键,使该组腿并拢,也就是消除输入偏差。当松开键,重新设置输入偏差,使双腿分开。 DONE (3.从输入中获取信息,当两腿均并拢,进入跳跃模式,否则离开跳跃模式,在跳跃模式下,如何通过输入计算出应该给出多大、哪个方向的的跳跃力是核心和难点 (4.马脚和马脚的控制点很难控制,数据也经常抖动,我不想通过这两个变量来计算跳跃的力。我打算直接通过输入值判断 (5.尝试:首先,若处于跳跃模式,每帧记录上一帧输入,并计算一个瞬时速度,当瞬时速度的y大于0,也就代表此时腿在上升,在预备,不考虑。若瞬时速度的y小于0,说明腿开始下降,可能会跳起。此时判断此瞬时速度的模长是否大于某个阈值,若是,进入戒备状态,此后的若干帧后,有任何一帧再低于阈值,说明输入结束,输出最后的速度,并给予马刚体。若此时瞬时速度的模长小于阈值 ,说明太慢,不记录。在这个戒备状态中的每一帧,需要记录瞬时速度,并累计影响,最终经过乘以调整值、取反(因为是相对作用)操作,得到需要赋予马的力,然后把力赋给马刚体,完成一次跳跃 (6.Good!初步尝试有效。在马着地后,重置跳跃状态,即可完成循环,开始下一次跳跃。 至此,马基本可以跳跃,但是手感极差,并且键鼠几乎没有操作空间,需要后续进一步优化……
2022-07-26 00:00:56 +08:00
m_Children: []
2022-07-17 23:29:12 +08:00
m_Position:
serializedVersion: 2
x: 0
任务:搭建基本玩法 1.让马可以跳跃 (1.测试,如果我给马的刚体一个(1,1)的力代表跳跃,是否可行? Good Job!通过测试,可以通过给力的方式使马整体起飞,而且控制点和马蹄都会随之起飞,是理想的状态。 (2.让马并拢每一组腿,当按住某键,使该组腿并拢,也就是消除输入偏差。当松开键,重新设置输入偏差,使双腿分开。 DONE (3.从输入中获取信息,当两腿均并拢,进入跳跃模式,否则离开跳跃模式,在跳跃模式下,如何通过输入计算出应该给出多大、哪个方向的的跳跃力是核心和难点 (4.马脚和马脚的控制点很难控制,数据也经常抖动,我不想通过这两个变量来计算跳跃的力。我打算直接通过输入值判断 (5.尝试:首先,若处于跳跃模式,每帧记录上一帧输入,并计算一个瞬时速度,当瞬时速度的y大于0,也就代表此时腿在上升,在预备,不考虑。若瞬时速度的y小于0,说明腿开始下降,可能会跳起。此时判断此瞬时速度的模长是否大于某个阈值,若是,进入戒备状态,此后的若干帧后,有任何一帧再低于阈值,说明输入结束,输出最后的速度,并给予马刚体。若此时瞬时速度的模长小于阈值 ,说明太慢,不记录。在这个戒备状态中的每一帧,需要记录瞬时速度,并累计影响,最终经过乘以调整值、取反(因为是相对作用)操作,得到需要赋予马的力,然后把力赋给马刚体,完成一次跳跃 (6.Good!初步尝试有效。在马着地后,重置跳跃状态,即可完成循环,开始下一次跳跃。 至此,马基本可以跳跃,但是手感极差,并且键鼠几乎没有操作空间,需要后续进一步优化……
2022-07-26 00:00:56 +08:00
y: 752.8
width: 1536
任务:搭建基本玩法 1.让马可以跳跃 (1.测试,如果我给马的刚体一个(1,1)的力代表跳跃,是否可行? Good Job!通过测试,可以通过给力的方式使马整体起飞,而且控制点和马蹄都会随之起飞,是理想的状态。 (2.让马并拢每一组腿,当按住某键,使该组腿并拢,也就是消除输入偏差。当松开键,重新设置输入偏差,使双腿分开。 DONE (3.从输入中获取信息,当两腿均并拢,进入跳跃模式,否则离开跳跃模式,在跳跃模式下,如何通过输入计算出应该给出多大、哪个方向的的跳跃力是核心和难点 (4.马脚和马脚的控制点很难控制,数据也经常抖动,我不想通过这两个变量来计算跳跃的力。我打算直接通过输入值判断 (5.尝试:首先,若处于跳跃模式,每帧记录上一帧输入,并计算一个瞬时速度,当瞬时速度的y大于0,也就代表此时腿在上升,在预备,不考虑。若瞬时速度的y小于0,说明腿开始下降,可能会跳起。此时判断此瞬时速度的模长是否大于某个阈值,若是,进入戒备状态,此后的若干帧后,有任何一帧再低于阈值,说明输入结束,输出最后的速度,并给予马刚体。若此时瞬时速度的模长小于阈值 ,说明太慢,不记录。在这个戒备状态中的每一帧,需要记录瞬时速度,并累计影响,最终经过乘以调整值、取反(因为是相对作用)操作,得到需要赋予马的力,然后把力赋给马刚体,完成一次跳跃 (6.Good!初步尝试有效。在马着地后,重置跳跃状态,即可完成循环,开始下一次跳跃。 至此,马基本可以跳跃,但是手感极差,并且键鼠几乎没有操作空间,需要后续进一步优化……
2022-07-26 00:00:56 +08:00
height: 20
m_MinSize: {x: 0, y: 0}
m_MaxSize: {x: 0, y: 0}
2022-07-17 23:29:12 +08:00
--- !u!114 &5
MonoBehaviour:
m_ObjectHideFlags: 52
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 0}
m_Enabled: 1
m_EditorHideFlags: 1
任务:搭建基本玩法 1.让马可以跳跃 (1.测试,如果我给马的刚体一个(1,1)的力代表跳跃,是否可行? Good Job!通过测试,可以通过给力的方式使马整体起飞,而且控制点和马蹄都会随之起飞,是理想的状态。 (2.让马并拢每一组腿,当按住某键,使该组腿并拢,也就是消除输入偏差。当松开键,重新设置输入偏差,使双腿分开。 DONE (3.从输入中获取信息,当两腿均并拢,进入跳跃模式,否则离开跳跃模式,在跳跃模式下,如何通过输入计算出应该给出多大、哪个方向的的跳跃力是核心和难点 (4.马脚和马脚的控制点很难控制,数据也经常抖动,我不想通过这两个变量来计算跳跃的力。我打算直接通过输入值判断 (5.尝试:首先,若处于跳跃模式,每帧记录上一帧输入,并计算一个瞬时速度,当瞬时速度的y大于0,也就代表此时腿在上升,在预备,不考虑。若瞬时速度的y小于0,说明腿开始下降,可能会跳起。此时判断此瞬时速度的模长是否大于某个阈值,若是,进入戒备状态,此后的若干帧后,有任何一帧再低于阈值,说明输入结束,输出最后的速度,并给予马刚体。若此时瞬时速度的模长小于阈值 ,说明太慢,不记录。在这个戒备状态中的每一帧,需要记录瞬时速度,并累计影响,最终经过乘以调整值、取反(因为是相对作用)操作,得到需要赋予马的力,然后把力赋给马刚体,完成一次跳跃 (6.Good!初步尝试有效。在马着地后,重置跳跃状态,即可完成循环,开始下一次跳跃。 至此,马基本可以跳跃,但是手感极差,并且键鼠几乎没有操作空间,需要后续进一步优化……
2022-07-26 00:00:56 +08:00
m_Script: {fileID: 12010, guid: 0000000000000000e000000000000000, type: 0}
m_Name:
2022-07-17 23:29:12 +08:00
m_EditorClassIdentifier:
任务:搭建基本玩法 1.让马可以跳跃 (1.测试,如果我给马的刚体一个(1,1)的力代表跳跃,是否可行? Good Job!通过测试,可以通过给力的方式使马整体起飞,而且控制点和马蹄都会随之起飞,是理想的状态。 (2.让马并拢每一组腿,当按住某键,使该组腿并拢,也就是消除输入偏差。当松开键,重新设置输入偏差,使双腿分开。 DONE (3.从输入中获取信息,当两腿均并拢,进入跳跃模式,否则离开跳跃模式,在跳跃模式下,如何通过输入计算出应该给出多大、哪个方向的的跳跃力是核心和难点 (4.马脚和马脚的控制点很难控制,数据也经常抖动,我不想通过这两个变量来计算跳跃的力。我打算直接通过输入值判断 (5.尝试:首先,若处于跳跃模式,每帧记录上一帧输入,并计算一个瞬时速度,当瞬时速度的y大于0,也就代表此时腿在上升,在预备,不考虑。若瞬时速度的y小于0,说明腿开始下降,可能会跳起。此时判断此瞬时速度的模长是否大于某个阈值,若是,进入戒备状态,此后的若干帧后,有任何一帧再低于阈值,说明输入结束,输出最后的速度,并给予马刚体。若此时瞬时速度的模长小于阈值 ,说明太慢,不记录。在这个戒备状态中的每一帧,需要记录瞬时速度,并累计影响,最终经过乘以调整值、取反(因为是相对作用)操作,得到需要赋予马的力,然后把力赋给马刚体,完成一次跳跃 (6.Good!初步尝试有效。在马着地后,重置跳跃状态,即可完成循环,开始下一次跳跃。 至此,马基本可以跳跃,但是手感极差,并且键鼠几乎没有操作空间,需要后续进一步优化……
2022-07-26 00:00:56 +08:00
m_Children:
- {fileID: 6}
- {fileID: 9}
- {fileID: 10}
- {fileID: 11}
2022-07-17 23:29:12 +08:00
m_Position:
serializedVersion: 2
x: 0
任务:搭建基本玩法 1.让马可以跳跃 (1.测试,如果我给马的刚体一个(1,1)的力代表跳跃,是否可行? Good Job!通过测试,可以通过给力的方式使马整体起飞,而且控制点和马蹄都会随之起飞,是理想的状态。 (2.让马并拢每一组腿,当按住某键,使该组腿并拢,也就是消除输入偏差。当松开键,重新设置输入偏差,使双腿分开。 DONE (3.从输入中获取信息,当两腿均并拢,进入跳跃模式,否则离开跳跃模式,在跳跃模式下,如何通过输入计算出应该给出多大、哪个方向的的跳跃力是核心和难点 (4.马脚和马脚的控制点很难控制,数据也经常抖动,我不想通过这两个变量来计算跳跃的力。我打算直接通过输入值判断 (5.尝试:首先,若处于跳跃模式,每帧记录上一帧输入,并计算一个瞬时速度,当瞬时速度的y大于0,也就代表此时腿在上升,在预备,不考虑。若瞬时速度的y小于0,说明腿开始下降,可能会跳起。此时判断此瞬时速度的模长是否大于某个阈值,若是,进入戒备状态,此后的若干帧后,有任何一帧再低于阈值,说明输入结束,输出最后的速度,并给予马刚体。若此时瞬时速度的模长小于阈值 ,说明太慢,不记录。在这个戒备状态中的每一帧,需要记录瞬时速度,并累计影响,最终经过乘以调整值、取反(因为是相对作用)操作,得到需要赋予马的力,然后把力赋给马刚体,完成一次跳跃 (6.Good!初步尝试有效。在马着地后,重置跳跃状态,即可完成循环,开始下一次跳跃。 至此,马基本可以跳跃,但是手感极差,并且键鼠几乎没有操作空间,需要后续进一步优化……
2022-07-26 00:00:56 +08:00
y: 30
width: 1536
任务:搭建基本玩法 1.让马可以跳跃 (1.测试,如果我给马的刚体一个(1,1)的力代表跳跃,是否可行? Good Job!通过测试,可以通过给力的方式使马整体起飞,而且控制点和马蹄都会随之起飞,是理想的状态。 (2.让马并拢每一组腿,当按住某键,使该组腿并拢,也就是消除输入偏差。当松开键,重新设置输入偏差,使双腿分开。 DONE (3.从输入中获取信息,当两腿均并拢,进入跳跃模式,否则离开跳跃模式,在跳跃模式下,如何通过输入计算出应该给出多大、哪个方向的的跳跃力是核心和难点 (4.马脚和马脚的控制点很难控制,数据也经常抖动,我不想通过这两个变量来计算跳跃的力。我打算直接通过输入值判断 (5.尝试:首先,若处于跳跃模式,每帧记录上一帧输入,并计算一个瞬时速度,当瞬时速度的y大于0,也就代表此时腿在上升,在预备,不考虑。若瞬时速度的y小于0,说明腿开始下降,可能会跳起。此时判断此瞬时速度的模长是否大于某个阈值,若是,进入戒备状态,此后的若干帧后,有任何一帧再低于阈值,说明输入结束,输出最后的速度,并给予马刚体。若此时瞬时速度的模长小于阈值 ,说明太慢,不记录。在这个戒备状态中的每一帧,需要记录瞬时速度,并累计影响,最终经过乘以调整值、取反(因为是相对作用)操作,得到需要赋予马的力,然后把力赋给马刚体,完成一次跳跃 (6.Good!初步尝试有效。在马着地后,重置跳跃状态,即可完成循环,开始下一次跳跃。 至此,马基本可以跳跃,但是手感极差,并且键鼠几乎没有操作空间,需要后续进一步优化……
2022-07-26 00:00:56 +08:00
height: 722.8
m_MinSize: {x: 400, y: 200}
m_MaxSize: {x: 32384, y: 16192}
vertical: 0
2022-08-04 17:37:45 +08:00
controlID: 691
2022-07-17 23:29:12 +08:00
--- !u!114 &6
MonoBehaviour:
m_ObjectHideFlags: 52
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 0}
m_Enabled: 1
m_EditorHideFlags: 1
m_Script: {fileID: 12010, guid: 0000000000000000e000000000000000, type: 0}
2022-07-17 23:29:12 +08:00
m_Name:
m_EditorClassIdentifier:
m_Children:
任务:搭建基本玩法 1.让马可以跳跃 (1.测试,如果我给马的刚体一个(1,1)的力代表跳跃,是否可行? Good Job!通过测试,可以通过给力的方式使马整体起飞,而且控制点和马蹄都会随之起飞,是理想的状态。 (2.让马并拢每一组腿,当按住某键,使该组腿并拢,也就是消除输入偏差。当松开键,重新设置输入偏差,使双腿分开。 DONE (3.从输入中获取信息,当两腿均并拢,进入跳跃模式,否则离开跳跃模式,在跳跃模式下,如何通过输入计算出应该给出多大、哪个方向的的跳跃力是核心和难点 (4.马脚和马脚的控制点很难控制,数据也经常抖动,我不想通过这两个变量来计算跳跃的力。我打算直接通过输入值判断 (5.尝试:首先,若处于跳跃模式,每帧记录上一帧输入,并计算一个瞬时速度,当瞬时速度的y大于0,也就代表此时腿在上升,在预备,不考虑。若瞬时速度的y小于0,说明腿开始下降,可能会跳起。此时判断此瞬时速度的模长是否大于某个阈值,若是,进入戒备状态,此后的若干帧后,有任何一帧再低于阈值,说明输入结束,输出最后的速度,并给予马刚体。若此时瞬时速度的模长小于阈值 ,说明太慢,不记录。在这个戒备状态中的每一帧,需要记录瞬时速度,并累计影响,最终经过乘以调整值、取反(因为是相对作用)操作,得到需要赋予马的力,然后把力赋给马刚体,完成一次跳跃 (6.Good!初步尝试有效。在马着地后,重置跳跃状态,即可完成循环,开始下一次跳跃。 至此,马基本可以跳跃,但是手感极差,并且键鼠几乎没有操作空间,需要后续进一步优化……
2022-07-26 00:00:56 +08:00
- {fileID: 7}
- {fileID: 8}
2022-07-17 23:29:12 +08:00
m_Position:
serializedVersion: 2
x: 0
y: 0
2022-08-04 17:37:45 +08:00
width: 664.8
height: 722.8
m_MinSize: {x: 100, y: 200}
m_MaxSize: {x: 8096, y: 16192}
vertical: 1
2022-08-04 17:37:45 +08:00
controlID: 810
2022-07-17 23:29:12 +08:00
--- !u!114 &7
MonoBehaviour:
m_ObjectHideFlags: 52
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 0}
m_Enabled: 1
m_EditorHideFlags: 1
m_Script: {fileID: 12006, guid: 0000000000000000e000000000000000, type: 0}
任务:搭建基本玩法 1.让马可以跳跃 (1.测试,如果我给马的刚体一个(1,1)的力代表跳跃,是否可行? Good Job!通过测试,可以通过给力的方式使马整体起飞,而且控制点和马蹄都会随之起飞,是理想的状态。 (2.让马并拢每一组腿,当按住某键,使该组腿并拢,也就是消除输入偏差。当松开键,重新设置输入偏差,使双腿分开。 DONE (3.从输入中获取信息,当两腿均并拢,进入跳跃模式,否则离开跳跃模式,在跳跃模式下,如何通过输入计算出应该给出多大、哪个方向的的跳跃力是核心和难点 (4.马脚和马脚的控制点很难控制,数据也经常抖动,我不想通过这两个变量来计算跳跃的力。我打算直接通过输入值判断 (5.尝试:首先,若处于跳跃模式,每帧记录上一帧输入,并计算一个瞬时速度,当瞬时速度的y大于0,也就代表此时腿在上升,在预备,不考虑。若瞬时速度的y小于0,说明腿开始下降,可能会跳起。此时判断此瞬时速度的模长是否大于某个阈值,若是,进入戒备状态,此后的若干帧后,有任何一帧再低于阈值,说明输入结束,输出最后的速度,并给予马刚体。若此时瞬时速度的模长小于阈值 ,说明太慢,不记录。在这个戒备状态中的每一帧,需要记录瞬时速度,并累计影响,最终经过乘以调整值、取反(因为是相对作用)操作,得到需要赋予马的力,然后把力赋给马刚体,完成一次跳跃 (6.Good!初步尝试有效。在马着地后,重置跳跃状态,即可完成循环,开始下一次跳跃。 至此,马基本可以跳跃,但是手感极差,并且键鼠几乎没有操作空间,需要后续进一步优化……
2022-07-26 00:00:56 +08:00
m_Name: SceneView
2022-07-17 23:29:12 +08:00
m_EditorClassIdentifier:
m_Children: []
m_Position:
serializedVersion: 2
任务:搭建基本玩法 1.让马可以跳跃 (1.测试,如果我给马的刚体一个(1,1)的力代表跳跃,是否可行? Good Job!通过测试,可以通过给力的方式使马整体起飞,而且控制点和马蹄都会随之起飞,是理想的状态。 (2.让马并拢每一组腿,当按住某键,使该组腿并拢,也就是消除输入偏差。当松开键,重新设置输入偏差,使双腿分开。 DONE (3.从输入中获取信息,当两腿均并拢,进入跳跃模式,否则离开跳跃模式,在跳跃模式下,如何通过输入计算出应该给出多大、哪个方向的的跳跃力是核心和难点 (4.马脚和马脚的控制点很难控制,数据也经常抖动,我不想通过这两个变量来计算跳跃的力。我打算直接通过输入值判断 (5.尝试:首先,若处于跳跃模式,每帧记录上一帧输入,并计算一个瞬时速度,当瞬时速度的y大于0,也就代表此时腿在上升,在预备,不考虑。若瞬时速度的y小于0,说明腿开始下降,可能会跳起。此时判断此瞬时速度的模长是否大于某个阈值,若是,进入戒备状态,此后的若干帧后,有任何一帧再低于阈值,说明输入结束,输出最后的速度,并给予马刚体。若此时瞬时速度的模长小于阈值 ,说明太慢,不记录。在这个戒备状态中的每一帧,需要记录瞬时速度,并累计影响,最终经过乘以调整值、取反(因为是相对作用)操作,得到需要赋予马的力,然后把力赋给马刚体,完成一次跳跃 (6.Good!初步尝试有效。在马着地后,重置跳跃状态,即可完成循环,开始下一次跳跃。 至此,马基本可以跳跃,但是手感极差,并且键鼠几乎没有操作空间,需要后续进一步优化……
2022-07-26 00:00:56 +08:00
x: 0
2022-07-17 23:29:12 +08:00
y: 0
2022-08-04 17:37:45 +08:00
width: 664.8
height: 528.8
m_MinSize: {x: 201, y: 221}
m_MaxSize: {x: 4001, y: 4021}
2022-08-04 17:37:45 +08:00
m_ActualView: {fileID: 13}
m_Panes:
2022-08-04 17:37:45 +08:00
- {fileID: 13}
m_Selected: 0
m_LastSelected: 0
2022-07-17 23:29:12 +08:00
--- !u!114 &8
MonoBehaviour:
m_ObjectHideFlags: 52
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 0}
m_Enabled: 1
m_EditorHideFlags: 1
m_Script: {fileID: 12006, guid: 0000000000000000e000000000000000, type: 0}
任务:搭建基本玩法 1.让马可以跳跃 (1.测试,如果我给马的刚体一个(1,1)的力代表跳跃,是否可行? Good Job!通过测试,可以通过给力的方式使马整体起飞,而且控制点和马蹄都会随之起飞,是理想的状态。 (2.让马并拢每一组腿,当按住某键,使该组腿并拢,也就是消除输入偏差。当松开键,重新设置输入偏差,使双腿分开。 DONE (3.从输入中获取信息,当两腿均并拢,进入跳跃模式,否则离开跳跃模式,在跳跃模式下,如何通过输入计算出应该给出多大、哪个方向的的跳跃力是核心和难点 (4.马脚和马脚的控制点很难控制,数据也经常抖动,我不想通过这两个变量来计算跳跃的力。我打算直接通过输入值判断 (5.尝试:首先,若处于跳跃模式,每帧记录上一帧输入,并计算一个瞬时速度,当瞬时速度的y大于0,也就代表此时腿在上升,在预备,不考虑。若瞬时速度的y小于0,说明腿开始下降,可能会跳起。此时判断此瞬时速度的模长是否大于某个阈值,若是,进入戒备状态,此后的若干帧后,有任何一帧再低于阈值,说明输入结束,输出最后的速度,并给予马刚体。若此时瞬时速度的模长小于阈值 ,说明太慢,不记录。在这个戒备状态中的每一帧,需要记录瞬时速度,并累计影响,最终经过乘以调整值、取反(因为是相对作用)操作,得到需要赋予马的力,然后把力赋给马刚体,完成一次跳跃 (6.Good!初步尝试有效。在马着地后,重置跳跃状态,即可完成循环,开始下一次跳跃。 至此,马基本可以跳跃,但是手感极差,并且键鼠几乎没有操作空间,需要后续进一步优化……
2022-07-26 00:00:56 +08:00
m_Name: GameView
2022-07-17 23:29:12 +08:00
m_EditorClassIdentifier:
m_Children: []
m_Position:
serializedVersion: 2
任务:搭建基本玩法 1.让马可以跳跃 (1.测试,如果我给马的刚体一个(1,1)的力代表跳跃,是否可行? Good Job!通过测试,可以通过给力的方式使马整体起飞,而且控制点和马蹄都会随之起飞,是理想的状态。 (2.让马并拢每一组腿,当按住某键,使该组腿并拢,也就是消除输入偏差。当松开键,重新设置输入偏差,使双腿分开。 DONE (3.从输入中获取信息,当两腿均并拢,进入跳跃模式,否则离开跳跃模式,在跳跃模式下,如何通过输入计算出应该给出多大、哪个方向的的跳跃力是核心和难点 (4.马脚和马脚的控制点很难控制,数据也经常抖动,我不想通过这两个变量来计算跳跃的力。我打算直接通过输入值判断 (5.尝试:首先,若处于跳跃模式,每帧记录上一帧输入,并计算一个瞬时速度,当瞬时速度的y大于0,也就代表此时腿在上升,在预备,不考虑。若瞬时速度的y小于0,说明腿开始下降,可能会跳起。此时判断此瞬时速度的模长是否大于某个阈值,若是,进入戒备状态,此后的若干帧后,有任何一帧再低于阈值,说明输入结束,输出最后的速度,并给予马刚体。若此时瞬时速度的模长小于阈值 ,说明太慢,不记录。在这个戒备状态中的每一帧,需要记录瞬时速度,并累计影响,最终经过乘以调整值、取反(因为是相对作用)操作,得到需要赋予马的力,然后把力赋给马刚体,完成一次跳跃 (6.Good!初步尝试有效。在马着地后,重置跳跃状态,即可完成循环,开始下一次跳跃。 至此,马基本可以跳跃,但是手感极差,并且键鼠几乎没有操作空间,需要后续进一步优化……
2022-07-26 00:00:56 +08:00
x: 0
2022-08-04 17:37:45 +08:00
y: 528.8
width: 664.8
height: 194
m_MinSize: {x: 201, y: 221}
m_MaxSize: {x: 4001, y: 4021}
2022-08-04 17:37:45 +08:00
m_ActualView: {fileID: 12}
m_Panes:
2022-08-04 17:37:45 +08:00
- {fileID: 12}
m_Selected: 0
m_LastSelected: 0
2022-07-17 23:29:12 +08:00
--- !u!114 &9
MonoBehaviour:
m_ObjectHideFlags: 52
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 0}
m_Enabled: 1
m_EditorHideFlags: 1
m_Script: {fileID: 12006, guid: 0000000000000000e000000000000000, type: 0}
2022-07-17 23:29:12 +08:00
m_Name:
m_EditorClassIdentifier:
m_Children: []
2022-07-17 23:29:12 +08:00
m_Position:
serializedVersion: 2
2022-08-04 17:37:45 +08:00
x: 664.8
2022-07-17 23:29:12 +08:00
y: 0
2022-08-04 17:37:45 +08:00
width: 252
height: 722.8
任务:搭建基本玩法 1.让马可以跳跃 (1.测试,如果我给马的刚体一个(1,1)的力代表跳跃,是否可行? Good Job!通过测试,可以通过给力的方式使马整体起飞,而且控制点和马蹄都会随之起飞,是理想的状态。 (2.让马并拢每一组腿,当按住某键,使该组腿并拢,也就是消除输入偏差。当松开键,重新设置输入偏差,使双腿分开。 DONE (3.从输入中获取信息,当两腿均并拢,进入跳跃模式,否则离开跳跃模式,在跳跃模式下,如何通过输入计算出应该给出多大、哪个方向的的跳跃力是核心和难点 (4.马脚和马脚的控制点很难控制,数据也经常抖动,我不想通过这两个变量来计算跳跃的力。我打算直接通过输入值判断 (5.尝试:首先,若处于跳跃模式,每帧记录上一帧输入,并计算一个瞬时速度,当瞬时速度的y大于0,也就代表此时腿在上升,在预备,不考虑。若瞬时速度的y小于0,说明腿开始下降,可能会跳起。此时判断此瞬时速度的模长是否大于某个阈值,若是,进入戒备状态,此后的若干帧后,有任何一帧再低于阈值,说明输入结束,输出最后的速度,并给予马刚体。若此时瞬时速度的模长小于阈值 ,说明太慢,不记录。在这个戒备状态中的每一帧,需要记录瞬时速度,并累计影响,最终经过乘以调整值、取反(因为是相对作用)操作,得到需要赋予马的力,然后把力赋给马刚体,完成一次跳跃 (6.Good!初步尝试有效。在马着地后,重置跳跃状态,即可完成循环,开始下一次跳跃。 至此,马基本可以跳跃,但是手感极差,并且键鼠几乎没有操作空间,需要后续进一步优化……
2022-07-26 00:00:56 +08:00
m_MinSize: {x: 202, y: 221}
m_MaxSize: {x: 4002, y: 4021}
m_ActualView: {fileID: 14}
m_Panes:
任务:搭建基本玩法 1.让马可以跳跃 (1.测试,如果我给马的刚体一个(1,1)的力代表跳跃,是否可行? Good Job!通过测试,可以通过给力的方式使马整体起飞,而且控制点和马蹄都会随之起飞,是理想的状态。 (2.让马并拢每一组腿,当按住某键,使该组腿并拢,也就是消除输入偏差。当松开键,重新设置输入偏差,使双腿分开。 DONE (3.从输入中获取信息,当两腿均并拢,进入跳跃模式,否则离开跳跃模式,在跳跃模式下,如何通过输入计算出应该给出多大、哪个方向的的跳跃力是核心和难点 (4.马脚和马脚的控制点很难控制,数据也经常抖动,我不想通过这两个变量来计算跳跃的力。我打算直接通过输入值判断 (5.尝试:首先,若处于跳跃模式,每帧记录上一帧输入,并计算一个瞬时速度,当瞬时速度的y大于0,也就代表此时腿在上升,在预备,不考虑。若瞬时速度的y小于0,说明腿开始下降,可能会跳起。此时判断此瞬时速度的模长是否大于某个阈值,若是,进入戒备状态,此后的若干帧后,有任何一帧再低于阈值,说明输入结束,输出最后的速度,并给予马刚体。若此时瞬时速度的模长小于阈值 ,说明太慢,不记录。在这个戒备状态中的每一帧,需要记录瞬时速度,并累计影响,最终经过乘以调整值、取反(因为是相对作用)操作,得到需要赋予马的力,然后把力赋给马刚体,完成一次跳跃 (6.Good!初步尝试有效。在马着地后,重置跳跃状态,即可完成循环,开始下一次跳跃。 至此,马基本可以跳跃,但是手感极差,并且键鼠几乎没有操作空间,需要后续进一步优化……
2022-07-26 00:00:56 +08:00
- {fileID: 14}
m_Selected: 0
m_LastSelected: 0
2022-07-17 23:29:12 +08:00
--- !u!114 &10
MonoBehaviour:
m_ObjectHideFlags: 52
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 0}
m_Enabled: 1
m_EditorHideFlags: 1
m_Script: {fileID: 12006, guid: 0000000000000000e000000000000000, type: 0}
2022-07-17 23:29:12 +08:00
m_Name:
m_EditorClassIdentifier:
m_Children: []
2022-07-17 23:29:12 +08:00
m_Position:
serializedVersion: 2
2022-08-04 17:37:45 +08:00
x: 916.8
2022-07-17 23:29:12 +08:00
y: 0
2022-08-04 17:37:45 +08:00
width: 368.8
任务:搭建基本玩法 1.让马可以跳跃 (1.测试,如果我给马的刚体一个(1,1)的力代表跳跃,是否可行? Good Job!通过测试,可以通过给力的方式使马整体起飞,而且控制点和马蹄都会随之起飞,是理想的状态。 (2.让马并拢每一组腿,当按住某键,使该组腿并拢,也就是消除输入偏差。当松开键,重新设置输入偏差,使双腿分开。 DONE (3.从输入中获取信息,当两腿均并拢,进入跳跃模式,否则离开跳跃模式,在跳跃模式下,如何通过输入计算出应该给出多大、哪个方向的的跳跃力是核心和难点 (4.马脚和马脚的控制点很难控制,数据也经常抖动,我不想通过这两个变量来计算跳跃的力。我打算直接通过输入值判断 (5.尝试:首先,若处于跳跃模式,每帧记录上一帧输入,并计算一个瞬时速度,当瞬时速度的y大于0,也就代表此时腿在上升,在预备,不考虑。若瞬时速度的y小于0,说明腿开始下降,可能会跳起。此时判断此瞬时速度的模长是否大于某个阈值,若是,进入戒备状态,此后的若干帧后,有任何一帧再低于阈值,说明输入结束,输出最后的速度,并给予马刚体。若此时瞬时速度的模长小于阈值 ,说明太慢,不记录。在这个戒备状态中的每一帧,需要记录瞬时速度,并累计影响,最终经过乘以调整值、取反(因为是相对作用)操作,得到需要赋予马的力,然后把力赋给马刚体,完成一次跳跃 (6.Good!初步尝试有效。在马着地后,重置跳跃状态,即可完成循环,开始下一次跳跃。 至此,马基本可以跳跃,但是手感极差,并且键鼠几乎没有操作空间,需要后续进一步优化……
2022-07-26 00:00:56 +08:00
height: 722.8
m_MinSize: {x: 232, y: 271}
m_MaxSize: {x: 10002, y: 10021}
m_ActualView: {fileID: 15}
m_Panes:
任务:搭建基本玩法 1.让马可以跳跃 (1.测试,如果我给马的刚体一个(1,1)的力代表跳跃,是否可行? Good Job!通过测试,可以通过给力的方式使马整体起飞,而且控制点和马蹄都会随之起飞,是理想的状态。 (2.让马并拢每一组腿,当按住某键,使该组腿并拢,也就是消除输入偏差。当松开键,重新设置输入偏差,使双腿分开。 DONE (3.从输入中获取信息,当两腿均并拢,进入跳跃模式,否则离开跳跃模式,在跳跃模式下,如何通过输入计算出应该给出多大、哪个方向的的跳跃力是核心和难点 (4.马脚和马脚的控制点很难控制,数据也经常抖动,我不想通过这两个变量来计算跳跃的力。我打算直接通过输入值判断 (5.尝试:首先,若处于跳跃模式,每帧记录上一帧输入,并计算一个瞬时速度,当瞬时速度的y大于0,也就代表此时腿在上升,在预备,不考虑。若瞬时速度的y小于0,说明腿开始下降,可能会跳起。此时判断此瞬时速度的模长是否大于某个阈值,若是,进入戒备状态,此后的若干帧后,有任何一帧再低于阈值,说明输入结束,输出最后的速度,并给予马刚体。若此时瞬时速度的模长小于阈值 ,说明太慢,不记录。在这个戒备状态中的每一帧,需要记录瞬时速度,并累计影响,最终经过乘以调整值、取反(因为是相对作用)操作,得到需要赋予马的力,然后把力赋给马刚体,完成一次跳跃 (6.Good!初步尝试有效。在马着地后,重置跳跃状态,即可完成循环,开始下一次跳跃。 至此,马基本可以跳跃,但是手感极差,并且键鼠几乎没有操作空间,需要后续进一步优化……
2022-07-26 00:00:56 +08:00
- {fileID: 15}
m_Selected: 0
m_LastSelected: 0
2022-07-17 23:29:12 +08:00
--- !u!114 &11
MonoBehaviour:
m_ObjectHideFlags: 52
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 0}
m_Enabled: 1
m_EditorHideFlags: 1
m_Script: {fileID: 12006, guid: 0000000000000000e000000000000000, type: 0}
m_Name:
m_EditorClassIdentifier:
m_Children: []
m_Position:
serializedVersion: 2
2022-08-04 17:37:45 +08:00
x: 1285.6
任务:搭建基本玩法 1.让马可以跳跃 (1.测试,如果我给马的刚体一个(1,1)的力代表跳跃,是否可行? Good Job!通过测试,可以通过给力的方式使马整体起飞,而且控制点和马蹄都会随之起飞,是理想的状态。 (2.让马并拢每一组腿,当按住某键,使该组腿并拢,也就是消除输入偏差。当松开键,重新设置输入偏差,使双腿分开。 DONE (3.从输入中获取信息,当两腿均并拢,进入跳跃模式,否则离开跳跃模式,在跳跃模式下,如何通过输入计算出应该给出多大、哪个方向的的跳跃力是核心和难点 (4.马脚和马脚的控制点很难控制,数据也经常抖动,我不想通过这两个变量来计算跳跃的力。我打算直接通过输入值判断 (5.尝试:首先,若处于跳跃模式,每帧记录上一帧输入,并计算一个瞬时速度,当瞬时速度的y大于0,也就代表此时腿在上升,在预备,不考虑。若瞬时速度的y小于0,说明腿开始下降,可能会跳起。此时判断此瞬时速度的模长是否大于某个阈值,若是,进入戒备状态,此后的若干帧后,有任何一帧再低于阈值,说明输入结束,输出最后的速度,并给予马刚体。若此时瞬时速度的模长小于阈值 ,说明太慢,不记录。在这个戒备状态中的每一帧,需要记录瞬时速度,并累计影响,最终经过乘以调整值、取反(因为是相对作用)操作,得到需要赋予马的力,然后把力赋给马刚体,完成一次跳跃 (6.Good!初步尝试有效。在马着地后,重置跳跃状态,即可完成循环,开始下一次跳跃。 至此,马基本可以跳跃,但是手感极差,并且键鼠几乎没有操作空间,需要后续进一步优化……
2022-07-26 00:00:56 +08:00
y: 0
2022-08-04 17:37:45 +08:00
width: 250.40002
任务:搭建基本玩法 1.让马可以跳跃 (1.测试,如果我给马的刚体一个(1,1)的力代表跳跃,是否可行? Good Job!通过测试,可以通过给力的方式使马整体起飞,而且控制点和马蹄都会随之起飞,是理想的状态。 (2.让马并拢每一组腿,当按住某键,使该组腿并拢,也就是消除输入偏差。当松开键,重新设置输入偏差,使双腿分开。 DONE (3.从输入中获取信息,当两腿均并拢,进入跳跃模式,否则离开跳跃模式,在跳跃模式下,如何通过输入计算出应该给出多大、哪个方向的的跳跃力是核心和难点 (4.马脚和马脚的控制点很难控制,数据也经常抖动,我不想通过这两个变量来计算跳跃的力。我打算直接通过输入值判断 (5.尝试:首先,若处于跳跃模式,每帧记录上一帧输入,并计算一个瞬时速度,当瞬时速度的y大于0,也就代表此时腿在上升,在预备,不考虑。若瞬时速度的y小于0,说明腿开始下降,可能会跳起。此时判断此瞬时速度的模长是否大于某个阈值,若是,进入戒备状态,此后的若干帧后,有任何一帧再低于阈值,说明输入结束,输出最后的速度,并给予马刚体。若此时瞬时速度的模长小于阈值 ,说明太慢,不记录。在这个戒备状态中的每一帧,需要记录瞬时速度,并累计影响,最终经过乘以调整值、取反(因为是相对作用)操作,得到需要赋予马的力,然后把力赋给马刚体,完成一次跳跃 (6.Good!初步尝试有效。在马着地后,重置跳跃状态,即可完成循环,开始下一次跳跃。 至此,马基本可以跳跃,但是手感极差,并且键鼠几乎没有操作空间,需要后续进一步优化……
2022-07-26 00:00:56 +08:00
height: 722.8
m_MinSize: {x: 276, y: 71}
任务:实现基本玩法 1.策划数学模型 2.搬迁工具类如单例模式模板 3.创建玩家类,用于接受和发出指令、记录玩家信息等 4.创建马类,用来接受信息、物理计算、控制马的碰撞等模拟等 5.实装数学模型,实现马脚的控制 6.探索物理实现方式,给控制点加上碰撞体和刚体,似乎可行 --NG,分离的刚体无法作为整体传递力,脚的反作用力传不到身体上 7.把操控分组,左摇杆控制后两条腿、右摇杆控制前两条腿 8.探索物理的实现方式,尝试仅在主物体上挂载仅一个刚体,探索碰撞体组的使用方式/ ((1.给马添加四个碰撞体代表马足 ((2.每帧刷新碰撞体的偏移,使其对准真实马蹄位置,所以需要找准offset和世界空间下位置的对应关系 ((3.如何让马前进?目前发现无法使用真实物理的反作用力,只能根据输入或其他信息算出这个反作用力 (((1.最终应该通过原速度 + 计算出输入速度,不能使用力,因为使用力涉及的参数极多,很难修改 (((2.应该通过马足真实位置计算输入速度,不能使用控制点位置 (((3.每只足应该记住自己上一帧的位置,并每帧更新 ((4.本帧位置减上帧位置 = 运动速度,一个二维向量 ((5.并非一直有效,当本帧马足位置低于圆心 + 调整值时,才有效,否则该足贡献的速度为0.同时,需要有输入才有效,若无输入,同样贡献速度为0 ((6.NG,主要在判断速度是否有效上出了问题,试试每帧给足和地面测距,小于阈值的才给过,然后才加速度 ((7.GoodJob!通过上述方法和其他细微调整,已经使得马可以行走,并且得到不错的效果。但是肯定还有问题,需要后期更进一步调整 目前马能够受到控制,并且可以走动。同样支持键盘游玩,但是体验极差
2022-07-24 21:15:22 +08:00
m_MaxSize: {x: 4001, y: 4021}
任务:搭建基本玩法 1.让马可以跳跃 (1.测试,如果我给马的刚体一个(1,1)的力代表跳跃,是否可行? Good Job!通过测试,可以通过给力的方式使马整体起飞,而且控制点和马蹄都会随之起飞,是理想的状态。 (2.让马并拢每一组腿,当按住某键,使该组腿并拢,也就是消除输入偏差。当松开键,重新设置输入偏差,使双腿分开。 DONE (3.从输入中获取信息,当两腿均并拢,进入跳跃模式,否则离开跳跃模式,在跳跃模式下,如何通过输入计算出应该给出多大、哪个方向的的跳跃力是核心和难点 (4.马脚和马脚的控制点很难控制,数据也经常抖动,我不想通过这两个变量来计算跳跃的力。我打算直接通过输入值判断 (5.尝试:首先,若处于跳跃模式,每帧记录上一帧输入,并计算一个瞬时速度,当瞬时速度的y大于0,也就代表此时腿在上升,在预备,不考虑。若瞬时速度的y小于0,说明腿开始下降,可能会跳起。此时判断此瞬时速度的模长是否大于某个阈值,若是,进入戒备状态,此后的若干帧后,有任何一帧再低于阈值,说明输入结束,输出最后的速度,并给予马刚体。若此时瞬时速度的模长小于阈值 ,说明太慢,不记录。在这个戒备状态中的每一帧,需要记录瞬时速度,并累计影响,最终经过乘以调整值、取反(因为是相对作用)操作,得到需要赋予马的力,然后把力赋给马刚体,完成一次跳跃 (6.Good!初步尝试有效。在马着地后,重置跳跃状态,即可完成循环,开始下一次跳跃。 至此,马基本可以跳跃,但是手感极差,并且键鼠几乎没有操作空间,需要后续进一步优化……
2022-07-26 00:00:56 +08:00
m_ActualView: {fileID: 16}
2022-07-17 23:29:12 +08:00
m_Panes:
任务:搭建基本玩法 1.让马可以跳跃 (1.测试,如果我给马的刚体一个(1,1)的力代表跳跃,是否可行? Good Job!通过测试,可以通过给力的方式使马整体起飞,而且控制点和马蹄都会随之起飞,是理想的状态。 (2.让马并拢每一组腿,当按住某键,使该组腿并拢,也就是消除输入偏差。当松开键,重新设置输入偏差,使双腿分开。 DONE (3.从输入中获取信息,当两腿均并拢,进入跳跃模式,否则离开跳跃模式,在跳跃模式下,如何通过输入计算出应该给出多大、哪个方向的的跳跃力是核心和难点 (4.马脚和马脚的控制点很难控制,数据也经常抖动,我不想通过这两个变量来计算跳跃的力。我打算直接通过输入值判断 (5.尝试:首先,若处于跳跃模式,每帧记录上一帧输入,并计算一个瞬时速度,当瞬时速度的y大于0,也就代表此时腿在上升,在预备,不考虑。若瞬时速度的y小于0,说明腿开始下降,可能会跳起。此时判断此瞬时速度的模长是否大于某个阈值,若是,进入戒备状态,此后的若干帧后,有任何一帧再低于阈值,说明输入结束,输出最后的速度,并给予马刚体。若此时瞬时速度的模长小于阈值 ,说明太慢,不记录。在这个戒备状态中的每一帧,需要记录瞬时速度,并累计影响,最终经过乘以调整值、取反(因为是相对作用)操作,得到需要赋予马的力,然后把力赋给马刚体,完成一次跳跃 (6.Good!初步尝试有效。在马着地后,重置跳跃状态,即可完成循环,开始下一次跳跃。 至此,马基本可以跳跃,但是手感极差,并且键鼠几乎没有操作空间,需要后续进一步优化……
2022-07-26 00:00:56 +08:00
- {fileID: 16}
2022-07-17 23:29:12 +08:00
m_Selected: 0
m_LastSelected: 0
2022-07-17 23:29:12 +08:00
--- !u!114 &12
2022-08-04 17:37:45 +08:00
MonoBehaviour:
m_ObjectHideFlags: 52
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 0}
m_Enabled: 1
m_EditorHideFlags: 1
m_Script: {fileID: 12015, guid: 0000000000000000e000000000000000, type: 0}
m_Name:
m_EditorClassIdentifier:
m_MinSize: {x: 200, y: 200}
m_MaxSize: {x: 4000, y: 4000}
m_TitleContent:
m_Text: "\u6E38\u620F"
m_Image: {fileID: 4621777727084837110, guid: 0000000000000000d000000000000000, type: 0}
m_Tooltip:
m_Pos:
serializedVersion: 2
x: 0
y: 602.4
width: 663.8
height: 173
m_ViewDataDictionary: {fileID: 0}
m_OverlayCanvas:
m_LastAppliedPresetName: Default
m_SaveData: []
m_SerializedViewNames: []
m_SerializedViewValues: []
m_PlayModeViewName: GameView
m_ShowGizmos: 0
m_TargetDisplay: 0
m_ClearColor: {r: 0, g: 0, b: 0, a: 0}
m_TargetSize: {x: 338, y: 190}
m_TextureFilterMode: 0
m_TextureHideFlags: 61
m_RenderIMGUI: 1
m_EnterPlayModeBehavior: 1
m_UseMipMap: 0
m_VSyncEnabled: 0
m_Gizmos: 0
m_Stats: 0
m_SelectedSizes: 01000000000000000000000000000000000000000000000000000000000000000000000000000000
m_ZoomArea:
m_HRangeLocked: 0
m_VRangeLocked: 0
hZoomLockedByDefault: 0
vZoomLockedByDefault: 0
m_HBaseRangeMin: -135.2
m_HBaseRangeMax: 135.2
m_VBaseRangeMin: -76
m_VBaseRangeMax: 76
m_HAllowExceedBaseRangeMin: 1
m_HAllowExceedBaseRangeMax: 1
m_VAllowExceedBaseRangeMin: 1
m_VAllowExceedBaseRangeMax: 1
m_ScaleWithWindow: 0
m_HSlider: 0
m_VSlider: 0
m_IgnoreScrollWheelUntilClicked: 0
m_EnableMouseInput: 1
m_EnableSliderZoomHorizontal: 0
m_EnableSliderZoomVertical: 0
m_UniformScale: 1
m_UpDirection: 1
m_DrawArea:
serializedVersion: 2
x: 0
y: 21
width: 663.8
height: 152
m_Scale: {x: 1, y: 1}
m_Translation: {x: 331.9, y: 76}
m_MarginLeft: 0
m_MarginRight: 0
m_MarginTop: 0
m_MarginBottom: 0
m_LastShownAreaInsideMargins:
serializedVersion: 2
x: -331.9
y: -76
width: 663.8
height: 152
m_MinimalGUI: 1
m_defaultScale: 1
m_LastWindowPixelSize: {x: 829.75, y: 216.25}
m_ClearInEditMode: 1
m_NoCameraWarning: 1
m_LowResolutionForAspectRatios: 00000000000000000000
m_XRRenderMode: 0
m_RenderTexture: {fileID: 0}
--- !u!114 &13
MonoBehaviour:
m_ObjectHideFlags: 52
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 0}
m_Enabled: 1
m_EditorHideFlags: 1
任务:搭建基本玩法 1.让马可以跳跃 (1.测试,如果我给马的刚体一个(1,1)的力代表跳跃,是否可行? Good Job!通过测试,可以通过给力的方式使马整体起飞,而且控制点和马蹄都会随之起飞,是理想的状态。 (2.让马并拢每一组腿,当按住某键,使该组腿并拢,也就是消除输入偏差。当松开键,重新设置输入偏差,使双腿分开。 DONE (3.从输入中获取信息,当两腿均并拢,进入跳跃模式,否则离开跳跃模式,在跳跃模式下,如何通过输入计算出应该给出多大、哪个方向的的跳跃力是核心和难点 (4.马脚和马脚的控制点很难控制,数据也经常抖动,我不想通过这两个变量来计算跳跃的力。我打算直接通过输入值判断 (5.尝试:首先,若处于跳跃模式,每帧记录上一帧输入,并计算一个瞬时速度,当瞬时速度的y大于0,也就代表此时腿在上升,在预备,不考虑。若瞬时速度的y小于0,说明腿开始下降,可能会跳起。此时判断此瞬时速度的模长是否大于某个阈值,若是,进入戒备状态,此后的若干帧后,有任何一帧再低于阈值,说明输入结束,输出最后的速度,并给予马刚体。若此时瞬时速度的模长小于阈值 ,说明太慢,不记录。在这个戒备状态中的每一帧,需要记录瞬时速度,并累计影响,最终经过乘以调整值、取反(因为是相对作用)操作,得到需要赋予马的力,然后把力赋给马刚体,完成一次跳跃 (6.Good!初步尝试有效。在马着地后,重置跳跃状态,即可完成循环,开始下一次跳跃。 至此,马基本可以跳跃,但是手感极差,并且键鼠几乎没有操作空间,需要后续进一步优化……
2022-07-26 00:00:56 +08:00
m_Script: {fileID: 12013, guid: 0000000000000000e000000000000000, type: 0}
m_Name:
m_EditorClassIdentifier:
m_MinSize: {x: 200, y: 200}
m_MaxSize: {x: 4000, y: 4000}
m_TitleContent:
任务:搭建基本玩法 1.让马可以跳跃 (1.测试,如果我给马的刚体一个(1,1)的力代表跳跃,是否可行? Good Job!通过测试,可以通过给力的方式使马整体起飞,而且控制点和马蹄都会随之起飞,是理想的状态。 (2.让马并拢每一组腿,当按住某键,使该组腿并拢,也就是消除输入偏差。当松开键,重新设置输入偏差,使双腿分开。 DONE (3.从输入中获取信息,当两腿均并拢,进入跳跃模式,否则离开跳跃模式,在跳跃模式下,如何通过输入计算出应该给出多大、哪个方向的的跳跃力是核心和难点 (4.马脚和马脚的控制点很难控制,数据也经常抖动,我不想通过这两个变量来计算跳跃的力。我打算直接通过输入值判断 (5.尝试:首先,若处于跳跃模式,每帧记录上一帧输入,并计算一个瞬时速度,当瞬时速度的y大于0,也就代表此时腿在上升,在预备,不考虑。若瞬时速度的y小于0,说明腿开始下降,可能会跳起。此时判断此瞬时速度的模长是否大于某个阈值,若是,进入戒备状态,此后的若干帧后,有任何一帧再低于阈值,说明输入结束,输出最后的速度,并给予马刚体。若此时瞬时速度的模长小于阈值 ,说明太慢,不记录。在这个戒备状态中的每一帧,需要记录瞬时速度,并累计影响,最终经过乘以调整值、取反(因为是相对作用)操作,得到需要赋予马的力,然后把力赋给马刚体,完成一次跳跃 (6.Good!初步尝试有效。在马着地后,重置跳跃状态,即可完成循环,开始下一次跳跃。 至此,马基本可以跳跃,但是手感极差,并且键鼠几乎没有操作空间,需要后续进一步优化……
2022-07-26 00:00:56 +08:00
m_Text: "\u573A\u666F"
m_Image: {fileID: 8634526014445323508, guid: 0000000000000000d000000000000000, type: 0}
2022-07-17 23:29:12 +08:00
m_Tooltip:
m_Pos:
serializedVersion: 2
任务:搭建基本玩法 1.让马可以跳跃 (1.测试,如果我给马的刚体一个(1,1)的力代表跳跃,是否可行? Good Job!通过测试,可以通过给力的方式使马整体起飞,而且控制点和马蹄都会随之起飞,是理想的状态。 (2.让马并拢每一组腿,当按住某键,使该组腿并拢,也就是消除输入偏差。当松开键,重新设置输入偏差,使双腿分开。 DONE (3.从输入中获取信息,当两腿均并拢,进入跳跃模式,否则离开跳跃模式,在跳跃模式下,如何通过输入计算出应该给出多大、哪个方向的的跳跃力是核心和难点 (4.马脚和马脚的控制点很难控制,数据也经常抖动,我不想通过这两个变量来计算跳跃的力。我打算直接通过输入值判断 (5.尝试:首先,若处于跳跃模式,每帧记录上一帧输入,并计算一个瞬时速度,当瞬时速度的y大于0,也就代表此时腿在上升,在预备,不考虑。若瞬时速度的y小于0,说明腿开始下降,可能会跳起。此时判断此瞬时速度的模长是否大于某个阈值,若是,进入戒备状态,此后的若干帧后,有任何一帧再低于阈值,说明输入结束,输出最后的速度,并给予马刚体。若此时瞬时速度的模长小于阈值 ,说明太慢,不记录。在这个戒备状态中的每一帧,需要记录瞬时速度,并累计影响,最终经过乘以调整值、取反(因为是相对作用)操作,得到需要赋予马的力,然后把力赋给马刚体,完成一次跳跃 (6.Good!初步尝试有效。在马着地后,重置跳跃状态,即可完成循环,开始下一次跳跃。 至此,马基本可以跳跃,但是手感极差,并且键鼠几乎没有操作空间,需要后续进一步优化……
2022-07-26 00:00:56 +08:00
x: 0
y: 73.6
2022-08-04 17:37:45 +08:00
width: 663.8
height: 507.8
2022-07-17 23:29:12 +08:00
m_ViewDataDictionary: {fileID: 0}
m_OverlayCanvas:
m_LastAppliedPresetName: Default
m_SaveData:
- dockPosition: 0
containerId: overlay-toolbar__top
floating: 0
collapsed: 0
displayed: 1
2022-08-04 17:37:45 +08:00
snapOffset: {x: -100, y: -25.600006}
snapOffsetDelta: {x: 0, y: 0}
snapCorner: 3
id: Tool Settings
index: 0
layout: 1
- dockPosition: 0
containerId: overlay-toolbar__top
floating: 0
collapsed: 0
displayed: 1
2022-08-04 17:37:45 +08:00
snapOffset: {x: -141, y: -183.79999}
snapOffsetDelta: {x: 0, y: 0}
2022-08-04 17:37:45 +08:00
snapCorner: 3
id: unity-grid-and-snap-toolbar
index: 1
layout: 1
- dockPosition: 1
containerId: overlay-toolbar__top
floating: 0
collapsed: 0
displayed: 1
2022-08-04 17:37:45 +08:00
snapOffset: {x: 0, y: 24.8}
snapOffsetDelta: {x: 0, y: 0}
snapCorner: 0
id: unity-scene-view-toolbar
index: 0
layout: 1
- dockPosition: 1
containerId: overlay-toolbar__top
floating: 0
collapsed: 0
displayed: 0
snapOffset: {x: 0, y: 0}
snapOffsetDelta: {x: 0, y: 0}
snapCorner: 1
id: unity-search-toolbar
index: 1
layout: 1
- dockPosition: 1
containerId: overlay-toolbar__top
floating: 0
collapsed: 0
displayed: 0
snapOffset: {x: 0, y: 0}
snapOffsetDelta: {x: 0, y: 0}
snapCorner: 0
id: Scene View/Open Tile Palette
index: 2
layout: 4
- dockPosition: 1
containerId: overlay-toolbar__top
floating: 0
collapsed: 0
displayed: 0
snapOffset: {x: 0, y: 0}
snapOffsetDelta: {x: 0, y: 0}
snapCorner: 0
id: Scene View/Tilemap Focus
index: 3
layout: 4
- dockPosition: 0
containerId: overlay-container--left
floating: 0
collapsed: 0
displayed: 1
snapOffset: {x: 0, y: 0}
snapOffsetDelta: {x: 0, y: 0}
snapCorner: 0
id: unity-transform-toolbar
index: 0
layout: 2
- dockPosition: 0
containerId: overlay-container--right
floating: 0
collapsed: 0
displayed: 1
2022-08-04 17:37:45 +08:00
snapOffset: {x: 67.5, y: -124}
snapOffsetDelta: {x: 0, y: 0}
2022-08-04 17:37:45 +08:00
snapCorner: 2
id: Orientation
index: 0
layout: 4
- dockPosition: 1
containerId: overlay-container--right
floating: 0
collapsed: 0
displayed: 0
snapOffset: {x: 0, y: 0}
snapOffsetDelta: {x: 0, y: 0}
snapCorner: 0
id: Scene View/Light Settings
index: 0
layout: 4
- dockPosition: 1
containerId: overlay-container--right
floating: 0
collapsed: 0
displayed: 0
snapOffset: {x: 0, y: 0}
snapOffsetDelta: {x: 0, y: 0}
snapCorner: 0
id: Scene View/Camera
index: 1
layout: 4
- dockPosition: 1
containerId: overlay-container--right
floating: 0
collapsed: 0
displayed: 0
snapOffset: {x: 0, y: 0}
snapOffsetDelta: {x: 0, y: 0}
snapCorner: 0
id: Scene View/Cloth Constraints
index: 2
layout: 4
- dockPosition: 1
containerId: overlay-container--right
floating: 0
collapsed: 0
displayed: 0
snapOffset: {x: 0, y: 0}
snapOffsetDelta: {x: 0, y: 0}
snapCorner: 0
id: Scene View/Cloth Collisions
index: 3
layout: 4
- dockPosition: 1
containerId: overlay-container--right
floating: 0
collapsed: 0
displayed: 0
snapOffset: {x: 0, y: 0}
snapOffsetDelta: {x: 0, y: 0}
snapCorner: 0
id: Scene View/Navmesh Display
index: 4
layout: 4
- dockPosition: 1
containerId: overlay-container--right
floating: 0
collapsed: 0
displayed: 0
snapOffset: {x: 0, y: 0}
snapOffsetDelta: {x: 0, y: 0}
snapCorner: 0
id: Scene View/Agent Display
index: 5
layout: 4
- dockPosition: 1
containerId: overlay-container--right
floating: 0
collapsed: 0
displayed: 0
snapOffset: {x: 0, y: 0}
snapOffsetDelta: {x: 0, y: 0}
snapCorner: 0
id: Scene View/Obstacle Display
index: 6
layout: 4
- dockPosition: 1
containerId: overlay-container--right
floating: 0
collapsed: 0
displayed: 0
snapOffset: {x: 0, y: 0}
snapOffsetDelta: {x: 0, y: 0}
snapCorner: 0
id: Scene View/Occlusion Culling
index: 7
layout: 4
- dockPosition: 1
containerId: overlay-container--right
floating: 0
collapsed: 0
displayed: 0
snapOffset: {x: 0, y: 0}
snapOffsetDelta: {x: 0, y: 0}
snapCorner: 0
id: Scene View/Physics Debugger
index: 8
layout: 4
- dockPosition: 1
containerId: overlay-container--right
floating: 0
collapsed: 0
displayed: 0
snapOffset: {x: 0, y: 0}
snapOffsetDelta: {x: 0, y: 0}
snapCorner: 0
id: Scene View/Scene Visibility
index: 9
layout: 4
- dockPosition: 1
containerId: overlay-container--right
floating: 0
collapsed: 0
displayed: 0
snapOffset: {x: 0, y: 0}
snapOffsetDelta: {x: 0, y: 0}
snapCorner: 0
id: Scene View/Particles
index: 10
layout: 4
m_WindowGUID: 932fa420110f25f488f2a7bbcd1fb02a
2022-07-17 23:29:12 +08:00
m_Gizmos: 1
m_OverrideSceneCullingMask: 6917529027641081856
m_SceneIsLit: 1
m_SceneLighting: 1
m_2DMode: 1
2022-07-17 23:29:12 +08:00
m_isRotationLocked: 0
m_PlayAudio: 0
m_AudioPlay: 0
m_Position:
2022-08-04 17:37:45 +08:00
m_Target: {x: -28.486532, y: -2.2456534, z: 0.41698262}
2022-07-17 23:29:12 +08:00
speed: 2
2022-08-04 17:37:45 +08:00
m_Value: {x: -28.413153, y: -2.3026543, z: 0.41856292}
2022-07-17 23:29:12 +08:00
m_RenderMode: 0
m_CameraMode:
drawMode: 0
name: Shaded
section: Shading Mode
m_ValidateTrueMetals: 0
m_DoValidateTrueMetals: 0
m_ExposureSliderValue: 0
m_SceneViewState:
m_AlwaysRefresh: 0
2022-07-17 23:29:12 +08:00
showFog: 1
showSkybox: 1
showFlares: 1
showImageEffects: 1
showParticleSystems: 1
showVisualEffectGraphs: 1
m_FxEnabled: 1
2022-07-17 23:29:12 +08:00
m_Grid:
xGrid:
m_Fade:
m_Target: 0
speed: 2
m_Value: 0
m_Color: {r: 0.5, g: 0.5, b: 0.5, a: 0.4}
m_Pivot: {x: 0, y: 0, z: 0}
m_Size: {x: 0, y: 0}
yGrid:
m_Fade:
m_Target: 0
2022-07-17 23:29:12 +08:00
speed: 2
m_Value: 0
2022-07-17 23:29:12 +08:00
m_Color: {r: 0.5, g: 0.5, b: 0.5, a: 0.4}
m_Pivot: {x: 0, y: 0, z: 0}
m_Size: {x: 1, y: 1}
zGrid:
m_Fade:
2022-08-04 17:37:45 +08:00
m_Target: 0
2022-07-17 23:29:12 +08:00
speed: 2
2022-08-04 17:37:45 +08:00
m_Value: 0
2022-07-17 23:29:12 +08:00
m_Color: {r: 0.5, g: 0.5, b: 0.5, a: 0.4}
m_Pivot: {x: 0, y: 0, z: 0}
m_Size: {x: 1, y: 1}
2022-08-04 17:37:45 +08:00
m_ShowGrid: 0
2022-07-17 23:29:12 +08:00
m_GridAxis: 1
m_gridOpacity: 0.5
m_Rotation:
m_Target: {x: 0, y: 0, z: 0, w: 1}
2022-07-17 23:29:12 +08:00
speed: 2
m_Value: {x: 0, y: 0, z: 0, w: 1}
2022-07-17 23:29:12 +08:00
m_Size:
2022-08-04 17:37:45 +08:00
m_Target: 3.6698096
2022-07-17 23:29:12 +08:00
speed: 2
2022-08-04 17:37:45 +08:00
m_Value: 3.5117795
2022-07-17 23:29:12 +08:00
m_Ortho:
m_Target: 1
2022-07-17 23:29:12 +08:00
speed: 2
m_Value: 1
2022-07-17 23:29:12 +08:00
m_CameraSettings:
m_Speed: 1
m_SpeedNormalized: 0.5
m_SpeedMin: 0.01
2022-07-17 23:29:12 +08:00
m_SpeedMax: 2
m_EasingEnabled: 1
m_EasingDuration: 0.4
m_AccelerationEnabled: 1
m_FieldOfViewHorizontalOrVertical: 60
2022-07-17 23:29:12 +08:00
m_NearClip: 0.03
m_FarClip: 10000
m_DynamicClip: 1
m_OcclusionCulling: 0
m_LastSceneViewRotation: {x: -0.08717229, y: 0.89959055, z: -0.21045254, w: -0.3726226}
2022-07-17 23:29:12 +08:00
m_LastSceneViewOrtho: 0
m_ReplacementShader: {fileID: 0}
m_ReplacementString:
m_SceneVisActive: 1
m_LastLockedObject: {fileID: 0}
m_ViewIsLockedToObject: 0
任务:搭建基本玩法 1.让马可以跳跃 (1.测试,如果我给马的刚体一个(1,1)的力代表跳跃,是否可行? Good Job!通过测试,可以通过给力的方式使马整体起飞,而且控制点和马蹄都会随之起飞,是理想的状态。 (2.让马并拢每一组腿,当按住某键,使该组腿并拢,也就是消除输入偏差。当松开键,重新设置输入偏差,使双腿分开。 DONE (3.从输入中获取信息,当两腿均并拢,进入跳跃模式,否则离开跳跃模式,在跳跃模式下,如何通过输入计算出应该给出多大、哪个方向的的跳跃力是核心和难点 (4.马脚和马脚的控制点很难控制,数据也经常抖动,我不想通过这两个变量来计算跳跃的力。我打算直接通过输入值判断 (5.尝试:首先,若处于跳跃模式,每帧记录上一帧输入,并计算一个瞬时速度,当瞬时速度的y大于0,也就代表此时腿在上升,在预备,不考虑。若瞬时速度的y小于0,说明腿开始下降,可能会跳起。此时判断此瞬时速度的模长是否大于某个阈值,若是,进入戒备状态,此后的若干帧后,有任何一帧再低于阈值,说明输入结束,输出最后的速度,并给予马刚体。若此时瞬时速度的模长小于阈值 ,说明太慢,不记录。在这个戒备状态中的每一帧,需要记录瞬时速度,并累计影响,最终经过乘以调整值、取反(因为是相对作用)操作,得到需要赋予马的力,然后把力赋给马刚体,完成一次跳跃 (6.Good!初步尝试有效。在马着地后,重置跳跃状态,即可完成循环,开始下一次跳跃。 至此,马基本可以跳跃,但是手感极差,并且键鼠几乎没有操作空间,需要后续进一步优化……
2022-07-26 00:00:56 +08:00
--- !u!114 &14
MonoBehaviour:
m_ObjectHideFlags: 52
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 0}
m_Enabled: 1
m_EditorHideFlags: 1
m_Script: {fileID: 12061, guid: 0000000000000000e000000000000000, type: 0}
m_Name:
m_EditorClassIdentifier:
m_MinSize: {x: 200, y: 200}
m_MaxSize: {x: 4000, y: 4000}
m_TitleContent:
m_Text: "\u5C42\u7EA7"
m_Image: {fileID: -3734745235275155857, guid: 0000000000000000d000000000000000, type: 0}
m_Tooltip:
m_Pos:
serializedVersion: 2
2022-08-04 17:37:45 +08:00
x: 664.8
任务:搭建基本玩法 1.让马可以跳跃 (1.测试,如果我给马的刚体一个(1,1)的力代表跳跃,是否可行? Good Job!通过测试,可以通过给力的方式使马整体起飞,而且控制点和马蹄都会随之起飞,是理想的状态。 (2.让马并拢每一组腿,当按住某键,使该组腿并拢,也就是消除输入偏差。当松开键,重新设置输入偏差,使双腿分开。 DONE (3.从输入中获取信息,当两腿均并拢,进入跳跃模式,否则离开跳跃模式,在跳跃模式下,如何通过输入计算出应该给出多大、哪个方向的的跳跃力是核心和难点 (4.马脚和马脚的控制点很难控制,数据也经常抖动,我不想通过这两个变量来计算跳跃的力。我打算直接通过输入值判断 (5.尝试:首先,若处于跳跃模式,每帧记录上一帧输入,并计算一个瞬时速度,当瞬时速度的y大于0,也就代表此时腿在上升,在预备,不考虑。若瞬时速度的y小于0,说明腿开始下降,可能会跳起。此时判断此瞬时速度的模长是否大于某个阈值,若是,进入戒备状态,此后的若干帧后,有任何一帧再低于阈值,说明输入结束,输出最后的速度,并给予马刚体。若此时瞬时速度的模长小于阈值 ,说明太慢,不记录。在这个戒备状态中的每一帧,需要记录瞬时速度,并累计影响,最终经过乘以调整值、取反(因为是相对作用)操作,得到需要赋予马的力,然后把力赋给马刚体,完成一次跳跃 (6.Good!初步尝试有效。在马着地后,重置跳跃状态,即可完成循环,开始下一次跳跃。 至此,马基本可以跳跃,但是手感极差,并且键鼠几乎没有操作空间,需要后续进一步优化……
2022-07-26 00:00:56 +08:00
y: 73.6
2022-08-04 17:37:45 +08:00
width: 250
任务:搭建基本玩法 1.让马可以跳跃 (1.测试,如果我给马的刚体一个(1,1)的力代表跳跃,是否可行? Good Job!通过测试,可以通过给力的方式使马整体起飞,而且控制点和马蹄都会随之起飞,是理想的状态。 (2.让马并拢每一组腿,当按住某键,使该组腿并拢,也就是消除输入偏差。当松开键,重新设置输入偏差,使双腿分开。 DONE (3.从输入中获取信息,当两腿均并拢,进入跳跃模式,否则离开跳跃模式,在跳跃模式下,如何通过输入计算出应该给出多大、哪个方向的的跳跃力是核心和难点 (4.马脚和马脚的控制点很难控制,数据也经常抖动,我不想通过这两个变量来计算跳跃的力。我打算直接通过输入值判断 (5.尝试:首先,若处于跳跃模式,每帧记录上一帧输入,并计算一个瞬时速度,当瞬时速度的y大于0,也就代表此时腿在上升,在预备,不考虑。若瞬时速度的y小于0,说明腿开始下降,可能会跳起。此时判断此瞬时速度的模长是否大于某个阈值,若是,进入戒备状态,此后的若干帧后,有任何一帧再低于阈值,说明输入结束,输出最后的速度,并给予马刚体。若此时瞬时速度的模长小于阈值 ,说明太慢,不记录。在这个戒备状态中的每一帧,需要记录瞬时速度,并累计影响,最终经过乘以调整值、取反(因为是相对作用)操作,得到需要赋予马的力,然后把力赋给马刚体,完成一次跳跃 (6.Good!初步尝试有效。在马着地后,重置跳跃状态,即可完成循环,开始下一次跳跃。 至此,马基本可以跳跃,但是手感极差,并且键鼠几乎没有操作空间,需要后续进一步优化……
2022-07-26 00:00:56 +08:00
height: 701.8
m_ViewDataDictionary: {fileID: 0}
m_OverlayCanvas:
m_LastAppliedPresetName: Default
m_SaveData: []
m_SceneHierarchy:
m_TreeViewState:
scrollPos: {x: 0, y: 0}
2022-08-04 17:37:45 +08:00
m_SelectedIDs:
m_LastClickedID: 0
m_ExpandedIDs: 92f8ffff0efbffff947800002a790000
任务:搭建基本玩法 1.让马可以跳跃 (1.测试,如果我给马的刚体一个(1,1)的力代表跳跃,是否可行? Good Job!通过测试,可以通过给力的方式使马整体起飞,而且控制点和马蹄都会随之起飞,是理想的状态。 (2.让马并拢每一组腿,当按住某键,使该组腿并拢,也就是消除输入偏差。当松开键,重新设置输入偏差,使双腿分开。 DONE (3.从输入中获取信息,当两腿均并拢,进入跳跃模式,否则离开跳跃模式,在跳跃模式下,如何通过输入计算出应该给出多大、哪个方向的的跳跃力是核心和难点 (4.马脚和马脚的控制点很难控制,数据也经常抖动,我不想通过这两个变量来计算跳跃的力。我打算直接通过输入值判断 (5.尝试:首先,若处于跳跃模式,每帧记录上一帧输入,并计算一个瞬时速度,当瞬时速度的y大于0,也就代表此时腿在上升,在预备,不考虑。若瞬时速度的y小于0,说明腿开始下降,可能会跳起。此时判断此瞬时速度的模长是否大于某个阈值,若是,进入戒备状态,此后的若干帧后,有任何一帧再低于阈值,说明输入结束,输出最后的速度,并给予马刚体。若此时瞬时速度的模长小于阈值 ,说明太慢,不记录。在这个戒备状态中的每一帧,需要记录瞬时速度,并累计影响,最终经过乘以调整值、取反(因为是相对作用)操作,得到需要赋予马的力,然后把力赋给马刚体,完成一次跳跃 (6.Good!初步尝试有效。在马着地后,重置跳跃状态,即可完成循环,开始下一次跳跃。 至此,马基本可以跳跃,但是手感极差,并且键鼠几乎没有操作空间,需要后续进一步优化……
2022-07-26 00:00:56 +08:00
m_RenameOverlay:
m_UserAcceptedRename: 0
m_Name:
m_OriginalName:
m_EditFieldRect:
serializedVersion: 2
x: 0
y: 0
width: 0
height: 0
m_UserData: 0
m_IsWaitingForDelay: 0
m_IsRenaming: 0
m_OriginalEventType: 11
m_IsRenamingFilename: 0
m_ClientGUIView: {fileID: 9}
m_SearchString:
m_ExpandedScenes: []
m_CurrenRootInstanceID: 0
m_LockTracker:
m_IsLocked: 0
m_CurrentSortingName: TransformSorting
m_WindowGUID: 2e41307eb01faed4e87abe86bae87f81
--- !u!114 &15
MonoBehaviour:
m_ObjectHideFlags: 52
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 0}
m_Enabled: 1
m_EditorHideFlags: 1
m_Script: {fileID: 12014, guid: 0000000000000000e000000000000000, type: 0}
m_Name:
m_EditorClassIdentifier:
m_MinSize: {x: 230, y: 250}
m_MaxSize: {x: 10000, y: 10000}
m_TitleContent:
m_Text: "\u9879\u76EE"
m_Image: {fileID: -5179483145760003458, guid: 0000000000000000d000000000000000, type: 0}
m_Tooltip:
m_Pos:
serializedVersion: 2
2022-08-04 17:37:45 +08:00
x: 916.8
任务:搭建基本玩法 1.让马可以跳跃 (1.测试,如果我给马的刚体一个(1,1)的力代表跳跃,是否可行? Good Job!通过测试,可以通过给力的方式使马整体起飞,而且控制点和马蹄都会随之起飞,是理想的状态。 (2.让马并拢每一组腿,当按住某键,使该组腿并拢,也就是消除输入偏差。当松开键,重新设置输入偏差,使双腿分开。 DONE (3.从输入中获取信息,当两腿均并拢,进入跳跃模式,否则离开跳跃模式,在跳跃模式下,如何通过输入计算出应该给出多大、哪个方向的的跳跃力是核心和难点 (4.马脚和马脚的控制点很难控制,数据也经常抖动,我不想通过这两个变量来计算跳跃的力。我打算直接通过输入值判断 (5.尝试:首先,若处于跳跃模式,每帧记录上一帧输入,并计算一个瞬时速度,当瞬时速度的y大于0,也就代表此时腿在上升,在预备,不考虑。若瞬时速度的y小于0,说明腿开始下降,可能会跳起。此时判断此瞬时速度的模长是否大于某个阈值,若是,进入戒备状态,此后的若干帧后,有任何一帧再低于阈值,说明输入结束,输出最后的速度,并给予马刚体。若此时瞬时速度的模长小于阈值 ,说明太慢,不记录。在这个戒备状态中的每一帧,需要记录瞬时速度,并累计影响,最终经过乘以调整值、取反(因为是相对作用)操作,得到需要赋予马的力,然后把力赋给马刚体,完成一次跳跃 (6.Good!初步尝试有效。在马着地后,重置跳跃状态,即可完成循环,开始下一次跳跃。 至此,马基本可以跳跃,但是手感极差,并且键鼠几乎没有操作空间,需要后续进一步优化……
2022-07-26 00:00:56 +08:00
y: 73.6
2022-08-04 17:37:45 +08:00
width: 366.8
任务:搭建基本玩法 1.让马可以跳跃 (1.测试,如果我给马的刚体一个(1,1)的力代表跳跃,是否可行? Good Job!通过测试,可以通过给力的方式使马整体起飞,而且控制点和马蹄都会随之起飞,是理想的状态。 (2.让马并拢每一组腿,当按住某键,使该组腿并拢,也就是消除输入偏差。当松开键,重新设置输入偏差,使双腿分开。 DONE (3.从输入中获取信息,当两腿均并拢,进入跳跃模式,否则离开跳跃模式,在跳跃模式下,如何通过输入计算出应该给出多大、哪个方向的的跳跃力是核心和难点 (4.马脚和马脚的控制点很难控制,数据也经常抖动,我不想通过这两个变量来计算跳跃的力。我打算直接通过输入值判断 (5.尝试:首先,若处于跳跃模式,每帧记录上一帧输入,并计算一个瞬时速度,当瞬时速度的y大于0,也就代表此时腿在上升,在预备,不考虑。若瞬时速度的y小于0,说明腿开始下降,可能会跳起。此时判断此瞬时速度的模长是否大于某个阈值,若是,进入戒备状态,此后的若干帧后,有任何一帧再低于阈值,说明输入结束,输出最后的速度,并给予马刚体。若此时瞬时速度的模长小于阈值 ,说明太慢,不记录。在这个戒备状态中的每一帧,需要记录瞬时速度,并累计影响,最终经过乘以调整值、取反(因为是相对作用)操作,得到需要赋予马的力,然后把力赋给马刚体,完成一次跳跃 (6.Good!初步尝试有效。在马着地后,重置跳跃状态,即可完成循环,开始下一次跳跃。 至此,马基本可以跳跃,但是手感极差,并且键鼠几乎没有操作空间,需要后续进一步优化……
2022-07-26 00:00:56 +08:00
height: 701.8
m_ViewDataDictionary: {fileID: 0}
m_OverlayCanvas:
m_LastAppliedPresetName: Default
m_SaveData: []
m_SearchFilter:
m_NameFilter:
m_ClassNames: []
m_AssetLabels: []
m_AssetBundleNames: []
m_VersionControlStates: []
m_SoftLockControlStates: []
m_ReferencingInstanceIDs:
m_SceneHandles:
m_ShowAllHits: 0
m_SkipHidden: 0
m_SearchArea: 1
m_Folders:
2022-08-04 17:37:45 +08:00
- "Assets/\u5F85\u5B9E\u88C5\u7F8E\u672F\u7D20\u6750/\u9AA8\u9ABC"
任务:搭建基本玩法 1.让马可以跳跃 (1.测试,如果我给马的刚体一个(1,1)的力代表跳跃,是否可行? Good Job!通过测试,可以通过给力的方式使马整体起飞,而且控制点和马蹄都会随之起飞,是理想的状态。 (2.让马并拢每一组腿,当按住某键,使该组腿并拢,也就是消除输入偏差。当松开键,重新设置输入偏差,使双腿分开。 DONE (3.从输入中获取信息,当两腿均并拢,进入跳跃模式,否则离开跳跃模式,在跳跃模式下,如何通过输入计算出应该给出多大、哪个方向的的跳跃力是核心和难点 (4.马脚和马脚的控制点很难控制,数据也经常抖动,我不想通过这两个变量来计算跳跃的力。我打算直接通过输入值判断 (5.尝试:首先,若处于跳跃模式,每帧记录上一帧输入,并计算一个瞬时速度,当瞬时速度的y大于0,也就代表此时腿在上升,在预备,不考虑。若瞬时速度的y小于0,说明腿开始下降,可能会跳起。此时判断此瞬时速度的模长是否大于某个阈值,若是,进入戒备状态,此后的若干帧后,有任何一帧再低于阈值,说明输入结束,输出最后的速度,并给予马刚体。若此时瞬时速度的模长小于阈值 ,说明太慢,不记录。在这个戒备状态中的每一帧,需要记录瞬时速度,并累计影响,最终经过乘以调整值、取反(因为是相对作用)操作,得到需要赋予马的力,然后把力赋给马刚体,完成一次跳跃 (6.Good!初步尝试有效。在马着地后,重置跳跃状态,即可完成循环,开始下一次跳跃。 至此,马基本可以跳跃,但是手感极差,并且键鼠几乎没有操作空间,需要后续进一步优化……
2022-07-26 00:00:56 +08:00
m_Globs: []
m_OriginalText:
m_ViewMode: 1
m_StartGridSize: 64
m_LastFolders:
2022-08-04 17:37:45 +08:00
- "Assets/\u5F85\u5B9E\u88C5\u7F8E\u672F\u7D20\u6750/\u9AA8\u9ABC"
任务:搭建基本玩法 1.让马可以跳跃 (1.测试,如果我给马的刚体一个(1,1)的力代表跳跃,是否可行? Good Job!通过测试,可以通过给力的方式使马整体起飞,而且控制点和马蹄都会随之起飞,是理想的状态。 (2.让马并拢每一组腿,当按住某键,使该组腿并拢,也就是消除输入偏差。当松开键,重新设置输入偏差,使双腿分开。 DONE (3.从输入中获取信息,当两腿均并拢,进入跳跃模式,否则离开跳跃模式,在跳跃模式下,如何通过输入计算出应该给出多大、哪个方向的的跳跃力是核心和难点 (4.马脚和马脚的控制点很难控制,数据也经常抖动,我不想通过这两个变量来计算跳跃的力。我打算直接通过输入值判断 (5.尝试:首先,若处于跳跃模式,每帧记录上一帧输入,并计算一个瞬时速度,当瞬时速度的y大于0,也就代表此时腿在上升,在预备,不考虑。若瞬时速度的y小于0,说明腿开始下降,可能会跳起。此时判断此瞬时速度的模长是否大于某个阈值,若是,进入戒备状态,此后的若干帧后,有任何一帧再低于阈值,说明输入结束,输出最后的速度,并给予马刚体。若此时瞬时速度的模长小于阈值 ,说明太慢,不记录。在这个戒备状态中的每一帧,需要记录瞬时速度,并累计影响,最终经过乘以调整值、取反(因为是相对作用)操作,得到需要赋予马的力,然后把力赋给马刚体,完成一次跳跃 (6.Good!初步尝试有效。在马着地后,重置跳跃状态,即可完成循环,开始下一次跳跃。 至此,马基本可以跳跃,但是手感极差,并且键鼠几乎没有操作空间,需要后续进一步优化……
2022-07-26 00:00:56 +08:00
m_LastFoldersGridSize: -1
m_LastProjectPath: "C:\\Users\\13259\\Desktop\\\u8D5B\u9A6C"
m_LockTracker:
m_IsLocked: 0
m_FolderTreeState:
scrollPos: {x: 0, y: 0}
2022-08-04 17:37:45 +08:00
m_SelectedIDs: 38780000
m_LastClickedID: 30776
m_ExpandedIDs: 000000000c7800000e7800001078000012780000147800001678000018780000
任务:搭建基本玩法 1.让马可以跳跃 (1.测试,如果我给马的刚体一个(1,1)的力代表跳跃,是否可行? Good Job!通过测试,可以通过给力的方式使马整体起飞,而且控制点和马蹄都会随之起飞,是理想的状态。 (2.让马并拢每一组腿,当按住某键,使该组腿并拢,也就是消除输入偏差。当松开键,重新设置输入偏差,使双腿分开。 DONE (3.从输入中获取信息,当两腿均并拢,进入跳跃模式,否则离开跳跃模式,在跳跃模式下,如何通过输入计算出应该给出多大、哪个方向的的跳跃力是核心和难点 (4.马脚和马脚的控制点很难控制,数据也经常抖动,我不想通过这两个变量来计算跳跃的力。我打算直接通过输入值判断 (5.尝试:首先,若处于跳跃模式,每帧记录上一帧输入,并计算一个瞬时速度,当瞬时速度的y大于0,也就代表此时腿在上升,在预备,不考虑。若瞬时速度的y小于0,说明腿开始下降,可能会跳起。此时判断此瞬时速度的模长是否大于某个阈值,若是,进入戒备状态,此后的若干帧后,有任何一帧再低于阈值,说明输入结束,输出最后的速度,并给予马刚体。若此时瞬时速度的模长小于阈值 ,说明太慢,不记录。在这个戒备状态中的每一帧,需要记录瞬时速度,并累计影响,最终经过乘以调整值、取反(因为是相对作用)操作,得到需要赋予马的力,然后把力赋给马刚体,完成一次跳跃 (6.Good!初步尝试有效。在马着地后,重置跳跃状态,即可完成循环,开始下一次跳跃。 至此,马基本可以跳跃,但是手感极差,并且键鼠几乎没有操作空间,需要后续进一步优化……
2022-07-26 00:00:56 +08:00
m_RenameOverlay:
m_UserAcceptedRename: 0
m_Name:
m_OriginalName:
m_EditFieldRect:
serializedVersion: 2
x: 0
y: 0
width: 0
height: 0
m_UserData: 0
m_IsWaitingForDelay: 0
m_IsRenaming: 0
m_OriginalEventType: 11
m_IsRenamingFilename: 1
2022-08-04 17:37:45 +08:00
m_ClientGUIView: {fileID: 10}
任务:搭建基本玩法 1.让马可以跳跃 (1.测试,如果我给马的刚体一个(1,1)的力代表跳跃,是否可行? Good Job!通过测试,可以通过给力的方式使马整体起飞,而且控制点和马蹄都会随之起飞,是理想的状态。 (2.让马并拢每一组腿,当按住某键,使该组腿并拢,也就是消除输入偏差。当松开键,重新设置输入偏差,使双腿分开。 DONE (3.从输入中获取信息,当两腿均并拢,进入跳跃模式,否则离开跳跃模式,在跳跃模式下,如何通过输入计算出应该给出多大、哪个方向的的跳跃力是核心和难点 (4.马脚和马脚的控制点很难控制,数据也经常抖动,我不想通过这两个变量来计算跳跃的力。我打算直接通过输入值判断 (5.尝试:首先,若处于跳跃模式,每帧记录上一帧输入,并计算一个瞬时速度,当瞬时速度的y大于0,也就代表此时腿在上升,在预备,不考虑。若瞬时速度的y小于0,说明腿开始下降,可能会跳起。此时判断此瞬时速度的模长是否大于某个阈值,若是,进入戒备状态,此后的若干帧后,有任何一帧再低于阈值,说明输入结束,输出最后的速度,并给予马刚体。若此时瞬时速度的模长小于阈值 ,说明太慢,不记录。在这个戒备状态中的每一帧,需要记录瞬时速度,并累计影响,最终经过乘以调整值、取反(因为是相对作用)操作,得到需要赋予马的力,然后把力赋给马刚体,完成一次跳跃 (6.Good!初步尝试有效。在马着地后,重置跳跃状态,即可完成循环,开始下一次跳跃。 至此,马基本可以跳跃,但是手感极差,并且键鼠几乎没有操作空间,需要后续进一步优化……
2022-07-26 00:00:56 +08:00
m_SearchString:
m_CreateAssetUtility:
m_EndAction: {fileID: 0}
m_InstanceID: 0
m_Path:
m_Icon: {fileID: 0}
m_ResourceFile:
m_AssetTreeState:
scrollPos: {x: 0, y: 0}
m_SelectedIDs:
m_LastClickedID: 0
2022-08-04 17:37:45 +08:00
m_ExpandedIDs: 000000000c7800000e7800001078000012780000147800001678000018780000
任务:搭建基本玩法 1.让马可以跳跃 (1.测试,如果我给马的刚体一个(1,1)的力代表跳跃,是否可行? Good Job!通过测试,可以通过给力的方式使马整体起飞,而且控制点和马蹄都会随之起飞,是理想的状态。 (2.让马并拢每一组腿,当按住某键,使该组腿并拢,也就是消除输入偏差。当松开键,重新设置输入偏差,使双腿分开。 DONE (3.从输入中获取信息,当两腿均并拢,进入跳跃模式,否则离开跳跃模式,在跳跃模式下,如何通过输入计算出应该给出多大、哪个方向的的跳跃力是核心和难点 (4.马脚和马脚的控制点很难控制,数据也经常抖动,我不想通过这两个变量来计算跳跃的力。我打算直接通过输入值判断 (5.尝试:首先,若处于跳跃模式,每帧记录上一帧输入,并计算一个瞬时速度,当瞬时速度的y大于0,也就代表此时腿在上升,在预备,不考虑。若瞬时速度的y小于0,说明腿开始下降,可能会跳起。此时判断此瞬时速度的模长是否大于某个阈值,若是,进入戒备状态,此后的若干帧后,有任何一帧再低于阈值,说明输入结束,输出最后的速度,并给予马刚体。若此时瞬时速度的模长小于阈值 ,说明太慢,不记录。在这个戒备状态中的每一帧,需要记录瞬时速度,并累计影响,最终经过乘以调整值、取反(因为是相对作用)操作,得到需要赋予马的力,然后把力赋给马刚体,完成一次跳跃 (6.Good!初步尝试有效。在马着地后,重置跳跃状态,即可完成循环,开始下一次跳跃。 至此,马基本可以跳跃,但是手感极差,并且键鼠几乎没有操作空间,需要后续进一步优化……
2022-07-26 00:00:56 +08:00
m_RenameOverlay:
m_UserAcceptedRename: 0
m_Name:
m_OriginalName:
m_EditFieldRect:
serializedVersion: 2
x: 0
y: 0
width: 0
height: 0
m_UserData: 0
m_IsWaitingForDelay: 0
m_IsRenaming: 0
m_OriginalEventType: 11
m_IsRenamingFilename: 1
m_ClientGUIView: {fileID: 0}
m_SearchString:
m_CreateAssetUtility:
m_EndAction: {fileID: 0}
m_InstanceID: 0
m_Path:
m_Icon: {fileID: 0}
m_ResourceFile:
m_ListAreaState:
m_SelectedInstanceIDs:
m_LastClickedInstanceID: 0
m_HadKeyboardFocusLastEvent: 1
2022-08-04 17:37:45 +08:00
m_ExpandedInstanceIDs: ee770000
任务:搭建基本玩法 1.让马可以跳跃 (1.测试,如果我给马的刚体一个(1,1)的力代表跳跃,是否可行? Good Job!通过测试,可以通过给力的方式使马整体起飞,而且控制点和马蹄都会随之起飞,是理想的状态。 (2.让马并拢每一组腿,当按住某键,使该组腿并拢,也就是消除输入偏差。当松开键,重新设置输入偏差,使双腿分开。 DONE (3.从输入中获取信息,当两腿均并拢,进入跳跃模式,否则离开跳跃模式,在跳跃模式下,如何通过输入计算出应该给出多大、哪个方向的的跳跃力是核心和难点 (4.马脚和马脚的控制点很难控制,数据也经常抖动,我不想通过这两个变量来计算跳跃的力。我打算直接通过输入值判断 (5.尝试:首先,若处于跳跃模式,每帧记录上一帧输入,并计算一个瞬时速度,当瞬时速度的y大于0,也就代表此时腿在上升,在预备,不考虑。若瞬时速度的y小于0,说明腿开始下降,可能会跳起。此时判断此瞬时速度的模长是否大于某个阈值,若是,进入戒备状态,此后的若干帧后,有任何一帧再低于阈值,说明输入结束,输出最后的速度,并给予马刚体。若此时瞬时速度的模长小于阈值 ,说明太慢,不记录。在这个戒备状态中的每一帧,需要记录瞬时速度,并累计影响,最终经过乘以调整值、取反(因为是相对作用)操作,得到需要赋予马的力,然后把力赋给马刚体,完成一次跳跃 (6.Good!初步尝试有效。在马着地后,重置跳跃状态,即可完成循环,开始下一次跳跃。 至此,马基本可以跳跃,但是手感极差,并且键鼠几乎没有操作空间,需要后续进一步优化……
2022-07-26 00:00:56 +08:00
m_RenameOverlay:
m_UserAcceptedRename: 0
m_Name:
m_OriginalName:
m_EditFieldRect:
serializedVersion: 2
x: 0
y: 0
width: 0
height: 0
m_UserData: 0
m_IsWaitingForDelay: 0
m_IsRenaming: 0
m_OriginalEventType: 11
m_IsRenamingFilename: 1
m_ClientGUIView: {fileID: 10}
m_CreateAssetUtility:
m_EndAction: {fileID: 0}
m_InstanceID: 0
m_Path:
m_Icon: {fileID: 0}
m_ResourceFile:
m_NewAssetIndexInList: -1
m_ScrollPosition: {x: 0, y: 0}
m_GridSize: 64
m_SkipHiddenPackages: 0
2022-08-04 17:37:45 +08:00
m_DirectoriesAreaWidth: 161
任务:搭建基本玩法 1.让马可以跳跃 (1.测试,如果我给马的刚体一个(1,1)的力代表跳跃,是否可行? Good Job!通过测试,可以通过给力的方式使马整体起飞,而且控制点和马蹄都会随之起飞,是理想的状态。 (2.让马并拢每一组腿,当按住某键,使该组腿并拢,也就是消除输入偏差。当松开键,重新设置输入偏差,使双腿分开。 DONE (3.从输入中获取信息,当两腿均并拢,进入跳跃模式,否则离开跳跃模式,在跳跃模式下,如何通过输入计算出应该给出多大、哪个方向的的跳跃力是核心和难点 (4.马脚和马脚的控制点很难控制,数据也经常抖动,我不想通过这两个变量来计算跳跃的力。我打算直接通过输入值判断 (5.尝试:首先,若处于跳跃模式,每帧记录上一帧输入,并计算一个瞬时速度,当瞬时速度的y大于0,也就代表此时腿在上升,在预备,不考虑。若瞬时速度的y小于0,说明腿开始下降,可能会跳起。此时判断此瞬时速度的模长是否大于某个阈值,若是,进入戒备状态,此后的若干帧后,有任何一帧再低于阈值,说明输入结束,输出最后的速度,并给予马刚体。若此时瞬时速度的模长小于阈值 ,说明太慢,不记录。在这个戒备状态中的每一帧,需要记录瞬时速度,并累计影响,最终经过乘以调整值、取反(因为是相对作用)操作,得到需要赋予马的力,然后把力赋给马刚体,完成一次跳跃 (6.Good!初步尝试有效。在马着地后,重置跳跃状态,即可完成循环,开始下一次跳跃。 至此,马基本可以跳跃,但是手感极差,并且键鼠几乎没有操作空间,需要后续进一步优化……
2022-07-26 00:00:56 +08:00
--- !u!114 &16
MonoBehaviour:
m_ObjectHideFlags: 52
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 0}
m_Enabled: 1
m_EditorHideFlags: 1
m_Script: {fileID: 12019, guid: 0000000000000000e000000000000000, type: 0}
m_Name:
m_EditorClassIdentifier:
m_MinSize: {x: 275, y: 50}
m_MaxSize: {x: 4000, y: 4000}
m_TitleContent:
m_Text: "\u68C0\u67E5\u5668"
m_Image: {fileID: -440750813802333266, guid: 0000000000000000d000000000000000, type: 0}
m_Tooltip:
m_Pos:
serializedVersion: 2
2022-08-04 17:37:45 +08:00
x: 1285.6
任务:搭建基本玩法 1.让马可以跳跃 (1.测试,如果我给马的刚体一个(1,1)的力代表跳跃,是否可行? Good Job!通过测试,可以通过给力的方式使马整体起飞,而且控制点和马蹄都会随之起飞,是理想的状态。 (2.让马并拢每一组腿,当按住某键,使该组腿并拢,也就是消除输入偏差。当松开键,重新设置输入偏差,使双腿分开。 DONE (3.从输入中获取信息,当两腿均并拢,进入跳跃模式,否则离开跳跃模式,在跳跃模式下,如何通过输入计算出应该给出多大、哪个方向的的跳跃力是核心和难点 (4.马脚和马脚的控制点很难控制,数据也经常抖动,我不想通过这两个变量来计算跳跃的力。我打算直接通过输入值判断 (5.尝试:首先,若处于跳跃模式,每帧记录上一帧输入,并计算一个瞬时速度,当瞬时速度的y大于0,也就代表此时腿在上升,在预备,不考虑。若瞬时速度的y小于0,说明腿开始下降,可能会跳起。此时判断此瞬时速度的模长是否大于某个阈值,若是,进入戒备状态,此后的若干帧后,有任何一帧再低于阈值,说明输入结束,输出最后的速度,并给予马刚体。若此时瞬时速度的模长小于阈值 ,说明太慢,不记录。在这个戒备状态中的每一帧,需要记录瞬时速度,并累计影响,最终经过乘以调整值、取反(因为是相对作用)操作,得到需要赋予马的力,然后把力赋给马刚体,完成一次跳跃 (6.Good!初步尝试有效。在马着地后,重置跳跃状态,即可完成循环,开始下一次跳跃。 至此,马基本可以跳跃,但是手感极差,并且键鼠几乎没有操作空间,需要后续进一步优化……
2022-07-26 00:00:56 +08:00
y: 73.6
2022-08-04 17:37:45 +08:00
width: 249.40002
任务:搭建基本玩法 1.让马可以跳跃 (1.测试,如果我给马的刚体一个(1,1)的力代表跳跃,是否可行? Good Job!通过测试,可以通过给力的方式使马整体起飞,而且控制点和马蹄都会随之起飞,是理想的状态。 (2.让马并拢每一组腿,当按住某键,使该组腿并拢,也就是消除输入偏差。当松开键,重新设置输入偏差,使双腿分开。 DONE (3.从输入中获取信息,当两腿均并拢,进入跳跃模式,否则离开跳跃模式,在跳跃模式下,如何通过输入计算出应该给出多大、哪个方向的的跳跃力是核心和难点 (4.马脚和马脚的控制点很难控制,数据也经常抖动,我不想通过这两个变量来计算跳跃的力。我打算直接通过输入值判断 (5.尝试:首先,若处于跳跃模式,每帧记录上一帧输入,并计算一个瞬时速度,当瞬时速度的y大于0,也就代表此时腿在上升,在预备,不考虑。若瞬时速度的y小于0,说明腿开始下降,可能会跳起。此时判断此瞬时速度的模长是否大于某个阈值,若是,进入戒备状态,此后的若干帧后,有任何一帧再低于阈值,说明输入结束,输出最后的速度,并给予马刚体。若此时瞬时速度的模长小于阈值 ,说明太慢,不记录。在这个戒备状态中的每一帧,需要记录瞬时速度,并累计影响,最终经过乘以调整值、取反(因为是相对作用)操作,得到需要赋予马的力,然后把力赋给马刚体,完成一次跳跃 (6.Good!初步尝试有效。在马着地后,重置跳跃状态,即可完成循环,开始下一次跳跃。 至此,马基本可以跳跃,但是手感极差,并且键鼠几乎没有操作空间,需要后续进一步优化……
2022-07-26 00:00:56 +08:00
height: 701.8
m_ViewDataDictionary: {fileID: 0}
m_OverlayCanvas:
m_LastAppliedPresetName: Default
m_SaveData: []
m_ObjectsLockedBeforeSerialization: []
m_InstanceIDsLockedBeforeSerialization:
m_PreviewResizer:
m_CachedPref: -160
m_ControlHash: -371814159
m_PrefName: Preview_InspectorPreview
m_LastInspectedObjectInstanceID: -1
m_LastVerticalScrollValue: 0
任务:搭建基本玩法 1.让马可以跳跃 (1.测试,如果我给马的刚体一个(1,1)的力代表跳跃,是否可行? Good Job!通过测试,可以通过给力的方式使马整体起飞,而且控制点和马蹄都会随之起飞,是理想的状态。 (2.让马并拢每一组腿,当按住某键,使该组腿并拢,也就是消除输入偏差。当松开键,重新设置输入偏差,使双腿分开。 DONE (3.从输入中获取信息,当两腿均并拢,进入跳跃模式,否则离开跳跃模式,在跳跃模式下,如何通过输入计算出应该给出多大、哪个方向的的跳跃力是核心和难点 (4.马脚和马脚的控制点很难控制,数据也经常抖动,我不想通过这两个变量来计算跳跃的力。我打算直接通过输入值判断 (5.尝试:首先,若处于跳跃模式,每帧记录上一帧输入,并计算一个瞬时速度,当瞬时速度的y大于0,也就代表此时腿在上升,在预备,不考虑。若瞬时速度的y小于0,说明腿开始下降,可能会跳起。此时判断此瞬时速度的模长是否大于某个阈值,若是,进入戒备状态,此后的若干帧后,有任何一帧再低于阈值,说明输入结束,输出最后的速度,并给予马刚体。若此时瞬时速度的模长小于阈值 ,说明太慢,不记录。在这个戒备状态中的每一帧,需要记录瞬时速度,并累计影响,最终经过乘以调整值、取反(因为是相对作用)操作,得到需要赋予马的力,然后把力赋给马刚体,完成一次跳跃 (6.Good!初步尝试有效。在马着地后,重置跳跃状态,即可完成循环,开始下一次跳跃。 至此,马基本可以跳跃,但是手感极差,并且键鼠几乎没有操作空间,需要后续进一步优化……
2022-07-26 00:00:56 +08:00
m_GlobalObjectId:
m_InspectorMode: 0
m_LockTracker:
m_IsLocked: 0
m_PreviewWindow: {fileID: 0}