Godot3游戏引擎入门之十五：RigidBody2D刚体节点的几种应用场景及示例

var _velocity := Vector2.ZERO
var _isInfInertia := true

func _physics_process(delta):
    var hDir := int(Input.is_action_pressed('ui_right')) - int(Input.is_action_pressed('ui_left'))
    var vDir := int(Input.is_action_pressed('ui_down')) - int(Input.is_action_pressed('ui_up'))
    var velocity := Vector2(hDir, vDir if isTopDown else 0).normalized() * moveSpeed
    if !isTopDown:
        velocity.y = _velocity.y + gravity * delta
    _velocity = self.move_and_slide(velocity, FLOOR_NORMAL, true, 4, PI / 2, _isInfInertia)

    # 省略代码……

func _shoot() -> void:
    if ! bulletScene || ! _canShoot:
        return
    _canShoot = false
    _timer.start()
    var ball := bulletScene.instance() as RigidBody2D
    ball.position = _bulletPosition.global_position
    ball.apply_central_impulse(bulletForce * _bulletPosition.transform.x)
    self.get_parent().add_child(ball)

# 设置玩家是否为无限惯性力
func setInfiniteInertia(value : bool) -> void:
    _isInfInertia = value

export var mouseSensitivity := 0.25
export var deadPosition := 800.0

var _isPicked := false  # 判断当前刚体是否被鼠标拖拽

func _input_event(viewport, event, shape_idx):
    # 右键按下时拖拽箱子
    var e : InputEventMouseButton = event as InputEventMouseButton
    if e && e.button_index == BUTTON_RIGHT && e.pressed:
        pickup()

func _unhandled_input(event):
    # 右键松开时抛掉箱子
    var e : InputEventMouseButton = event as InputEventMouseButton
    if e && e.button_index == BUTTON_RIGHT && ! e.pressed:
        # 传入鼠标的移动速度
        var v := Input.get_last_mouse_speed() * mouseSensitivity
        drop(v)

func _physics_process(delta):
    # 更新拖拽盒子的位置，跟随鼠标移动
    if _isPicked:
        self.global_transform.origin = self.get_global_mouse_position()

    # 盒子掉出地图之外删除
    if self.position.y > deadPosition:
        self.queue_free()

func pickup() -> void:
    if _isPicked:
        return
    _isPicked = true
    self.mode = RigidBody2D.MODE_STATIC   # 拾起盒子，更改为静态模式

func drop(velocity: Vector2 = Vector2.ZERO) -> void:
    if ! _isPicked:
        return
    _isPicked = false
    self.mode = RigidBody2D.MODE_RIGID   # 抛掉盒子，更改为刚体模式
    # self.sleeping = false              # 防止刚体睡眠
    self.apply_central_impulse(velocity) # 给盒子一个抛力

# 引起爆炸的物体分组名集合，这里为玩家和子弹
export(Array, String) var triggerGroups := ['player', 'bullet']

func _on_Area2D_area_or_body_entered(area_or_body):
    for group in triggerGroups:
        if area_or_body.is_in_group(group):
            $Explode.explode()
            $Area2D.queue_free()
            return

# 设置房间的位置和大小
func makeRoom(pos: Vector2, size: Vector2) -> void:
    self.position = pos
    _size = size

# 获取房间的位置尺寸，可以传入一个偏差值
func getRect(tolerance : float = 0.0) -> Rect2:
    var s = _size - Vector2(tolerance, tolerance)
    return Rect2(self.position - s / 2, s)

export var roomScene : PackedScene = null  # 房间子场景
export var roomCount : int = 25            # 房间总数量
export var tileSize : int = 32             # 地图瓦片单元尺寸
export var minSize : int = 4               # 房间最小尺寸，乘以瓦片尺寸
export var maxSize : int = 10              # 房间最大尺寸，乘以瓦片尺寸
export(float, 0.0, 1.0) var cullTolerance : float = 0.4  # 剔除部分房间，系数

onready var _roomContainer := $RoomContainer
onready var _camera := $Camera2D
onready var _windowSize : Vector2 = self.get_viewport_rect().size

var _isWorking := false                    # 是否正在进行生成中
var _astarPath : AStar = null              # AStar算法实例
var _zoom : Vector2 = Vector2.ONE          # 相机缩放
var _offset : Vector2 = Vector2.ZERO       # 相机偏移

# 随机地图生成方法，可以拆分为多个函数，这里分4步
func generateRooms() -> void:
    if ! roomScene || _isWorking:
        return

    # 标记，删除旧房间
    _isWorking = true
    _astarPath = null
    for room in _roomContainer.get_children():
        room.queue_free()

    # 随机生成新的房间，尺寸随机
    randomize()
    for i in range(roomCount):
        var room : Room = roomScene.instance()
        var width := randi() % (maxSize - minSize) + minSize
        var height := randi() % (maxSize - minSize) + minSize
        var size := Vector2(width, height) * tileSize
        room.makeRoom(Vector2.ZERO, size)
        _roomContainer.add_child(room)
    print('Step 1 is done.') # 第一步完成

    # 停留1秒，让生成的房间有足够时间分散开
    yield(self.get_tree().create_timer(1.0), 'timeout')

    # 随机删除一部分房间，把房间的位置全部添加到数组，注意时 Vector3 类型
    var allPoints : Array = []
    for room in _roomContainer.get_children():
        if randf() < cullTolerance:
            room.queue_free()
        else:
            room.mode = RigidBody2D.MODE_STATIC
            allPoints.append(Vector3(room.position.x, room.position.y, 0.0))
    print('Step 2 is done.') # 第二步完成

    # 创建新的AStar算法，添加第一个点
    _astarPath = AStar.new()
    _astarPath.add_point(_astarPath.get_available_point_id(), allPoints.pop_front())
    # 循环所有【未添加的点】，循环所有AStar中【已添加的点】
    # 找出【未添加点】与【已添加点】的距离中，【最短】的距离点，并添加到AStar中
    # 同时将该点从【未添加点集合】中删除
    while allPoints:
        var minDistance : float = INF
        var minDistancePosition : Vector3
        var minDistancePositionIndex : int
        var currentPointId :int = -1
        for point in _astarPath.get_points():
            for index in range(allPoints.size()):
                var pos = allPoints[index]
                var distance = _astarPath.get_point_position(point).distance_to(pos)
                if distance < minDistance:
                    minDistance = distance
                    minDistancePosition = pos
                    minDistancePositionIndex = index
                    currentPointId = point
        var id = _astarPath.get_available_point_id()
        _astarPath.add_point(id, minDistancePosition)
        _astarPath.connect_points(currentPointId, id)
        allPoints.remove(minDistancePositionIndex)
    print('Step 3 is done.') # 第三步完成

    # 等待一帧的时间，用于等待被删除的房间被彻底移除
    yield(self.get_tree(), 'idle_frame')
    if _roomContainer.get_child_count() == 0:
        return

    # 找出所有房间最左上角和最右下角的两个坐标，确定摄像机的缩放和位移
    var minPos := Vector2(_roomContainer.get_child(0).position.x, _roomContainer.get_child(0).position.y)
    var maxPos := minPos
    for room in _roomContainer.get_children():
        var rect := room.getRect() as Rect2
        if rect.position.x < minPos.x:
            minPos.x = rect.position.x
        if rect.end.x > maxPos.x:
            maxPos.x = rect.end.x
        if rect.position.y < minPos.y:
            minPos.y = rect.position.y
        if rect.end.y > maxPos.y:
            maxPos.y = rect.end.y
    _zoom = Vector2.ONE * ceil(max((maxPos.x - minPos.x) / _windowSize.x, (maxPos.y - minPos.y) / _windowSize.y))
    _offset = (maxPos + minPos) / 2
    print('Step 4 is done.') # 第四步完成

    _isWorking = false