internal static SavedD20ActionSequence[] SaveSequences(List <ActionSequence> sequences)
{
var result = new SavedD20ActionSequence[sequences.Count];
for (var i = 0; i < result.Length; i++)
{
var sequence = sequences[i];
result[i] = new SavedD20ActionSequence
{
Actions = sequence.d20ActArray.Select(SaveAction).ToArray(),
IsPerforming = sequence.IsPerforming,
IsInterrupted = sequence.IsInterrupted,
CurrentActionIndex = sequence.d20aCurIdx,
TurnStatus = SaveTurnStatus(sequence.tbStatus),
PerformerLocation = sequence.performerLoc,
IgnoreLineOfSight = sequence.ignoreLos,
Spell = ActiveSpellSaver.SaveActiveSpell(sequence.spellPktBody, false),
Performer = sequence.performer?.id ?? ObjectId.CreateNull(),
PreviousSequenceIndex = sequence.prevSeq != null?sequences.IndexOf(sequence.prevSeq) : -1,
InterruptedSequenceIndex = sequence.interruptSeq != null?sequences.IndexOf(sequence.interruptSeq) : -1,
};
}
return(result);
}
public static SavedActiveSpell SaveActiveSpell(SpellPacketBody spellPacket, bool isActive)
{
var result = new SavedActiveSpell
{
Id = spellPacket.spellId,
IsActive = isActive,
SpellEnum = spellPacket.spellEnum,
SpellEnumOriginal = spellPacket.spellEnumOriginal,
AnimFlags = spellPacket.animFlags,
CasterId = spellPacket.caster?.id ?? ObjectId.CreateNull(),
CasterPartSysHash = GetPartSysNameHash(spellPacket.casterPartSys),
ClassCode = spellPacket.spellClass,
SpellLevel = spellPacket.spellKnownSlotLevel,
CasterLevel = spellPacket.casterLevel,
DC = spellPacket.dc,
AoEObjectId = spellPacket.aoeObj?.id ?? ObjectId.CreateNull(),
SpellObjects = spellPacket.spellObjs
.Select(spellObj => (spellObj.obj.id, GetPartSysNameHash(spellObj.partSys)))
.ToList(),
Targets = spellPacket.Targets
.Select(target => (target.Object.id, GetPartSysNameHash(target.ParticleSystem)))
.ToList(),
InitialTargets = spellPacket.InitialTargets.Select(obj => obj.id).ToHashSet(),
Projectiles = spellPacket.projectiles.Select(p => p.id).ToList(),
AoECenter = spellPacket.aoeCenter,
AoECenterZ = spellPacket.aoeCenterZ,
Duration = spellPacket.duration,
DurationRemaining = spellPacket.durationRemaining,
SpellRange = spellPacket.spellRange,
SavingThrowResult = spellPacket.savingThrowResult,
MetaMagic = spellPacket.metaMagicData
};
return(result);
}
public static void WriteEntries(BinaryWriter writer, List <LogbookCombatEntry> entries)
{
Trace.Assert(entries.Count <= 5);
for (var i = 0; i < 5; i++)
{
if (i < entries.Count)
{
entries[i].Write(writer);
}
else
{
writer.WriteObjectId(ObjectId.CreateNull());
writer.WriteInt32(0);
writer.WriteInt32(0);
}
}
}
internal static SavedD20Action SaveAction(D20Action action)
{
return(new SavedD20Action
{
Type = action.d20ActType,
Data = action.data1,
Flags = action.d20Caf,
TargetLocation = action.destLoc,
DistanceTraveled = action.distTraversed,
RadialMenuArg = action.radialMenuActualArg,
RollHistoryId0 = action.rollHistId0,
RollHistoryId1 = action.rollHistId1,
RollHistoryId2 = action.rollHistId2,
SpellData = action.d20SpellData,
SpellId = action.spellId,
AnimActionId = action.animID,
Performer = action.d20APerformer?.id ?? ObjectId.CreateNull(),
Target = action.d20ATarget?.id ?? ObjectId.CreateNull(),
});
}
public void Save(BinaryWriter writer)
{
// 32 object ids + count for 10 groups
for (var i = 0; i < 10; i++)
{
if (SavedGroups.TryGetValue(i, out var savedGroup))
{
writer.WriteInt32(savedGroup.Length);
}
else
{
writer.WriteInt32(0);
}
}
for (var i = 0; i < 10; i++)
{
if (SavedGroups.TryGetValue(i, out var savedGroup))
{
for (var j = 0; j < 32; j++)
{
if (j < savedGroup.Length)
{
writer.WriteObjectId(savedGroup[j]);
}
else
{
writer.WriteObjectId(ObjectId.CreateNull());
}
}
}
else
{
for (var j = 0; j < 32; j++)
{
writer.WriteObjectId(ObjectId.CreateNull());
}
}
}
}
/// <summary>
/// Reads a ToEE object id from the reader.
/// </summary>
/// <param name="reader"></param>
/// <returns></returns>
public static ObjectId ReadObjectId(this BinaryReader reader)
{
Span <byte> buffer = stackalloc byte[24];
if (reader.Read(buffer) != buffer.Length)
{
throw new Exception("Failed to read 24-byte ObjectId");
}
var type = BitConverter.ToUInt16(buffer.Slice(0, sizeof(ushort)));
var payload = buffer.Slice(8); // ObjectId seems to use 8-byte packed
switch (type)
{
case 0:
return(ObjectId.CreateNull());
case 1:
var protoId = BitConverter.ToUInt16(payload.Slice(0, sizeof(ushort)));
return(ObjectId.CreatePrototype(protoId));
case 2:
var guid = MemoryMarshal.Read <Guid>(payload);
return(ObjectId.CreatePermanent(guid));
case 3:
var positionalId = MemoryMarshal.Read <PositionalId>(payload);
return(ObjectId.CreatePositional(positionalId));
case 0xFFFE:
throw new Exception("Cannot load 'handle' ObjectIDs because the pointers are stale!");
case 0xFFFF:
return(ObjectId.CreateBlocked());
default:
throw new Exception("Unknown ObjectId type: " + type);
}
}
