/// <summary>
/// Adds a model to the appropriate list for its type; returns the model.
/// </summary>
public Model Add(Model model)
{
switch (model)
{
case Model.MapPiece m: MapPieces.Add(m); break;
case Model.Object m: Objects.Add(m); break;
case Model.Enemy m: Enemies.Add(m); break;
case Model.Item m: Items.Add(m); break;
case Model.Player m: Players.Add(m); break;
case Model.Collision m: Collisions.Add(m); break;
case Model.Navmesh m: Navmeshes.Add(m); break;
case Model.Other m: Others.Add(m); break;
default:
throw new ArgumentException($"Unrecognized type {model.GetType()}.", nameof(model));
}
return(model);
}
/// <summary>
/// Adds a part to the appropriate list for its type; returns the part.
/// </summary>
public Part Add(Part part)
{
switch (part)
{
case Part.MapPiece p: MapPieces.Add(p); break;
case Part.Object p: Objects.Add(p); break;
case Part.Enemy p: Enemies.Add(p); break;
case Part.Player p: Players.Add(p); break;
case Part.Collision p: Collisions.Add(p); break;
case Part.Protoboss p: Protobosses.Add(p); break;
case Part.Navmesh p: Navmeshes.Add(p); break;
case Part.DummyObject p: DummyObjects.Add(p); break;
case Part.DummyEnemy p: DummyEnemies.Add(p); break;
case Part.ConnectCollision p: ConnectCollisions.Add(p); break;
default:
throw new ArgumentException($"Unrecognized type {part.GetType()}.", nameof(part));
}
return(part);
}
public void Add(IMsbPart item)
{
switch (item)
{
case Part.MapPiece m:
MapPieces.Add(m);
break;
case Part.Object m:
Objects.Add(m);
break;
case Part.Collision m:
Collisions.Add(m);
break;
case Part.Navmesh m:
Navmeshes.Add(m);
break;
case Part.ConnectCollision m:
ConnectCollisions.Add(m);
break;
default:
throw new ArgumentException(
message: "Item is not recognized",
paramName: nameof(item));
}
}
internal override Model ReadEntry(BinaryReaderEx br)
{
ModelType type = br.GetEnum32 <ModelType>(br.Position + 8);
switch (type)
{
case ModelType.MapPiece:
return(MapPieces.EchoAdd(new Model.MapPiece(br)));
case ModelType.Object:
return(Objects.EchoAdd(new Model.Object(br)));
case ModelType.Enemy:
return(Enemies.EchoAdd(new Model.Enemy(br)));
case ModelType.Item:
return(Items.EchoAdd(new Model.Item(br)));
case ModelType.Player:
return(Players.EchoAdd(new Model.Player(br)));
case ModelType.Collision:
return(Collisions.EchoAdd(new Model.Collision(br)));
case ModelType.Navmesh:
return(Navmeshes.EchoAdd(new Model.Navmesh(br)));
case ModelType.Other:
return(Others.EchoAdd(new Model.Other(br)));
default:
throw new NotImplementedException($"Unimplemented model type: {type}");
}
}
/// <summary>
/// Adds an event to the appropriate list for its type; returns the event.
/// </summary>
public Event Add(Event evnt)
{
switch (evnt)
{
case Event.Light e: Lights.Add(e); break;
case Event.Sound e: Sounds.Add(e); break;
case Event.SFX e: SFX.Add(e); break;
case Event.Wind e: Wind.Add(e); break;
case Event.Treasure e: Treasures.Add(e); break;
case Event.Generator e: Generators.Add(e); break;
case Event.Message e: Messages.Add(e); break;
case Event.ObjAct e: ObjActs.Add(e); break;
case Event.SpawnPoint e: SpawnPoints.Add(e); break;
case Event.MapOffset e: MapOffsets.Add(e); break;
case Event.Navmesh e: Navmeshes.Add(e); break;
case Event.Environment e: Environments.Add(e); break;
case Event.PseudoMultiplayer e: PseudoMultiplayers.Add(e); break;
default:
throw new ArgumentException($"Unrecognized type {evnt.GetType()}.", nameof(evnt));
}
return(evnt);
}
internal override Part ReadEntry(BinaryReaderEx br)
{
PartType type = br.GetEnum16 <PartType>(br.Position + 8);
switch (type)
{
case PartType.MapPiece:
var mapPiece = new Part.MapPiece(br);
MapPieces.Add(mapPiece);
return(mapPiece);
case PartType.Object:
var obj = new Part.Object(br);
Objects.Add(obj);
return(obj);
case PartType.Collision:
var collision = new Part.Collision(br);
Collisions.Add(collision);
return(collision);
case PartType.Navmesh:
var navmesh = new Part.Navmesh(br);
Navmeshes.Add(navmesh);
return(navmesh);
case PartType.ConnectCollision:
var connectCollision = new Part.ConnectCollision(br);
ConnectCollisions.Add(connectCollision);
return(connectCollision);
default:
throw new NotImplementedException($"Unimplemented part type: {type}");
}
}
internal override Part ReadEntry(BinaryReaderEx br)
{
PartType type = br.GetEnum8 <PartType>(br.Position + br.VarintSize);
switch (type)
{
case PartType.MapPiece:
return(MapPieces.EchoAdd(new Part.MapPiece(br)));
case PartType.Object:
return(Objects.EchoAdd(new Part.Object(br)));
case PartType.Collision:
return(Collisions.EchoAdd(new Part.Collision(br)));
case PartType.Navmesh:
return(Navmeshes.EchoAdd(new Part.Navmesh(br)));
case PartType.ConnectCollision:
return(ConnectCollisions.EchoAdd(new Part.ConnectCollision(br)));
default:
throw new NotImplementedException($"Unimplemented part type: {type}");
}
}
internal override void Write(BinaryWriterEx bw)
{
var connectorPoints = new ConnectorPointSection();
var connectorConditions = new ConnectorConditionSection();
foreach (Connector connector in Connectors)
{
connector.GivePointsAndConds(connectorPoints, connectorConditions);
}
bw.BigEndian = false;
bw.WriteASCII("NVMA");
bw.WriteUInt32((uint)Version);
bw.ReserveUInt32("FileSize");
bw.WriteInt32(Version == NVAVersion.OldBloodborne ? 8 : 9);
Navmeshes.Write(bw, 0);
Entries1.Write(bw, 1);
Entries2.Write(bw, 2);
new Section3().Write(bw, 3);
Connectors.Write(bw, 4);
connectorPoints.Write(bw, 5);
connectorConditions.Write(bw, 6);
Entries7.Write(bw, 7);
if (Version != NVAVersion.OldBloodborne)
{
Entries8.Write(bw, 8);
}
bw.FillUInt32("FileSize", (uint)bw.Position);
}
internal override Part ReadEntry(BinaryReaderEx br)
{
PartType type = br.GetEnum32 <PartType>(br.Position + 4);
switch (type)
{
case PartType.MapPiece:
var mapPiece = new Part.MapPiece(br);
MapPieces.Add(mapPiece);
return(mapPiece);
case PartType.Object:
var obj = new Part.Object(br);
Objects.Add(obj);
return(obj);
case PartType.Enemy:
var enemy = new Part.Enemy(br);
Enemies.Add(enemy);
return(enemy);
case PartType.Player:
var player = new Part.Player(br);
Players.Add(player);
return(player);
case PartType.Collision:
var collision = new Part.Collision(br);
Collisions.Add(collision);
return(collision);
case PartType.Navmesh:
var navmesh = new Part.Navmesh(br);
Navmeshes.Add(navmesh);
return(navmesh);
case PartType.DummyObject:
var dummyObject = new Part.DummyObject(br);
DummyObjects.Add(dummyObject);
return(dummyObject);
case PartType.DummyEnemy:
var dummyEnemy = new Part.DummyEnemy(br);
DummyEnemies.Add(dummyEnemy);
return(dummyEnemy);
case PartType.ConnectCollision:
var connectCollision = new Part.ConnectCollision(br);
ConnectCollisions.Add(connectCollision);
return(connectCollision);
default:
throw new NotImplementedException($"Unimplemented part type: {type}");
}
}
internal override Event ReadEntry(BinaryReaderEx br)
{
EventType type = br.GetEnum32 <EventType>(br.Position + 8);
switch (type)
{
case EventType.Light:
return(Lights.EchoAdd(new Event.Light(br)));
case EventType.Sound:
return(Sounds.EchoAdd(new Event.Sound(br)));
case EventType.SFX:
return(SFX.EchoAdd(new Event.SFX(br)));
case EventType.Wind:
return(Wind.EchoAdd(new Event.Wind(br)));
case EventType.Treasure:
return(Treasures.EchoAdd(new Event.Treasure(br)));
case EventType.Generator:
return(Generators.EchoAdd(new Event.Generator(br)));
case EventType.Message:
return(Messages.EchoAdd(new Event.Message(br)));
case EventType.ObjAct:
return(ObjActs.EchoAdd(new Event.ObjAct(br)));
case EventType.SpawnPoint:
return(SpawnPoints.EchoAdd(new Event.SpawnPoint(br)));
case EventType.MapOffset:
return(MapOffsets.EchoAdd(new Event.MapOffset(br)));
case EventType.Navmesh:
return(Navmeshes.EchoAdd(new Event.Navmesh(br)));
case EventType.Environment:
return(Environments.EchoAdd(new Event.Environment(br)));
case EventType.PseudoMultiplayer:
return(PseudoMultiplayers.EchoAdd(new Event.PseudoMultiplayer(br)));
default:
throw new NotImplementedException($"Unsupported event type: {type}");
}
}
public override async Task <GetRandomPointResponse> GetRandomPoint(GetRandomPointRequest request, ServerCallContext context)
{
Navmesh mesh;
if (!Navmeshes.TryGetValue(request.Navmesh, out mesh))
{
Metrics.QPSByResult["NavmeshUnavailable"].Increment();
return(new GetRandomPointResponse());
}
var onDequeue = Metrics.Record("RandomPoint", request.Navmesh);
return(await Task.Factory.StartNew(() => {
lock (mesh) {
onDequeue();
var center = ToRecastFloats(request.Position.X, request.Position.Y, request.Position.Z + 8);
var cradius = request.Radius *CONVERSION_FACTOR;
var outVec = new float[3];
var defaultInclude = dtPolyFlags.ALL ^ dtPolyFlags.DISABLED;
var defaultExclude = (dtPolyFlags)0;
var filter = new[] { defaultInclude, defaultExclude };
var polyPickEx = new float[3] {
2.0f, 4.0f, 2.0f
};
var status = FindRandomPointAroundCircle(mesh.QueryPtr, center, cradius, polyPickEx, filter, outVec, () => (float)mesh.Random.NextDouble());
if ((status & dtStatus.DT_SUCCESS) == 0)
{
Metrics.QPSByResult["NoRandomPointFound"].Increment();
return new GetRandomPointResponse();
}
Metrics.QPSByResult["RandomPointFound"].Increment();
return new GetRandomPointResponse {
Point = new Vec3 {
X = outVec[0] * INV_FACTOR, Y = outVec[2] * INV_FACTOR, Z = outVec[1] * INV_FACTOR
}
};
}
}, TaskCreationOptions.LongRunning));
}
internal override Part ReadEntry(BinaryReaderEx br)
{
PartType type = br.GetEnum32 <PartType>(br.Position + 4);
switch (type)
{
case PartType.MapPiece:
return(MapPieces.EchoAdd(new Part.MapPiece(br)));
case PartType.Object:
return(Objects.EchoAdd(new Part.Object(br)));
case PartType.Enemy:
return(Enemies.EchoAdd(new Part.Enemy(br)));
case PartType.Player:
return(Players.EchoAdd(new Part.Player(br)));
case PartType.Collision:
return(Collisions.EchoAdd(new Part.Collision(br)));
case PartType.Protoboss:
return(Protobosses.EchoAdd(new Part.Protoboss(br)));
case PartType.Navmesh:
return(Navmeshes.EchoAdd(new Part.Navmesh(br)));
case PartType.DummyObject:
return(DummyObjects.EchoAdd(new Part.DummyObject(br)));
case PartType.DummyEnemy:
return(DummyEnemies.EchoAdd(new Part.DummyEnemy(br)));
case PartType.ConnectCollision:
return(ConnectCollisions.EchoAdd(new Part.ConnectCollision(br)));
default:
throw new NotImplementedException($"Unimplemented part type: {type}");
}
}
internal override Event ReadEntry(BinaryReaderEx br)
{
EventType type = br.GetEnum32 <EventType>(br.Position + 8);
switch (type)
{
case EventType.Light:
var light = new Event.Light(br);
Lights.Add(light);
return(light);
case EventType.Sound:
var sound = new Event.Sound(br);
Sounds.Add(sound);
return(sound);
case EventType.SFX:
var sfx = new Event.SFX(br);
SFXs.Add(sfx);
return(sfx);
case EventType.WindSFX:
var windSFX = new Event.WindSFX(br);
WindSFXs.Add(windSFX);
return(windSFX);
case EventType.Treasure:
var treasure = new Event.Treasure(br);
Treasures.Add(treasure);
return(treasure);
case EventType.Generator:
var generator = new Event.Generator(br);
Generators.Add(generator);
return(generator);
case EventType.Message:
var message = new Event.Message(br);
Messages.Add(message);
return(message);
case EventType.ObjAct:
var objAct = new Event.ObjAct(br);
ObjActs.Add(objAct);
return(objAct);
case EventType.SpawnPoint:
var spawnPoint = new Event.SpawnPoint(br);
SpawnPoints.Add(spawnPoint);
return(spawnPoint);
case EventType.MapOffset:
var mapOffset = new Event.MapOffset(br);
MapOffsets.Add(mapOffset);
return(mapOffset);
case EventType.Navmesh:
var navmesh = new Event.Navmesh(br);
Navmeshes.Add(navmesh);
return(navmesh);
case EventType.Environment:
var environment = new Event.Environment(br);
Environments.Add(environment);
return(environment);
case EventType.PseudoMultiplayer:
var pseudoMultiplayer = new Event.PseudoMultiplayer(br);
PseudoMultiplayers.Add(pseudoMultiplayer);
return(pseudoMultiplayer);
default:
throw new NotImplementedException($"Unsupported event type: {type}");
}
}
public override async Task <PathingResponse> GetPathStraight(PathingRequest request, ServerCallContext context)
{
// NOTE: Consider using GetPathStreamed instead
Navmesh mesh;
if (!Navmeshes.TryGetValue(request.Navmesh, out mesh))
{
Metrics.QPSByResult["NavmeshUnavailable"].Increment();
return(new PathingResponse {
ResultCode = PathingResult.NavmeshUnavailable
});
}
var onDequeue = Metrics.Record("Path", request.Navmesh);
return(await Task.Factory.StartNew(() => {
lock (mesh) {
onDequeue();
var startFloats = ToRecastFloats(request.StartingPoint.X, request.StartingPoint.Y, request.StartingPoint.Z + 8);
var endFloats = ToRecastFloats(request.DestinationPoint.X, request.DestinationPoint.Y,
request.DestinationPoint.Z + 8);
var numNodes = 0;
var buffer = new float[MAX_POLY * 3];
var flags = new dtPolyFlags[MAX_POLY];
var includeFilter = dtPolyFlags.ALL ^ dtPolyFlags.DISABLED;
var excludeFilter = (dtPolyFlags)0;
var filter = new[] { includeFilter, excludeFilter };
var polyExt = ToRecastFloats(64f, 64f, 256f);
var options = dtStraightPathOptions.DT_STRAIGHTPATH_ALL_CROSSINGS;
var status = PathStraight(mesh.QueryPtr, startFloats, endFloats, polyExt, filter, options, ref numNodes, buffer, flags);
if ((status & dtStatus.DT_SUCCESS) == 0)
{
Metrics.QPSByResult["NoPathFound"].Increment();
return new PathingResponse {
ResultCode = PathingResult.NoPathFound
};
}
var points = new PathPoint[numNodes];
var positions = Vector3ArrayFromRecastFloats(buffer, numNodes);
for (var i = 0; i < numNodes; i++)
{
points[i] = new PathPoint {
Flags = (uint)flags[i], Position = positions[i]
};
}
if ((status & dtStatus.DT_PARTIAL_RESULT) == 0)
{
Metrics.QPSByResult["PathFound"].Increment();
return new PathingResponse {
ResultCode = PathingResult.PathFound,
Path = { points }
};
}
Metrics.QPSByResult["PartialPathFound"].Increment();
return new PathingResponse {
ResultCode = PathingResult.PartialPathFound,
Path = { points }
};
}
}, TaskCreationOptions.LongRunning));
}
private unsafe PathingResponse GetPathForStreaming(PathingRequest request)
{
Navmesh mesh;
if (!Navmeshes.TryGetValue(request.Navmesh, out mesh))
{
Metrics.QPSByResult["NavmeshUnavailable"].Increment();
return(new PathingResponse()
{
SequenceID = request.SequenceID,
ResultCode = PathingResult.NavmeshUnavailable,
});
}
var onDequeue = Metrics.Record("PathStreamed", request.Navmesh);
lock (mesh)
{
onDequeue();
var startFloats = ToRecastFloats(request.StartingPoint.X, request.StartingPoint.Y, request.StartingPoint.Z + 8);
var endFloats = ToRecastFloats(request.DestinationPoint.X, request.DestinationPoint.Y,
request.DestinationPoint.Z + 8);
var numNodes = 0;
var buffer = new float[MAX_POLY * 3];
var flags = new dtPolyFlags[MAX_POLY];
var includeFilter = dtPolyFlags.ALL ^ dtPolyFlags.DISABLED;
var excludeFilter = (dtPolyFlags)0;
var filter = new[] { includeFilter, excludeFilter };
var polyExt = ToRecastFloats(64f, 64f, 256f);
var options = dtStraightPathOptions.DT_STRAIGHTPATH_ALL_CROSSINGS;
var status = PathStraight(mesh.QueryPtr, startFloats, endFloats, polyExt, filter, options, ref numNodes, buffer, flags);
if ((status & dtStatus.DT_SUCCESS) == 0)
{
Metrics.QPSByResult["NoPathFound"].Increment();
return(new PathingResponse()
{
SequenceID = request.SequenceID,
ResultCode = PathingResult.NoPathFound,
});
}
var code = PathingResult.PathFound;
if ((status & dtStatus.DT_PARTIAL_RESULT) != 0)
{
Metrics.QPSByResult["PartialPathFound"].Increment();
code = PathingResult.PartialPathFound;
}
else
{
Metrics.QPSByResult["PathFound"].Increment();
}
// Create nodes
var positions = Vector3ArrayFromRecastFloats(buffer, numNodes);
var oneStructSize = Marshal.SizeOf <PathPointStruct>();
var oneStruct = Marshal.AllocHGlobal(oneStructSize);
byte[] buf = new byte[oneStructSize * numNodes];
for (int i = 0; i < numNodes; i++)
{
var vec = positions[i];
var pp = new PathPointStruct {
Flags = flags[i],
X = (float)vec.X,
Y = (float)vec.Y,
Z = (float)vec.Z,
};
Marshal.StructureToPtr(pp, oneStruct, false);
Marshal.Copy(oneStruct, buf, i * oneStructSize, oneStructSize);
}
return(new PathingResponse()
{
SequenceID = request.SequenceID,
PathNodes = (uint)numNodes,
ResultCode = code,
SerializedNodes = ByteString.CopyFrom(buf, 0, buf.Length)
});
}
}
public void Add(IMsbEvent item)
{
switch (item)
{
case Event.Light e:
Lights.Add(e);
break;
case Event.Sound e:
Sounds.Add(e);
break;
case Event.SFX e:
SFXs.Add(e);
break;
case Event.WindSFX e:
WindSFXs.Add(e);
break;
case Event.Treasure e:
Treasures.Add(e);
break;
case Event.Generator e:
Generators.Add(e);
break;
case Event.Message e:
Messages.Add(e);
break;
case Event.ObjAct e:
ObjActs.Add(e);
break;
case Event.SpawnPoint e:
SpawnPoints.Add(e);
break;
case Event.MapOffset e:
MapOffsets.Add(e);
break;
case Event.Navmesh e:
Navmeshes.Add(e);
break;
case Event.Environment e:
Environments.Add(e);
break;
case Event.PseudoMultiplayer e:
PseudoMultiplayers.Add(e);
break;
default:
throw new ArgumentException(
message: "Item is not recognized",
paramName: nameof(item));
}
}
