AstralTransRocketries/Cubyz
1
0
Fork 0
mirror of https://github.com/PixelGuys/Cubyz.git synced 2025-08-03 11:17:05 -04:00
Code Issues Packages Projects Releases Wiki Activity

Refactor itemdrop.zig to use BinaryReader (#1189)

Browse Source 
* Refactor readPosition to use BinaryReader

* Refactor getPositionAndVelocityData to use BinaryWriter

* Update src/itemdrop.zig
This commit is contained in:
Krzysztof Wiśniewski 2025-03-11 22:15:23 +01:00 committed by GitHub
parent 39fe3bd1a7
commit 4d7905ce0f
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
3 changed files with 22 additions and 24 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
src/itemdrop.zig
View File

@ -20,6 +20,8 @@ const Mat4f = vec.Mat4f;
const Vec3d = vec.Vec3d; const Vec3d = vec.Vec3d;
const Vec3f = vec.Vec3f; const Vec3f = vec.Vec3f;
const Vec3i = vec.Vec3i; const Vec3i = vec.Vec3i;
const BinaryReader = main.utils.BinaryReader;
const BinaryWriter = main.utils.BinaryWriter;
const NeverFailingAllocator = main.heap.NeverFailingAllocator; const NeverFailingAllocator = main.heap.NeverFailingAllocator;
const ItemDrop = struct { // MARK: ItemDrop const ItemDrop = struct { // MARK: ItemDrop
@ -116,19 +118,17 @@ pub const ItemDropManager = struct { // MARK: ItemDropManager
} }
pub fn getPositionAndVelocityData(self: *ItemDropManager, allocator: NeverFailingAllocator) []u8 { pub fn getPositionAndVelocityData(self: *ItemDropManager, allocator: NeverFailingAllocator) []u8 {
const _data = allocator.alloc(u8, self.size*50); var writer = utils.BinaryWriter.initCapacity(allocator, main.network.networkEndian, self.size*50);
var data = _data;
for(self.indices[0..self.size]) |i| { for(self.indices[0..self.size]) |i| {
std.mem.writeInt(u16, data[0..2], i, .big); writer.writeInt(u16, i);
std.mem.writeInt(u64, data[2..10], @bitCast(self.list.items(.pos)[i][0]), .big); writer.writeFloat(f64, self.list.items(.pos)[i][0]);
std.mem.writeInt(u64, data[10..18], @bitCast(self.list.items(.pos)[i][1]), .big); writer.writeFloat(f64, self.list.items(.pos)[i][1]);
std.mem.writeInt(u64, data[18..26], @bitCast(self.list.items(.pos)[i][2]), .big); writer.writeFloat(f64, self.list.items(.pos)[i][2]);
std.mem.writeInt(u64, data[26..34], @bitCast(self.list.items(.vel)[i][0]), .big); writer.writeFloat(f64, self.list.items(.vel)[i][0]);
std.mem.writeInt(u64, data[34..42], @bitCast(self.list.items(.vel)[i][1]), .big); writer.writeFloat(f64, self.list.items(.vel)[i][1]);
std.mem.writeInt(u64, data[42..50], @bitCast(self.list.items(.vel)[i][2]), .big); writer.writeFloat(f64, self.list.items(.vel)[i][2]);
data = data[50..];
} }
return _data; return writer.data.toOwnedSlice();
} }
pub fn getInitialList(self: *ItemDropManager, allocator: NeverFailingAllocator) ZonElement { pub fn getInitialList(self: *ItemDropManager, allocator: NeverFailingAllocator) ZonElement {
@ -463,20 +463,18 @@ pub const ClientItemDropManager = struct { // MARK: ClientItemDropManager
self.super.deinit(); self.super.deinit();
} }
pub fn readPosition(self: *ClientItemDropManager, _data: []const u8, time: i16) void { pub fn readPosition(self: *ClientItemDropManager, reader: *BinaryReader, time: i16) !void {
var data = _data;
self.timeDifference.addDataPoint(time); self.timeDifference.addDataPoint(time);
var pos: [ItemDropManager.maxCapacity]Vec3d = undefined; var pos: [ItemDropManager.maxCapacity]Vec3d = undefined;
var vel: [ItemDropManager.maxCapacity]Vec3d = undefined; var vel: [ItemDropManager.maxCapacity]Vec3d = undefined;
while(data.len != 0) { while(reader.remaining.len != 0) {
const i = std.mem.readInt(u16, data[0..2], .big); const i = try reader.readInt(u16);
pos[i][0] = @bitCast(std.mem.readInt(u64, data[2..10], .big)); pos[i][0] = try reader.readFloat(f64);
pos[i][1] = @bitCast(std.mem.readInt(u64, data[10..18], .big)); pos[i][1] = try reader.readFloat(f64);
pos[i][2] = @bitCast(std.mem.readInt(u64, data[18..26], .big)); pos[i][2] = try reader.readFloat(f64);
vel[i][0] = @bitCast(std.mem.readInt(u64, data[26..34], .big)); vel[i][0] = try reader.readFloat(f64);
vel[i][1] = @bitCast(std.mem.readInt(u64, data[34..42], .big)); vel[i][1] = try reader.readFloat(f64);
vel[i][2] = @bitCast(std.mem.readInt(u64, data[42..50], .big)); vel[i][2] = try reader.readFloat(f64);
data = data[50..];
} }
mutex.lock(); mutex.lock();
defer mutex.unlock(); defer mutex.unlock();

2
src/network.zig
View File

@ -883,7 +883,7 @@ pub const Protocols = struct {
if(typ == type_entity) { if(typ == type_entity) {
try main.entity.ClientEntityManager.serverUpdate(time, reader); try main.entity.ClientEntityManager.serverUpdate(time, reader);
} else if(typ == type_item) { } else if(typ == type_item) {
world.itemDrops.readPosition(reader.remaining, time); try world.itemDrops.readPosition(reader, time);
} }
} }
} }

2
src/utils.zig
View File

@ -1469,7 +1469,7 @@ pub const BinaryWriter = struct {
std.mem.writeInt(T, self.data.addMany(bufSize)[0..bufSize], value, self.endian); std.mem.writeInt(T, self.data.addMany(bufSize)[0..bufSize], value, self.endian);
} }
pub fn writeFloat(self: *BinaryWriter, T: type, value: T) T { pub fn writeFloat(self: *BinaryWriter, T: type, value: T) void {
const IntT = std.meta.Int(.unsigned, @typeInfo(T).float.bits); const IntT = std.meta.Int(.unsigned, @typeInfo(T).float.bits);
self.writeInt(IntT, @bitCast(value)); self.writeInt(IntT, @bitCast(value));
} }