public void Read(RakNet.BitStream stream, RakNet.Packet packet, Client client)
{
int plID = 0;
stream.Read(out plID);
if (plID == 0 || !sWorld.VobDict.ContainsKey(plID))
{
throw new Exception("Vob not found!");
}
Vob vob = sWorld.VobDict[plID];
if (!(vob is NPCProto))
{
throw new Exception("Vob is not an NPC!");
}
if (vob.Address == 0)
{
return;
}
Process process = Process.ThisProcess();
oCNpc npc = new oCNpc(process, vob.Address);
zVec3 pos = npc.GetPosition();
npc.ResetPos(pos);
pos.Dispose();
}
public void SetScale(Vec3f scale)
{
using (zVec3 vec = scale.CreateGVec())
{
thisVob.SetModelScale(vec);
}
}
public void SetLookAt(zVec3 lookAt)
{
zVec3 pos = GetPosition();
float[] dir = new float[] { lookAt.X - pos.X, lookAt.Y - pos.Y, lookAt.Z - pos.Z };
pos.Dispose();
float revScalar = (float)Math.Sqrt(dir[0] * dir[0] + dir[1] * dir[1] + dir[2] * dir[2]);
dir[0] /= revScalar; dir[1] /= revScalar; dir[2] /= revScalar;
float[] upVector = new float[] { TrafoObjToWorld.get(1), TrafoObjToWorld.get(5), TrafoObjToWorld.get(9) };
float[] rightVector = new float[3];
rightVector[0] = dir[1] * upVector[2] - dir[2] * upVector[1];
rightVector[1] = dir[2] * upVector[0] - dir[0] * upVector[2];
rightVector[2] = dir[0] * upVector[1] - dir[1] * upVector[0];
TrafoObjToWorld.set(0, -1 * rightVector[0]);
TrafoObjToWorld.set(4, -1 * rightVector[1]);
TrafoObjToWorld.set(8, -1 * rightVector[2]);
TrafoObjToWorld.set(2, dir[0]); TrafoObjToWorld.set(6, dir[1]); TrafoObjToWorld.set(10, dir[2]);
}
partial void pDespawn()
{
// check the level for hits
//Vec3f currentPos = this.GetPosition();
//Vec3f direction = (this.Destination - currentPos).Normalise();
Vec3f startPos = this.BaseInst.StartPosition; // currentPos + direction * -100;
Vec3f ray = (Destination - startPos).Normalise() * (Destination.GetDistance(startPos) + 100f); //direction * 200;
using (zVec3 zStart = startPos.CreateGVec())
using (zVec3 zRay = ray.CreateGVec())
{
var gWorld = GothicGlobals.Game.GetWorld();
const zCWorld.zTraceRay parm = zCWorld.zTraceRay.Ignore_Alpha | zCWorld.zTraceRay.Test_Water | zCWorld.zTraceRay.Return_POLY | zCWorld.zTraceRay.Ignore_NPC | zCWorld.zTraceRay.Ignore_Projectiles | zCWorld.zTraceRay.Ignore_Vob_No_Collision;
if (gWorld.TraceRayNearestHit(zStart, zRay, parm))
{
var poly = gWorld.Raytrace_FoundPoly;
SoundDefinition sfx;
if (poly.Address == 0)
{
sfx = sfx_wo_wo; // wood
}
else
{
switch (poly.Material.MatGroup)
{
default:
case 0: // undef
case 3: // wood
sfx = sfx_wo_wo;
break;
case 1: // metal
sfx = sfx_wo_me;
break;
case 2: // stone
sfx = sfx_wo_st;
break;
case 4: // earth
sfx = sfx_wo_ea;
break;
case 5: // water
sfx = sfx_wo_wa;
break;
case 6: // snow
sfx = sfx_wo_sa;
break;
}
}
SoundHandler.PlaySound3D(sfx, Destination);
}
}
}
public static oCMsgMovement Create(SubTypes type, zVec3 vec)
{
int address = Process.CDECLCALL <IntArg>(0x764680); //_CreateInstance()
//Konstruktor...
Process.THISCALL <NullReturnCall>(address, 0x765A30, (IntArg)(int)type, vec);
return(new oCMsgMovement(address));
}
public zVec3 GetPosition()
{
Matrix4 traf = this.TrafoObjToWorld;
zVec3 pos = zVec3.Create(Process);
pos.X = Process.ReadFloat(traf.Address + 3 * 4);
pos.Y = Process.ReadFloat(traf.Address + 7 * 4);
pos.Z = Process.ReadFloat(traf.Address + 11 * 4);
return(pos);
}
public void Enable(float x, float y, float z)
{
zVec3 vec = zVec3.Create(Process);
vec.X = x;
vec.Y = y;
vec.Z = z;
Enable(vec);
vec.Dispose();
}
public void Project(zVec3 pos, out float x, out float y)
{
int xAddr = Process.Alloc(8).ToInt32();
int yAddr = xAddr + 4;
Process.THISCALL <NullReturnCall>(Address, 0x530030, pos, (IntArg)xAddr, (IntArg)yAddr);
x = Process.ReadFloat(xAddr);
y = Process.ReadFloat(yAddr);
Process.Free(new IntPtr(xAddr), 8);
}
public void Project(float x, float y, float z, out int oX, out int oY)
{
zVec3 in1 = zVec3.Create(Process);
in1.X = x;
in1.Y = y;
in1.Z = z;
Project(in1, out oX, out oY);
in1.Dispose();
}
public void SetPositionWorld(float[] pos)
{
zVec3 p = zVec3.Create(Process);
p.X = pos[0];
p.Y = pos[1];
p.Z = pos[2];
SetPositionWorld(p);
p.Dispose();
}
static bool CanSee(Vec3f start, Vec3f end, BaseVobInst target)
{
using (zVec3 zStart = start.CreateGVec())
using (zVec3 zDir = (end - start).CreateGVec())
{
var zWorld = GothicGlobals.Game.GetWorld();
if (zWorld.TraceRayFirstHit(zStart, zDir, zCWorld.zTraceRay.Ignore_Alpha | zCWorld.zTraceRay.Ignore_NPC | zCWorld.zTraceRay.Ignore_Vob_No_Collision))
{
return(zWorld.Raytrace_FoundVob.Address == target.BaseInst.gVob.Address);
}
}
return(true);
}
public void Project(zVec3 in1, out float oX, out float oY)
{
IntPtr out1 = Process.Alloc(4);
IntPtr out2 = Process.Alloc(4);
Process.THISCALL <NullReturnCall>((uint)Address, (uint)FuncOffsets.Project_Float, new CallValue[] { in1, new IntArg(out1.ToInt32()), new IntArg(out2.ToInt32()) });
oX = Process.ReadFloat(out1.ToInt32());
oY = Process.ReadFloat(out2.ToInt32());
Process.Free(out1, 4);
Process.Free(out2, 4);
}
public void SetModelScale(float[] scale)
{
if (scale.Length != 3)
{
return;
}
using (zVec3 vec = zVec3.Create())
{
vec.X = scale[0];
vec.Y = scale[1];
vec.Z = scale[2];
SetModelScale(vec);
}
}
public void setScale(Vec3f scale)
{
this.Scale = scale;
if (this.Address != 0)
{
Process process = Process.ThisProcess();
oCNpc npc = new oCNpc(process, this.Address);
zVec3 v = zVec3.Create(process);
v.X = scale.X;
v.Y = scale.Y;
v.Z = scale.Z;
npc.SetModelScale(v);
v.Dispose();
}
}
public override void Despawn()
{
if (!IsSpawned || this.Address == 0)
{
return;
}
Process process = Process.ThisProcess();
oCNpc npc = new oCNpc(process, this.Address);
using (zVec3 vec = npc.GetPosition())
{
Position = (Vec3f)(new float[] { vec.X, vec.Y, vec.Z });
}
npc.HP = 0;
npc.SetPosition(-1000, -100000, -100000);
int WeaponMode = weaponMode;
setWeaponMode(0);
weaponMode = WeaponMode;
oCGame.Game(process).World.DisableVob(npc);
oCGame.Game(process).GetSpawnManager().DeleteNPC(npc);
//oCGame.Game(process).GetSpawnManager().DeleteNPC(npc);//Bei verwandlung wird bedmempointer aufgerufen :/
//new DespawnTimer(this.Address);
this.Address = 0;
sWorld.SpawnedVobDict.Remove(npc.Address);
foreach (Item it in itemList)
{
sWorld.SpawnedVobDict.Remove(it.Address);
it.Address = 0;
}
}
public void Turn(zVec3 pos)
{
Process.THISCALL <NullReturnCall>((uint)Address, (uint)FuncOffsets.Turn, new CallValue[] { pos });
}
public void SetModelScale(zVec3 val)
{
Process.THISCALL <NullReturnCall>((uint)Address, (uint)FuncOffsets.SetModelScale, new CallValue[] { val });
}
public void SetGVec(zVec3 zVec)
{
zVec.X = this.X;
zVec.Y = this.Y;
zVec.Z = this.Z;
}
public void SetPosition(zVec3 position)
{
TrafoObjToWorld.set(3, position.X);
TrafoObjToWorld.set(7, position.Y);
TrafoObjToWorld.set(11, position.Z);
}
/// <summary>
/// Spawnt den NPC
/// </summary>
/// <param name="vec"></param>
public void Enable(zVec3 vec)
{
Process.THISCALL <NullReturnCall>((uint)Address, (uint)FuncOffsets.Enable, new CallValue[] { vec });
}
public bool DetectClimbUpLedge(zVec3 resultPos, bool arg)
{
return(Process.THISCALL <BoolArg>(Address, 0x50FD90, resultPos, (BoolArg)arg));
}
public void SetModelScale(zVec3 scale)
{
Process.THISCALL <NullReturnCall>(Address, FuncAddresses.SetModelScale, scale);
}
public void StartCastEffect(zCVob vob, zVec3 pos)
{
Process.THISCALL <NullReturnCall>((uint)Address, (uint)FuncOffsets.StartCastEffect, new CallValue[] { vob, pos });
}
public void Init(zCVob self, zCVob owner, zVec3 start, float angle, float force, zMat4 trafo)
{
Process.THISCALL <NullReturnCall>(Address, 0x69F540, self, owner, start, (FloatArg)angle, (FloatArg)force, trafo);
}
public int GetFreePosition(oCNpc npc, zVec3 vec)
{
return(Process.THISCALL <IntArg>(Address, 0x71DF50, npc, vec));
}
static void Update()
{
NPCInst hero = currentPlayer;
if (hero == null)
{
Deactivate();
return;
}
float maxYaw = Angles.Deg2Rad(60);
bool fightMode = hero.IsInFightMode;
ItemInst wep = hero.GetDrawnWeapon();
float maxRange = (fightMode && wep != null && wep.IsWepRanged) ? 3000 : 400;
Vec3f heroPos = hero.GetPosition();
Angles heroAng = hero.GetAngles();
float bestFit = 2.0f;
BaseVobInst bestVob = null;
if (hero?.World?.BaseWorld != null)
{
hero.World.BaseWorld.ForEachVob(v =>
{
BaseVobInst vob = (BaseVobInst)v.ScriptObject;
if (vob == hero)
{
return;
}
bool hasPriority = false;
if (fightMode)
{
if (!(vob is NPCInst npc))
{
return;
}
if (npc.IsDead)
{
return;
}
if (bestVob != null)
{
NPCInst bestNPC = (NPCInst)bestVob;
if (npc.IsUnconscious)
{
if (!bestNPC.IsUnconscious)
{
return; // alive targets are more important
}
}
else
{
if (bestNPC.IsUnconscious)
{
hasPriority = true;
}
}
if (npc.TeamID == hero.TeamID)
{
if (bestNPC.TeamID != hero.TeamID)
{
return;
}
}
else
{
if (bestNPC.TeamID == hero.TeamID)
{
hasPriority = true;
}
}
}
}
Vec3f targetPos;
using (zVec3 z = zVec3.Create())
{
vob.BaseInst.gVob.BBox3D.GetCenter(z);
targetPos = (Vec3f)z;
}
float distance = heroPos.GetDistance(targetPos);
if (distance > maxRange)
{
return;
}
float yaw = Angles.GetYawFromAtVector(targetPos - heroPos);
yaw = Math.Abs(Angles.Difference(yaw, heroAng.Yaw));
if (yaw > maxYaw)
{
return; // target is not in front of hero
}
if (!CanSee(heroPos, targetPos, vob))
{
return;
}
float fit = distance / maxRange + yaw / maxYaw;
if (hasPriority || fit < bestFit)
{
bestVob = vob;
bestFit = fit;
}
});
SetFocus(bestVob);
}
}
public void SetHeadingAtWorld(zVec3 target)
{
Process.THISCALL <NullReturnCall>((uint)Address, (uint)FuncOffsets.SetHeadingAtWorld, new CallValue[] { target });
}
public bool TraceRayFirstHit(zVec3 start, zVec3 ray, zTraceRay rayType)
{
return(Process.FASTCALL <BoolArg>(Address, start.Address, FuncAddresses.TraceRayFirstHit, ray, new IntArg(0), new IntArg((int)rayType)));
}
public void SetPositionWorld(zVec3 pos)
{
Process.THISCALL <NullReturnCall>((uint)Address, (uint)FuncOffsets.SetPositionWorld, new CallValue[] { pos });
}
public static void Write(oSDamageDescriptor oDD, oCNpc victim)
{
if (!sWorld.SpawnedVobDict.ContainsKey(victim.Address))
{
throw new Exception("Victim: " + victim.Address + " " + victim.Name.Value + " was not found!");
}
Vob vicProto = sWorld.SpawnedVobDict[victim.Address];
Vob attProto = null;
Vob weaponVob = null;
BitStream stream = Program.client.sentBitStream;
stream.Reset();
stream.Write((byte)RakNet.DefaultMessageIDTypes.ID_USER_PACKET_ENUM);
stream.Write((byte)NetworkID.OnDamageMessage);
zVec3 locHit = oDD.LocationHit;
zVec3 dirFly = oDD.DirectionFly;
zCVob attacker = oDD.AttackerNPC;
int weaponMode = oDD.ModeWeapon;
int spellID = oDD.SpellID;
zString weapon = oDD.Weapon.ObjectName;
byte sendFlags = 0;
if (locHit.Address != 0)
{
sendFlags |= 1;
}
if (dirFly.Address != 0)
{
sendFlags |= 2;
}
if (attacker.Address != 0)
{
if (!sWorld.SpawnedVobDict.ContainsKey(attacker.Address))
{
throw new Exception("Attacker: " + attacker.Address + " " + attacker.ObjectName.Value + " was not found!");
}
attProto = sWorld.SpawnedVobDict[attacker.Address];
sendFlags |= 4;
}
if (weaponMode != 0)
{
sendFlags |= 8;
}
if (spellID > 100)
{
sendFlags |= 16;
}
if (oDD.Weapon.Address != 0)
{
if (!sWorld.SpawnedVobDict.ContainsKey(oDD.Weapon.Address))
{
throw new Exception("Weapon: " + oDD.Weapon.Address + " " + oDD.Weapon.ObjectName.Value + " was not found!");
}
weaponVob = sWorld.SpawnedVobDict[oDD.Weapon.Address];
sendFlags |= 32;
}
if (oDD.DamageType == oSDamageDescriptor.DamageTypes.DAM_FALL)
{
sendFlags |= 64;
}
stream.Write(vicProto.ID);
stream.Write((byte)oDD.ModeDamage);
stream.Write(sendFlags);
if (locHit.Address != 0)
{
stream.Write(new Vec3f(locHit.X, locHit.Y, locHit.Z));
}
if (dirFly.Address != 0)
{
stream.Write(new Vec3f(dirFly.X, dirFly.Y, dirFly.Z));
}
if (attacker.Address != 0)
{
stream.Write(attProto.ID);
}
if (weaponMode != 0)
{
stream.Write(weaponMode);
}
if (spellID > 100)
{
stream.Write(spellID);
}
if (oDD.Weapon.Address != 0)
{
stream.Write(weaponVob.ID);
}
if ((sendFlags & 64) == 64)
{
stream.Write(victim.HumanAI.FallDownDistanceY);
}
Program.client.client.Send(stream, PacketPriority.HIGH_PRIORITY, PacketReliability.RELIABLE_ORDERED, (char)0, RakNet.RakNet.UNASSIGNED_SYSTEM_ADDRESS, true);
}
