mirror of
https://gitlab.com/cable-mc/cobblemon.git
synced 2026-11-21 07:38:54 -05:00
Compare commits
7
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
bd1b8a029c | ||
|
|
6e3c2c3b31 | ||
|
|
12493d2a0d | ||
|
|
f4b4e63ca1 | ||
|
|
6fc8349a6f | ||
|
|
aa5609c47d | ||
|
|
70dc7a319c |
No files matched your search
@@ -24,6 +24,7 @@ import com.cobblemon.mod.common.client.net.data.DataRegistrySyncPacketHandler
|
||||
import com.cobblemon.mod.common.client.net.data.PokemonInteractionsSyncHandler
|
||||
import com.cobblemon.mod.common.client.net.data.RideSettingsSyncHandler
|
||||
import com.cobblemon.mod.common.client.net.debug.OpenRidingStatsDebugGUIHandler
|
||||
import com.cobblemon.mod.common.client.net.debug.S2CUpdateObsAvoidHandler
|
||||
import com.cobblemon.mod.common.client.net.debug.UpdateTrackedBrainDataHandler
|
||||
import com.cobblemon.mod.common.client.net.dialogue.DialogueClosedHandler
|
||||
import com.cobblemon.mod.common.client.net.dialogue.DialogueOpenedHandler
|
||||
@@ -67,6 +68,7 @@ import com.cobblemon.mod.common.net.messages.client.callback.OpenPartyMoveCallba
|
||||
import com.cobblemon.mod.common.net.messages.client.cooking.SeasoningRegistrySyncPacket
|
||||
import com.cobblemon.mod.common.net.messages.client.cooking.ToggleCookingPotLidPacket
|
||||
import com.cobblemon.mod.common.net.messages.client.data.*
|
||||
import com.cobblemon.mod.common.net.messages.client.debug.ClientboundUpdateObsAvoidPacket
|
||||
import com.cobblemon.mod.common.net.messages.client.debug.RequestOpenRidingStatsDebugGUIPacket
|
||||
import com.cobblemon.mod.common.net.messages.client.debug.UpdateTrackedBrainDataPacket
|
||||
import com.cobblemon.mod.common.net.messages.client.dialogue.DialogueClosedPacket
|
||||
@@ -190,7 +192,11 @@ import com.cobblemon.mod.common.net.serverhandling.storage.party.SwapPartyPokemo
|
||||
import com.cobblemon.mod.common.net.serverhandling.storage.pc.*
|
||||
import com.cobblemon.mod.common.net.serverhandling.trade.*
|
||||
import com.cobblemon.mod.common.util.server
|
||||
import net.minecraft.server.level.ServerLevel
|
||||
import net.minecraft.server.level.ServerPlayer
|
||||
import net.minecraft.world.entity.Entity
|
||||
import com.cobblemon.mod.common.mixin.accessor.ChunkMapAccessor
|
||||
import com.cobblemon.mod.common.mixin.accessor.TrackedEntityAccessor
|
||||
|
||||
/**
|
||||
* Registers Cobblemon network packets.
|
||||
@@ -213,6 +219,19 @@ object CobblemonNetwork {
|
||||
fun sendToAllPlayers(packet: NetworkPacket<*>) = sendPacketToPlayers(server()!!.playerList.players, packet)
|
||||
@JvmStatic
|
||||
fun sendPacketToPlayers(players: Iterable<ServerPlayer>, packet: NetworkPacket<*>) = players.forEach { sendPacketToPlayer(it, packet) }
|
||||
fun sendPacketToTrackingPlayers(entity: Entity, packet: NetworkPacket<*>) {
|
||||
val level = entity.level() as? ServerLevel ?: return
|
||||
|
||||
val chunkMap = level.chunkSource.chunkMap
|
||||
val entityTracker = (chunkMap as ChunkMapAccessor).entityMap[entity.id]
|
||||
|
||||
if (entityTracker is TrackedEntityAccessor) {
|
||||
entityTracker.seenBy.forEach { connection ->
|
||||
sendPacketToPlayer(connection.player, packet)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
val s2cPayloads = generateS2CPacketInfoList()
|
||||
val c2sPayloads = generateC2SPacketInfoList()
|
||||
@@ -420,6 +439,7 @@ object CobblemonNetwork {
|
||||
|
||||
// Debug / cheats
|
||||
list.add(PacketRegisterInfo(CalculateSeatPositionsPacket.ID, CalculateSeatPositionsPacket::decode, CalculateSeatPositionsHandler))
|
||||
list.add(PacketRegisterInfo(ClientboundUpdateObsAvoidPacket.ID, ClientboundUpdateObsAvoidPacket::decode, S2CUpdateObsAvoidHandler))
|
||||
|
||||
// Riding
|
||||
list.add(PacketRegisterInfo(ClientboundUpdateRidingStatePacket.ID, ClientboundUpdateRidingStatePacket::decode, ClientboundUpdateRidingStateHandler))
|
||||
|
||||
@@ -14,6 +14,7 @@ import net.minecraft.world.entity.ai.behavior.BlockPosTracker
|
||||
import net.minecraft.world.entity.ai.behavior.EntityTracker
|
||||
import net.minecraft.world.entity.ai.behavior.PositionTracker
|
||||
import net.minecraft.world.entity.ai.memory.WalkTarget
|
||||
import net.minecraft.world.phys.Vec3
|
||||
|
||||
/**
|
||||
* A trivial wrapper around an entity and a position tracker to make the entity look at the position each tick.
|
||||
|
||||
+134
@@ -0,0 +1,134 @@
|
||||
/*
|
||||
* Copyright (C) 2023 Cobblemon Contributors
|
||||
*
|
||||
* This Source Code Form is subject to the terms of the Mozilla Public
|
||||
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
||||
* file, You can obtain one at https://mozilla.org/MPL/2.0/.
|
||||
*/
|
||||
|
||||
package com.cobblemon.mod.common.api.ai.biggerbrain.fixation
|
||||
|
||||
import com.cobblemon.mod.common.api.ai.biggerbrain.BiggerBrain
|
||||
import com.cobblemon.mod.common.api.ai.biggerbrain.LookingTracker
|
||||
import com.cobblemon.mod.common.api.ai.biggerbrain.MovementStatus
|
||||
import com.cobblemon.mod.common.api.ai.biggerbrain.MovementTracker
|
||||
import com.cobblemon.mod.common.api.ai.biggerbrain.distraction.Distraction
|
||||
import com.cobblemon.mod.common.api.ai.biggerbrain.distraction.DistractionType
|
||||
import com.cobblemon.mod.common.api.ai.biggerbrain.objective.WanderAround
|
||||
import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
|
||||
import com.cobblemon.mod.common.entity.pokemon.ai.PokemonMoveControl
|
||||
import com.cobblemon.mod.common.entity.pokemon.extensions.orientEntityToTravel
|
||||
import com.cobblemon.mod.common.entity.pokemon.extensions.steerToTarget
|
||||
import com.cobblemon.mod.common.util.math.geometry.toRadians
|
||||
import net.minecraft.util.Mth
|
||||
import net.minecraft.world.entity.LivingEntity
|
||||
import net.minecraft.world.phys.Vec3
|
||||
import kotlin.math.abs
|
||||
|
||||
/**
|
||||
* Fixation for random wander (Essentially Reynolds wander for steered entities
|
||||
*
|
||||
* @author Jackson
|
||||
* @since April 13th, 2026
|
||||
*/
|
||||
class RandomWanderFixation(
|
||||
val objective: WanderAround,
|
||||
val pokemonEntity: PokemonEntity,
|
||||
val moveControl: PokemonMoveControl,
|
||||
val center: Vec3 = pokemonEntity.position(),
|
||||
val boundarySize: Double = 25.0,
|
||||
val durationTicks: Int = 400
|
||||
) : EntityFixation, MovementTrackerFixation {
|
||||
override val movementTracker: MovementTracker? = null
|
||||
var ticksRemaining = durationTicks
|
||||
|
||||
// Wander state — pulled from BoidsMoveControl.wander()
|
||||
var currHorzWander = 0.0
|
||||
var currVertWander = 0.0
|
||||
val wanderDisp = 5.0
|
||||
|
||||
override fun getDescription(entity: LivingEntity) = "Reynolds wandering ($ticksRemaining ticks left)"
|
||||
|
||||
override fun canDistract(distraction: Distraction, entity: LivingEntity) =
|
||||
distraction.isForce || distraction.isComfort || distraction.isDamage
|
||||
|
||||
override fun onDistract(distraction: Distraction, entity: LivingEntity) {}
|
||||
|
||||
override fun tick(entity: LivingEntity, brain: BiggerBrain): Boolean {
|
||||
if (entity !is PokemonEntity) return false
|
||||
if (ticksRemaining-- <= 0) return false
|
||||
|
||||
val maxSpeed = moveControl.getTopSpeed(pokemonEntity) * 2.0
|
||||
entity.setFlying(true)
|
||||
|
||||
// TODO: deadlock detection — track position delta over last ~40 ticks, if average movement < threshold mark objective.deadlock = true and return false
|
||||
|
||||
applyWanderForce(maxSpeed)
|
||||
applyBoundaryForce(maxSpeed)
|
||||
|
||||
// moveControl.mob.speed = 0f // This is done in PokemonMoveControl however it needs to be done
|
||||
// moveControl.mob.setZza(0f)
|
||||
// moveControl.mob.setXxa(0f)
|
||||
// pokemonEntity.setDiscardFriction(true)
|
||||
// pokemonEntity.orientEntityToTravel(1.0f)
|
||||
|
||||
return true
|
||||
}
|
||||
|
||||
private fun applyWanderForce(maxSpeed: Double) {
|
||||
val maxForce = 0.2
|
||||
|
||||
val normVec = if (pokemonEntity.deltaMovement.lengthSqr() > 0.0001) {
|
||||
pokemonEntity.lookAngle.normalize()
|
||||
} else {
|
||||
Vec3(
|
||||
kotlin.random.Random.nextDouble(-1.0, 1.0),
|
||||
kotlin.random.Random.nextDouble(-1.0, 1.0),
|
||||
kotlin.random.Random.nextDouble(-1.0, 1.0)
|
||||
).normalize()
|
||||
// pokemonEntity.lookAngle.normalize()
|
||||
}
|
||||
|
||||
var wanderOff = normVec
|
||||
val currPitchS = Mth.atan2(wanderOff.y, wanderOff.horizontalDistance())
|
||||
if (currPitchS >= 0.85f || currPitchS <= -0.85f) {
|
||||
currVertWander = 0.0
|
||||
}
|
||||
wanderOff = wanderOff.xRot(currVertWander.toFloat().toRadians())
|
||||
wanderOff = wanderOff.yRot(currHorzWander.toFloat().toRadians())
|
||||
|
||||
val centerDistance = 4.0
|
||||
val wanderCenter = pokemonEntity.position().add(normVec.scale(centerDistance))
|
||||
val wanderRadius = 0.2
|
||||
val wanderPoint = wanderCenter.add(wanderOff.scale(wanderRadius))
|
||||
|
||||
currVertWander = Mth.wrapDegrees(kotlin.random.Random.nextDouble(-wanderDisp, wanderDisp) + currVertWander)
|
||||
currHorzWander = Mth.wrapDegrees(kotlin.random.Random.nextDouble(-wanderDisp, wanderDisp) + currHorzWander)
|
||||
|
||||
val wanderForce = pokemonEntity.steerToTarget(wanderPoint, maxSpeed, maxForce)
|
||||
pokemonEntity.deltaMovement = pokemonEntity.deltaMovement.add(wanderForce)
|
||||
}
|
||||
|
||||
private fun applyBoundaryForce(maxSpeed: Double) {
|
||||
val maxBoundaryForce = 0.01
|
||||
val halfSize = 12 //boundarySize / 2.0
|
||||
val entityPos = pokemonEntity.position()
|
||||
val posFromCenter = entityPos.subtract(center)
|
||||
|
||||
val xExceed = maxOf(0.0, abs(posFromCenter.x) - halfSize)
|
||||
val yExceed = maxOf(0.0, abs(posFromCenter.y) - halfSize)
|
||||
val zExceed = maxOf(0.0, abs(posFromCenter.z) - halfSize)
|
||||
|
||||
if (xExceed == 0.0 && yExceed == 0.0 && zExceed == 0.0) return
|
||||
|
||||
var desiredPos = entityPos.add(pokemonEntity.deltaMovement)
|
||||
if (xExceed != 0.0) desiredPos = Vec3(center.x, desiredPos.y, desiredPos.z)
|
||||
if (yExceed != 0.0) desiredPos = Vec3(desiredPos.x, center.y, desiredPos.z)
|
||||
if (zExceed != 0.0) desiredPos = Vec3(desiredPos.x, desiredPos.y, center.z)
|
||||
|
||||
val correctiveForce = desiredPos.subtract(entityPos).normalize().scale(maxSpeed)
|
||||
var steer = correctiveForce.subtract(pokemonEntity.deltaMovement)
|
||||
if (steer.length() > maxBoundaryForce) steer = steer.normalize().scale(maxBoundaryForce)
|
||||
pokemonEntity.deltaMovement = pokemonEntity.deltaMovement.add(steer)
|
||||
}
|
||||
}
|
||||
+1
@@ -31,6 +31,7 @@ import net.minecraft.world.entity.ai.memory.MemoryModuleType
|
||||
|
||||
/**
|
||||
* Swim or fly in a circle objective
|
||||
* TODO: this may just need to be included in [WanderAround]?
|
||||
*/
|
||||
class CircleAround(
|
||||
val poseTypes: Set<PoseType>,
|
||||
|
||||
+302
@@ -0,0 +1,302 @@
|
||||
/*
|
||||
* Copyright (C) 2023 Cobblemon Contributors
|
||||
*
|
||||
* This Source Code Form is subject to the terms of the Mozilla Public
|
||||
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
||||
* file, You can obtain one at https://mozilla.org/MPL/2.0/.
|
||||
*/
|
||||
|
||||
package com.cobblemon.mod.common.api.ai.biggerbrain.objective
|
||||
|
||||
|
||||
import com.cobblemon.mod.common.CobblemonMemories
|
||||
import com.cobblemon.mod.common.api.ai.BehaviourConfigurationContext
|
||||
import com.cobblemon.mod.common.api.ai.ExpressionOrEntityVariable
|
||||
import com.cobblemon.mod.common.api.ai.asVariables
|
||||
import com.cobblemon.mod.common.api.ai.biggerbrain.BiggerBrain
|
||||
import com.cobblemon.mod.common.api.ai.biggerbrain.MovementTracker
|
||||
import com.cobblemon.mod.common.api.ai.biggerbrain.distraction.Distraction
|
||||
import com.cobblemon.mod.common.api.ai.biggerbrain.distraction.idleBoredomDistraction
|
||||
import com.cobblemon.mod.common.api.ai.biggerbrain.fixation.EntityFixation
|
||||
import com.cobblemon.mod.common.api.ai.biggerbrain.fixation.MovementTrackerFixation
|
||||
import com.cobblemon.mod.common.api.ai.config.objective.ObjectiveConfig
|
||||
import com.cobblemon.mod.common.api.ai.resolveFloat
|
||||
import com.cobblemon.mod.common.entity.PoseType
|
||||
import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
|
||||
import com.cobblemon.mod.common.entity.pokemon.ai.PokemonMoveControl
|
||||
import com.cobblemon.mod.common.entity.pokemon.extensions.steerToTarget
|
||||
import com.cobblemon.mod.common.util.asExpression
|
||||
import com.cobblemon.mod.common.util.getMemorySafely
|
||||
import com.cobblemon.mod.common.util.math.geometry.toRadians
|
||||
import com.mojang.datafixers.util.Either
|
||||
import net.minecraft.server.level.ServerLevel
|
||||
import net.minecraft.world.entity.LivingEntity
|
||||
import net.minecraft.world.entity.ai.memory.MemoryModuleType
|
||||
import net.minecraft.world.phys.Vec3
|
||||
import java.util.UUID
|
||||
import kotlin.math.cos
|
||||
|
||||
/**
|
||||
* Flock or School to stay cool
|
||||
* This objective and fixation is currently not working as intended and needs modification or scrapped.
|
||||
*/
|
||||
class Flock(
|
||||
val poseTypes: Set<PoseType> = setOf(PoseType.FLY, PoseType.HOVER, PoseType.SWIM, PoseType.FLOAT),
|
||||
val separationWeight: Float = 0.8f,
|
||||
val alignmentWeight: Float = 0.6f,
|
||||
val cohesionWeight: Float = 0.6f,
|
||||
val neighborRadius: Float = 8f,
|
||||
val maxForce: Double = 0.02
|
||||
) : Objective {
|
||||
var fixation: EntityFixation? = null
|
||||
|
||||
override fun getDescription(entity: LivingEntity) = "Flocking"
|
||||
|
||||
override fun perform(
|
||||
entity: LivingEntity,
|
||||
brain: BiggerBrain,
|
||||
activeObjectiveTags: MutableSet<String>
|
||||
): ObjectiveStatus {
|
||||
if (entity !is PokemonEntity) return ObjectiveStatus.INVALID
|
||||
val moveControl = entity.moveControl as? PokemonMoveControl ?: return ObjectiveStatus.INVALID
|
||||
|
||||
if (brain.isFixation(fixation)) {
|
||||
activeObjectiveTags.add(Objective.OBJECTIVE_TAG_WANDERING)
|
||||
return ObjectiveStatus.FIXATED
|
||||
} else if (brain.fixation != null) {
|
||||
fixation = null
|
||||
}
|
||||
|
||||
if (entity.getCurrentPoseType() !in poseTypes) return ObjectiveStatus.INACTIVE
|
||||
|
||||
val leaderUUID = brain.getMemory(CobblemonMemories.HERD_LEADER)
|
||||
?: if (brain.hasMemoryValue(CobblemonMemories.HERD_SIZE)) entity.uuid.toString() else return ObjectiveStatus.INACTIVE
|
||||
|
||||
if (!brain.distract(idleBoredomDistraction)) return ObjectiveStatus.BLOCKED
|
||||
|
||||
fixation = brain.fixate(FlockFixation(this, entity, leaderUUID, moveControl))
|
||||
return ObjectiveStatus.FIXATED
|
||||
}
|
||||
|
||||
inner class FlockFixation(
|
||||
val objective: Flock,
|
||||
val pokemonEntity: PokemonEntity,
|
||||
val leaderUUID: String,
|
||||
val moveControl: PokemonMoveControl,
|
||||
) : EntityFixation, MovementTrackerFixation {
|
||||
override val movementTracker: MovementTracker? = null
|
||||
var maxSpeed = moveControl.getTopSpeed(pokemonEntity).toFloat()
|
||||
var maxForce = 0.02 // TODO: possibly move these to configs
|
||||
var flockNumber = 0
|
||||
|
||||
override fun getDescription(entity: LivingEntity) = "Flocking with ${this.flockNumber} friends"
|
||||
|
||||
override fun canDistract(distraction: Distraction, entity: LivingEntity) =
|
||||
distraction.isForce || distraction.isComfort || distraction.isDamage
|
||||
|
||||
override fun onDistract(distraction: Distraction, entity: LivingEntity) {}
|
||||
|
||||
override fun tick(entity: LivingEntity, brain: BiggerBrain): Boolean {
|
||||
if (entity !is PokemonEntity) return false
|
||||
if (entity.getCurrentPoseType() !in objective.poseTypes) return false
|
||||
val isLeader = leaderUUID == pokemonEntity.uuid.toString()
|
||||
if (!isLeader && brain.getMemory(CobblemonMemories.HERD_LEADER) != leaderUUID) return false
|
||||
|
||||
|
||||
this.maxSpeed = moveControl.getTopSpeed(pokemonEntity).toFloat() * 1.0f // TODO: can this be made to be static per species? and then friction calcs are done elsewhere?
|
||||
this.maxForce = 0.02
|
||||
val flockMates = getFlockMates(brain)
|
||||
this.flockNumber = flockMates.size
|
||||
val force = computeBoidForce(flockMates)
|
||||
applyBoidForce(force)
|
||||
return true
|
||||
}
|
||||
|
||||
private fun getFlockMates(brain: BiggerBrain): List<PokemonEntity> {
|
||||
val isLeader = leaderUUID == pokemonEntity.uuid.toString()
|
||||
|
||||
val followers = brain.getMemory(MemoryModuleType.NEAREST_VISIBLE_LIVING_ENTITIES)
|
||||
?.findAll {
|
||||
it is PokemonEntity && it != pokemonEntity &&
|
||||
it.brain.getMemorySafely(CobblemonMemories.HERD_LEADER).orElse(null) == leaderUUID
|
||||
}
|
||||
?.filterIsInstance<PokemonEntity>()
|
||||
?: emptyList()
|
||||
|
||||
if (isLeader) return followers
|
||||
|
||||
val level = pokemonEntity.level() as? ServerLevel
|
||||
val leader = level?.getEntity(UUID.fromString(leaderUUID)) as? PokemonEntity
|
||||
return if (leader != null) followers + leader else followers
|
||||
}
|
||||
|
||||
/**
|
||||
* Compute all forces involved in classic boid behaviour.
|
||||
* Each returns a Vec3 force, scale by respective weight, sum them
|
||||
*/
|
||||
private fun computeBoidForce(flockMates: List<PokemonEntity>): Vec3 {
|
||||
// TODO: implement separation, alignment, cohesion
|
||||
|
||||
var totalForce = Vec3.ZERO
|
||||
|
||||
val separationForce = this.separation(flockMates)?.scale(objective.separationWeight.toDouble())
|
||||
separationForce?.let { totalForce = totalForce.add(it) }
|
||||
|
||||
val alignmentForce = this.alignment(flockMates)?.scale(objective.alignmentWeight.toDouble())
|
||||
alignmentForce?.let { totalForce = totalForce.add(it) }
|
||||
|
||||
val cohesionForce = this.cohesion(flockMates)?.scale(objective.cohesionWeight.toDouble())
|
||||
cohesionForce?.let { totalForce = totalForce.add(it) }
|
||||
|
||||
val vel = pokemonEntity.deltaMovement
|
||||
val dir = if (vel.lengthSqr() > 0.0001) vel.normalize() else Vec3(
|
||||
-kotlin.math.sin(Math.toRadians(pokemonEntity.yRot.toDouble())),
|
||||
0.0,
|
||||
kotlin.math.cos(Math.toRadians(pokemonEntity.yRot.toDouble()))
|
||||
)
|
||||
val pointAhead = pokemonEntity.position().add(dir.scale(4.0))
|
||||
val forwardForce = pokemonEntity.steerToTarget(pointAhead, maxSpeed.toDouble(), maxForce)
|
||||
//totalForce = totalForce.add(dir.scale(maxForce * 1.5))
|
||||
|
||||
return totalForce
|
||||
}
|
||||
|
||||
private fun separation(flockMates: List<PokemonEntity>): Vec3? {
|
||||
var seperationVec: Vec3? = null
|
||||
|
||||
// Gather the total separation vec of all close entities
|
||||
flockMates.forEach { boid ->
|
||||
val toTargetVec = pokemonEntity.position().subtract(boid.position())
|
||||
val desiredSeperation = boid.bbWidth * 2.0 // Base the seperation distance on the model width
|
||||
val currDist = toTargetVec.length()
|
||||
if (currDist < desiredSeperation) {
|
||||
if (seperationVec == null) seperationVec = Vec3.ZERO
|
||||
// Make the seperation force inversely proprotional to the serperation distance
|
||||
// Also, scale the force by the bbwidth of the model so
|
||||
seperationVec = seperationVec.add(toTargetVec.normalize().scale((1.0 - (currDist / desiredSeperation)) ))
|
||||
}
|
||||
}
|
||||
|
||||
if (seperationVec != null) {
|
||||
//if (seperationVec.length() > this.maxSpeed) seperationVec = seperationVec.normalize().scale(this.maxSpeed)
|
||||
seperationVec = seperationVec.normalize().scale(this.maxSpeed.toDouble())
|
||||
seperationVec = seperationVec.subtract(pokemonEntity.deltaMovement)
|
||||
if (seperationVec.length() > this.maxForce) {
|
||||
seperationVec = seperationVec.normalize().scale(this.maxForce)
|
||||
}
|
||||
}
|
||||
return seperationVec
|
||||
}
|
||||
|
||||
private fun alignment(flockMates: List<PokemonEntity>): Vec3? {
|
||||
val neighborDist = objective.neighborRadius
|
||||
var summedVel: Vec3? = null
|
||||
var alignmentVec: Vec3? = null
|
||||
var boidCount = 0
|
||||
|
||||
// Gather the average position of the boid
|
||||
flockMates.forEach { boid ->
|
||||
val vecToOther = boid.position().subtract(this.pokemonEntity.position())
|
||||
val distToOther = vecToOther.length()
|
||||
val widthOfViewInDeg = 360
|
||||
val isInSightLine = pokemonEntity.deltaMovement.normalize().dot(vecToOther) > cos((widthOfViewInDeg / 2.0).toRadians())
|
||||
|
||||
if (isInSightLine && distToOther < neighborDist) {
|
||||
if (summedVel == null) summedVel = Vec3.ZERO
|
||||
summedVel = summedVel.add(boid.deltaMovement.normalize())
|
||||
boidCount++
|
||||
}
|
||||
}
|
||||
|
||||
if (summedVel != null) {
|
||||
// Get the average vel/alignment by dividing by the number of boids sampled
|
||||
val averageVel = summedVel.scale(1.0 / boidCount)
|
||||
|
||||
//alignmentVec = if (averageVel.length() > this.maxSpeed) averageVel.normalize().scale(this.maxSpeed) else averageVel
|
||||
alignmentVec = averageVel.normalize().scale(this.maxSpeed.toDouble())
|
||||
alignmentVec = alignmentVec.subtract(pokemonEntity.deltaMovement)
|
||||
if (alignmentVec.length() > this.maxForce) {
|
||||
alignmentVec = alignmentVec.normalize().scale(this.maxForce)
|
||||
}
|
||||
}
|
||||
return alignmentVec
|
||||
}
|
||||
|
||||
private fun cohesion(flockMates: List<PokemonEntity>): Vec3? {
|
||||
var summedPos: Vec3? = null
|
||||
var cohesionVec: Vec3? = null
|
||||
var boidCount = 0
|
||||
val cohesionRadius = objective.neighborRadius
|
||||
|
||||
// Gather the average position of the boid
|
||||
flockMates.forEach { boid ->
|
||||
val vecToOther = boid.position().subtract(this.pokemonEntity.position())
|
||||
val distToOther = vecToOther.length()
|
||||
val widthOfViewInDeg = 360
|
||||
val isInSightLine = pokemonEntity.deltaMovement.normalize().dot(vecToOther) > cos((widthOfViewInDeg / 2.0).toRadians())
|
||||
|
||||
if (isInSightLine && distToOther < cohesionRadius) { // Only use members that are within a certain radius and eyeline
|
||||
if (summedPos == null) summedPos = Vec3.ZERO
|
||||
summedPos = summedPos.add(boid.position())
|
||||
boidCount++
|
||||
}
|
||||
}
|
||||
|
||||
if (summedPos != null) {
|
||||
// Get the average position by dividing by the number of boids sampled
|
||||
var averagePos = summedPos.scale(1.0 / boidCount)
|
||||
|
||||
// Further weight the entire boid towards the leaders position 50/50 all and leader
|
||||
val isLeader = leaderUUID == pokemonEntity.uuid.toString()
|
||||
if (!isLeader) {
|
||||
val level = pokemonEntity.level() as? ServerLevel
|
||||
val leader = level?.getEntity(UUID.fromString(leaderUUID)) as? PokemonEntity
|
||||
leader?.let { averagePos = averagePos.add(it.position()).scale(0.5) }
|
||||
}
|
||||
|
||||
// Get the vector towards that average position and scale
|
||||
cohesionVec = averagePos.subtract(pokemonEntity.position())
|
||||
//if (cohesionVec.length() > this.maxSpeed) cohesionVec = cohesionVec.normalize().scale(this.maxSpeed)
|
||||
cohesionVec = cohesionVec.normalize().scale(this.maxSpeed.toDouble())
|
||||
cohesionVec = cohesionVec.subtract(pokemonEntity.deltaMovement)
|
||||
if (cohesionVec.length() > this.maxForce) {
|
||||
cohesionVec = cohesionVec.normalize().scale(this.maxForce)
|
||||
}
|
||||
}
|
||||
|
||||
return cohesionVec
|
||||
}
|
||||
|
||||
private fun applyBoidForce(force: Vec3) {
|
||||
var finalForce = force
|
||||
if (finalForce.length() < maxForce) {
|
||||
finalForce = finalForce.normalize().scale(maxForce)
|
||||
}
|
||||
pokemonEntity.deltaMovement = pokemonEntity.deltaMovement.add(finalForce)
|
||||
}
|
||||
}
|
||||
|
||||
class Config : ObjectiveConfig {
|
||||
val poseTypes: Set<PoseType> = setOf(PoseType.FLY, PoseType.HOVER, PoseType.SWIM, PoseType.FLOAT)
|
||||
val separationWeight: ExpressionOrEntityVariable = Either.left("0.8".asExpression())
|
||||
val alignmentWeight: ExpressionOrEntityVariable = Either.left("0.6".asExpression())
|
||||
val cohesionWeight: ExpressionOrEntityVariable = Either.left("0.6".asExpression())
|
||||
val neighborRadius: ExpressionOrEntityVariable = Either.left("8.0".asExpression())
|
||||
val maxForce: ExpressionOrEntityVariable = Either.left("0.02".asExpression())
|
||||
|
||||
override fun getVariables(entity: LivingEntity, behaviourConfigurationContext: BehaviourConfigurationContext) =
|
||||
listOf(separationWeight, alignmentWeight, cohesionWeight, neighborRadius, maxForce).asVariables()
|
||||
|
||||
override fun create(entity: LivingEntity, behaviourConfigurationContext: BehaviourConfigurationContext): Objective? {
|
||||
if (entity !is PokemonEntity) return null
|
||||
return Flock(
|
||||
poseTypes = poseTypes,
|
||||
separationWeight = separationWeight.resolveFloat(behaviourConfigurationContext.runtime),
|
||||
alignmentWeight = alignmentWeight.resolveFloat(behaviourConfigurationContext.runtime),
|
||||
cohesionWeight = cohesionWeight.resolveFloat(behaviourConfigurationContext.runtime),
|
||||
neighborRadius = neighborRadius.resolveFloat(behaviourConfigurationContext.runtime),
|
||||
maxForce = maxForce.resolveFloat(behaviourConfigurationContext.runtime).toDouble()
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
+2
@@ -19,6 +19,7 @@ import com.cobblemon.mod.common.api.ai.biggerbrain.objective.GatherNectar
|
||||
import com.cobblemon.mod.common.api.ai.biggerbrain.objective.GoToSleep
|
||||
import com.cobblemon.mod.common.api.ai.biggerbrain.objective.HarvestSweetBerryBush
|
||||
import com.cobblemon.mod.common.api.ai.biggerbrain.objective.Herd
|
||||
import com.cobblemon.mod.common.api.ai.biggerbrain.objective.Flock
|
||||
import com.cobblemon.mod.common.api.ai.biggerbrain.objective.LookAtNearbyEntities
|
||||
import com.cobblemon.mod.common.api.ai.biggerbrain.objective.MaintainFluidY
|
||||
import com.cobblemon.mod.common.api.ai.biggerbrain.objective.MoveIntoWater
|
||||
@@ -46,6 +47,7 @@ interface ObjectiveConfig {
|
||||
cobblemonResource("wander_around") to WanderAround.Config::class.java,
|
||||
cobblemonResource("eat_grass") to EatGrass.Config::class.java,
|
||||
cobblemonResource("herd") to Herd.Config::class.java,
|
||||
cobblemonResource("flock") to Flock.Config::class.java,
|
||||
cobblemonResource("stay_afloat") to StayAfloat.Config::class.java,
|
||||
cobblemonResource("maintain_fluid_y") to MaintainFluidY.Config::class.java,
|
||||
cobblemonResource("move_out_of_water") to MoveOutOfWater.Config::class.java,
|
||||
|
||||
@@ -145,6 +145,7 @@ import net.minecraft.world.entity.item.ItemEntity
|
||||
import net.minecraft.world.entity.monster.Monster
|
||||
import net.minecraft.world.entity.player.Player
|
||||
import net.minecraft.world.item.ItemStack
|
||||
import net.minecraft.world.item.enchantment.EnchantmentHelper
|
||||
import net.minecraft.world.level.ClipContext
|
||||
import net.minecraft.world.level.GameType
|
||||
import net.minecraft.world.level.Level
|
||||
@@ -311,7 +312,7 @@ object MoLangFunctions {
|
||||
runtime.environment.variable = params.environment.variable
|
||||
val args = params.params.subList(1, params.params.size)
|
||||
runtime.environment.context = ContextStruct(
|
||||
params.environment.context.map + args.mapIndexed { index, value -> "arg_${index + 1}" to value }.toMap()
|
||||
(params.environment.context?.map ?: emptyMap()) + args.mapIndexed { index, value -> "arg_${index + 1}" to value }.toMap()
|
||||
)
|
||||
val script = params.getString(0).asIdentifierDefaultingNamespace()
|
||||
// store the args in the
|
||||
@@ -324,13 +325,24 @@ object MoLangFunctions {
|
||||
runtime.environment.context = params.environment.context
|
||||
val expression = params.getString(0).asExpressionLike()
|
||||
val delayInSeconds = params.getDoubleOrNull(1)?.toFloat() ?: 0.0f
|
||||
|
||||
fun evaluate(): MoValue {
|
||||
return try {
|
||||
runtime.resolve(expression)
|
||||
} catch (ex: Exception) {
|
||||
Cobblemon.LOGGER.warn("Failed to evaluate MoLang expression${if (delayInSeconds > 0.0f) " (delayed)" else ""}: $expression", ex)
|
||||
DoubleValue.ZERO
|
||||
}
|
||||
}
|
||||
|
||||
if (delayInSeconds > 0.0f) {
|
||||
val tracker = if (Cobblemon.implementation.environment() == Environment.SERVER) ServerTaskTracker else ClientTaskTracker
|
||||
tracker.after(delayInSeconds) {
|
||||
runtime.resolve(expression)
|
||||
evaluate()
|
||||
}
|
||||
DoubleValue.ONE
|
||||
} else {
|
||||
runtime.resolve(expression)
|
||||
evaluate()
|
||||
}
|
||||
},
|
||||
"system_time_millis" to java.util.function.Function { _ ->
|
||||
@@ -340,23 +352,28 @@ object MoLangFunctions {
|
||||
"date_local_time" to java.util.function.Function { _ ->
|
||||
val time = System.currentTimeMillis()
|
||||
val date = java.util.Date(time)
|
||||
val formatted = java.text.SimpleDateFormat("DD/MM/YYYY").format(date)
|
||||
val formatted = java.text.SimpleDateFormat("dd/MM/yyyy").format(date)
|
||||
StringValue(formatted)
|
||||
},
|
||||
"date_of" to java.util.function.Function { params ->
|
||||
val time = params.getDouble(0).toLong()
|
||||
val date = java.util.Date(time)
|
||||
val formatted = java.text.SimpleDateFormat("DD/MM/YYYY").format(date)
|
||||
val formatted = java.text.SimpleDateFormat("dd/MM/yyyy").format(date)
|
||||
StringValue(formatted)
|
||||
},
|
||||
"date_is_after" to java.util.function.Function { params ->
|
||||
val dateA = params.getString(0)
|
||||
val dateB = params.getString(1)
|
||||
val format = java.text.SimpleDateFormat("DD/MM/YYYY")
|
||||
val format = java.text.SimpleDateFormat("dd/MM/yyyy")
|
||||
val a = format.parse(dateA)
|
||||
val b = format.parse(dateB)
|
||||
DoubleValue(a.after(b))
|
||||
},
|
||||
"get_move_from_id" to java.util.function.Function { params ->
|
||||
val moveId = params.getString(0)
|
||||
val moveTemplate = Moves.getByName(moveId)
|
||||
return@Function moveTemplate?.struct ?: DoubleValue.ZERO
|
||||
},
|
||||
"create_simple_party_provider" to java.util.function.Function { params ->
|
||||
val partyProvider = SimplePartyProvider()
|
||||
return@Function partyProvider.struct
|
||||
@@ -367,6 +384,13 @@ object MoLangFunctions {
|
||||
val pickupItem = ObtainableItem(item = item, pickupPriority = pickupPriority)
|
||||
return@Function pickupItem.struct
|
||||
},
|
||||
"create_itemstack" to java.util.function.Function { params ->
|
||||
val itemId = params.getString(0).asIdentifierDefaultingNamespace()
|
||||
val item = BuiltInRegistries.ITEM.get(itemId) ?: return@Function DoubleValue.ZERO
|
||||
val count = params.getIntOrNull(1) ?: 1
|
||||
val itemStack = ItemStack(item, count)
|
||||
return@Function ObjectValue(itemStack)
|
||||
},
|
||||
"file" to java.util.function.Function { MoLangLoadedFilesCache.struct }
|
||||
)
|
||||
val biomeFunctions = mutableListOf<(Holder<Biome>) -> HashMap<String, java.util.function.Function<MoParams, Any>>>()
|
||||
@@ -572,6 +596,62 @@ object MoLangFunctions {
|
||||
}
|
||||
return@put items
|
||||
}
|
||||
map.put("has_inventory_space") { _ ->
|
||||
val inventory = player.inventory
|
||||
return@put if (inventory.getFreeSlot() != -1) DoubleValue.ONE else DoubleValue.ZERO
|
||||
}
|
||||
map.put("set_inventory_slot") { params ->
|
||||
val slot = params.getInt(0)
|
||||
val inventory = player.inventory
|
||||
if (slot !in 0 until inventory.containerSize) return@put DoubleValue.ZERO
|
||||
|
||||
val value = params.getOrNull<MoValue>(1) ?: return@put DoubleValue.ZERO
|
||||
|
||||
val stack: ItemStack? = when (value) {
|
||||
is ObjectValue<*> -> value.obj as? ItemStack
|
||||
is StringValue -> {
|
||||
val id = ResourceLocation.parse(value.value)
|
||||
val item = player.registryAccess().registryOrThrow(Registries.ITEM).get(id) ?: return@put DoubleValue.ZERO
|
||||
ItemStack(item)
|
||||
}
|
||||
else -> null
|
||||
}
|
||||
|
||||
if (stack == null) return@put DoubleValue.ZERO
|
||||
|
||||
inventory.setItem(slot, stack)
|
||||
return@put DoubleValue.ONE
|
||||
}
|
||||
map.put("give_item") { params ->
|
||||
val inventory = player.inventory
|
||||
val freeSlot = inventory.getFreeSlot()
|
||||
val value = params.getOrNull<MoValue>(0) ?: return@put DoubleValue.ZERO
|
||||
val dropIfFull = params.getBooleanOrNull(1) ?: false
|
||||
|
||||
val stack: ItemStack? = when (value) {
|
||||
is ObjectValue<*> -> value.obj as? ItemStack
|
||||
is StringValue -> {
|
||||
val id = ResourceLocation.parse(value.value)
|
||||
val item = player.registryAccess().registryOrThrow(Registries.ITEM).get(id) ?: return@put DoubleValue.ZERO
|
||||
ItemStack(item)
|
||||
}
|
||||
else -> null
|
||||
}
|
||||
|
||||
if (stack == null) return@put DoubleValue.ZERO
|
||||
|
||||
if (freeSlot == -1) {
|
||||
if (dropIfFull) {
|
||||
player.drop(stack, false)
|
||||
return@put DoubleValue.ONE
|
||||
} else {
|
||||
return@put DoubleValue.ZERO
|
||||
}
|
||||
}
|
||||
|
||||
inventory.setItem(freeSlot, stack)
|
||||
return@put DoubleValue.ONE
|
||||
}
|
||||
map.put("face") { params -> ObjectValue(PlayerDialogueFaceProvider(player.uuid, params.getBooleanOrNull(0) != false)) }
|
||||
map.put("swing_hand") { _ -> player.swing(player.usedItemHand) }
|
||||
map.put("food_level") { _ -> DoubleValue(player.foodData.foodLevel) }
|
||||
@@ -615,8 +695,7 @@ object MoLangFunctions {
|
||||
}
|
||||
map.put("active_dialogue") { _ ->
|
||||
if (player.isInDialogue) {
|
||||
player.activeDialogue?.dialogueId.toString()
|
||||
return@put DoubleValue.ONE
|
||||
return@put player.activeDialogue?.toMoLangStruct() ?: DoubleValue.ZERO
|
||||
} else {
|
||||
DoubleValue.ZERO
|
||||
}
|
||||
@@ -793,6 +872,8 @@ object MoLangFunctions {
|
||||
|
||||
DoubleValue(value)
|
||||
}
|
||||
map.put("get_starter_uuid") { _ -> Cobblemon.playerDataManager.getGenericData(player).starterUUID?.let{ StringValue(it.toString()) } ?: DoubleValue.ZERO }
|
||||
map.put("has_chosen_starter") { _ -> DoubleValue(Cobblemon.playerDataManager.getGenericData(player).starterSelected) }
|
||||
}
|
||||
map
|
||||
}
|
||||
@@ -813,6 +894,15 @@ object MoLangFunctions {
|
||||
map.put("is_of") { params -> DoubleValue(holder.`is`(params.getString(0).asIdentifierDefaultingNamespace())) }
|
||||
map.put("is_in") { params -> DoubleValue(holder.`is`(TagKey.create(Registries.ITEM, params.getString(0).replace("#", "").asIdentifierDefaultingNamespace()))) }
|
||||
map.put("is_food") { params -> DoubleValue(stack.has(DataComponents.FOOD)) }
|
||||
map.put("is_enchanted") { params -> DoubleValue(stack.hasFoil()) }
|
||||
map.put("has_enchantment") { params ->
|
||||
val enchantmentId = params.getString(0).asIdentifierDefaultingNamespace()
|
||||
val minLevel = params.getIntOrNull(1) ?: 1
|
||||
val enchantmentRegistry = registryAccess.registryOrThrow(Registries.ENCHANTMENT)
|
||||
val holder = enchantmentRegistry.getHolder(enchantmentId).orElse(null) ?: return@put DoubleValue.ZERO
|
||||
val level = EnchantmentHelper.getItemEnchantmentLevel(holder, stack)
|
||||
return@put DoubleValue(level >= minLevel)
|
||||
}
|
||||
return@mutableListOf map
|
||||
}
|
||||
)
|
||||
@@ -1752,6 +1842,30 @@ object MoLangFunctions {
|
||||
map.put("remove_cosmetic_item") { _ ->
|
||||
pokemon.removeCosmeticItem()
|
||||
}
|
||||
map.put("marks") { _ -> pokemon.marks.asArrayValue { StringValue(it.identifier.toString()) } }
|
||||
map.put("has_mark") { params ->
|
||||
var hasMark = false
|
||||
val identifier = params.getString(0).asIdentifierDefaultingNamespace()
|
||||
val mark = Marks.getByIdentifier(identifier)
|
||||
if (mark != null) {
|
||||
hasMark = pokemon.marks.contains(mark)
|
||||
}
|
||||
|
||||
DoubleValue(hasMark)
|
||||
}
|
||||
map.put("remove_marks") { params ->
|
||||
var removedMark = false
|
||||
for (param in params.params) {
|
||||
val identifier = param.asString().asIdentifierDefaultingNamespace()
|
||||
val mark = Marks.getByIdentifier(identifier)
|
||||
if (mark != null) {
|
||||
pokemon.exchangeMark(mark, false)
|
||||
removedMark = true
|
||||
}
|
||||
}
|
||||
|
||||
DoubleValue(removedMark)
|
||||
}
|
||||
map.put("add_marks") { params ->
|
||||
var appliedMark = false
|
||||
for (param in params.params) {
|
||||
@@ -1931,7 +2045,6 @@ object MoLangFunctions {
|
||||
map.put("in_battle") { DoubleValue(pokemonEntity.isBattling) }
|
||||
map.put("is_moving") { DoubleValue((pokemonEntity.moveControl as? PokemonMoveControl)?.hasWanted() == true) }
|
||||
map.put("is_flying") { DoubleValue(pokemonEntity.getBehaviourFlag(PokemonBehaviourFlag.FLYING)) }
|
||||
map.put("is_dancing") { DoubleValue(pokemonEntity.getBehaviourFlag(PokemonBehaviourFlag.DANCING)) }
|
||||
map.put("get_riding_state") { params ->
|
||||
val name = params.getStringOrNull(0)
|
||||
pokemonEntity.ifRidingAvailableSupply(DoubleValue.ZERO) { behaviour, settings, state ->
|
||||
@@ -1946,9 +2059,13 @@ object MoLangFunctions {
|
||||
}
|
||||
}
|
||||
map.put("is_sprinting") {
|
||||
pokemonEntity.ifRidingAvailableSupply(DoubleValue.ZERO) { behaviour, settings, state ->
|
||||
val moValue = behaviour.asMoLangValue(settings, state, pokemonEntity)
|
||||
return@ifRidingAvailableSupply moValue.functions.get("sprinting")?.apply(MoParams.EMPTY) as? MoValue ?: DoubleValue.ZERO
|
||||
if (pokemonEntity.hasControllingPassenger()) { // If its being ridden then the riding state sets the animation
|
||||
pokemonEntity.ifRidingAvailableSupply(DoubleValue.ZERO) { behaviour, settings, state ->
|
||||
val moValue = behaviour.asMoLangValue(settings, state, pokemonEntity)
|
||||
return@ifRidingAvailableSupply moValue.functions.get("sprinting")?.apply(MoParams.EMPTY) as? MoValue ?: DoubleValue.ZERO
|
||||
}
|
||||
} else {
|
||||
pokemonEntity.isPokemonSprinting
|
||||
}
|
||||
}
|
||||
map.put("is_drifting") {
|
||||
@@ -2738,8 +2855,8 @@ object MoLangFunctions {
|
||||
}
|
||||
variable
|
||||
}
|
||||
else -> null
|
||||
} ?: throw IllegalArgumentException("Invalid NBT element type: ${nbt.type}")
|
||||
else -> VariableStruct()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -22,6 +22,8 @@ import kotlin.math.min
|
||||
|
||||
class Vec3Spring(
|
||||
var value: Vec3 = Vec3.ZERO,
|
||||
|
||||
|
||||
var velocity: Vec3 = Vec3.ZERO
|
||||
) {
|
||||
val history = ArrayDeque<Vec3>()
|
||||
|
||||
+9
-2
@@ -20,8 +20,7 @@ import com.cobblemon.mod.common.api.pokeball.PokeBalls
|
||||
import com.cobblemon.mod.common.api.pokemon.aspect.aspectParticleMap
|
||||
import com.cobblemon.mod.common.api.pokemon.PokemonSpecies
|
||||
import com.cobblemon.mod.common.api.pokemon.aspect.ParticleData
|
||||
import com.cobblemon.mod.common.api.riding.behaviour.RidingBehaviourState
|
||||
import com.cobblemon.mod.common.api.riding.stats.RidingStat
|
||||
import com.cobblemon.mod.common.util.math.FloatSpring
|
||||
import com.cobblemon.mod.common.api.scheduling.ScheduledTask
|
||||
import com.cobblemon.mod.common.api.scheduling.SchedulingTracker
|
||||
import com.cobblemon.mod.common.api.scheduling.afterOnClient
|
||||
@@ -42,6 +41,7 @@ import com.cobblemon.mod.common.util.MovingSoundInstance
|
||||
import com.cobblemon.mod.common.util.asExpressionLike
|
||||
import com.cobblemon.mod.common.util.asIdentifierDefaultingNamespace
|
||||
import com.cobblemon.mod.common.util.cobblemonResource
|
||||
import com.cobblemon.mod.common.util.math.InertialVals
|
||||
import com.cobblemon.mod.common.util.resolve
|
||||
import com.mojang.blaze3d.vertex.PoseStack
|
||||
import net.minecraft.client.Minecraft
|
||||
@@ -90,6 +90,13 @@ class PokemonClientDelegate : PosableState(), PokemonSideDelegate {
|
||||
var playedSendOutSound: Boolean = false
|
||||
var playedThrowingSound: Boolean = false
|
||||
|
||||
var renderYRotSpring: FloatSpring = FloatSpring()
|
||||
var lastRenderTime: Long = 0
|
||||
var lastKnownYBodyRot: Float = 0F
|
||||
var renderYRot: Float = 0F
|
||||
|
||||
var inertialYRot: InertialVals = InertialVals()
|
||||
|
||||
val secondsSinceBeamEffectStarted: Float
|
||||
get() = (System.currentTimeMillis() - beamStartTime) / 1000F
|
||||
|
||||
|
||||
+25
@@ -0,0 +1,25 @@
|
||||
/*
|
||||
* Copyright (C) 2023 Cobblemon Contributors
|
||||
*
|
||||
* This Source Code Form is subject to the terms of the Mozilla Public
|
||||
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
||||
* file, You can obtain one at https://mozilla.org/MPL/2.0/.
|
||||
*/
|
||||
|
||||
package com.cobblemon.mod.common.client.net.debug
|
||||
|
||||
import com.cobblemon.mod.common.api.net.ClientNetworkPacketHandler
|
||||
import com.cobblemon.mod.common.client.render.debug.LineState
|
||||
import com.cobblemon.mod.common.client.render.debug.SteerForceRenderer
|
||||
import com.cobblemon.mod.common.net.messages.client.debug.ClientboundUpdateObsAvoidPacket
|
||||
import net.minecraft.client.Minecraft
|
||||
|
||||
object S2CUpdateObsAvoidHandler : ClientNetworkPacketHandler<ClientboundUpdateObsAvoidPacket> {
|
||||
override fun handle(packet: ClientboundUpdateObsAvoidPacket, client: Minecraft) {
|
||||
client.executeIfPossible {
|
||||
//ObjectAvoidanceRenderer.avoidanceLines[packet.entityId] = packet.lines
|
||||
val lineState = SteerForceRenderer.lineStates.getOrPut(packet.entityId) { LineState() }
|
||||
lineState.update(packet.lines)
|
||||
}
|
||||
}
|
||||
}
|
||||
+116
@@ -0,0 +1,116 @@
|
||||
/*
|
||||
* Copyright (C) 2023 Cobblemon Contributors
|
||||
*
|
||||
* This Source Code Form is subject to the terms of the Mozilla Public
|
||||
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
||||
* file, You can obtain one at https://mozilla.org/MPL/2.0/.
|
||||
*/
|
||||
|
||||
package com.cobblemon.mod.common.client.render.debug
|
||||
|
||||
import com.cobblemon.mod.common.api.net.Encodable
|
||||
import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
|
||||
import com.mojang.blaze3d.vertex.PoseStack
|
||||
import com.mojang.blaze3d.vertex.VertexConsumer
|
||||
import net.minecraft.client.Camera
|
||||
import net.minecraft.client.Minecraft
|
||||
import net.minecraft.network.RegistryFriendlyByteBuf
|
||||
import net.minecraft.util.Mth
|
||||
import net.minecraft.world.phys.Vec3
|
||||
|
||||
/**
|
||||
* Data class currently used for storing line data for rendering in [SteerForceRenderer]
|
||||
*
|
||||
* @author Jackson
|
||||
* @since September 18th, 2025
|
||||
*/
|
||||
data class EntityDebugLine(
|
||||
val vector: Vec3, // Direction/magnitude in world space, relative to entity origin
|
||||
val r: Float,
|
||||
val g: Float,
|
||||
val b: Float,
|
||||
val a: Float,
|
||||
) : Encodable {
|
||||
override fun encode(buffer: RegistryFriendlyByteBuf) {
|
||||
buffer.writeVec3(vector)
|
||||
buffer.writeFloat(r)
|
||||
buffer.writeFloat(g)
|
||||
buffer.writeFloat(b)
|
||||
buffer.writeFloat(a)
|
||||
}
|
||||
|
||||
companion object {
|
||||
operator fun invoke(vector: Vec3, r: Float = 1f, g: Float = 1f, b: Float = 1f, a: Float = 1f): EntityDebugLine {
|
||||
return EntityDebugLine(vector, r.coerceIn(0f,1f), g.coerceIn(0f,1f), b.coerceIn(0f,1f), a.coerceIn(0f,1f))
|
||||
}
|
||||
|
||||
fun decode(buffer: RegistryFriendlyByteBuf): EntityDebugLine {
|
||||
val vector = buffer.readVec3()
|
||||
return EntityDebugLine(vector, buffer.readFloat(), buffer.readFloat(), buffer.readFloat(), buffer.readFloat())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
class LineState {
|
||||
/**
|
||||
* The comparison of the previous and current lines relies on the order being consistent
|
||||
*/
|
||||
var previousLines: List<EntityDebugLine> = emptyList()
|
||||
var currentLines: List<EntityDebugLine> = emptyList()
|
||||
var lastReceivedLineTick: Long? = null
|
||||
|
||||
fun tick() {
|
||||
previousLines = currentLines
|
||||
}
|
||||
|
||||
fun update(newLines: List<EntityDebugLine>) {
|
||||
lastReceivedLineTick = Minecraft.getInstance().level?.gameTime
|
||||
currentLines = newLines
|
||||
if (previousLines.isEmpty()) previousLines = newLines
|
||||
}
|
||||
|
||||
// entityPos: interpolated world position of the entity this tick
|
||||
fun draw(vc: VertexConsumer, pose: PoseStack.Pose, partialTick: Float, camera: Camera, entity: PokemonEntity, partialTicks: Float) {
|
||||
previousLines.zip(currentLines).forEach { (prev, curr) ->
|
||||
val iVec = prev.vector.lerp(curr.vector, partialTick.toDouble())
|
||||
val iR = prev.r.lerp(curr.r, partialTick)
|
||||
val iG = prev.g.lerp(curr.g, partialTick)
|
||||
val iB = prev.b.lerp(curr.b, partialTick)
|
||||
val iA = prev.a.lerp(curr.a, partialTick)
|
||||
|
||||
// Interpolated world position — same method used everywhere in the renderer
|
||||
val worldStart = Vec3(
|
||||
Mth.lerp(partialTicks.toDouble(), entity.xOld, entity.x),
|
||||
Mth.lerp(partialTicks.toDouble(), entity.yOld, entity.y),
|
||||
Mth.lerp(partialTicks.toDouble(), entity.zOld, entity.z)
|
||||
)
|
||||
val worldEnd = worldStart.add(iVec)
|
||||
|
||||
val relStart = worldStart.subtract(camera.position)
|
||||
val relEnd = worldEnd.subtract(camera.position)
|
||||
|
||||
// Normal is the normalized direction of the segment
|
||||
val dir = iVec.normalize()
|
||||
val nx = dir.x.toFloat()
|
||||
val ny = dir.y.toFloat()
|
||||
val nz = dir.z.toFloat()
|
||||
|
||||
vc.addVertex(pose.pose(), relStart.x.toFloat(), relStart.y.toFloat(), relStart.z.toFloat())
|
||||
.setColor(iR, iG, iB, iA)
|
||||
.setNormal(pose, nx, ny, nz)
|
||||
|
||||
vc.addVertex(pose.pose(), relEnd.x.toFloat(), relEnd.y.toFloat(), relEnd.z.toFloat())
|
||||
.setColor(iR, iG, iB, iA)
|
||||
.setNormal(pose, nx, ny, nz)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
fun reset() {
|
||||
previousLines = emptyList()
|
||||
currentLines = emptyList()
|
||||
}
|
||||
}
|
||||
|
||||
private fun Float.lerp(end: Float, t: Float): Float = this + (end - this) * t.coerceIn(0f, 1f)
|
||||
|
||||
+58
@@ -0,0 +1,58 @@
|
||||
/*
|
||||
* Copyright (C) 2023 Cobblemon Contributors
|
||||
*
|
||||
* This Source Code Form is subject to the terms of the Mozilla Public
|
||||
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
||||
* file, You can obtain one at https://mozilla.org/MPL/2.0/.
|
||||
*/
|
||||
|
||||
package com.cobblemon.mod.common.client.render.debug
|
||||
|
||||
import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
|
||||
import com.cobblemon.mod.common.platform.events.PlatformEvents
|
||||
import com.mojang.blaze3d.vertex.PoseStack
|
||||
import net.minecraft.client.Camera
|
||||
import net.minecraft.client.Minecraft
|
||||
import net.minecraft.client.renderer.MultiBufferSource
|
||||
import net.minecraft.client.renderer.RenderType
|
||||
|
||||
object SteerForceRenderer {
|
||||
|
||||
// Lines to render attached to the uuid of entities.
|
||||
val lineStates = mutableMapOf<Int, LineState>()
|
||||
|
||||
fun registerTickHandler() {
|
||||
// Advance line States
|
||||
PlatformEvents.CLIENT_TICK_PRE.subscribe {
|
||||
lineStates.forEach { uuid, lineState ->
|
||||
lineState.tick()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fun render(poseStack: PoseStack, multiBufferSource: MultiBufferSource, partialTicks: Float, camera: Camera) {
|
||||
val matrix = poseStack.last().pose()
|
||||
val level = Minecraft.getInstance().level ?: return
|
||||
|
||||
val currTick = level.gameTime
|
||||
val ticksUntilStale = 3
|
||||
|
||||
val keysToRemove = lineStates.keys.filter { entityId ->
|
||||
val entity = level.getEntity(entityId) as? PokemonEntity
|
||||
val lastRecTick = lineStates[entityId]?.lastReceivedLineTick
|
||||
entity == null || (lastRecTick != null && (currTick - lastRecTick) > ticksUntilStale)
|
||||
}
|
||||
keysToRemove.forEach { lineStates.remove(it) }
|
||||
|
||||
// One buffer for all independent line segments
|
||||
val lineBuffer = multiBufferSource.getBuffer(RenderType.lines())
|
||||
|
||||
lineStates.forEach { entityId, lineState ->
|
||||
val entity = level.getEntity(entityId) as? PokemonEntity ?: return@forEach
|
||||
lineState.draw(lineBuffer, poseStack.last(), partialTicks, camera, entity, partialTicks)
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
+45
-3
@@ -31,6 +31,7 @@ import com.cobblemon.mod.common.client.render.renderBeaconBeam
|
||||
import com.cobblemon.mod.common.client.settings.ServerSettings
|
||||
import com.cobblemon.mod.common.entity.PlatformType
|
||||
import com.cobblemon.mod.common.entity.PosableEntity
|
||||
import com.cobblemon.mod.common.entity.PoseType
|
||||
import com.cobblemon.mod.common.entity.npc.NPCEntity
|
||||
import com.cobblemon.mod.common.entity.pokeball.EmptyPokeBallEntity
|
||||
import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
|
||||
@@ -39,10 +40,8 @@ import com.cobblemon.mod.common.pokeball.PokeBall
|
||||
import com.cobblemon.mod.common.util.effectiveName
|
||||
import com.cobblemon.mod.common.util.isLookingAt
|
||||
import com.cobblemon.mod.common.util.lang
|
||||
import com.cobblemon.mod.common.util.math.DoubleRange
|
||||
import com.cobblemon.mod.common.util.math.*
|
||||
import com.cobblemon.mod.common.util.math.geometry.toRadians
|
||||
import com.cobblemon.mod.common.util.math.remap
|
||||
import com.google.common.primitives.Floats
|
||||
import com.mojang.blaze3d.vertex.PoseStack
|
||||
import com.mojang.math.Axis
|
||||
import net.minecraft.ChatFormatting
|
||||
@@ -148,7 +147,50 @@ class PokemonRenderer(
|
||||
if (entity.passengers.isNotEmpty()) {
|
||||
renderRiding(entity, entityYaw, partialTicks, poseMatrix, buffer, packedLight)
|
||||
} else {
|
||||
val now = System.nanoTime()
|
||||
val dt = (now - clientDelegate.lastRenderTime) / 1_000_000_000f
|
||||
clientDelegate.lastRenderTime = now
|
||||
val poseTypes: Set<PoseType> = setOf(PoseType.FLY, PoseType.HOVER, PoseType.SWIM, PoseType.FLOAT)
|
||||
val halflife = if (entity.getCurrentPoseType() !in poseTypes) 0.2F else 0.3F
|
||||
//simpleSpringDamper(clientDelegate.renderYRotSpring, entity.yBodyRot, halflife, dt, isAngle = true)
|
||||
//clientDelegate.renderYRot = clientDelegate.renderYRotSpring.value
|
||||
|
||||
/**
|
||||
* Run this every time the "goal" changes
|
||||
*/
|
||||
val inertVals = clientDelegate.inertialYRot
|
||||
if (entity.yBodyRot != clientDelegate.lastKnownYBodyRot) {
|
||||
clientDelegate.lastKnownYBodyRot = entity.yBodyRot
|
||||
val diff = Mth.wrapDegrees(entity.yBodyRot - clientDelegate.renderYRot)
|
||||
val currentVelocity = smoothstepDt(inertVals.t, inertVals.s)
|
||||
smoothstepSolve(inertVals, diff, currentVelocity, 0.05f)
|
||||
inertVals.offset = clientDelegate.renderYRot - smoothstep(inertVals.t, inertVals.s)
|
||||
}
|
||||
|
||||
/**
|
||||
* Ran every frame
|
||||
*/
|
||||
val d: Double = entity.x - entity.xo
|
||||
val e: Double = entity.z - entity.zo
|
||||
val isMoving = d * d + e * e > 2.5000003E-7
|
||||
//TODO: drive moving blendtime to current movement speed? Currently having issues not making it look sluggish
|
||||
//TODO: likely could also use some influence with size of mon especially when stationary.
|
||||
val blendTime = if (isMoving) 0.3f//Mth.lerp(Mth.clamp(entity.deltaMovement.lengthSqr() / (0.2 * 0.2), 0.0, 1.0), 0.8,0.3).toFloat()
|
||||
else 0.8f
|
||||
|
||||
inertVals.t += dt / blendTime
|
||||
clientDelegate.renderYRot = inertVals.offset + smoothstep(inertVals.t, inertVals.s)
|
||||
|
||||
|
||||
val priorYBody = entity.yBodyRot
|
||||
val priorYBodyO = entity.yBodyRotO
|
||||
entity.yBodyRot = clientDelegate.renderYRot
|
||||
entity.yBodyRotO = clientDelegate.renderYRot
|
||||
|
||||
super.render(entity, entityYaw, partialTicks, poseMatrix, buffer, packedLight)
|
||||
|
||||
entity.yBodyRot = priorYBody
|
||||
entity.yBodyRotO = priorYBodyO
|
||||
}
|
||||
|
||||
modelNow.green = 1F
|
||||
|
||||
@@ -10,7 +10,6 @@ package com.cobblemon.mod.common.entity.ai
|
||||
|
||||
import com.cobblemon.mod.common.CobblemonBlocks
|
||||
import com.cobblemon.mod.common.entity.OmniPathingEntity
|
||||
import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
|
||||
import com.cobblemon.mod.common.pokemon.ai.OmniPathNodeMaker
|
||||
import com.cobblemon.mod.common.util.deleteNode
|
||||
import com.cobblemon.mod.common.util.getWaterAndLavaIn
|
||||
@@ -35,6 +34,7 @@ import net.minecraft.world.phys.Vec3
|
||||
import kotlin.math.PI
|
||||
import kotlin.math.abs
|
||||
import kotlin.math.acos
|
||||
import kotlin.math.max
|
||||
|
||||
/**
|
||||
* A navigator designed to work with the [OmniPathNodeMaker], allowing a path that can cross land, water, and air
|
||||
@@ -49,6 +49,8 @@ class OmniPathNavigation(val world: Level, val entity: Mob) : GroundPathNavigati
|
||||
|
||||
var cachedCurrentNode: Node? = null
|
||||
var currentNodeDistance = 0F
|
||||
var segmentIndex: Int = 0
|
||||
var pathFollowTarget: Vec3? = null
|
||||
|
||||
data class NavigationContext(
|
||||
val onHit: (damage: DamageSource) -> Unit = {},
|
||||
@@ -102,11 +104,11 @@ class OmniPathNavigation(val world: Level, val entity: Mob) : GroundPathNavigati
|
||||
|
||||
val targetVec = targetPos?.toVec3d()?.add(0.5, 0.0, 0.5)
|
||||
if (targetVec != null && targetVec.distanceTo(vec3d) <= navigationContext.destinationProximity && path != null) {
|
||||
path = null
|
||||
cachedCurrentNode = null
|
||||
navigationContext.onArrival()
|
||||
// If we arrived at a not-flying destination
|
||||
val node = path?.nextNode?.type
|
||||
path = null
|
||||
if (node != null && node != PathType.OPEN && pather.couldStopFlying()) {
|
||||
pather.setFlying(false)
|
||||
}
|
||||
@@ -160,6 +162,67 @@ class OmniPathNavigation(val world: Level, val entity: Mob) : GroundPathNavigati
|
||||
}
|
||||
|
||||
doStuckDetection(vec3d)
|
||||
|
||||
// Gather the steer target from the segment pathing
|
||||
// TODO: this shouldn't live here
|
||||
val currentPath = path ?: return
|
||||
if (!currentPath.isDone) {
|
||||
segmentIndex = segmentIndex.coerceIn(0, max(currentPath.nodeCount - 2, 0))
|
||||
pathFollowTarget = getPathSteerTarget(currentPath, mob)
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets a steering target for the current path
|
||||
* This video explains it well: https://www.youtube.com/watch?v=rlZYT-uvmGQ
|
||||
* Uses Reynolds path following for velocity steered entities
|
||||
*/
|
||||
fun getPathSteerTarget(
|
||||
path: Path,
|
||||
mob: Mob
|
||||
): Vec3 {
|
||||
// If this is the final segment then just seek towards the end
|
||||
if (segmentIndex >= path.nodeCount - 1) return path.getNode(path.nodeCount - 1).asVec3().add(0.5, 0.0, 0.5)
|
||||
|
||||
// Determine future position to use in steering calculations
|
||||
val ticksInFuture = 5
|
||||
val baseLookAhead = mob.bbWidth / 2.0
|
||||
val lookAheadDist = mob.deltaMovement.length() * ticksInFuture + baseLookAhead
|
||||
val futurePos = mob.position().add(mob.deltaMovement.normalize().scale(lookAheadDist))
|
||||
|
||||
// Gather the current segment points
|
||||
var pointS1 = path.getNode(segmentIndex).asVec3().add(0.5, 0.0, 0.5) // Add the 0.5's to get the blockface center as blockpos is on a corner
|
||||
var pointS2 = path.getNode(segmentIndex + 1).asVec3().add(0.5, 0.0, 0.5)
|
||||
|
||||
// Project the future point onto the current segment
|
||||
var vecA = futurePos.subtract(pointS1)
|
||||
var vecB = pointS2.subtract(pointS1)
|
||||
var normB = vecB.normalize()
|
||||
val lenB = vecB.length()
|
||||
var projAB = max(vecA.dot(normB), 0.0) // make at least 0 as negative means we are projecting behind the segment which we don't want
|
||||
|
||||
// If the projection goes off the front of the segment then advance to the next segment and recalculate the projection
|
||||
if (projAB > lenB && segmentIndex < path.nodeCount - 2) {
|
||||
segmentIndex++
|
||||
pointS1 = path.getNode(segmentIndex).asVec3().add(0.5, 0.0, 0.5)
|
||||
pointS2 = path.getNode(segmentIndex + 1).asVec3().add(0.5, 0.0, 0.5)
|
||||
vecA = futurePos.subtract(pointS1)
|
||||
vecB = pointS2.subtract(pointS1)
|
||||
normB = vecB.normalize()
|
||||
projAB = max(vecA.dot(normB), 0.0)
|
||||
}
|
||||
|
||||
// Get the projected point on the segment
|
||||
val projPoint = pointS1.add(normB.scale(projAB ))
|
||||
|
||||
// Determine if the future position is too far from the path by getting its distance from its projected position on the current path segment
|
||||
val futureDistFromPath = projPoint.distanceTo(futurePos)
|
||||
val acceptableDist = mob.bbWidth / 3.0 //TODO: figure out what this really needs to be
|
||||
|
||||
val pushForward = 0.1 // Advance the projected point along the segment to avoid going backwards
|
||||
val seekPoint = if (futureDistFromPath < acceptableDist) futurePos.add(normB.scale(pushForward)) else projPoint.add(normB.scale(pushForward))
|
||||
|
||||
return seekPoint
|
||||
}
|
||||
|
||||
fun isAirborne(world: Level, pos: BlockPos) =
|
||||
@@ -223,6 +286,8 @@ class OmniPathNavigation(val world: Level, val entity: Mob) : GroundPathNavigati
|
||||
|
||||
fun moveTo(x: Double, y: Double, z: Double, speed: Double = 1.0, navigationContext: NavigationContext) {
|
||||
this.navigationContext = navigationContext
|
||||
segmentIndex = 0
|
||||
pathFollowTarget = null
|
||||
this.moveTo(x, y, z, speed)
|
||||
}
|
||||
|
||||
@@ -269,10 +334,7 @@ class OmniPathNavigation(val world: Level, val entity: Mob) : GroundPathNavigati
|
||||
// If we can fly and we're airborne, return the current Y position
|
||||
return vec.y
|
||||
}
|
||||
if (world.getBlockState(blockPos).block == CobblemonBlocks.SACCHARINE_LEAVES && pather.canPathThroughSaccLeaves()) {
|
||||
return vec.y + 0.5
|
||||
}
|
||||
return if ((canFloat()) && blockGetter.getFluidState(blockPos).`is`(FluidTags.WATER)) vec.y else super.getGroundY(vec)
|
||||
return if ((canFloat()) && blockGetter.getFluidState(blockPos).`is`(FluidTags.WATER)) vec.y + 0.5 else super.getGroundY(vec)
|
||||
}
|
||||
|
||||
override fun createPath(entity: Entity, distance: Int): Path? {
|
||||
@@ -280,6 +342,8 @@ class OmniPathNavigation(val world: Level, val entity: Mob) : GroundPathNavigati
|
||||
}
|
||||
|
||||
override fun moveTo(path: Path?, speed: Double): Boolean {
|
||||
segmentIndex = 0
|
||||
pathFollowTarget = null
|
||||
if (path != null && path.nodeCount > 0) {
|
||||
val node = path.getNode(0)!!
|
||||
// pokemonEntity.discard()
|
||||
@@ -402,6 +466,8 @@ class OmniPathNavigation(val world: Level, val entity: Mob) : GroundPathNavigati
|
||||
this.cachedCurrentNode = null
|
||||
path = null
|
||||
nodeEvaluator.done()
|
||||
segmentIndex = 0
|
||||
pathFollowTarget = null
|
||||
// In case a path is cancelled instead of completed, check if we should stop flying
|
||||
if (pather.couldStopFlying() && !isAirborne(entity.level(), entity.blockPosition())) {
|
||||
pather.setFlying(false)
|
||||
|
||||
@@ -0,0 +1,77 @@
|
||||
/*
|
||||
* Copyright (C) 2023 Cobblemon Contributors
|
||||
*
|
||||
* This Source Code Form is subject to the terms of the Mozilla Public
|
||||
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
||||
* file, You can obtain one at https://mozilla.org/MPL/2.0/.
|
||||
*/
|
||||
|
||||
package com.cobblemon.mod.common.entity.ai.steering
|
||||
|
||||
import com.cobblemon.mod.common.CobblemonNetwork.sendPacketToTrackingPlayers
|
||||
import com.cobblemon.mod.common.client.render.debug.EntityDebugLine
|
||||
import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
|
||||
import com.cobblemon.mod.common.net.messages.client.debug.ClientboundUpdateObsAvoidPacket
|
||||
import net.minecraft.world.phys.Vec3
|
||||
|
||||
// Runs a list of SteerRules in priority order, consuming a force budget.
|
||||
// High priority rules get their full contribution first. Lower priority
|
||||
// rules only get what budget remains.
|
||||
class SteerArbitrator(
|
||||
val entity: PokemonEntity,
|
||||
val maxForce: Double,
|
||||
val rules: MutableList<SteerRule> = mutableListOf()
|
||||
) {
|
||||
|
||||
private var sortedRules: List<SteerRule> = emptyList()
|
||||
private var dirty = true
|
||||
|
||||
fun addRule(rule: SteerRule) { rules.add(rule); dirty = true }
|
||||
fun removeRule(rule: SteerRule) { rules.remove(rule); dirty = true }
|
||||
fun clearRules() { rules.clear(); dirty = true }
|
||||
|
||||
fun calculate(debug: Boolean = false): Vec3 {
|
||||
if (dirty) {
|
||||
sortedRules = rules.sortedByDescending { it.priority }
|
||||
dirty = false
|
||||
}
|
||||
|
||||
var remaining = maxForce
|
||||
var result = Vec3.ZERO
|
||||
val debugLines = if (debug) mutableListOf<EntityDebugLine>() else null
|
||||
|
||||
for (rule in sortedRules) {
|
||||
if (remaining <= 0.0) break
|
||||
|
||||
val force = rule.calculate() ?: continue
|
||||
val scaled = force.scale(rule.weight.toDouble())
|
||||
val len = scaled.length()
|
||||
if (len <= 0.0) continue
|
||||
|
||||
val contribution = if (len <= remaining) {
|
||||
remaining -= len
|
||||
scaled
|
||||
} else {
|
||||
val partial = remaining
|
||||
remaining = 0.0
|
||||
scaled.normalize().scale(partial)
|
||||
}
|
||||
|
||||
result = result.add(contribution)
|
||||
|
||||
debugLines?.let {
|
||||
val (r, g, b) = rule.debugColor
|
||||
it.add(EntityDebugLine(contribution.scale(50.0), r, g, b, 1.0f))
|
||||
}
|
||||
}
|
||||
|
||||
debugLines?.let {
|
||||
if (result.lengthSqr() > 0.0)
|
||||
it.add(EntityDebugLine(result.scale(50.0), 1f, 1f, 1f, 1.5f))
|
||||
if (it.isNotEmpty())
|
||||
sendPacketToTrackingPlayers(entity, ClientboundUpdateObsAvoidPacket(entity.id, it))
|
||||
}
|
||||
|
||||
return result
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,34 @@
|
||||
/*
|
||||
* Copyright (C) 2023 Cobblemon Contributors
|
||||
*
|
||||
* This Source Code Form is subject to the terms of the Mozilla Public
|
||||
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
||||
* file, You can obtain one at https://mozilla.org/MPL/2.0/.
|
||||
*/
|
||||
|
||||
package com.cobblemon.mod.common.entity.ai.steering
|
||||
|
||||
import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
|
||||
import net.minecraft.world.phys.Vec3
|
||||
|
||||
// A per-tick steering force contributor evaluated by SteerArbitrator.
|
||||
// Return null from calculate() if the rule has nothing to say this tick.
|
||||
interface SteerRule {
|
||||
|
||||
val entity: PokemonEntity
|
||||
|
||||
// Higher = evaluated first, consumes force budget before lower priority rules.
|
||||
// 90-100: obstacle avoidance
|
||||
// 60-89: threat / boundary
|
||||
// 30-59: social (separation, alignment, cohesion)
|
||||
// 0-29: goal / wander
|
||||
val priority: Int
|
||||
|
||||
// Multiplied against the rule output before budget accounting.
|
||||
val weight: Float
|
||||
|
||||
// RGB 0-1 for the debug line drawn by SteerArbitrator.
|
||||
val debugColor: Triple<Float, Float, Float> get() = Triple(1f, 1f, 1f)
|
||||
|
||||
fun calculate(): Vec3?
|
||||
}
|
||||
+76
@@ -0,0 +1,76 @@
|
||||
/*
|
||||
* Copyright (C) 2023 Cobblemon Contributors
|
||||
*
|
||||
* This Source Code Form is subject to the terms of the Mozilla Public
|
||||
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
||||
* file, You can obtain one at https://mozilla.org/MPL/2.0/.
|
||||
*/
|
||||
|
||||
package com.cobblemon.mod.common.entity.ai.steering.rules
|
||||
|
||||
import com.cobblemon.mod.common.entity.ai.steering.SteerRule
|
||||
import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
|
||||
import com.cobblemon.mod.common.entity.pokemon.ai.PokemonMoveControl
|
||||
import com.cobblemon.mod.common.entity.pokemon.extensions.steerToTarget
|
||||
import net.minecraft.world.phys.Vec3
|
||||
import kotlin.math.max
|
||||
import kotlin.math.sin
|
||||
import kotlin.math.sqrt
|
||||
import kotlin.math.cos
|
||||
|
||||
// Forward AABB projection obstacle avoidance. Stateful — one instance per entity.
|
||||
class ObstacleAvoidRule(
|
||||
override val entity: PokemonEntity,
|
||||
override val priority: Int = 100,
|
||||
override val weight: Float = 1.0f,
|
||||
override val debugColor: Triple<Float, Float, Float> = Triple(1f, 0f, 0f),
|
||||
val maxForce: Double = 0.02,
|
||||
val lookAheadTicks: Int = 10,
|
||||
val smoothingAlpha: Double = 0.25
|
||||
) : SteerRule {
|
||||
|
||||
private var prevForce: Vec3 = Vec3.ZERO
|
||||
|
||||
override fun calculate(): Vec3? {
|
||||
val topSpeed = (entity.moveControl as? PokemonMoveControl)?.steerSpeed ?: 0.1
|
||||
|
||||
val forwardVec = if (entity.deltaMovement.horizontalDistanceSqr() < 0.001) {
|
||||
val yaw = Math.toRadians(entity.yRot.toDouble())
|
||||
Vec3(-sin(yaw), 0.0, cos(yaw))
|
||||
} else {
|
||||
Vec3(entity.deltaMovement.x, 0.0, entity.deltaMovement.z).normalize()
|
||||
}
|
||||
|
||||
val lookAheadDist = max(entity.deltaMovement.length() * lookAheadTicks, entity.bbWidth / 2.0)
|
||||
val collBox = entity.boundingBox.move(forwardVec.scale(lookAheadDist))
|
||||
val shapes = entity.level().getBlockCollisions(entity, collBox)
|
||||
|
||||
val nearestShape = shapes.minByOrNull { shape ->
|
||||
shape.bounds().center.distanceToSqr(entity.position())
|
||||
}
|
||||
|
||||
if (nearestShape == null) {
|
||||
prevForce = prevForce.lerp(Vec3.ZERO, smoothingAlpha)
|
||||
return if (prevForce.lengthSqr() < 1e-6) null else prevForce
|
||||
}
|
||||
|
||||
val obsCenter = nearestShape.bounds().center
|
||||
val toObs = obsCenter.subtract(entity.position())
|
||||
val projVec = forwardVec.scale(toObs.dot(forwardVec))
|
||||
val lateralComponent = toObs.subtract(projVec)
|
||||
|
||||
val avoidForce = if (lateralComponent.lengthSqr() < 0.001) {
|
||||
// Dead ahead — turn right
|
||||
val rightVec = forwardVec.cross(Vec3(0.0, 1.0, 0.0))
|
||||
entity.steerToTarget(entity.position().add(rightVec), topSpeed, maxForce, horzOnly = true)
|
||||
} else {
|
||||
var avoidanceVec = Vec3(lateralComponent.x * -1.0, 0.0, lateralComponent.z * -1.0)
|
||||
val avoidStrength = sqrt(1.0 - (avoidanceVec.length() / (entity.bbWidth / 2.0 + 0.5)).coerceIn(0.0, 0.7))
|
||||
val avoidancePoint = entity.position().add(avoidanceVec)
|
||||
entity.steerToTarget(avoidancePoint, topSpeed, maxForce * avoidStrength, horzOnly = true)
|
||||
}
|
||||
|
||||
prevForce = prevForce.lerp(avoidForce, smoothingAlpha)
|
||||
return prevForce
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,35 @@
|
||||
/*
|
||||
* Copyright (C) 2023 Cobblemon Contributors
|
||||
*
|
||||
* This Source Code Form is subject to the terms of the Mozilla Public
|
||||
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
||||
* file, You can obtain one at https://mozilla.org/MPL/2.0/.
|
||||
*/
|
||||
|
||||
package com.cobblemon.mod.common.entity.ai.steering.rules
|
||||
|
||||
import com.cobblemon.mod.common.entity.ai.steering.SteerRule
|
||||
import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
|
||||
import com.cobblemon.mod.common.entity.pokemon.ai.PokemonMoveControl
|
||||
import com.cobblemon.mod.common.entity.pokemon.extensions.steerToTarget
|
||||
import net.minecraft.world.phys.Vec3
|
||||
|
||||
// Steers toward a target position. Reads speed from PokemonMoveControl.steerSpeed.
|
||||
// Return null from targetProvider to deactivate for a tick.
|
||||
class SeekRule(
|
||||
override val entity: PokemonEntity,
|
||||
override val priority: Int = 10,
|
||||
override val weight: Float = 1.0f,
|
||||
override val debugColor: Triple<Float, Float, Float> = Triple(0f, 1f, 1f),
|
||||
val maxForce: Double,
|
||||
val horzOnly: Boolean = false,
|
||||
val arrivalRange: Double? = null,
|
||||
val targetProvider: (PokemonEntity) -> Vec3?
|
||||
) : SteerRule {
|
||||
|
||||
override fun calculate(): Vec3? {
|
||||
val target = targetProvider(entity) ?: return null
|
||||
val speed = (entity.moveControl as? PokemonMoveControl)?.steerSpeed ?: 0.1
|
||||
return entity.steerToTarget(target, speed, maxForce, arrivalRange, horzOnly)
|
||||
}
|
||||
}
|
||||
+44
@@ -0,0 +1,44 @@
|
||||
/*
|
||||
* Copyright (C) 2023 Cobblemon Contributors
|
||||
*
|
||||
* This Source Code Form is subject to the terms of the Mozilla Public
|
||||
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
||||
* file, You can obtain one at https://mozilla.org/MPL/2.0/.
|
||||
*/
|
||||
|
||||
package com.cobblemon.mod.common.entity.ai.steering.rules
|
||||
|
||||
import com.cobblemon.mod.common.entity.ai.steering.SteerRule
|
||||
import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
|
||||
import com.cobblemon.mod.common.entity.pokemon.ai.PokemonMoveControl
|
||||
import com.cobblemon.mod.common.entity.pokemon.extensions.steerToTarget
|
||||
import net.minecraft.world.phys.Vec3
|
||||
import kotlin.math.sin
|
||||
|
||||
// Steers toward a point directly ahead of the entity's current velocity/yaw.
|
||||
// Useful as a baseline test rule.
|
||||
class WalkForwardRule(
|
||||
override val entity: PokemonEntity,
|
||||
override val priority: Int = 10,
|
||||
override val weight: Float = 1.0f,
|
||||
override val debugColor: Triple<Float, Float, Float> = Triple(0f, 1f, 0f),
|
||||
val maxForce: Double = 0.02
|
||||
) : SteerRule {
|
||||
|
||||
override fun calculate(): Vec3? {
|
||||
val speed = (entity.moveControl as? PokemonMoveControl)?.steerSpeed ?: 0.1
|
||||
|
||||
val forwardVec = if (entity.deltaMovement.horizontalDistanceSqr() < 0.001) {
|
||||
val yaw = Math.toRadians(entity.yRot.toDouble())
|
||||
Vec3(-sin(yaw), 0.0, cos(yaw))
|
||||
} else {
|
||||
Vec3(entity.deltaMovement.x, 0.0, entity.deltaMovement.z).normalize()
|
||||
}
|
||||
|
||||
val pointAhead = entity.position().add(forwardVec)
|
||||
return entity.steerToTarget(pointAhead, speed, maxForce, horzOnly = true)
|
||||
}
|
||||
}
|
||||
|
||||
private fun cos(d: Double) = kotlin.math.cos(d)
|
||||
private fun sin(d: Double) = kotlin.math.sin(d)
|
||||
+71
@@ -0,0 +1,71 @@
|
||||
/*
|
||||
* Copyright (C) 2023 Cobblemon Contributors
|
||||
*
|
||||
* This Source Code Form is subject to the terms of the Mozilla Public
|
||||
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
||||
* file, You can obtain one at https://mozilla.org/MPL/2.0/.
|
||||
*/
|
||||
|
||||
package com.cobblemon.mod.common.entity.ai.steering.rules
|
||||
|
||||
import com.cobblemon.mod.common.entity.ai.steering.SteerRule
|
||||
import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
|
||||
import com.cobblemon.mod.common.entity.pokemon.ai.PokemonMoveControl
|
||||
import com.cobblemon.mod.common.entity.pokemon.extensions.steerToTarget
|
||||
import net.minecraft.util.Mth
|
||||
import net.minecraft.world.phys.Vec3
|
||||
import kotlin.math.abs
|
||||
import kotlin.math.sin
|
||||
import kotlin.random.Random
|
||||
|
||||
// Reynolds wander — projects a sphere ahead and offsets a point on it each tick.
|
||||
// Stateful: holds current wander angles, one instance per entity.
|
||||
// https://slsdo.github.io/steering-behaviors/
|
||||
class WanderRule(
|
||||
override val entity: PokemonEntity,
|
||||
override val priority: Int = 10,
|
||||
override val weight: Float = 1.0f,
|
||||
override val debugColor: Triple<Float, Float, Float> = Triple(1f, 0.5f, 0f),
|
||||
val maxForce: Double = 0.02,
|
||||
val wanderDisp: Double = 15.0,
|
||||
val centerDistance: Double = 4.0,
|
||||
val wanderRadius: Double = 4.0,
|
||||
val horzOnly: Boolean = false //TODO: all of these should be checks if flying or walking
|
||||
) : SteerRule {
|
||||
|
||||
var currHorzWander = 0.0
|
||||
var currVertWander = 0.0
|
||||
|
||||
override fun calculate(): Vec3? {
|
||||
val speed = (entity.moveControl as? PokemonMoveControl)?.steerSpeed ?: 0.1
|
||||
|
||||
val normVec = if (entity.deltaMovement.lengthSqr() > 0.0001) {
|
||||
entity.lookAngle.normalize()
|
||||
} else {
|
||||
Vec3(
|
||||
Random.nextDouble(-1.0, 1.0),
|
||||
Random.nextDouble(-1.0, 1.0),
|
||||
Random.nextDouble(-1.0, 1.0)
|
||||
).normalize()
|
||||
}
|
||||
|
||||
var wanderOff = normVec
|
||||
|
||||
// Clamp vertical wander when getting too steep
|
||||
val currPitchS = sin(Mth.atan2(wanderOff.y, wanderOff.horizontalDistance()))
|
||||
if (currPitchS >= 0.5f || currPitchS <= -0.5f) currVertWander = 0.0
|
||||
|
||||
wanderOff = wanderOff.xRot(Math.toRadians(currVertWander).toFloat())
|
||||
wanderOff = wanderOff.yRot(Math.toRadians(currHorzWander).toFloat())
|
||||
|
||||
val wanderCenter = entity.position().add(normVec.scale(centerDistance))
|
||||
val wanderPoint = wanderCenter.add(wanderOff.scale(wanderRadius))
|
||||
|
||||
// Advance wander angles
|
||||
currVertWander = Mth.wrapDegrees(currVertWander + Random.nextDouble(-wanderDisp, wanderDisp))
|
||||
currHorzWander = Mth.wrapDegrees(currHorzWander + Random.nextDouble(-wanderDisp, wanderDisp))
|
||||
|
||||
val force = entity.steerToTarget(wanderPoint, speed, maxForce)
|
||||
return if (horzOnly) Vec3(force.x, 0.0, force.z) else force
|
||||
}
|
||||
}
|
||||
@@ -80,6 +80,8 @@ import com.cobblemon.mod.common.entity.ai.OmniPathNavigation
|
||||
import com.cobblemon.mod.common.entity.generic.GenericBedrockEntity
|
||||
import com.cobblemon.mod.common.entity.npc.NPCEntity
|
||||
import com.cobblemon.mod.common.entity.pokemon.ai.PokemonMoveControl
|
||||
import com.cobblemon.mod.common.entity.pokemon.ai.PokemonBodyRotationControl
|
||||
import com.cobblemon.mod.common.entity.pokemon.ai.PokemonLookControl
|
||||
import com.cobblemon.mod.common.entity.pokemon.effects.EffectTracker
|
||||
import com.cobblemon.mod.common.entity.pokemon.effects.IllusionEffect
|
||||
import com.cobblemon.mod.common.net.messages.client.OpenBehaviourEditorPacket
|
||||
@@ -151,6 +153,7 @@ import net.minecraft.world.entity.*
|
||||
import net.minecraft.world.entity.ai.Brain
|
||||
import net.minecraft.world.entity.ai.attributes.AttributeSupplier
|
||||
import net.minecraft.world.entity.ai.attributes.Attributes
|
||||
import net.minecraft.world.entity.ai.control.BodyRotationControl
|
||||
import net.minecraft.world.entity.ai.control.MoveControl
|
||||
import net.minecraft.world.entity.ai.memory.MemoryModuleType
|
||||
import net.minecraft.world.entity.ai.memory.MemoryStatus
|
||||
@@ -215,6 +218,7 @@ open class PokemonEntity(
|
||||
@JvmStatic var RIDE_BOOSTS = SynchedEntityData.defineId(PokemonEntity::class.java, RideBoostsDataSerializer)
|
||||
@JvmStatic var RIDE_STAMINA = SynchedEntityData.defineId(PokemonEntity::class.java, EntityDataSerializers.FLOAT)
|
||||
@JvmStatic var SCALE_MODIFIER = SynchedEntityData.defineId(PokemonEntity::class.java, EntityDataSerializers.FLOAT)
|
||||
@JvmStatic val IS_SPRINTING = SynchedEntityData.defineId(PokemonEntity::class.java, EntityDataSerializers.BOOLEAN)
|
||||
|
||||
const val FALL_DAMAGE_MULT_FLYINGTYPE = 0.5f
|
||||
const val FALL_DAMAGE_MULT_MOVEMENT_FLY = 0.2f
|
||||
@@ -290,6 +294,9 @@ open class PokemonEntity(
|
||||
var shownItem: ItemStack
|
||||
get() = entityData.get(SHOWN_HELD_ITEM)
|
||||
set(value) = entityData.set(SHOWN_HELD_ITEM, value)
|
||||
var isPokemonSprinting: Boolean
|
||||
get() = entityData.get(IS_SPRINTING)
|
||||
set(value) { entityData.set(IS_SPRINTING, value) }
|
||||
|
||||
var lastLightningBoltUUID: UUID? = null
|
||||
|
||||
@@ -312,6 +319,13 @@ open class PokemonEntity(
|
||||
var previousRidingState: RidingBehaviourState? = null
|
||||
private set
|
||||
|
||||
/** Currently just used to ignore the killing of 0.003 length deltaMovement components that happens in
|
||||
* this.aiStep(). Its needed to settle the entities movement to zero but for slow mons like snorlax it
|
||||
* causes their minute forces upon movement start in PokemonMoveControl to be ignored. This saving of
|
||||
* movement is being done in stead of a mixin for now.
|
||||
* */
|
||||
var aiMovement: Vec3 = Vec3.ZERO
|
||||
|
||||
val runtime: MoLangRuntime by lazy {
|
||||
MoLangRuntime()
|
||||
.setup()
|
||||
@@ -423,6 +437,7 @@ open class PokemonEntity(
|
||||
delegate.changePokemon(pokemon)
|
||||
addPosableFunctions(struct)
|
||||
moveControl = PokemonMoveControl(this)
|
||||
lookControl = PokemonLookControl(this)
|
||||
if (!level().isClientSide) {
|
||||
remakeBrain()
|
||||
}
|
||||
@@ -459,6 +474,7 @@ open class PokemonEntity(
|
||||
builder.define(RIDE_BOOSTS, emptyMap())
|
||||
builder.define(RIDE_STAMINA, 1F)
|
||||
builder.define(SCALE_MODIFIER, 1F)
|
||||
builder.define(IS_SPRINTING, false)
|
||||
}
|
||||
|
||||
override fun onSyncedDataUpdated(data: EntityDataAccessor<*>) {
|
||||
@@ -703,6 +719,10 @@ open class PokemonEntity(
|
||||
this.moveControl = moveControl
|
||||
}
|
||||
|
||||
override fun createBodyControl(): BodyRotationControl {
|
||||
return PokemonBodyRotationControl(this)
|
||||
}
|
||||
|
||||
/**
|
||||
* Prevents water type Pokémon from taking drowning damage.
|
||||
*/
|
||||
@@ -1813,6 +1833,7 @@ open class PokemonEntity(
|
||||
val riders = this.passengers.filterIsInstance<LivingEntity>()
|
||||
if ( riders.isEmpty() || this.controllingPassenger == null) {
|
||||
super.travel(movementInput)
|
||||
this.aiMovement = this.deltaMovement
|
||||
} else {
|
||||
val inp = ifRidingAvailableSupply(fallback = Vec3.ZERO) { behaviour, settings, state ->
|
||||
behaviour.velocity(settings, state, this, this.controllingPassenger as Player, deltaMovement)
|
||||
|
||||
+550
@@ -0,0 +1,550 @@
|
||||
/*
|
||||
* Copyright (C) 2023 Cobblemon Contributors
|
||||
*
|
||||
* This Source Code Form is subject to the terms of the Mozilla Public
|
||||
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
||||
* file, You can obtain one at https://mozilla.org/MPL/2.0/.
|
||||
*/
|
||||
|
||||
package com.cobblemon.mod.common.entity.pokemon.ai
|
||||
|
||||
|
||||
import com.cobblemon.mod.common.CobblemonActivities
|
||||
import com.cobblemon.mod.common.CobblemonNetwork.sendPacketToTrackingPlayers
|
||||
import com.cobblemon.mod.common.client.render.debug.EntityDebugLine
|
||||
import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
|
||||
import com.cobblemon.mod.common.entity.pokemon.extensions.*
|
||||
import com.cobblemon.mod.common.net.messages.client.debug.ClientboundUpdateObsAvoidPacket
|
||||
import com.cobblemon.mod.common.util.math.geometry.toRadians
|
||||
import com.cobblemon.mod.common.util.resolveDouble
|
||||
import net.minecraft.util.Mth
|
||||
import net.minecraft.world.entity.LivingEntity
|
||||
import net.minecraft.world.entity.ai.control.MoveControl
|
||||
import net.minecraft.world.entity.ai.memory.MemoryModuleType
|
||||
import net.minecraft.world.level.ClipContext
|
||||
import net.minecraft.world.phys.HitResult
|
||||
import net.minecraft.world.phys.Vec3
|
||||
import kotlin.math.*
|
||||
import kotlin.random.Random
|
||||
|
||||
class BoidsMoveControl(val pokemonEntity: PokemonEntity, val target: LivingEntity) : MoveControl(pokemonEntity) {
|
||||
companion object {
|
||||
const val VERY_CLOSE = 2.500000277905201E-3
|
||||
const val MAX_SPEED = 0.3 / 2
|
||||
const val MAX_FORCE = 0.02
|
||||
const val PREDATOR_MAX_SPEED = 0.6
|
||||
// const val MAX_SPEED = 0.2
|
||||
// const val MAX_FORCE = 0.013
|
||||
}
|
||||
|
||||
// TODO: might need to hold its own velocity so minecraft doesn't do its nonsense to it?
|
||||
// Can handle collisions ourselves as well
|
||||
var speed: Double? = null
|
||||
var drawLines: MutableList<EntityDebugLine> = mutableListOf()
|
||||
|
||||
// wander vars
|
||||
var currHorzWander = 0.0
|
||||
var currVertWander = 0.0
|
||||
val wanderDisp = 15.0 // The degrees of change from tick to tick in wander angle
|
||||
|
||||
override fun tick() {
|
||||
// Clear since the info is sent and is now stale
|
||||
drawLines.clear()
|
||||
|
||||
// Steering constants
|
||||
val orbitRadius = 16.0
|
||||
val targetPos = target.position().add(0.0, 4.0, 0.0)
|
||||
val arrivalRange = 2.0 // in blocks
|
||||
|
||||
val species = pokemonEntity.pokemon.species.name
|
||||
// Set this to ensure the flying pose is active
|
||||
|
||||
// ignore all the friction stuff from outside
|
||||
speed?.let { pokemonEntity.setDeltaMovement(pokemonEntity.deltaMovement.normalize().scale(it)) }
|
||||
|
||||
// Constrain to rectangular boundary
|
||||
val cubeWidth = 16.0
|
||||
val cubeHeight = 16.0
|
||||
val cubeCenter = target.position().add(0.0, cubeHeight / 2.0, 0.0)
|
||||
//forceRectBoundary(cubeCenter, cubeWidth, cubeHeight)
|
||||
|
||||
// Apply boid forces
|
||||
|
||||
// Obstacle Avoidance
|
||||
val whiskerRange = 1.0
|
||||
val avoidanceAngle = 20.0 // x degrees to the left, right, up, and down
|
||||
//val obsAvoidForce = whisObsAvoid(whiskerRange, avoidanceAngle)
|
||||
|
||||
// if (obsAvoidForce != null) {
|
||||
// pokemonEntity.deltaMovement = pokemonEntity.deltaMovement.add(obsAvoidForce.scale(0.5))
|
||||
// }
|
||||
|
||||
// TODO: obviously don't hardcode each pokemon. Remove this after testing is finished.
|
||||
// TODO I commented everything out ha
|
||||
// if (pokemonEntity.pokemon.species.name.lowercase() == "charizard") {
|
||||
// pokemonEntity.setFlying(true)
|
||||
// pokemonEntity.resetFallDistance()
|
||||
// seekPrey(pokemonEntity)
|
||||
// } else if (pokemonEntity.pokemon.species.name.lowercase() == "garchomp") {
|
||||
// pokemonEntity.setFlying(false)
|
||||
// val walkSpeed = pokemonEntity.runtime.resolveDouble(pokemonEntity.behaviour.moving.walk.walkSpeed) * 1.5
|
||||
// val steerForce = pokemonEntity.steerToTarget(target.position(), walkSpeed, walkSpeed / 12)
|
||||
// pokemonEntity.deltaMovement = pokemonEntity.deltaMovement.add(steerForce.x, 0.0, steerForce.z)
|
||||
//// speed?.let { this.mob.setZza(speed!!.toFloat()) }
|
||||
// } else if (pokemonEntity.pokemon.species.name.lowercase() == "skiddo") {
|
||||
// pokemonEntity.setFlying(false)
|
||||
// //wander(pokemonEntity,1.0)
|
||||
//// val steerForce = pokemonEntity.steerToTargetForce(target.position(), MAX_SPEED, MAX_FORCE)
|
||||
//// pokemonEntity.deltaMovement = pokemonEntity.deltaMovement.add(steerForce.x, 0.0, steerForce.z)
|
||||
// aviodPredators(pokemonEntity, includePlayer = true)
|
||||
// boid(isFlyingOrSwimming = false)
|
||||
// } else {
|
||||
// pokemonEntity.setFlying(true)
|
||||
// pokemonEntity.resetFallDistance()
|
||||
// wander(pokemonEntity,0.8)
|
||||
// boid()
|
||||
// aviodPredators(pokemonEntity, includePlayer = true)
|
||||
//
|
||||
// // Force towards ground
|
||||
//
|
||||
//
|
||||
// forceRectBoundary(pokemonEntity, cubeCenter, cubeWidth, cubeHeight)
|
||||
// }
|
||||
|
||||
// val avoidForce = avoidTarget(target.position(), MAX_SPEED, MAX_FORCE, 10.0)
|
||||
// pokemonEntity.deltaMovement = pokemonEntity.deltaMovement.add(avoidForce.scale(1.0))
|
||||
|
||||
// Apply steering force to current movement
|
||||
// val dm = pokemonEntity.deltaMovement
|
||||
// val w_pos = pokemonEntity.position().add(Vec3(dm.x, 0.0, dm.z))
|
||||
// val steerForce = steerToTargetForce(w_pos, MAX_SPEED, MAX_FORCE)
|
||||
// pokemonEntity.deltaMovement = pokemonEntity.deltaMovement.add(steerForce)
|
||||
|
||||
// Take note of speed again to avoid minecraft's friction logic
|
||||
speed = pokemonEntity.deltaMovement.length() * 0.98
|
||||
|
||||
// Test out what this setting of speed does.
|
||||
//speed?.let { this.mob.speed = speed!!.toFloat() }
|
||||
|
||||
// Limit upwards speed to be half of max speed. The boids kept bumping into the top of the box more so than birds
|
||||
// would. Honestly birds probably mostly want to move in the x,z plane anyhow
|
||||
// pokemonEntity.deltaMovement = Vec3(
|
||||
// pokemonEntity.deltaMovement.x,
|
||||
// min(pokemonEntity.deltaMovement.y, MAX_SPEED * 0.5),
|
||||
// pokemonEntity.deltaMovement.y
|
||||
// ).normalize().scale(speed!!)
|
||||
|
||||
pokemonEntity.orientEntityToTravel(0.4f)
|
||||
|
||||
if (false && drawLines.isNotEmpty()) { //TODO: Re-enable
|
||||
sendPacketToTrackingPlayers(pokemonEntity, ClientboundUpdateObsAvoidPacket(pokemonEntity.id, drawLines))
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// private fun aviodPredators(entity: PokemonEntity, includePlayer: Boolean = false) {
|
||||
// val fearRadius = 5.0
|
||||
// val brain = entity.brain
|
||||
// val predators = brain.getMemory(MemoryModuleType.NEAREST_LIVING_ENTITIES).map { nearbyEntities ->
|
||||
// nearbyEntities.filterIsInstance<PokemonEntity>().filter { pokemon ->
|
||||
// pokemon.brain.activeNonCoreActivity.orElse(null) == CobblemonActivities.POKEMON_BOIDS &&
|
||||
// pokemon.pokemon.species.name.lowercase() == "charizard" &&
|
||||
// entity.position().subtract(pokemon.position()).length() <= fearRadius
|
||||
// }
|
||||
// }.orElse(emptyList())
|
||||
//
|
||||
// var totalEvasionVec = Vec3.ZERO
|
||||
// var predatorCount = predators.size
|
||||
//
|
||||
// // If the player should be included in avoidance then add the player as a predator.
|
||||
// if (includePlayer) {
|
||||
// totalEvasionVec = totalEvasionVec.add(entity.avoidTarget(target.position(), MAX_SPEED * 1.2, MAX_FORCE * 2, fearRadius))
|
||||
// predatorCount += 1
|
||||
// }
|
||||
// // Average evasion forces for all predators in the area and apply it to the prey entity
|
||||
// if (predatorCount > 0) {
|
||||
// for (predator in predators) {
|
||||
// totalEvasionVec = totalEvasionVec.add(entity.avoidTarget(predator.position(), MAX_SPEED * 1.2, MAX_FORCE * 2, fearRadius))
|
||||
// }
|
||||
// totalEvasionVec = totalEvasionVec.scale(1.0 / predatorCount)
|
||||
// if (entity.isFlying() || entity.isSwimming) {
|
||||
// entity.deltaMovement = entity.deltaMovement.add(totalEvasionVec)
|
||||
// } else {
|
||||
// entity.deltaMovement = entity.deltaMovement.add(Vec3(totalEvasionVec.x, 0.0, totalEvasionVec.z))
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// /*************************************************************************************************************
|
||||
// Seek the closest prey and pursue
|
||||
// *************************************************************************************************************/
|
||||
// private fun seekPrey(predator: PokemonEntity) {
|
||||
// val SeekRadius = 20.0
|
||||
// val brain = predator.brain
|
||||
// // Do calcs for head height as it looks better this way than a charizard flying crotch first at a group of pidgeys
|
||||
// val kindaHeadHeight = predator.position()
|
||||
//
|
||||
// val prey = brain.getMemory(MemoryModuleType.NEAREST_LIVING_ENTITIES).map { nearbyEntities ->
|
||||
// nearbyEntities.filterIsInstance<PokemonEntity>().filter { pokemon ->
|
||||
// pokemon.brain.activeNonCoreActivity.orElse(null) == CobblemonActivities.POKEMON_BOIDS &&
|
||||
// (pokemon.pokemon.species.name.lowercase() == "pidgey" || pokemon.pokemon.species.name.lowercase() == "skiddo") &&
|
||||
// kindaHeadHeight.subtract(pokemon.position()).length() <= SeekRadius
|
||||
// }
|
||||
// }.orElse(emptyList())
|
||||
//
|
||||
// // Find the closest prey and seek towards it
|
||||
// val nearestPrey = prey.minByOrNull { pokePrey ->
|
||||
// kindaHeadHeight.subtract(pokePrey.position()).length()
|
||||
// }
|
||||
// nearestPrey?.let { prey ->
|
||||
//
|
||||
// // Do the actual attack
|
||||
// // TODO: make this not dumb
|
||||
// if(kindaHeadHeight.subtract(nearestPrey.position()).length() < 0.5 + predator.bbWidth + nearestPrey.bbWidth) {
|
||||
// //predator.doHurtTarget(nearestPrey)
|
||||
// }
|
||||
//
|
||||
// // Steer towards the target
|
||||
// val steerForce = predator.steerToTarget(prey.position(), PREDATOR_MAX_SPEED, MAX_FORCE)
|
||||
// predator.deltaMovement = predator.deltaMovement.add(steerForce)
|
||||
// }
|
||||
//
|
||||
// }
|
||||
|
||||
/*************************************************************************************************************
|
||||
Whisker Obstacle Avoidance
|
||||
This function ray casts in a cone in front of the entity
|
||||
*************************************************************************************************************/
|
||||
private fun whisObsAvoid(range: Double, lookWidth: Double): Vec3? {
|
||||
|
||||
// --- 1. Build the Orientation Matrix ---
|
||||
val forward = pokemonEntity.lookAngle.scale(range)
|
||||
// val tempUp = if (abs(forward.y) > 0.999) Vec3(0.0, 0.0, 1.0) else Vec3(0.0, 1.0, 0.0)
|
||||
// val right = forward.cross(tempUp).normalize()
|
||||
// val up = right.cross(forward).normalize()
|
||||
//
|
||||
// val orientation = Matrix3f()
|
||||
// .setColumn(0, Vector3f(right.x.toFloat(), right.y.toFloat(), right.z.toFloat()))
|
||||
// .setColumn(1, Vector3f(up.x.toFloat(), up.y.toFloat(), up.z.toFloat()))
|
||||
// .setColumn(2, Vector3f(forward.x.toFloat(), forward.y.toFloat(), forward.z.toFloat()))
|
||||
|
||||
// --- 2. Define Whiskers in Simple, Local Space ---
|
||||
val radLookWidth = lookWidth.toRadians().toFloat()
|
||||
// val localWhiskers: List<Vector3f> = listOf(
|
||||
// Vector3f(0f, 0f, 1f), // Forward
|
||||
//// Vector3f(sin(radLookWidth), 0f, cos(radLookWidth)), // Left
|
||||
//// Vector3f(-sin(radLookWidth), 0f, cos(radLookWidth)), // Right
|
||||
//// Vector3f(0f, sin(radLookWidth), cos(radLookWidth)), // Up
|
||||
//// Vector3f(0f, -sin(radLookWidth), cos(radLookWidth)) // Down
|
||||
// )
|
||||
//
|
||||
// // --- 3. Transform Local Whiskers to World Space using the Matrix ---
|
||||
// val whiskerOffsets = localWhiskers.map { localVec ->
|
||||
// orientation.transform(localVec, Vector3f()).toVec3d().scale(range) // Transform and store in a new vector
|
||||
// }
|
||||
|
||||
// Obtain all points to be raycasted to
|
||||
val scaledLookVec = pokemonEntity.deltaMovement.normalize().scale(range)
|
||||
val lookPoints: List<Vec3> = listOf(
|
||||
forward,
|
||||
// forward.yRot(radLookWidth),
|
||||
// forward.yRot(-radLookWidth),
|
||||
// forward.xRot(90.toRadians()),
|
||||
// forward.xRot((-90).toRadians()),
|
||||
)
|
||||
|
||||
|
||||
// iterate through each point and raycast to it starting from the entities pos (may need to be from somewhere else)
|
||||
// If a position is hit then add its avoidance force to the totalAvoidance forces.
|
||||
var totalAvoidance: Vec3? = null
|
||||
val level = pokemonEntity.level()
|
||||
val startPos = pokemonEntity.position()
|
||||
for (point in lookPoints) {
|
||||
val endPos = startPos.add(point)
|
||||
val hit = level.clip(
|
||||
ClipContext(
|
||||
startPos,
|
||||
endPos,
|
||||
ClipContext.Block.OUTLINE, // If this is being weird then go back to COLLIDER
|
||||
ClipContext.Fluid.ANY, // Birds should probably avoid fluid
|
||||
pokemonEntity
|
||||
)
|
||||
)
|
||||
|
||||
// Add the whisker to the debug lines to be drawn
|
||||
drawLines.add(EntityDebugLine(endPos, 1.0f, 0.0f, 0.0f))
|
||||
//visualizeRay(level, startPos, endPos, hit.type != HitResult.Type.MISS)
|
||||
|
||||
if (hit.type != HitResult.Type.MISS) {
|
||||
// Get the aviodance vector as the vector from the block detection point
|
||||
// to the pokemon.
|
||||
// Also inversely scale the size of the vector based on the distance the pokemon
|
||||
// is to the object. This means close obstacles are avoided more strongly
|
||||
val hitDist = hit.location.distanceTo(pokemonEntity.eyePosition)
|
||||
val avoidVec = startPos.subtract(endPos).normalize() //.scale(1.0 - (hitDist / range))
|
||||
|
||||
// Add avoid vec to total
|
||||
totalAvoidance = totalAvoidance?.add(avoidVec) ?: avoidVec
|
||||
}
|
||||
}
|
||||
|
||||
// // Scale all forces down to the max foce
|
||||
// if (totalAvoidance != null) {
|
||||
// // Cap the max total avoidance desire
|
||||
// if (totalAvoidance.length() > MAX_SPEED) totalAvoidance = totalAvoidance.normalize().scale(MAX_SPEED)
|
||||
// // Convert to Reynolds steering force
|
||||
// totalAvoidance = totalAvoidance.subtract(pokemonEntity.deltaMovement)
|
||||
// // Cap the max total avoidance force
|
||||
// if (totalAvoidance.length() > MAX_FORCE) totalAvoidance = totalAvoidance.normalize().scale(MAX_FORCE)
|
||||
// } // Is this next one even cleaner?
|
||||
|
||||
return totalAvoidance?.let { desiredVelocity ->
|
||||
// Cap the desired velocity (using lengthSqr is more efficient than length)
|
||||
val cappedVelocity = if (desiredVelocity.lengthSqr() > MAX_SPEED * MAX_SPEED) {
|
||||
desiredVelocity.normalize().scale(MAX_SPEED)
|
||||
} else {
|
||||
desiredVelocity
|
||||
}
|
||||
|
||||
// Convert to Reynolds steering force
|
||||
val steeringForce = cappedVelocity.subtract(pokemonEntity.deltaMovement)
|
||||
|
||||
// Cap the final steering force
|
||||
if (steeringForce.lengthSqr() > MAX_FORCE * MAX_FORCE) {
|
||||
steeringForce.normalize().scale(MAX_FORCE)
|
||||
} else {
|
||||
steeringForce
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private fun wander(entity: PokemonEntity, forceScale: Double = 1.0) {
|
||||
// Wander behaviour
|
||||
/*************************************************************************************************************
|
||||
* The wander behaviour is based of Reynolds wander behaviour which can be seen in the below link under wander
|
||||
* This version however is adapted to 3dimensions.
|
||||
* https://slsdo.github.io/steering-behaviors/
|
||||
*************************************************************************************************************/
|
||||
// Get curr steering positions in left/right and up/down offsets
|
||||
val normVec = if(entity.deltaMovement.lengthSqr() > 0.0001) {
|
||||
entity.lookAngle.normalize()
|
||||
} else {
|
||||
Vec3(
|
||||
Random.nextDouble(-1.0, 1.0),
|
||||
Random.nextDouble(-1.0, 1.0),
|
||||
Random.nextDouble(-1.0, 1.0)
|
||||
).normalize()
|
||||
}
|
||||
|
||||
var wanderOff = normVec
|
||||
|
||||
val currPitchS = sin(Mth.atan2(wanderOff.y, wanderOff.horizontalDistance()))
|
||||
if (currPitchS >= 0.5f || currPitchS <= -0.5f) { //TODO: make this y limit class wide
|
||||
this.currVertWander = 0.0
|
||||
}
|
||||
wanderOff = wanderOff.xRot(this.currVertWander.toRadians())
|
||||
wanderOff = wanderOff.yRot(this.currHorzWander.toRadians())
|
||||
|
||||
// Base the center off the current direction of travel
|
||||
val centerDistance = 4.0 // How many blocks the wander 'sphere' is in front of the entity
|
||||
val wanderCenter = entity.position().add(normVec.scale(centerDistance))
|
||||
// Get the wander circle's radius
|
||||
val wanderRadius = 4.0
|
||||
|
||||
val wanderPoint = wanderCenter.add(wanderOff.scale(wanderRadius))
|
||||
|
||||
// change wander points
|
||||
val randVert = Random.nextDouble(-wanderDisp, wanderDisp)
|
||||
val randHorz = Random.nextDouble(-wanderDisp, wanderDisp)
|
||||
currVertWander = Mth.wrapDegrees(randVert + currVertWander)
|
||||
currHorzWander = Mth.wrapDegrees(randHorz + currHorzWander)
|
||||
|
||||
drawLines.add(EntityDebugLine(wanderPoint.subtract(pokemonEntity.position()), 1.0f, 0.0f, 0.0f, 1.0f)) // Add WanderPoint
|
||||
drawLines.add(EntityDebugLine(wanderCenter.subtract(pokemonEntity.position()), 0.0f, 1.0f, 0.0f, 1.0f)) // Add wander center
|
||||
val wanderForce = entity.steerToTarget(wanderPoint, MAX_SPEED, MAX_FORCE)
|
||||
if(pokemonEntity.isFlying() || pokemonEntity.isSwimming) {
|
||||
entity.deltaMovement = pokemonEntity.deltaMovement.add(wanderForce.scale(forceScale))
|
||||
} else {
|
||||
entity.deltaMovement = pokemonEntity.deltaMovement.add(Vec3(wanderForce.x, 0.0, wanderForce.z).scale(forceScale))
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
// been moved to [Flock.kt]
|
||||
// private fun boid(isFlyingOrSwimming: Boolean = true) {
|
||||
// // TODO: maybe move this to a sensor that lives spins up on the boid activity creation
|
||||
// // Get a list of other boid entities in this entity's vicinity
|
||||
// val brain = pokemonEntity.brain
|
||||
// val boids = brain.getMemory(MemoryModuleType.NEAREST_LIVING_ENTITIES).map { nearbyEntities ->
|
||||
// nearbyEntities.filterIsInstance<PokemonEntity>().filter { pokemon ->
|
||||
// pokemon.brain.activeNonCoreActivity.orElse(null) == CobblemonActivities.POKEMON_BOIDS
|
||||
// }
|
||||
// }.orElse(emptyList())
|
||||
//
|
||||
// // separation
|
||||
// val separationForce = separation(boids)?.scale(0.8)
|
||||
// separationForce?.let { force ->
|
||||
// if( isFlyingOrSwimming) {
|
||||
// pokemonEntity.deltaMovement = pokemonEntity.deltaMovement.add(force)
|
||||
// } else {
|
||||
// pokemonEntity.deltaMovement = pokemonEntity.deltaMovement.add(Vec3(force.x, 0.0, force.z))
|
||||
// }
|
||||
// }
|
||||
// // alignment
|
||||
// val alignmentForce = alignment(boids)?.scale(0.0)
|
||||
// alignmentForce?.let { force ->
|
||||
// if( isFlyingOrSwimming) {
|
||||
// pokemonEntity.deltaMovement = pokemonEntity.deltaMovement.add(force)
|
||||
// } else {
|
||||
// pokemonEntity.deltaMovement = pokemonEntity.deltaMovement.add(Vec3(force.x, 0.0, force.z))
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// // cohesion
|
||||
// val cohesionForce = cohesion(boids)?.scale(0.6)
|
||||
// cohesionForce?.let { force ->
|
||||
// if( isFlyingOrSwimming) {
|
||||
// pokemonEntity.deltaMovement = pokemonEntity.deltaMovement.add(force)
|
||||
// } else {
|
||||
// pokemonEntity.deltaMovement = pokemonEntity.deltaMovement.add(Vec3(force.x, 0.0, force.z))
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// private fun separation(boids: List<PokemonEntity>): Vec3? {
|
||||
// var seperationVec: Vec3? = null
|
||||
//
|
||||
// // Gather the total separation vec of all close entities
|
||||
// boids.forEach { boid ->
|
||||
// val toTargetVec = pokemonEntity.position().subtract(boid.position())
|
||||
// val desiredSeperation = boid.bbWidth * 2.0 // Base the seperation distance on the model width
|
||||
// val currDist = toTargetVec.length()
|
||||
// if (currDist < desiredSeperation) {
|
||||
// if (seperationVec == null) seperationVec = Vec3.ZERO
|
||||
// // Make the seperation force inversely proprotional to the serperation distance
|
||||
// // Also, scale the force by the bbwidth of the model so
|
||||
// seperationVec = seperationVec.add(toTargetVec.normalize().scale((1.0 - (currDist / desiredSeperation)) ))
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// if (seperationVec != null) {
|
||||
// //if (seperationVec.length() > MAX_SPEED) seperationVec = seperationVec.normalize().scale(MAX_SPEED)
|
||||
// seperationVec = seperationVec.normalize().scale(MAX_SPEED)
|
||||
// seperationVec = seperationVec.subtract(pokemonEntity.deltaMovement)
|
||||
// if (seperationVec.length() > MAX_FORCE) {
|
||||
// seperationVec = seperationVec.normalize().scale(MAX_FORCE)
|
||||
// }
|
||||
// }
|
||||
// return seperationVec
|
||||
// }
|
||||
//
|
||||
// private fun alignment(boids: List<PokemonEntity>): Vec3? {
|
||||
// val neighborDist = 4.0
|
||||
// var summedVel: Vec3? = null
|
||||
// var alignmentVec: Vec3? = null
|
||||
// var boidCount = 0
|
||||
//
|
||||
// // Gather the average position of the boid
|
||||
// boids.forEach { boid ->
|
||||
// val vecToOther = boid.position().subtract(this.pokemonEntity.position())
|
||||
// val distToOther = vecToOther.length()
|
||||
// val widthOfViewInDeg = 180
|
||||
// val isInSightLine = pokemonEntity.deltaMovement.normalize().dot(vecToOther) > cos((widthOfViewInDeg / 2.0).toRadians())
|
||||
//
|
||||
// if (isInSightLine && distToOther < neighborDist) {
|
||||
// if (summedVel == null) summedVel = Vec3.ZERO
|
||||
// summedVel = summedVel.add(boid.deltaMovement.normalize())
|
||||
// boidCount++
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// if (summedVel != null) {
|
||||
// // Get the average vel/alignment by dividing by the number of boids sampled
|
||||
// val averageVel = summedVel.scale(1.0 / boidCount)
|
||||
//
|
||||
// //alignmentVec = if (averageVel.length() > MAX_SPEED) averageVel.normalize().scale(MAX_SPEED) else averageVel
|
||||
// alignmentVec = averageVel.normalize().scale(MAX_SPEED)
|
||||
// alignmentVec = alignmentVec.subtract(pokemonEntity.deltaMovement)
|
||||
// if (alignmentVec.length() > MAX_FORCE) {
|
||||
// alignmentVec = alignmentVec.normalize().scale(MAX_FORCE)
|
||||
// }
|
||||
// }
|
||||
// return alignmentVec
|
||||
// }
|
||||
|
||||
private fun cohesion(boids: List<PokemonEntity>): Vec3? {
|
||||
//val neighborDist = 5.0
|
||||
var summedPos: Vec3? = null
|
||||
var cohesionVec: Vec3? = null
|
||||
var boidCount = 0
|
||||
val cohesionRadius = 8.0
|
||||
|
||||
// Gather the average position of the boid
|
||||
boids.forEach { boid ->
|
||||
val vecToOther = boid.position().subtract(this.pokemonEntity.position())
|
||||
val distToOther = vecToOther.length()
|
||||
val widthOfViewInDeg = 360
|
||||
val isInSightLine = pokemonEntity.deltaMovement.normalize().dot(vecToOther) > cos((widthOfViewInDeg / 2.0).toRadians())
|
||||
|
||||
if (isInSightLine && distToOther < cohesionRadius) { // Only use members that are within a certain radius and eyeline
|
||||
if (summedPos == null) summedPos = Vec3.ZERO
|
||||
summedPos = summedPos.add(boid.position())
|
||||
boidCount++
|
||||
}
|
||||
}
|
||||
|
||||
if (summedPos != null) {
|
||||
// Get the average position by dividing by the number of boids sampled
|
||||
val averagePos = summedPos.scale(1.0 / boidCount)
|
||||
// Get the vector towards that average position and scale
|
||||
cohesionVec = averagePos.subtract(pokemonEntity.position())
|
||||
//if (cohesionVec.length() > MAX_SPEED) cohesionVec = cohesionVec.normalize().scale(MAX_SPEED)
|
||||
cohesionVec = cohesionVec.normalize().scale(MAX_SPEED)
|
||||
cohesionVec = cohesionVec.subtract(pokemonEntity.deltaMovement)
|
||||
if (cohesionVec.length() > MAX_FORCE) {
|
||||
cohesionVec = cohesionVec.normalize().scale(MAX_FORCE)
|
||||
}
|
||||
}
|
||||
return cohesionVec
|
||||
}
|
||||
|
||||
private fun forceRectBoundary(entity: PokemonEntity, basePos: Vec3, rectWidth: Double, rectHeight: Double) {
|
||||
val maxBoundaryForce = MAX_FORCE //* 2.0
|
||||
val correctiveForce = getRectCorrectiveForce(basePos, rectWidth, rectHeight)
|
||||
if (correctiveForce != null) {
|
||||
//val correctiveForce = steerToTargetForce(correctivePos, speedLimit, maxForce)
|
||||
var steer = correctiveForce.subtract(entity.deltaMovement)
|
||||
if (steer.length() > maxBoundaryForce) {
|
||||
steer = steer.normalize().scale(maxBoundaryForce)
|
||||
}
|
||||
entity.setDeltaMovement(entity.deltaMovement.add(steer))
|
||||
}
|
||||
}
|
||||
|
||||
// Returns the desired force to correct the entity back into the rectangle area
|
||||
private fun getRectCorrectiveForce( basePos: Vec3, rectWidth: Double, rectHeight: Double): Vec3? {
|
||||
val entityPos = pokemonEntity.position()
|
||||
val posFromBase = entityPos.subtract(basePos)
|
||||
val cubeHalfWidth = rectWidth / 2.0 // Useful as the basePoint is in the middle of the cube
|
||||
val cubeHalfHeight = rectHeight / 2.0
|
||||
|
||||
// Check the three possible faces for exceeding the boundary (x, y, and z faces of cube)
|
||||
val xExceed = max(0.0, abs(posFromBase.x) - cubeHalfWidth)
|
||||
val yExceed = max(0.0, abs(posFromBase.y) - cubeHalfHeight)
|
||||
val zExceed = max(0.0, abs(posFromBase.z) - cubeHalfWidth)
|
||||
|
||||
return if ( xExceed == 0.0 && yExceed == 0.0 && zExceed == 0.0) {
|
||||
null
|
||||
} else {
|
||||
var desiredPos = pokemonEntity.position().add(pokemonEntity.deltaMovement) // Add delta movement so we aren't slowing this guy down
|
||||
if (xExceed != 0.0) desiredPos = Vec3( basePos.x, desiredPos.y, desiredPos.z)
|
||||
if (yExceed != 0.0) desiredPos = Vec3( desiredPos.x, basePos.y, desiredPos.z)
|
||||
if (zExceed != 0.0) desiredPos = Vec3( desiredPos.x, desiredPos.y, basePos.z)
|
||||
return desiredPos.subtract(pokemonEntity.position()).normalize().scale(MAX_SPEED)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//val desiredScale = if (distToTarget > slowDownRadius) speedLimit else (distToTarget/slowDownRadius).pow(2) * speedLimit
|
||||
//desiredVec = desiredVec.normalize().scale(desiredScale)
|
||||
+42
@@ -0,0 +1,42 @@
|
||||
/*
|
||||
* Copyright (C) 2023 Cobblemon Contributors
|
||||
*
|
||||
* This Source Code Form is subject to the terms of the Mozilla Public
|
||||
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
||||
* file, You can obtain one at https://mozilla.org/MPL/2.0/.
|
||||
*/
|
||||
|
||||
package com.cobblemon.mod.common.entity.pokemon.ai
|
||||
|
||||
import com.cobblemon.mod.common.entity.PoseType
|
||||
import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
|
||||
import net.minecraft.util.Mth
|
||||
import net.minecraft.world.entity.ai.control.BodyRotationControl
|
||||
import kotlin.math.abs
|
||||
import net.minecraft.util.Mth.lerp
|
||||
|
||||
/**
|
||||
* Controls body movement of pokemon
|
||||
*/
|
||||
class PokemonBodyRotationControl(private val pokemon: PokemonEntity) : BodyRotationControl(pokemon) {
|
||||
override fun clientTick() {
|
||||
if (this.isMoving()) {
|
||||
this.mob.yBodyRot = this.mob.getYRot();
|
||||
this.rotateHeadIfNecessary();
|
||||
this.lastStableYHeadRot = this.mob.yHeadRot;
|
||||
this.headStableTime = 0;
|
||||
} else {
|
||||
val bodyToHeadDiff = Mth.wrapDegrees(pokemon.yHeadRot - pokemon.yBodyRot )
|
||||
if(this.mob.maxHeadYRot.toFloat() - abs(bodyToHeadDiff) < 1e-3) { // Poor check this should probably be done in the lookControl when clamping happens
|
||||
//TODO: a turn without big jumps might be really good for fliers but grounded mons need the large non slidey adjustments
|
||||
val poseTypes: Set<PoseType> = setOf(PoseType.FLY, PoseType.HOVER, PoseType.SWIM, PoseType.FLOAT)
|
||||
if(pokemon.getCurrentPoseType() !in poseTypes) {
|
||||
pokemon.yBodyRot += bodyToHeadDiff * 0.8f
|
||||
} else {
|
||||
pokemon.yBodyRot += bodyToHeadDiff * 0.1f
|
||||
}
|
||||
pokemon.yRot = pokemon.yBodyRot
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
+58
@@ -0,0 +1,58 @@
|
||||
/*
|
||||
* Copyright (C) 2023 Cobblemon Contributors
|
||||
*
|
||||
* This Source Code Form is subject to the terms of the Mozilla Public
|
||||
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
||||
* file, You can obtain one at https://mozilla.org/MPL/2.0/.
|
||||
*/
|
||||
|
||||
package com.cobblemon.mod.common.entity.pokemon.ai
|
||||
|
||||
import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
|
||||
import net.minecraft.util.Mth
|
||||
import net.minecraft.world.entity.ai.control.LookControl
|
||||
import java.util.function.Consumer
|
||||
|
||||
/**
|
||||
* Controls head movement of pokemon
|
||||
*/
|
||||
class PokemonLookControl(private val pokemon: PokemonEntity) : LookControl(pokemon) {
|
||||
override fun tick() {
|
||||
if (this.resetXRotOnTick()) {
|
||||
this.mob.setXRot(0.0f)
|
||||
}
|
||||
|
||||
if (this.lookAtCooldown > 0) {
|
||||
--this.lookAtCooldown
|
||||
val targetYRotOpt = getYRotD()
|
||||
if (targetYRotOpt.isPresent) {
|
||||
val targetYRot = targetYRotOpt.get()
|
||||
val attemptedRot = rotateTowards(mob.yHeadRot, targetYRot, yMaxRotSpeed)
|
||||
val headTurnAngle = Mth.wrapDegrees(attemptedRot - mob.yBodyRot)
|
||||
val headTurn = Mth.clamp(headTurnAngle, -this.mob.maxHeadYRot.toFloat(), this.mob.maxHeadYRot.toFloat())
|
||||
val bodyTurn = headTurnAngle - headTurn // Whats left over for the head to turn
|
||||
|
||||
mob.yHeadRot = mob.yBodyRot + headTurn
|
||||
|
||||
}
|
||||
getXRotD().ifPresent { targetXRot ->
|
||||
mob.setXRot(rotateTowards(mob.getXRot(), targetXRot, xMaxRotAngle))
|
||||
}
|
||||
} else {
|
||||
this.mob.yHeadRot = this.rotateTowards(this.mob.yHeadRot, this.mob.yBodyRot, 10.0f)
|
||||
}
|
||||
// Get diff between head and body
|
||||
|
||||
this.clampHeadRotationToBody()
|
||||
}
|
||||
|
||||
override fun clampHeadRotationToBody() {
|
||||
if (!this.mob.getNavigation().isDone) { //TODO: Is this needed?
|
||||
// Stolen from Mth.rotateIfNecessary()
|
||||
val f = Mth.degreesDifference(this.mob.yHeadRot, this.mob.yBodyRot)
|
||||
val g = Mth.clamp(f, -this.mob.getMaxHeadYRot().toFloat(), this.mob.getMaxHeadYRot().toFloat())
|
||||
this.mob.yHeadRot = this.mob.yBodyRot - g
|
||||
this.mob.yBodyRot = this.mob.yBodyRot - (f - g)
|
||||
}
|
||||
}
|
||||
}
|
||||
+323
-14
@@ -9,14 +9,21 @@
|
||||
package com.cobblemon.mod.common.entity.pokemon.ai
|
||||
|
||||
import com.bedrockk.molang.runtime.MoLangRuntime
|
||||
import com.cobblemon.mod.common.api.ai.biggerbrain.fixation.RandomWanderFixation
|
||||
import com.cobblemon.mod.common.api.molang.MoLangFunctions.addFunctions
|
||||
import com.cobblemon.mod.common.api.molang.MoLangFunctions.addStandardFunctions
|
||||
import com.cobblemon.mod.common.client.render.debug.EntityDebugLine
|
||||
import com.cobblemon.mod.common.entity.PlatformType
|
||||
import com.cobblemon.mod.common.entity.PoseType
|
||||
import com.cobblemon.mod.common.entity.ai.OmniPathNavigation
|
||||
import com.cobblemon.mod.common.entity.ai.steering.SteerArbitrator
|
||||
import com.cobblemon.mod.common.entity.ai.steering.rules.ObstacleAvoidRule
|
||||
import com.cobblemon.mod.common.entity.ai.steering.rules.SeekRule
|
||||
import com.cobblemon.mod.common.entity.ai.steering.rules.WanderRule
|
||||
import com.cobblemon.mod.common.entity.pokemon.PokemonBehaviourFlag
|
||||
import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
|
||||
import com.cobblemon.mod.common.entity.pokemon.extensions.*
|
||||
import com.cobblemon.mod.common.util.getWaterAndLavaIn
|
||||
import com.cobblemon.mod.common.util.math.geometry.toDegrees
|
||||
import com.cobblemon.mod.common.util.math.geometry.toRadians
|
||||
import com.cobblemon.mod.common.util.resolveFloat
|
||||
import kotlin.math.abs
|
||||
@@ -27,6 +34,7 @@ import net.minecraft.core.Direction
|
||||
import net.minecraft.tags.BlockTags
|
||||
import net.minecraft.tags.FluidTags
|
||||
import net.minecraft.util.Mth
|
||||
import net.minecraft.world.entity.LivingEntity
|
||||
import net.minecraft.world.entity.ai.attributes.Attributes
|
||||
import net.minecraft.world.entity.ai.control.MoveControl
|
||||
import net.minecraft.world.level.material.FluidState
|
||||
@@ -50,6 +58,41 @@ class PokemonMoveControl(val pokemonEntity: PokemonEntity) : MoveControl(pokemon
|
||||
var bankUpwardsBlocksPerTick = 0F
|
||||
var bankRightDegreesPerTick = 1F
|
||||
|
||||
var obsCorrectDir = 0F
|
||||
var drawLines: MutableList<EntityDebugLine> = mutableListOf()
|
||||
var prevForce: Vec3? = null
|
||||
|
||||
var steerSpeed = this.getTopSpeed(pokemonEntity)
|
||||
private val steerArbitrator by lazy {
|
||||
val steerArbitrator = SteerArbitrator(
|
||||
entity = pokemonEntity,
|
||||
maxForce = 0.02,
|
||||
rules = mutableListOf(
|
||||
ObstacleAvoidRule(
|
||||
entity = pokemonEntity,
|
||||
debugColor = Triple(1f, 0f, 0f),
|
||||
),
|
||||
SeekRule(
|
||||
entity = pokemonEntity,
|
||||
priority = 10,
|
||||
maxForce = 0.02,
|
||||
debugColor = Triple(0f, 1f, 0f),
|
||||
horzOnly = true,
|
||||
targetProvider = { e ->
|
||||
(e.navigation as? OmniPathNavigation)?.pathFollowTarget //TODO: maybe change this seems silly. Probably want a rule that checks explicitly?
|
||||
}
|
||||
),
|
||||
WanderRule(
|
||||
entity = pokemonEntity,
|
||||
debugColor = Triple(0f, 1f, 1f),
|
||||
horzOnly = true
|
||||
)
|
||||
)
|
||||
)
|
||||
steerArbitrator
|
||||
}
|
||||
|
||||
|
||||
fun startBanking(
|
||||
forwardBlocksPerTick: Float = 0F,
|
||||
upwardsBlocksPerTick: Float = 0F,
|
||||
@@ -73,6 +116,8 @@ class PokemonMoveControl(val pokemonEntity: PokemonEntity) : MoveControl(pokemon
|
||||
}
|
||||
|
||||
override fun tick() {
|
||||
mob.setDiscardFriction(false) // ignored while trying to move but if stopped or doing something else this needs reenabled
|
||||
pokemonEntity.deltaMovement = pokemonEntity.aiMovement //TODO: this also needs moved elsewhere probably
|
||||
if (banking && operation != Operation.WAIT) {
|
||||
banking = false
|
||||
}
|
||||
@@ -113,8 +158,144 @@ class PokemonMoveControl(val pokemonEntity: PokemonEntity) : MoveControl(pokemon
|
||||
operation = Operation.WAIT
|
||||
}
|
||||
}
|
||||
// Here we call the wander on every pokemon no matter what then they wander then leave
|
||||
// Just ignore all operatations and do whatever is being tested.
|
||||
if (false) {
|
||||
// val horzOnly = true
|
||||
//
|
||||
// var topSpeed = gatherTopSpeed(pokemonEntity)
|
||||
// var maxForce = 0.02 // Arbitrarily chosen as of right now.
|
||||
// pokemonEntity.isPokemonSprinting = false
|
||||
//
|
||||
// // grab forward travel vector direction
|
||||
// val forwardVec = if (pokemonEntity.deltaMovement.horizontalDistanceSqr() < 0.001) {
|
||||
// // No meaningful velocity so derive from yaw orientation instead
|
||||
// val yaw = Math.toRadians(pokemonEntity.yRot.toDouble())
|
||||
// Vec3(-sin(yaw), 0.0, cos(yaw))
|
||||
// } else {
|
||||
// if (horzOnly) Vec3(pokemonEntity.deltaMovement.x, 0.0, pokemonEntity.deltaMovement.z).normalize()
|
||||
// else pokemonEntity.deltaMovement.normalize()
|
||||
// }
|
||||
// val pointAhead = pokemonEntity.position().add(forwardVec)
|
||||
// val aheadForce = pokemonEntity.steerToTarget(pointAhead, topSpeed, maxForce, horzOnly = horzOnly)
|
||||
//
|
||||
//
|
||||
//// val player = pokemonEntity.level().getNearestPlayer(pokemonEntity, 10.0) ?: return
|
||||
//// // Flee direction — away from player, flattened to XZ
|
||||
//// val toPlayerVec = pokemonEntity.position().subtract(player.position())
|
||||
////
|
||||
//// if (toPlayerVec.length() < 6.0) {
|
||||
//// pokemonEntity.isPokemonSprinting = true
|
||||
////// topSpeed = 0.4 // hardcoded high value
|
||||
////// maxForce = 0.04
|
||||
//// topSpeed *= 2.0f
|
||||
//// maxForce *= 2
|
||||
//// }
|
||||
////
|
||||
//// val fleePoint = pokemonEntity.position().add(toPlayerVec)
|
||||
//// val aheadForce = pokemonEntity.steerToTarget(fleePoint, topSpeed, maxForce, horzOnly = horzOnly)
|
||||
//
|
||||
// // For now just move forward by seeking towards a point ahead
|
||||
// val lookAheadTicks = 10 // How far in the future of this entities current movement to look ahead for collisions
|
||||
// val lookAheadDist = max(pokemonEntity.deltaMovement.length() * lookAheadTicks, pokemonEntity.bbWidth / 2.0) // At least always look ahead the width of the mons own hitbox
|
||||
//
|
||||
// // Get the collision box
|
||||
// val inflationAmount = 0.0 //pokemonEntity.bbWidth / 5.0 //TODO: is this needed? it seems to help a bit keeping them off walls but would stop them from entering gaps they truly could
|
||||
// val collBox = pokemonEntity.boundingBox.move(forwardVec.scale(lookAheadDist)).inflate(inflationAmount, 0.0, inflationAmount) // Inflate a bit
|
||||
// val shapes = pokemonEntity.level().getBlockCollisions(pokemonEntity, collBox)
|
||||
//
|
||||
// // Gather the nearest shape
|
||||
// val nearestShape = shapes.minByOrNull { shape ->
|
||||
// shape.bounds().center.distanceToSqr(pokemonEntity.position())
|
||||
// }
|
||||
//
|
||||
// var avoidancForce = Vec3.ZERO
|
||||
//
|
||||
// if (nearestShape != null) {
|
||||
// var hasLeftForce = false
|
||||
// var hasRightForce = false
|
||||
// val right = Vec3(-forwardVec.z, 0.0, forwardVec.x) //TODO: expand to 3 dimensions
|
||||
//
|
||||
// val obsCenter = nearestShape.bounds().center
|
||||
// val toObs = obsCenter.subtract(pokemonEntity.position())
|
||||
//
|
||||
// // Get the lateral avoidance point to seek to (the avoidance force really)
|
||||
// // It is the negated vector of toObs - Proj(toObs->forwardVec)
|
||||
// val projVec = forwardVec.scale(toObs.dot(forwardVec)) // Can do this because forwardVec is normalized
|
||||
// val lateralComponent = toObs.subtract(projVec) // TODO: moved back so that two opposing forces turn the dude around
|
||||
//
|
||||
// avoidancForce = if (lateralComponent.lengthSqr() < 0.001) { // If its dead ahead then just turn right
|
||||
// val rightVec = forwardVec.cross(Vec3(0.0,1.0,0.0))
|
||||
// obsCorrectDir = 1F
|
||||
// pokemonEntity.steerToTarget(pokemonEntity.position().add(rightVec), topSpeed, maxForce, horzOnly = horzOnly)
|
||||
// } else {
|
||||
// // Scale the strength of the avoidance vec based off how close to being dead center it is
|
||||
//
|
||||
// var avoidanceVec = lateralComponent.scale(-1.0)
|
||||
// if (horzOnly) avoidanceVec = Vec3(avoidanceVec.x, 0.0, avoidanceVec.z)
|
||||
// //var avoidStrength = (abs(toObs.dot(avoidanceVec)) / (pokemonEntity.bbWidth / 2.0) ).coerceIn(0.0, 1.0)
|
||||
//
|
||||
// // 0.5 to add half the block width allowance since if it catches the corner of a block it still gets the center
|
||||
// var avoidStrength = sqrt(1 - (avoidanceVec.length() / (pokemonEntity.bbWidth / 2.0 + 0.5) ).coerceIn(0.0, 0.7))
|
||||
// // Track which side this force is pushing toward
|
||||
// //val newObsCorrectDir = if (avoidanceVec.normalize().dot(right) > 0) 1F else -1f
|
||||
//
|
||||
// // If the new direction is opposite the last direction then invert it
|
||||
//// if (obsCorrectDir == 0F) {
|
||||
//// obsCorrectDir = newObsCorrectDir
|
||||
//// } else if (newObsCorrectDir != obsCorrectDir) {
|
||||
//// avoidanceVec = avoidanceVec.scale(-1.0)
|
||||
//// //avoidStrength = 1.0
|
||||
//// }
|
||||
//
|
||||
// val avoidancePoint = pokemonEntity.position().add(avoidanceVec)
|
||||
// pokemonEntity.steerToTarget(avoidancePoint, topSpeed, maxForce * avoidStrength, horzOnly = horzOnly)
|
||||
// }
|
||||
// } else {
|
||||
// obsCorrectDir = 0F
|
||||
// }
|
||||
//
|
||||
// // accumulte forces
|
||||
// // TODO: steertoTarget also checks stuff like this. Should that be different? The forces could compound here
|
||||
// val accumForce = aheadForce.scale(0.5).add(avoidancForce.scale(1.0))
|
||||
// var finalForce = if( avoidancForce == Vec3.ZERO) aheadForce
|
||||
// else avoidancForce
|
||||
//
|
||||
// prevForce?.let { finalForce = it.lerp(finalForce, 0.1) }
|
||||
// prevForce = finalForce
|
||||
//
|
||||
// pokemonEntity.deltaMovement = pokemonEntity.deltaMovement.add(finalForce)
|
||||
//
|
||||
// // Must be called to make sure we have complete control over our entities velocity.
|
||||
// mob.speed = 0f
|
||||
// mob.setZza(0f)
|
||||
// mob.setXxa(0f)
|
||||
// mob.setDiscardFriction(true)
|
||||
// pokemonEntity.orientEntityToTravel(1.0f)
|
||||
// pokemonEntity.setFlying(false)
|
||||
//
|
||||
// drawLines.add(EntityDebugLine(forwardVec))
|
||||
// if (drawLines.isNotEmpty()) {
|
||||
// sendPacketToTrackingPlayers(pokemonEntity, ClientboundUpdateObsAvoidPacket(pokemonEntity.id, drawLines.toList()))
|
||||
// drawLines.clear()
|
||||
// }
|
||||
|
||||
if (operation == Operation.STRAFE) {
|
||||
steerSpeed = getTopSpeed(pokemonEntity)
|
||||
val force = steerArbitrator.calculate(debug = true)
|
||||
pokemonEntity.deltaMovement = pokemonEntity.deltaMovement.add(force)
|
||||
mob.speed = 0f
|
||||
mob.setZza(0f)
|
||||
mob.setXxa(0f)
|
||||
mob.setDiscardFriction(true)
|
||||
pokemonEntity.orientEntityToTravel(1.0f)
|
||||
|
||||
} else if(pokemonEntity.biggerBrain.fixation is RandomWanderFixation){ //TODO: we probably want to have a fixation superclass that determines a group of fixations that need this logic...
|
||||
mob.speed = 0f
|
||||
mob.setZza(0f)
|
||||
mob.setXxa(0f)
|
||||
mob.setDiscardFriction(true)
|
||||
pokemonEntity.orientEntityToTravel(1.0f)
|
||||
} else if (operation == Operation.STRAFE) {
|
||||
var movingDistanceTotal = Mth.sqrt(strafeForwards * strafeForwards + strafeRight * strafeRight)
|
||||
if (movingDistanceTotal < 1.0f) {
|
||||
movingDistanceTotal = 1.0f
|
||||
@@ -161,10 +342,14 @@ class PokemonMoveControl(val pokemonEntity: PokemonEntity) : MoveControl(pokemon
|
||||
val horizontalDistanceFromTarget = xDist * xDist + zDist * zDist
|
||||
val closeHorizontally = horizontalDistanceFromTarget < VERY_CLOSE
|
||||
if (!closeHorizontally) {
|
||||
val angleToTarget = Mth.atan2(zDist, xDist).toDegrees() - 90.0f
|
||||
val currentMovingAngle = mob.yRot
|
||||
val steppedAngle = Mth.approachDegrees(currentMovingAngle, angleToTarget, 100 * mediumSpeed)
|
||||
mob.yRot = steppedAngle
|
||||
// NEW
|
||||
pokemonEntity.orientEntityToTravel(1.0f)
|
||||
|
||||
// OLD
|
||||
// val angleToTarget = Mth.atan2(zDist, xDist).toDegrees() - 90.0f
|
||||
// val currentMovingAngle = mob.yRot
|
||||
// val steppedAngle = Mth.approachDegrees(currentMovingAngle, angleToTarget, 100 * mediumSpeed)
|
||||
// mob.yRot = steppedAngle
|
||||
}
|
||||
|
||||
val (inWater, inLava) = mob.level().getWaterAndLavaIn(mob.boundingBox)
|
||||
@@ -187,19 +372,105 @@ class PokemonMoveControl(val pokemonEntity: PokemonEntity) : MoveControl(pokemon
|
||||
zDist
|
||||
)
|
||||
|
||||
val direction = fullDistance.normalize()
|
||||
|
||||
val scale = min(adjustedSpeed.toDouble(), fullDistance.length())
|
||||
val speed = adjustedSpeed.toDouble()
|
||||
//val scale = min(adjustedSpeed.toDouble(), fullDistance.length())
|
||||
|
||||
mob.deltaMovement = direction.scale(scale)
|
||||
|
||||
xDist = fullDistance.x
|
||||
zDist = fullDistance.z
|
||||
yDist = fullDistance.y
|
||||
|
||||
val maxForce = 0.015
|
||||
|
||||
// Gather the point to be steered to
|
||||
val nav = pokemonEntity.navigation
|
||||
nav.pathFollowTarget?.let { rt ->
|
||||
wantedX = rt.x
|
||||
wantedZ = rt.z
|
||||
wantedY = rt.y
|
||||
}
|
||||
// + 0.05 for dealing with swimming out of water, they otherwise get stuck on the lip
|
||||
val steerForce = pokemonEntity.steerToTarget(Vec3(wantedX, refine(wantedY + 0.05), wantedZ), speed, maxForce)
|
||||
mob.deltaMovement = mob.deltaMovement.add(steerForce)
|
||||
|
||||
mob.speed = 0f
|
||||
mob.setZza(0f)
|
||||
mob.setXxa(0f)
|
||||
mob.setDiscardFriction(true)
|
||||
} else {
|
||||
// division is to slow the speed down a bit so they don't overshoot when they get there.
|
||||
val forwardSpeed = min(adjustedSpeed, max(horizontalDistanceFromTarget.toFloat() / 2, 0.15F))
|
||||
mob.speed = forwardSpeed
|
||||
var forwardSpeed = adjustedSpeed
|
||||
var minForce = 0.005 // If its not at least this it breaks quite a few things. looking at you snorlax
|
||||
|
||||
val finalGoal: BlockPos? = pokemonEntity.navigation.path?.target
|
||||
val distanceToFinalGoal = finalGoal?.let {
|
||||
pokemonEntity.position().distanceTo(it.center).toFloat()
|
||||
} ?: 0.0f
|
||||
|
||||
// TODO: sprinting should likely be dictated by an objective?
|
||||
// if (distanceToFinalGoal > 8f) { //TODO: scale this to hitbox size
|
||||
// pokemonEntity.isPokemonSprinting = true
|
||||
// forwardSpeed *= 1.4f
|
||||
// minForce = 0.02 //TODO: figure out what to actually do for this
|
||||
// } else {
|
||||
// pokemonEntity.isPokemonSprinting = false
|
||||
// }
|
||||
|
||||
// New way
|
||||
val blockFriction = mob.level()
|
||||
.getBlockState(mob.getBlockPosBelowThatAffectsMyMovement())
|
||||
.block.getFriction()
|
||||
val frictionInfluencedSpeed = if (mob.onGround()) {
|
||||
forwardSpeed * (0.21600002f / (blockFriction * blockFriction * blockFriction))
|
||||
} else {
|
||||
0.02f // getFlyingSpeed() default for non-player controlled. Also hopefully our checks above this caught this case
|
||||
}
|
||||
|
||||
|
||||
val baseForce = (forwardSpeed * 0.98) * frictionInfluencedSpeed
|
||||
|
||||
// We find where the equilibrium between vanilla friction and the input force usually is to get a topSpeed for this mon.
|
||||
// Could be replaced in the future with direct topSpeed calculations in the pokemon species form
|
||||
val frictionAppliedAfter = blockFriction * 0.91
|
||||
val topSpeed = baseForce / (1 - frictionAppliedAfter)
|
||||
val currSpeed = pokemonEntity.deltaMovement.length()
|
||||
|
||||
//TODO: is this needed?
|
||||
// if (!pokemonEntity.isPokemonSprinting && currSpeed > topSpeed) { // TODO: this might mess up some stuff like tnt pushing mobs around
|
||||
// pokemonEntity.deltaMovement = pokemonEntity.deltaMovement.normalize().scale(lerp(currSpeed, topSpeed, 0.1))
|
||||
// }
|
||||
|
||||
// Get a force that looks natural
|
||||
val maxForce = minForce //max(baseForce * forceDiv, minForce)
|
||||
|
||||
// Gather the point to be steered to
|
||||
val nav = pokemonEntity.navigation
|
||||
nav.pathFollowTarget?.let { rt ->
|
||||
wantedX = rt.x
|
||||
wantedZ = rt.z
|
||||
wantedY = rt.y
|
||||
}
|
||||
|
||||
val steerForce = pokemonEntity.steerToTarget(
|
||||
Vec3(wantedX, wantedY, wantedZ),
|
||||
topSpeed, // Is never reached as minecraft relies on top speed being obtained when force=friction
|
||||
topSpeed / 15f, //TODO: Possibly scale with hitbox size?
|
||||
horzOnly = true
|
||||
)
|
||||
|
||||
// If this happens a lot then we have issues
|
||||
val mdt = LivingEntity.MIN_MOVEMENT_DISTANCE
|
||||
if ( abs(steerForce.x) < mdt || abs(steerForce.y) < mdt || abs(steerForce.z) < mdt) {
|
||||
//Cobblemon.LOGGER.info("INFO: Steer Force dimension smaller than minimum movement distance value") //TODO: figure this out
|
||||
}
|
||||
|
||||
pokemonEntity.deltaMovement = pokemonEntity.deltaMovement.add(steerForce)
|
||||
//pokemonEntity.deltaMovement = pokemonEntity.deltaMovement.add(Vec3(0.0103766, 0.0, 0.0))
|
||||
mob.speed = 0f
|
||||
mob.setZza(0f)
|
||||
mob.setXxa(0f)
|
||||
mob.setDiscardFriction(true)
|
||||
|
||||
// Old way
|
||||
// mob.speed = forwardSpeed
|
||||
}
|
||||
|
||||
if (!verticalHandled) {
|
||||
@@ -280,6 +551,44 @@ class PokemonMoveControl(val pokemonEntity: PokemonEntity) : MoveControl(pokemon
|
||||
}
|
||||
}
|
||||
|
||||
fun getTopSpeed(pokemonEntity: PokemonEntity): Double {
|
||||
val behaviour = pokemonEntity.behaviour
|
||||
var flyingOrSwimming = false
|
||||
val mediumSpeed = runtime.resolveFloat(if (pokemonEntity.getCurrentPoseType() in setOf(PoseType.FLY, PoseType.HOVER)) {
|
||||
flyingOrSwimming = true
|
||||
behaviour.moving.fly.flySpeedHorizontal
|
||||
} else if (pokemonEntity.isEyeInFluid(FluidTags.WATER) || pokemonEntity.isEyeInFluid(FluidTags.LAVA)) {
|
||||
flyingOrSwimming = true
|
||||
behaviour.moving.swim.swimSpeed
|
||||
} else {
|
||||
behaviour.moving.walk.walkSpeed
|
||||
}) * 2.5F //TODO: idk why this is 2.5 but I think we're stuck with it
|
||||
|
||||
val baseSpeed = mob.getAttributeValue(Attributes.MOVEMENT_SPEED).toFloat() * 0.4f //TODO: does this ever need to not be hardcoded?
|
||||
val adjustedSpeed = baseSpeed * mediumSpeed
|
||||
|
||||
val forwardSpeed = adjustedSpeed
|
||||
|
||||
val blockFriction = mob.level()
|
||||
.getBlockState(mob.getBlockPosBelowThatAffectsMyMovement())
|
||||
.block.getFriction()
|
||||
val frictionInfluencedSpeed = if (mob.onGround() || flyingOrSwimming) { // TODO: should flyingOrSwimming be treated completely differently?
|
||||
forwardSpeed * (0.21600002f / (blockFriction * blockFriction * blockFriction))
|
||||
} else {
|
||||
0.02f // getFlyingSpeed() default for non-player controlled
|
||||
}
|
||||
|
||||
// Force applied every tick through the usual vanilla route
|
||||
val baseForce = (forwardSpeed * 0.98) * frictionInfluencedSpeed
|
||||
|
||||
// We find where the equilibrium between vanilla friction and the input force usually is to get a topSpeed for this mon.
|
||||
// Could be replaced in the future with direct topSpeed calculations in the pokemon species form
|
||||
val frictionAppliedAfter = blockFriction * 0.91
|
||||
val topSpeed = baseForce / (1 - frictionAppliedAfter)
|
||||
|
||||
return topSpeed
|
||||
}
|
||||
|
||||
/*
|
||||
* Returns the ideal water level y position of a given pokemon during battle.
|
||||
* This is separate for the eye height check and is dependent on if the pokemon is rafted or swimming.
|
||||
|
||||
+111
@@ -0,0 +1,111 @@
|
||||
package com.cobblemon.mod.common.entity.pokemon.extensions
|
||||
|
||||
import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
|
||||
import com.cobblemon.mod.common.util.math.geometry.toDegrees
|
||||
import net.minecraft.util.Mth
|
||||
import net.minecraft.world.entity.LivingEntity
|
||||
import net.minecraft.world.phys.Vec3
|
||||
import kotlin.math.abs
|
||||
import kotlin.math.min
|
||||
import kotlin.math.sign
|
||||
|
||||
|
||||
/*************************************************************************************************************
|
||||
Steering to Target
|
||||
Detailed in: https://www.red3d.com/cwr/steer/gdc99/
|
||||
*************************************************************************************************************/
|
||||
fun PokemonEntity.steerToTarget(
|
||||
targetPos: Vec3,
|
||||
maxSpeed: Double,
|
||||
maxForce: Double,
|
||||
arrivalRange: Double? = null,
|
||||
horzOnly: Boolean = false
|
||||
): Vec3 {
|
||||
val cPos = if (horzOnly) Vec3(this.position().x, 0.0, this.position().z) else this.position()
|
||||
val tPos = if (horzOnly) Vec3(targetPos.x, 0.0, targetPos.z) else targetPos
|
||||
|
||||
// Ensure we can't have a negative range here
|
||||
val absArrivalRange = arrivalRange?.let { abs(arrivalRange) }
|
||||
|
||||
// Calculate the vector from the pokemons current position to the
|
||||
// target position. Set its desired magnitude to max speed or a
|
||||
// portion of it if within the arrivalRange
|
||||
val toTargetVec = tPos.subtract(cPos)
|
||||
|
||||
val distToTarget = toTargetVec.length()
|
||||
val desiredSpeed = if (absArrivalRange != null && distToTarget < absArrivalRange) (distToTarget/absArrivalRange) * maxSpeed else maxSpeed
|
||||
val desiredVec = toTargetVec.normalize().scale(desiredSpeed)
|
||||
|
||||
var steer = if (horzOnly) desiredVec.subtract(Vec3(this.deltaMovement.x, 0.0, this.deltaMovement.z))
|
||||
else desiredVec.subtract(this.deltaMovement)
|
||||
|
||||
if (steer.length() > maxForce) {
|
||||
steer = steer.normalize().scale(maxForce)
|
||||
}
|
||||
|
||||
return steer
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*************************************************************************************************************
|
||||
Steering Target Avoidance
|
||||
Detailed in: https://www.red3d.com/cwr/steer/gdc99/
|
||||
*************************************************************************************************************/
|
||||
fun PokemonEntity.avoidTarget(
|
||||
targetPos: Vec3,
|
||||
maxSpeed: Double,
|
||||
maxForce: Double,
|
||||
avoidanceRange: Double? = null
|
||||
): Vec3 {
|
||||
|
||||
// Calculate the vector from the targets current position to the
|
||||
// pokemon position. Set its desired magnitude to max speed scaled
|
||||
// linearly from 1.0 when right next to the target and 0.0 when on the
|
||||
// very edge of the avoidance Range
|
||||
var fromTargetVec = this.position().subtract(targetPos)
|
||||
|
||||
// Calculate distance to the target
|
||||
val distToTarget = fromTargetVec.length()
|
||||
if (distToTarget < 1.0E-4) {fromTargetVec = Vec3(0.0, 1.0, 0.0)} // Ensure the avoidance vector can't be ZERO
|
||||
|
||||
// Return no force otherwise a desired vector will be calculated that slows the velocity.
|
||||
if (avoidanceRange != null && distToTarget >= avoidanceRange) return Vec3.ZERO
|
||||
|
||||
// Scale the avoidance force linearly
|
||||
val desiredSpeed = when {
|
||||
avoidanceRange == null -> maxSpeed // If no avoidance range then just always flee as fast as you can
|
||||
avoidanceRange == 0.0 -> maxSpeed // Avoid weird divide by zero nonsense
|
||||
distToTarget < avoidanceRange -> (1.0 - (distToTarget / avoidanceRange)) * maxSpeed
|
||||
else -> 0.0
|
||||
}
|
||||
//TODO: determine if this should be scaled by distance. Probably not
|
||||
val desiredVec = fromTargetVec.normalize() //.scale(desiredSpeed)
|
||||
|
||||
// Steer the pokemon towards the desired vector
|
||||
var steer = desiredVec.subtract(this.deltaMovement)
|
||||
if (steer.length() > maxForce) {
|
||||
steer = steer.normalize().scale(maxForce)
|
||||
}
|
||||
|
||||
return steer
|
||||
}
|
||||
|
||||
/*************************************************************************************************************
|
||||
Lerp the mobs yRot to its direction of travel
|
||||
*************************************************************************************************************/
|
||||
fun PokemonEntity.orientEntityToTravel(k: Float = 1.0f) {
|
||||
val interpAmount = k.coerceIn(0.0f, 1.0f) //TODO: This probably shouldn't be a lerp like this.
|
||||
if (this.deltaMovement.length() < 0.01) return //LivingEntity.MIN_MOVEMENT_DISTANCE) return
|
||||
|
||||
// Ensure the entity is facing the direction it is moving in both pitch and yaw
|
||||
val normVec = this.deltaMovement.normalize()
|
||||
val targetAngle = Mth.atan2(normVec.z, normVec.x).toDegrees() - 90.0f
|
||||
val currAngle = this.yRot
|
||||
|
||||
val angleDiff = Mth.wrapDegrees(targetAngle - currAngle)
|
||||
val maxPerTickRotation = 30.0f // set really high to ignore for now 15.0f // TODO: is something like this needed or should it be a clientside spring or something?
|
||||
val effRot = min(abs(angleDiff), maxPerTickRotation) * sign(angleDiff)
|
||||
this.yRot = currAngle + (effRot * interpAmount)
|
||||
//entity.xRot = asin(normVec.y.toFloat()).toDegrees()
|
||||
}
|
||||
+49
@@ -0,0 +1,49 @@
|
||||
/*
|
||||
* Copyright (C) 2023 Cobblemon Contributors
|
||||
*
|
||||
* This Source Code Form is subject to the terms of the Mozilla Public
|
||||
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
||||
* file, You can obtain one at https://mozilla.org/MPL/2.0/.
|
||||
*/
|
||||
|
||||
package com.cobblemon.mod.common.net.messages.client.debug
|
||||
|
||||
import com.cobblemon.mod.common.api.net.NetworkPacket
|
||||
import com.cobblemon.mod.common.client.render.debug.EntityDebugLine
|
||||
import com.cobblemon.mod.common.entity.PoseType
|
||||
import com.cobblemon.mod.common.util.cobblemonResource
|
||||
import com.cobblemon.mod.common.util.readString
|
||||
import com.cobblemon.mod.common.util.writeCollection
|
||||
import com.cobblemon.mod.common.util.writeString
|
||||
import net.minecraft.network.RegistryFriendlyByteBuf
|
||||
import net.minecraft.resources.ResourceLocation
|
||||
import net.minecraft.world.phys.Vec3
|
||||
|
||||
/**
|
||||
* Packet sent to the client to update the obstacle avoidance lines to be rendered
|
||||
* while debugging
|
||||
*
|
||||
* @author Jackson
|
||||
* @since September 15th, 2025
|
||||
*/
|
||||
class ClientboundUpdateObsAvoidPacket(val entityId: Int, val lines: List<EntityDebugLine>) : NetworkPacket<ClientboundUpdateObsAvoidPacket> {
|
||||
override val id: ResourceLocation = ID
|
||||
override fun encode(buffer: RegistryFriendlyByteBuf) {
|
||||
buffer.writeInt(entityId)
|
||||
buffer.writeCollection(lines) { _, linePair ->
|
||||
linePair.encode(buffer)
|
||||
}
|
||||
}
|
||||
|
||||
companion object {
|
||||
val ID = cobblemonResource("obstacle_avoidance_lines")
|
||||
|
||||
fun decode(buffer: RegistryFriendlyByteBuf): ClientboundUpdateObsAvoidPacket {
|
||||
val entityId = buffer.readInt()
|
||||
val lines = buffer.readList { buf ->
|
||||
EntityDebugLine.decode(buf as RegistryFriendlyByteBuf)
|
||||
}
|
||||
return ClientboundUpdateObsAvoidPacket(entityId, lines)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -53,4 +53,60 @@ fun Quaternionf.toEulerXYZDegrees(): Vector3f {
|
||||
vector.z = vector.z.toDegrees()
|
||||
|
||||
return vector
|
||||
}
|
||||
|
||||
|
||||
/* // is not allocation free so just inline ".get(AxisAngle4f)" like in the function below this
|
||||
fun Quaternionf.toScaledAngleAxis(angAxisScaled: Vector3f) {
|
||||
val axisAng4 = AxisAngle4f()
|
||||
this.get(axisAng4)
|
||||
|
||||
angAxisScaled.x = axisAng4.x
|
||||
angAxisScaled.y = axisAng4.y
|
||||
angAxisScaled.z = axisAng4.z
|
||||
angAxisScaled.mul(axisAng4.angle)
|
||||
} */
|
||||
|
||||
fun Quaternionf.toScaledAngleAxis(dest: Vector3f) {
|
||||
var x = this.x
|
||||
var y = this.y
|
||||
var z = this.z
|
||||
var w = this.w
|
||||
|
||||
if (w > 1.0f) {
|
||||
val invNorm = 1.0f / kotlin.math.sqrt(x * x + y * y + z * z + w * w)
|
||||
x *= invNorm
|
||||
y *= invNorm
|
||||
z *= invNorm
|
||||
w *= invNorm
|
||||
}
|
||||
|
||||
val angle = 2.0f * kotlin.math.acos(w)
|
||||
val s = kotlin.math.sqrt(1.0f - w * w)
|
||||
|
||||
if (s < 0.001f) {
|
||||
dest.x = x * angle
|
||||
dest.y = y * angle
|
||||
dest.z = z * angle
|
||||
} else {
|
||||
val invS = angle / s
|
||||
dest.x = x * invS
|
||||
dest.y = y * invS
|
||||
dest.z = z * invS
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
fun Quaternionf.setFromScaledAngleAxis(angAxisScaled: Vector3f) {
|
||||
val len = angAxisScaled.length()
|
||||
if (len > 1e-5f) {
|
||||
this.rotationAxis(
|
||||
len,
|
||||
angAxisScaled.x / len,
|
||||
angAxisScaled.y / len,
|
||||
angAxisScaled.z / len
|
||||
)
|
||||
} else {
|
||||
this.identity()
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,155 @@
|
||||
/*
|
||||
* Copyright (C) 2023 Cobblemon Contributors
|
||||
*
|
||||
* This Source Code Form is subject to the terms of the Mozilla Public
|
||||
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
||||
* file, You can obtain one at https://mozilla.org/MPL/2.0/.
|
||||
*/
|
||||
|
||||
package com.cobblemon.mod.common.util.math
|
||||
|
||||
import net.minecraft.util.Mth
|
||||
import kotlin.math.max
|
||||
import kotlin.math.sqrt
|
||||
import kotlin.math.abs
|
||||
import org.joml.Quaternionf
|
||||
import org.joml.Vector3f
|
||||
|
||||
/**
|
||||
* Much of the code here is directly taken or inspired off this great article:
|
||||
* https://theorangeduck.com/page/spring-roll-call#critical
|
||||
*
|
||||
* Very much worth the read.
|
||||
*
|
||||
* Util funcitons for using springs to smoothly/naturally approach one value towards a target
|
||||
*/
|
||||
|
||||
/**
|
||||
* Need to pass in and mutate both a value and a velocity to a spring
|
||||
*/
|
||||
class FloatSpring(
|
||||
var value: Float = 0f,
|
||||
var velocity: Float = 0f
|
||||
)
|
||||
|
||||
class QuatSpring(
|
||||
var quat: Quaternionf = Quaternionf(),
|
||||
var angVel: Vector3f = Vector3f()
|
||||
)
|
||||
|
||||
|
||||
/**
|
||||
* Provides a fast negative exponent approximation for e^-x
|
||||
*/
|
||||
fun negExp(x: Float): Float {
|
||||
return 1.0f / (1.0f + x + 0.48f*x*x + 0.235f*x*x*x)
|
||||
}
|
||||
|
||||
fun halflifeToDamping(halflife: Float, eps: Float = 1e-5f): Float {
|
||||
return (4.0f * 0.69314718056f) / (halflife + eps)
|
||||
}
|
||||
|
||||
fun simpleSpringDamper(
|
||||
spring: FloatSpring,
|
||||
goalValue: Float,
|
||||
halflife: Float,
|
||||
dt: Float,
|
||||
isAngle: Boolean = false
|
||||
) {
|
||||
val y = halflifeToDamping(halflife) / 2.0f
|
||||
val j0 = if (isAngle) Mth.wrapDegrees(spring.value - goalValue) else spring.value - goalValue
|
||||
val j1 = spring.velocity + j0*y;
|
||||
val eydt = negExp(y*dt);
|
||||
|
||||
spring.value = eydt*(j0 + j1*dt) + goalValue;
|
||||
spring.velocity = eydt*(spring.velocity - j1*y*dt);
|
||||
}
|
||||
|
||||
fun simpleSpringDamperQuat(
|
||||
spring: QuatSpring,
|
||||
goalQuat: Quaternionf,
|
||||
halflife: Float,
|
||||
dt: Float
|
||||
) {
|
||||
val y = halflifeToDamping(halflife) / 2.0f
|
||||
|
||||
// Gather the rotation from the goal to the current
|
||||
val goalToCurrQuat = Quaternionf(spring.quat).mul(Quaternionf(goalQuat).conjugate())
|
||||
|
||||
val j0 = Vector3f()
|
||||
goalToCurrQuat.toScaledAngleAxis(j0)
|
||||
|
||||
val j1: Vector3f = Vector3f(spring.angVel).add(Vector3f(j0).mul(y))
|
||||
|
||||
val eydt: Float = negExp(y * dt)
|
||||
|
||||
val scaledAxis = Vector3f(j0).add(Vector3f(j1).mul(dt)).mul(eydt)
|
||||
|
||||
spring.quat.setFromScaledAngleAxis(scaledAxis)
|
||||
spring.quat.mul(goalQuat)
|
||||
|
||||
spring.angVel.sub(j1.mul(y * dt))
|
||||
spring.angVel.mul(eydt)
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Below is essentially the same code as found here: https://github.com/orangeduck/Spring-It-On/blob/main/inertialeasing.c
|
||||
* https://theorangeduck.com/page/inertial-easing <- the blogpost
|
||||
*/
|
||||
|
||||
// Class to hold the "time" along the curve/function and scale of the function currently
|
||||
// Held in this class so both can be mutated and returned in one function call
|
||||
class InertialVals(
|
||||
var t: Float = 0f,
|
||||
var s: Float = 0f,
|
||||
var offset: Float = 0f,
|
||||
)
|
||||
|
||||
// Includes the negative portion
|
||||
fun smoothstep(t: Float, s: Float): Float {
|
||||
return s * (if(t > 1.0f) 1.0f else 3*t*t - 2*t*t*t)
|
||||
}
|
||||
|
||||
// Derivative of the above smoothstep
|
||||
fun smoothstepDt(t: Float, s: Float): Float {
|
||||
return s * (if(t > 1.0f) 0.0f else 6*t - 6*t*t)
|
||||
}
|
||||
|
||||
// Solve for smoothstep parameters `t` and `s` given new target `x` and velocity `v`
|
||||
fun smoothstepSolve( //TODO change these names to make more sense
|
||||
vals: InertialVals,
|
||||
x: Float, // Target Value x
|
||||
v: Float, // Goal velocity
|
||||
overshoot: Float = 0.05f,
|
||||
eps: Float = 1e-8f
|
||||
) {
|
||||
// If velocity is low enough then start from time zero
|
||||
if (abs(v) < 1e-8f) {
|
||||
vals.t = 0f
|
||||
vals.s = x
|
||||
return
|
||||
}
|
||||
|
||||
// If x is negative then invert signs and re-Solve
|
||||
if (x < 0f) {
|
||||
smoothstepSolve(vals, -x, -v, overshoot, eps)
|
||||
vals.s *= -1f
|
||||
return
|
||||
}
|
||||
|
||||
// Find the possible times that solve for the given `x` and `v`
|
||||
// Quadratic formula!
|
||||
val q: Float = sqrt(max((6*x - v)*(6*x - v) + 8*v*v, eps))
|
||||
val t0: Float = (v - 6*x + q) / (4*v)
|
||||
val t1: Float = (v - 6*x - q) / (4*v)
|
||||
|
||||
// Overshoot if the alternative time is between -0.5f and -(0.5f + overshoot)
|
||||
vals.t = if(-0.5f > t1 && t1 > -(0.5f + overshoot)) t1 else t0;
|
||||
|
||||
// Find the un-scaled velocity at the fitted time
|
||||
val vt: Float = smoothstepDt(vals.t, 1f);
|
||||
|
||||
// Find the scaling factor so that the velocity at the fitted time matches
|
||||
vals.s = if(abs(vt) < eps) 0f else v / vt;
|
||||
}
|
||||
@@ -153,4 +153,10 @@ transitive-accessible method net/minecraft/client/model/HumanoidModel setupAttac
|
||||
transitive-accessible method net/minecraft/client/model/HumanoidModel poseRightArm (Lnet/minecraft/world/entity/LivingEntity;)V
|
||||
transitive-accessible method net/minecraft/client/model/HumanoidModel poseLeftArm (Lnet/minecraft/world/entity/LivingEntity;)V
|
||||
|
||||
transitive-accessible method net/minecraft/world/entity/ai/Brain forgetOutdatedMemories ()V
|
||||
transitive-accessible method net/minecraft/world/entity/ai/Brain forgetOutdatedMemories ()V
|
||||
|
||||
transitive-accessible field net/minecraft/world/entity/ai/control/BodyRotationControl mob Lnet/minecraft/world/entity/Mob;
|
||||
transitive-accessible field net/minecraft/world/entity/ai/control/BodyRotationControl headStableTime I
|
||||
transitive-accessible field net/minecraft/world/entity/ai/control/BodyRotationControl lastStableYHeadRot F
|
||||
transitive-accessible method net/minecraft/world/entity/ai/control/BodyRotationControl isMoving ()Z
|
||||
transitive-accessible method net/minecraft/world/entity/ai/control/BodyRotationControl rotateHeadIfNecessary ()V
|
||||
@@ -3,44 +3,10 @@
|
||||
"description": "cobblemon.behaviour.pokemon_herds.desc",
|
||||
"entityType": "cobblemon:pokemon",
|
||||
"configurations": [
|
||||
{
|
||||
"type": "cobblemon:add_tasks_to_activity",
|
||||
"activity": "idle",
|
||||
"tasksByPriority": {
|
||||
"8": [
|
||||
{
|
||||
"type": "cobblemon:find_herd_leader",
|
||||
"checkTicks": 20
|
||||
}
|
||||
],
|
||||
"9": [
|
||||
"cobblemon:switch_to_herd",
|
||||
{
|
||||
"type": "cobblemon:count_followers",
|
||||
"checkTicks": 10
|
||||
}
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "add_tasks_to_activity",
|
||||
"activity": "cobblemon:pokemon_herd",
|
||||
"tasksByPriority": {
|
||||
"1": [
|
||||
"cobblemon:switch_from_herd"
|
||||
],
|
||||
"2": [
|
||||
"cobblemon:follow_herd_leader",
|
||||
"cobblemon:maintain_herd_leader"
|
||||
]
|
||||
}
|
||||
},
|
||||
|
||||
{
|
||||
"type": "cobblemon:add_objectives",
|
||||
"objectivesByPriority": {
|
||||
"4": [
|
||||
"cobblemon:herd"
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
|
||||
@@ -7,9 +7,6 @@
|
||||
"objectivesByPriority": {
|
||||
"7": [
|
||||
"cobblemon:wander_around"
|
||||
],
|
||||
"9": [
|
||||
"cobblemon:circle_around"
|
||||
]
|
||||
}
|
||||
}
|
||||
|
||||
@@ -7,37 +7,6 @@
|
||||
"objectivesByPriority": {
|
||||
"7": [
|
||||
"cobblemon:wander_around"
|
||||
],
|
||||
"9": [
|
||||
{
|
||||
"type": "cobblemon:circle_around",
|
||||
"poseTypes": ["SWIM", "FLOAT"],
|
||||
"speed": {
|
||||
"variableName": "swim_circling_speed",
|
||||
"category": "cobblemon.entity.variable.category.wander",
|
||||
"defaultValue": 2.3,
|
||||
"type": "NUMBER",
|
||||
"displayName": "cobblemon.entity.variable.swim_circling_speed.name",
|
||||
"description": "cobblemon.entity.variable.swim_circling_speed.desc"
|
||||
},
|
||||
"minAngularVelocityDegrees": {
|
||||
"variableName": "min_swim_circling_angular_velocity",
|
||||
"category": "cobblemon.entity.variable.category.wander",
|
||||
"defaultValue": 0.0,
|
||||
"type": "NUMBER",
|
||||
"displayName": "cobblemon.entity.variable.min_swim_circling_angular_velocity.name",
|
||||
"description": "cobblemon.entity.variable.min_swim_circling_angular_velocity.desc"
|
||||
},
|
||||
"maxAngularVelocityDegrees": {
|
||||
"variableName": "max_swim_circling_angular_velocity",
|
||||
"category": "cobblemon.entity.variable.category.wander",
|
||||
"defaultValue": 1.0,
|
||||
"type": "NUMBER",
|
||||
"displayName": "cobblemon.entity.variable.max_swim_circling_angular_velocity.name",
|
||||
"description": "cobblemon.entity.variable.max_swim_circling_angular_velocity.desc"
|
||||
},
|
||||
"verticalSpeed": 0
|
||||
}
|
||||
]
|
||||
}
|
||||
}
|
||||
|
||||
@@ -17,6 +17,7 @@ import com.cobblemon.mod.common.client.CobblemonClient.reloadCodedAssets
|
||||
import com.cobblemon.mod.common.client.keybind.CobblemonKeyBinds
|
||||
import com.cobblemon.mod.common.client.pokedex.PokedexType
|
||||
import com.cobblemon.mod.common.client.render.atlas.CobblemonAtlases
|
||||
import com.cobblemon.mod.common.client.render.debug.SteerForceRenderer
|
||||
import com.cobblemon.mod.common.client.render.item.CobblemonModelPredicateRegistry
|
||||
import com.cobblemon.mod.common.item.PokedexItem
|
||||
import com.cobblemon.mod.common.particle.CobblemonParticles
|
||||
@@ -171,6 +172,24 @@ class CobblemonFabricClient: ClientModInitializer, CobblemonClientImplementation
|
||||
)
|
||||
}
|
||||
|
||||
WorldRenderEvents.LAST.register { context ->
|
||||
val poseStack = context.matrixStack()
|
||||
val multiBufferSource = context.consumers()
|
||||
val camera = context.camera()
|
||||
val partialTicks = context.tickCounter().getGameTimeDeltaPartialTick(true)
|
||||
|
||||
// Add a null check to ensure all required tools are present before rendering
|
||||
if (poseStack != null && multiBufferSource != null && camera != null) {
|
||||
SteerForceRenderer.render(
|
||||
poseStack,
|
||||
multiBufferSource,
|
||||
partialTicks,
|
||||
camera
|
||||
)
|
||||
}
|
||||
SteerForceRenderer.registerTickHandler()
|
||||
}
|
||||
|
||||
CobblemonModelPredicateRegistry.registerPredicates()
|
||||
}
|
||||
|
||||
|
||||
@@ -28,12 +28,14 @@ lambDynamicLights = "4.1.6+1.21.1"
|
||||
debugutils-fabric = "1.21.1-1.0.9-fabric"
|
||||
mod-menu = "11.0.3"
|
||||
c2me-fabric = "0.3.0+alpha.0.320+1.21.1"
|
||||
spark-fabric = "1.10.109-fabric"
|
||||
|
||||
# NeoForge
|
||||
neoforge = "21.1.182"
|
||||
neo-kotlin-for-forge = "5.10.0"
|
||||
debugutils-forge = "1.21.1-1.0.9-neoforge"
|
||||
c2me-neoforge = "0.3.0+alpha.0.73+1.21.1"
|
||||
spark-neoforge = "1.10.109-neoforge"
|
||||
|
||||
# Data Storage
|
||||
mongo = "4.10.2"
|
||||
|
||||
@@ -19,6 +19,7 @@ import com.cobblemon.mod.common.client.gui.config.CobblemonConfigScreen
|
||||
import com.cobblemon.mod.common.client.keybind.CobblemonKeyBinds
|
||||
import com.cobblemon.mod.common.client.pokedex.PokedexType
|
||||
import com.cobblemon.mod.common.client.render.atlas.CobblemonAtlases
|
||||
import com.cobblemon.mod.common.client.render.debug.SteerForceRenderer
|
||||
import com.cobblemon.mod.common.client.render.item.CobblemonModelPredicateRegistry
|
||||
import com.cobblemon.mod.common.client.render.shader.CobblemonShaders
|
||||
import com.cobblemon.mod.common.item.PokedexItem
|
||||
@@ -68,6 +69,7 @@ import net.neoforged.neoforge.client.event.RegisterParticleProvidersEvent
|
||||
import net.neoforged.neoforge.client.event.RegisterShadersEvent
|
||||
import net.neoforged.neoforge.client.event.RenderGuiEvent
|
||||
import net.neoforged.neoforge.client.event.RenderGuiLayerEvent
|
||||
import net.neoforged.neoforge.client.event.RenderLevelStageEvent
|
||||
import net.neoforged.neoforge.client.gui.IConfigScreenFactory
|
||||
import net.neoforged.neoforge.client.gui.VanillaGuiLayers
|
||||
import net.neoforged.neoforge.common.NeoForge
|
||||
@@ -102,6 +104,18 @@ object CobblemonNeoForgeClient : CobblemonClientImplementation {
|
||||
modContainer.registerExtensionPoint(IConfigScreenFactory::class.java, object : IConfigScreenFactory {
|
||||
override fun createScreen(modContainer: ModContainer, arg: Screen): Screen = CobblemonConfigScreen(arg)
|
||||
})
|
||||
|
||||
NeoForge.EVENT_BUS.addListener<RenderLevelStageEvent> { event ->
|
||||
if (event.stage == RenderLevelStageEvent.Stage.AFTER_PARTICLES) {
|
||||
SteerForceRenderer.render(
|
||||
event.poseStack,
|
||||
Minecraft.getInstance().renderBuffers().bufferSource(),
|
||||
event.partialTick.gameTimeDeltaTicks,
|
||||
event.camera
|
||||
)
|
||||
}
|
||||
}
|
||||
SteerForceRenderer.registerTickHandler()
|
||||
}
|
||||
|
||||
private fun onRegisterReloadListener(event: RegisterClientReloadListenersEvent) {
|
||||
|
||||
Reference in new issue
Block a user