Updating method using packet session write

Author: RedStoneCraftGG

go.mod

@@ -2,21 +2,23 @@ module github.com/redstonecraftgg/df-noteblockplayer
 
 go 1.24.5
 
-require github.com/df-mc/dragonfly v0.10.8
+require (
+	github.com/df-mc/dragonfly v0.10.8
+	github.com/go-gl/mathgl v1.2.0
+	github.com/sandertv/gophertunnel v1.50.0
+)
 
 require (
 	github.com/brentp/intintmap v0.0.0-20190211203843-30dc0ade9af9 // indirect
 	github.com/cespare/xxhash/v2 v2.3.0 // indirect
 	github.com/df-mc/goleveldb v1.1.9 // indirect
 	github.com/df-mc/jsonc v1.0.5 // indirect
 	github.com/df-mc/worldupgrader v1.0.20 // indirect
-	github.com/go-gl/mathgl v1.2.0 // indirect
 	github.com/go-jose/go-jose/v4 v4.1.0 // indirect
 	github.com/golang/snappy v0.0.4 // indirect
 	github.com/google/uuid v1.6.0 // indirect
 	github.com/klauspost/compress v1.17.11 // indirect
 	github.com/sandertv/go-raknet v1.14.3-0.20250305181847-6af3e95113d6 // indirect
-	github.com/sandertv/gophertunnel v1.50.0 // indirect
 	github.com/segmentio/fasthash v1.0.3 // indirect
 	golang.org/x/exp v0.0.0-20250103183323-7d7fa50e5329 // indirect
 	golang.org/x/net v0.35.0 // indirect

noteblockplayer.go

@@ -194,45 +194,86 @@ func playSong(eh *world.EntityHandle, song *Song) {
 		}
 		if notes, found := notesPerTick[tick]; found {
 			for _, note := range notes {
-				inst := sound.Piano()
-				if note.Instrument >= 0 && note.Instrument < len(instrumentSounds) {
-					inst = instrumentSounds[note.Instrument]
-				}
-				pitch := pitchKey(note.Key)
-				// For further enhancement: use velocity, custom pitch, and panning as needed.
-				/* fmt.Printf(
-					"Tick=%d Layer=%d Instr=%d Key=%d Pitch=%d Vel=%d Pan=%d\n",
-					note.Tick, note.Layer, note.Instrument, note.Key, pitch, note.Velocity, note.Panning,
-				) */
-				playSoundSelf(eh, sound.Note{
-					Instrument: inst,
-					Pitch:      pitch,
+				_ = eh.ExecWorld(func(tx *world.Tx, ent world.Entity) {
+					pp, ok := ent.(*player.Player)
+					if !ok {
+						return
+					}
+					pos := pp.Position()
+					instrument := "note.harp"
+					if note.Instrument >= 0 && note.Instrument < len(instrumentSounds) {
+						switch note.Instrument {
+						case 1:
+							instrument = "note.basedrum"
+						case 2:
+							instrument = "note.snare"
+						case 3:
+							instrument = "note.hat"
+						case 4:
+							instrument = "note.bass"
+						case 5:
+							instrument = "note.flute"
+						case 6:
+							instrument = "note.bell"
+						case 7:
+							instrument = "note.guitar"
+						case 8:
+							instrument = "note.chime"
+						case 9:
+							instrument = "note.xylophone"
+						case 10:
+							instrument = "note.iron_xylophone"
+						case 11:
+							instrument = "note.cow_bell"
+						case 12:
+							instrument = "note.didgeridoo"
+						case 13:
+							instrument = "note.bit"
+						case 14:
+							instrument = "note.banjo"
+						case 15:
+							instrument = "note.pling"
+						}
+					}
+					pitch := Floatkey(note.Key)
+					volume := FloatVel(note.Velocity)
+					PacketPlaySound(pp, instrument, pitch, volume, pos)
 				})
 			}
 		}
 	}
 }
 
-// playSoundSelf plays a sound only for the provided player entity (self).
-func playSoundSelf(eh *world.EntityHandle, snd world.Sound) {
-	_ = eh.ExecWorld(func(tx *world.Tx, ent world.Entity) {
-		pp, ok := ent.(*player.Player)
-		if !ok {
-			return
-		}
-		pos := pp.Position()
-		tx.PlaySound(pos, snd)
-	})
-}
-
-// pitchKey calculates the Bedrock note pitch index based on the NBS note key.
+// PitchKey calculates the Bedrock note pitch index based on the NBS note key.
 // Bedrock's base is 33 (F#3).
-func pitchKey(key int) int {
+func PitchKey(key int) int {
 	base := 33 // F#3 is key 33 in Bedrock
 	return key - base
 }
 
-// Pow is a helper to call math.Pow.
+// Bedrock "note" starts at key 33 (F#3). Each +12 is one octave (double freq/float).
+//
+// F#3 = 0.5, F#4 = 1.0, F#5 = 2.0, etc.
+//
+// So, the formulat is: 0.5 * 2^((key-33)/12)
+func Floatkey(key int) float32 {
+	baseKey := 33
+	return float32(0.5 * math.Pow(2, float64(key-baseKey)/12))
+}
+
+// FloatVel converts NBS/JSON note velocity (0-100) to Bedrock/Dragonfly volume [0.0, 1.0].
+// Values below or equal 0 are muted; above 100 are clamped to 1.0
+func FloatVel(val int) float32 {
+	if val <= 0 {
+		return 0
+	}
+	if val >= 100 {
+		return 1.0
+	}
+	return float32(val) / 100.0
+}
+
+// Pow is a helper function alias for math.Pow (for convenience).
 func Pow(base, exp float64) float64 {
 	return math.Pow(base, exp)
 }

packetsession.go

@@ -0,0 +1,64 @@
+package noteblockplayer
+
+import (
+	"reflect"
+	"unsafe"
+
+	"github.com/df-mc/dragonfly/server/player"
+	"github.com/go-gl/mathgl/mgl64"
+	"github.com/sandertv/gophertunnel/minecraft/protocol/packet"
+)
+
+// PacketPlaySound sends a PlaySound packet directly to the player's session connection.
+//
+// This function takes a player pointer (p), the sound name (name), float32 pitch and volume,
+// and a 3D position (pos, mgl64.Vec3). It first converts the position to [3]float32 as required
+// by the network packet.
+//
+// Then, using Go reflection and pointer-unsafe tricks, it accesses the unexported player session
+// field "s" and attempts to invoke the "WritePacket" method on it. If not directly available, it
+// tries to extract the connection object (field "conn") and invoke "WritePacket" on that.
+//
+// Ultimately, this method delivers the PlaySound packet to the player, which makes the sound
+// play at the specified position with the given pitch and volume from the server side.
+// This bypasses higher level APIs and directly calls the underlying session, which is
+// useful for custom, low-level sound triggers in plugins or game logic.
+func PacketPlaySound(p *player.Player, name string, pitch, volume float32, pos mgl64.Vec3) {
+	mgl32Pos := [3]float32{float32(pos[0]), float32(pos[1]), float32(pos[2])}
+
+	val := reflect.ValueOf(p).Elem().FieldByName("s")
+	if !val.IsValid() {
+		return
+	}
+
+	sessionPtr := reflect.NewAt(val.Type(), unsafe.Pointer(val.UnsafeAddr())).Elem()
+
+	method := sessionPtr.MethodByName("WritePacket")
+	if method.IsValid() {
+		method.Call([]reflect.Value{
+			reflect.ValueOf(&packet.PlaySound{
+				SoundName: name,
+				Volume:    volume, // float32
+				Pitch:     pitch,  // float32
+				Position:  mgl32Pos,
+			}),
+		})
+		return
+	}
+
+	connField := sessionPtr.Elem().FieldByName("conn")
+	if connField.IsValid() {
+		conn := reflect.NewAt(connField.Type(), unsafe.Pointer(connField.UnsafeAddr())).Elem()
+		writeMethod := conn.MethodByName("WritePacket")
+		if writeMethod.IsValid() {
+			writeMethod.Call([]reflect.Value{
+				reflect.ValueOf(&packet.PlaySound{
+					SoundName: name,
+					Volume:    volume, // float32
+					Pitch:     pitch,  // float32
+					Position:  mgl32Pos,
+				}),
+			})
+		}
+	}
+}