// Culled does the real work of walking forward with a pair of pointers
// yielding only the nodes where a capsule clipped while attempting the direct path
private IEnumerable <Vector3> Culled(IEnumerable <Vector3> path)
{
Vector3[] orig = path.ToArray();
if (orig.Length < 2)
{
foreach (Vector3 step in orig)
{
yield return(step);
}
}
else
{
var seenEnts = new HashSet <EntHandle>();
int i = 0;
for (int j = 2; j < orig.Length - 1; j++)
{
if (Raycast(orig[i], orig[j], CapsuleSize, IntersectOptions.Everything ^ IntersectOptions.Vegetation, Self).DidHit)
{
Log($"Culled() up to {j}");
yield return(orig[j - 1]);
i = j;
}
else
{
// as we move j forward, "light up" the closest ents it passes
// once that ent has been activated (added to the seenEnts set),
// we will keep checking it for collision as j advances
foreach (EntHandle ent in NearbyObjects().OrderBy(DistanceTo(orig[j])).Take(4).Concat(seenEnts))
{
if (GetEntityType(ent) != EntityType.Invalid)
{
if (!seenEnts.Contains(ent))
{
seenEnts.Add(ent);
}
ModelHash model = GetModel(ent);
Matrix4x4 m = Matrix(ent);
GetModelDimensions(model, out Vector3 backLeft, out Vector3 frontRight);
if (IntersectModel(orig[i], orig[j], m, backLeft, frontRight))
{
Log($"Culled() up to {j} (using IntersectModel)");
yield return(orig[j - 1]);
i = j;
seenEnts.Clear();
break;
}
}
}
}
}
// always keep the last two steps untouched, as an anchor
yield return(orig[orig.Length - 2]);
yield return(orig[orig.Length - 1]);
}
}
public static void GetDoorState(ModelHash doorModel, Vector3 pos, out bool locked, out float heading)
{
bool _lock = true;
float h = 0f;
unsafe {
Call(GET_STATE_OF_CLOSEST_DOOR_OF_TYPE, doorModel, pos, new IntPtr(&_lock), new IntPtr(&h));
}
locked = _lock;
heading = h;
}
public DefaultIncrementalModelTreeTraverseService()
{
CurrentModelHash = new ModelHash();
IgnoredModelNodes = new List <ModelNode>();
DefaultDefinitionFullPathSeparator = "/";
DefaultDefinitionIdentityKeySeparator = ";";
DefaultPersistenceModelIdPrefix = "spmeta2.incremental_state";
EnableCaching = true;
}
public static IEnumerable <ModelBox> GetBlockingEnts(int limit = 30, bool debug = false)
{
foreach (EntHandle ent in NearbyObjects().Take(limit))
{
if (IsAttached(ent))
{
continue; // dont block on items held or carried by peds
}
Matrix4x4 m = Matrix(ent);
Vector3 pos = Position(m);
if (pos == Vector3.Zero || DistanceToSelf(pos) > 100f * 100f)
{
continue;
}
ModelHash model = GetModel(ent);
if (checkDoorModels.Contains(model))
{
GetDoorState(model, pos, out bool locked, out float heading);
if (!locked)
{
continue;
}
}
if (ignoreModels.Contains((long)model))
{
continue;
}
GetModelDimensions(model, out Vector3 backLeft, out Vector3 frontRight);
float volume = GetVolume(frontRight, backLeft);
if (debug)
{
DrawBox(m, backLeft, frontRight);
}
if (debug)
{
UI.DrawTextInWorldWithOffset(pos, 0f, .02f, $"{model} ({volume:F2})");
}
if (volume > 170)
{
ignoreModels.Add((long)model);
}
else
{
yield return(new ModelBox()
{
Model = model, Entity = ent, M = m, Front = frontRight, Back = backLeft
});
}
}
}
public static void GetModelDimensions(ModelHash model, out Vector3 backLeft, out Vector3 frontRight)
{
if (modelDimensionCache.TryGetValue(model, out ModelDims dims))
{
backLeft = dims.backLeft;
frontRight = dims.frontRight;
return;
}
NativeVector3 a, b;
unsafe { Call(GET_MODEL_DIMENSIONS, model, new IntPtr(&a), new IntPtr(&b)); }
backLeft = a;
frontRight = b;
modelDimensionCache.TryAdd(model, new ModelDims()
{
backLeft = a, frontRight = b
});
}
public static ProvisionServiceBase SetIncrementalProvisionModelHash(this ProvisionServiceBase service, ModelHash modelHash)
{
var typedModelService = GetIncrementalModelTraverseService(service);
typedModelService.PreviousModelHash = modelHash;
return(service);
}
public static EntHandle CreateObject(ModelHash model, Vector3 pos, bool dynamic)
{
return(RequestModel(model) != AssetStatus.Loaded
? EntHandle.Invalid
: Call <EntHandle>(CREATE_OBJECT_NO_OFFSET, model, pos, 1, 1, dynamic));
}
public static bool IsLoaded(ModelHash model) => model == 0 ? false : Call <bool>(HAS_MODEL_LOADED, model);
public string Register(RegisterMessage register)
{
// check length
if (!string.IsNullOrWhiteSpace(register.Username))
{
if (register.Username.Length > 20)
{
throw HttpResponseExceptionHelper.Create("Votre nom d'usager excède 20 caractères",
HttpStatusCode.BadRequest);
}
if (register.Username.Contains(" "))
{
throw HttpResponseExceptionHelper.Create("Votre nom d'usager ne doit pas contenir d'espace",
HttpStatusCode.BadRequest);
}
}
UserModel newUser;
//Check if credentials are OK
if (string.IsNullOrWhiteSpace(register.Username))
{
throw HttpResponseExceptionHelper.Create("Aucun nom d'usager spécifier", HttpStatusCode.BadRequest);
}
if (!register.Username.All(char.IsLetterOrDigit))
{
throw HttpResponseExceptionHelper.Create("Le nom d'usager doit être alpla numérique", HttpStatusCode.BadRequest);
}
if (string.IsNullOrWhiteSpace(register.Password) && string.IsNullOrWhiteSpace(register.FacebookId))
{
throw HttpResponseExceptionHelper.Create("Le format d'enregistrement est invalide", HttpStatusCode.BadRequest);
}
using (var db = new SystemDBContext())
{
UserModel user = null;
// Search facebook user and then username
if (!string.IsNullOrWhiteSpace(register.FacebookId))
{
user = db.Users.FirstOrDefault(x => x.FacebookId == register.FacebookId);
}
if (user != null)
{
throw HttpResponseExceptionHelper.Create("L'usager Facebook existe déjà", HttpStatusCode.BadRequest);
}
if (!string.IsNullOrWhiteSpace(register.Username))
{
user = db.Users.FirstOrDefault(x => x.Username == register.Username);
}
// User already exist
if (user != null)
{
throw HttpResponseExceptionHelper.Create("Un usager avec ce nom existe déjà",
HttpStatusCode.BadRequest);
}
// create new user
newUser = new UserModel()
{
FacebookId = register.FacebookId,
Username = register.Username,
Password = PasswordHash.CreateHash(register.Password),
FacebookPost = false,
PushNotification = false
};
newUser.HashId = ModelHash.GetUserHash(newUser);
var newProfile = ProfileModelHelper.Initialize(new ProfileModel());
newProfile.UserHashId = newUser.HashId;
newProfile.Username = register.Username;
// ALL MIGHTY POWER
// HACK FOR FELIX USER
if (newUser.Username.ToLower().Equals("felix"))
{
newProfile.Experience = 9000;
newProfile.PrincessTitle = EnumsModel.PrincessTitle.MASTER;
newProfile.Description = "ALL MIGHTY GOD OF THE BACKEND AND BACKLOG";
newProfile.Picture = EnumsModel.PrincessAvatar.Mulan;
newProfile.AchievementsString =
"{\"AddAvatar\":true,\"FastGamePoints\":true,\"FinishCampain\":true,\"FinishOtherSucess\":true,\"FirstMapCreated\":true,\"FirstOnlineGame\":true,\"FirstOnlineGameWon\":true,\"FirstTimeConnect\":true,\"GamePoints\":true,\"PlayWithAFriend\":true}";
}
// Add user
newUser = CreateUser(newUser);
// Add profile
db.Profiles.Add(newProfile);
db.SaveChanges();
}
return(GetToken(newUser));
}
public static bool IsHeli(ModelHash m) => Call <bool>(IS_THIS_MODEL_A_HELI, m);
public static bool IsAmphibiousCar(ModelHash m) => Call <bool>((Hash)0x633F6F44A537EBB6, m);
public static bool IsCar(ModelHash m) => Call <bool>(IS_THIS_MODEL_A_CAR, m);
public static bool IsBoat(ModelHash m) => Call <bool>(IS_THIS_MODEL_A_BOAT, m);
public static bool IsMotorbike(ModelHash m) => Call <bool>(IS_THIS_MODEL_A_BIKE, m);
public static bool IsBicycle(ModelHash m) => Call <bool>(IS_THIS_MODEL_A_BICYCLE, m);
public static AssetStatus RequestModel(ModelHash model) => (!IsValid(model))
? AssetStatus.Invalid
: Call <ModelHash>(REQUEST_MODEL, model) == model ? AssetStatus.Loaded : AssetStatus.Loading;
/// <summary> /// 获取哈希码。 /// </summary> /// <returns>返回 32 位整数。</returns> public override int GetHashCode() => ModelHash.CompatibleGetHashCode();
public static bool IsPlane(ModelHash m) => Call <bool>(IS_THIS_MODEL_A_PLANE, m);
protected override void OnBeforeDeployModel(object modelHost, ModelNode modelNode)
{
base.OnBeforeDeployModel(modelHost, modelNode);
// clean up current model hash
CurrentModelHash = new ModelHash();
ClearCaches();
TraceService.InformationFormat(0, "Starting incremental provision with EnableCaching = {0}", EnableCaching);
var storages = ResolvePersistenceStorages(modelHost, modelNode);
// restore previous one
if (Configuration != null && storages.Count() > 0)
{
TraceService.Information(0, "Model hash restore: found [{0}] storage impl in Configuration.PersistenceStorages. Automatic model hash management is used");
var modelIdProperty = modelNode.GetPropertyBagValue(DefaultModelNodePropertyBagValue.Sys.IncrementalProvision.PersistenceStorageModelId);
if (modelIdProperty == null)
{
throw new SPMeta2Exception("IncrementalProvisionModelId is not set. Either clean PersistenceStorages and handle model hash persistence manually or set .PersistenceStorageModelId");
}
var modelId = modelIdProperty;
var objectId = string.Format("{0}.{1}", DefaultPersistenceModelIdPrefix, modelId);
var serializer = ServiceContainer.Instance.GetService <DefaultXMLSerializationService>();
serializer.RegisterKnownTypes(new[]
{
typeof(ModelHash),
typeof(ModelNodeHash)
});
foreach (var storage in storages)
{
TraceService.Information(0, string.Format("Restoring model hash with object id:[{0}] using storage impl [{1}]",
objectId, storage.GetType()));
var data = storage.LoadObject(objectId);
if (data != null)
{
var dataString = Encoding.UTF8.GetString(data);
var dataObject = serializer.Deserialize(typeof(ModelHash), dataString) as ModelHash;
if (dataObject != null)
{
PreviousModelHash = dataObject;
TraceService.Information(0, string.Format("Restored model hash with object id:[{0}] using storage impl [{1}]",
objectId, storage.GetType()));
break;
}
}
else
{
TraceService.Information(0, string.Format("Restored model hash with object id:[{0}] using storage impl [{1}]",
objectId, storage.GetType()));
}
}
TraceService.Information(0, string.Format("Coudn't restore model hash with object id:[{0}]. Either first provision is user or storage is wrong.", objectId));
}
else
{
TraceService.Information(0, "Model hash restore: can't find any persistence storage impl in Configuration.PersistenceStorages. Assuming manual model hash management is used");
}
}
public static bool IsTrain(ModelHash m) => Call <bool>(IS_THIS_MODEL_A_TRAIN, m);
public static PedHandle CreatePedInsideVehicle(VehicleHandle veh, PedType type, ModelHash model, VehicleSeat seat)
{
switch (RequestModel(model))
{
case AssetStatus.Invalid: return(PedHandle.ModelInvalid);
case AssetStatus.Loading: return(PedHandle.ModelLoading);
default: return(Call <PedHandle>(CREATE_PED_INSIDE_VEHICLE, veh, type, model, seat, true, true));
}
}
public static bool IsVehicle(ModelHash m) => Call <bool>(IS_MODEL_A_VEHICLE, m);
public static void NotNeeded(ModelHash m) => Call(SET_MODEL_AS_NO_LONGER_NEEDED, m);
public static bool IsValid(ModelHash model) => model == ModelHash.Invalid ? false : Call <bool>(IS_MODEL_VALID, model);
