MinecraftV2/PhysicsHandler.py at master · Phoenix465/MinecraftV2 · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
from glm import vec3, length
from time import time

import ChunkHandler
import RayHandler
import TagHandler
import TweeningHandler


@TagHandler.ClassTag("PhysicsObjectAABB")
class PhysicsObjectAABB(object):
    def __init__(self, world=None, relativePositions=None, relativePositionPriority=None, gravityAffected=False, **kwargs):
        super(PhysicsObjectAABB, self).__init__(**kwargs)

        self.world = world
        self.relativePositions = relativePositions
        self.relativePositionPriority = relativePositionPriority
        self.gravityAffected = gravityAffected

        self.gravityVelocity = 0

        self.headPos = vec3(0, 0, 0)

        self.movementVector = vec3()
        self.movementTweenInfo = TweeningHandler.TweenInfo(time=1/20)

    def linkHeadPosToCamera(self, phyHeadPos):
        #  Ensuring Variable self.phyHeadPos is linked to phyHeadPos
        self.headPos = phyHeadPos

    @TagHandler.FunctionTag("physics-tick")
    def handleMovementAndCollision(self):
        movementVectorCopy = vec3(self.movementVector)
        self.movementVector = vec3(0, 0, 0)

        # Gravity
        if self.gravityAffected:
            self.gravityVelocity = (self.gravityVelocity - 0.08) * 0.98

        movementVectorCopy += vec3(0, self.gravityVelocity, 0)

        defaultBlock, closeChunks = RayHandler.DefaultBlockAABB(), ChunkHandler.GetCloseAdjacentChunks(self.world, self.headPos)

        multipliers = [
            vec3(0, 1, 0),
            vec3(0, 0, 1),
            vec3(1, 0, 0),
        ]
        inverse = [
            vec3(1, 0, 1),
            vec3(1, 1, 0),
            vec3(0, 1, 1),
        ]
        vectorIndexOrder = [
            1,  # Y
            2,  # Z
            0  # X
        ]

        if movementVectorCopy.z > movementVectorCopy.x:
            multipliers[1], multipliers[2] = multipliers[2], multipliers[1]
            inverse[1], inverse[2] = inverse[2], inverse[1]
            vectorIndexOrder[1], vectorIndexOrder[2] = vectorIndexOrder[2], vectorIndexOrder[1]

        phyHeadPosTemp = vec3(self.headPos)

        collisionIndex = [False, False, False]
        for vI, vMultiplier in enumerate(multipliers):
            movementDirection = movementVectorCopy * vMultiplier

            if length(movementDirection) == 0:
                continue

            moveRay = RayHandler.Ray(
                orig=phyHeadPosTemp,
                dir=movementDirection
            )

            didCollide = False
            distanceCollisions = []
            distanceI = []

            s = time()
            for i, relPos in enumerate(self.relativePositions):
                moveRay.orig = phyHeadPosTemp + relPos

                hitPos, *_, hitPosRoundV = RayHandler.FindRayHitBlock(
                    moveRay,
                    defaultBlock,
                    closeChunks,
                    maxDist=abs(movementDirection[vectorIndexOrder[vI]]),
                    debug=False
                )

                if hitPos:
                    didCollide = True

                    # Not Instant Collide
                    if length(hitPos - moveRay.orig):
                        # True Correction
                        relBPos = moveRay.dir * -vec3(0.5, 1, 0.5)
                        hitPos = hitPos * inverse[vI] + (hitPosRoundV + relBPos) * multipliers[vI]

                    distanceCollisions.append(length(hitPos - moveRay.orig))
                    distanceI.append(i)

            e = time() - s

            if not didCollide:
                phyHeadPosTemp += movementDirection
            else:
                vectorCheckIndex = vectorIndexOrder[vI]
                direction = round(moveRay.dir[vectorCheckIndex])

                priorityDistanceGroup = []
                priorityI = []
                for priorityGroup in self.relativePositionPriority[(vectorCheckIndex, direction)]:
                    foundRay = False
                    for rayIndex in priorityGroup:
                        if rayIndex in distanceI:
                            foundRay = True
                            priorityDistanceGroup.append(distanceCollisions[distanceI.index(rayIndex)])
                            priorityI.append(rayIndex)
                    if foundRay:
                        break

                minimumDistance = min(priorityDistanceGroup)
                phyHeadPosTemp += moveRay.dir * max(minimumDistance - 0.001, 0)

                collisionIndex[vectorCheckIndex] = True

        if collisionIndex[1]:
            self.gravityVelocity = 0

        if self.headPos != phyHeadPosTemp:
            tween = TweeningHandler.Tween(self, self.movementTweenInfo, {"headPos": phyHeadPosTemp})
            tween.playT()