Method updateSegmentCrashed

src/OpenLoco/src/Vehicles/VehicleBogie.cpp:167–297

0x004AA68E

    // 0x004AA68E
    void VehicleBogie::updateSegmentCrashed()
    {
        Speed32 speed = Speed32(var_5A & 0x7FFFFFFF);
        bool isComponentDestroyed = this->var_5A & (1U << 31);
        speed = speed - (speed / 64);
        if (speed <= 2.0_mph)
        {
            speed = 0.0_mph;
        }

        this->var_5A = speed.getRaw() | (isComponentDestroyed ? (1U << 31) : 0);

        auto& distances = getVehicleUpdateDistances();
        distances.unkDistance1 = speed.getRaw() / 128;
        distances.unkDistance2 = speed.getRaw() / 128;

        this->updateRoll(distances.unkDistance1);

        if (isComponentDestroyed)
        {
            if (speed >= 1.0_mph)
            {
                const auto distanceTravelled = speed.getRaw() / 16;
                auto xyDistance = Math::Trigonometry::computeXYVector(distanceTravelled, spriteYaw);

                uint16_t xDistanceLow = xyDistance.x & 0x0000FFFF;
                uint16_t yDistanceLow = xyDistance.y & 0x0000FFFF;
                // This is being casted to uint32_t as we want a negative value to round away from zero
                // this is due to splitting the precision of the distance into two parts
                World::Pos2 distanceWorld(static_cast<uint32_t>(xyDistance.x) / 65536, static_cast<uint32_t>(xyDistance.y) / 65536);
                // We are storing the lower precision in tileX and tileY they aren't actually being used as tileX and tileY.
                // Yay reusing fields for different purposes means we need to be careful with the sign of the type
                int32_t newTileX = static_cast<uint16_t>(this->tileX) + xDistanceLow;
                if (newTileX >= 0x00010000)
                {
                    distanceWorld.x++;
                }
                this->tileX = newTileX & 0x0000FFFF;

                int32_t newTileY = static_cast<uint16_t>(this->tileY) + yDistanceLow;
                if (newTileY >= 0x00010000)
                {
                    distanceWorld.y++;
                }
                this->tileY = newTileY & 0x0000FFFF;

                this->tileBaseZ++;
                int16_t zDistance = this->tileBaseZ / 32;

                // Calculate new position - but don't update yet!! This is pushed to the stack.
                World::Pos3 newPosition{ position + World::Pos3(distanceWorld, -zDistance) };

                if (!destroyedBogieCheckForCollision(*this, position))
                {
                    World::Pos3 positionToTest = { newPosition.x, newPosition.y, this->position.z };
                    if (destroyedBogieCheckForCollision(*this, positionToTest))
                    {
                        newPosition.x = this->position.x;