internal static extern void SnapshotManager_Open(
     HandleRef self,
      /* from(DataSource_t) */ Types.DataSource data_source,
      /* from(char const *) */ string file_name,
      /* from(SnapshotConflictPolicy_t) */ Types.SnapshotConflictPolicy conflict_policy,
      /* from(SnapshotManager_OpenCallback_t) */ OpenCallback callback,
      /* from(void *) */ IntPtr callback_arg);

 internal static extern void LeaderboardManager_FetchScorePage(
     HandleRef self,
      /* from(DataSource_t) */ Types.DataSource data_source,
      /* from(ScorePage_ScorePageToken_t) */ IntPtr token,
      /* from(uint32_t) */ uint max_results,
      /* from(LeaderboardManager_FetchScorePageCallback_t) */ FetchScorePageCallback callback,
      /* from(void *) */ IntPtr callback_arg);

 public static void UpdateArtCache(Types.PosterWidth pWidth, MainForm form, ProgressState progress)
 {
     int width = Types.GetPosterWidthByEnum(pWidth);
     int i = 0;
     int count = Program.Context.Movies.Count(p => p.Status == Types.ItemStatus.Synced);
     foreach (Movie file in Program.Context.Movies.Include(p => p.Art).Where(p => p.Status == Types.ItemStatus.Synced))
     {
         progress.SetSubText("(" + ((++i) + 1) + "/" + count + ") " + file.Title);
         form.scanningBackgroundWorker.ReportProgress(progress.Value, progress);
         if (file.Art?.WebPath != null && (file.Art.CachePath == null || !File.Exists(file.Art.CachePath) || file.Art.Quality != pWidth))
         {
             if (File.Exists(file.Art.CachePath))
             {
                 File.Delete(file.Art.CachePath);
             }
             using (WebClient webClient = new WebClient())
             {
                 file.Art.Quality = pWidth;
                 try
                 {
                     string url = Program.ImageCacheUrl + @"\" + file.Art.WebPath.GetHashCode() + ".jpg";
                     webClient.DownloadFile(file.Art.WebPath.Replace("V1_SX300.jpg", $"V1_SX{width}.jpg"), url);
                     file.Art.CachePath = url;
                 }
                 catch (Exception)
                 {
                     file.Art.CachePath = null;
                 }
             }
         }
     }
     Program.Context.SaveChanges();
 }

 public ObjectItemMinimalInformation(short objectGID, short powerRate, bool overMax, Types.ObjectEffect[] effects)
 {
     this.objectGID = objectGID;
     this.powerRate = powerRate;
     this.overMax = overMax;
     this.effects = effects;
 }

 public GuildInAllianceInformations(int guildId, string guildName, Types.GuildEmblem guildEmblem, byte guildLevel, byte nbMembers, bool enabled)
     : base(guildId, guildName, guildEmblem)
 {
     this.guildLevel = guildLevel;
     this.nbMembers = nbMembers;
     this.enabled = enabled;
 }

    public TileData(int x, int y, string name, Types type, int resourceQuantity, int moveCost, float _hp, float _defence, float _attk, float _shield, int nCost)
    {
        tileName = name;

        posX = x;
        posY = y;

        tileType = type;
        maxResourceQuantity = resourceQuantity;
        movementCost = moveCost;

        // MAKING ROCK UNWAKABLE

        if (type != Types.empty && type != Types.water) {
            isWalkable = false;
        }

        tileStats = new TileStats(_hp, _defence, _attk, _shield, nCost);

        //hp = _hp;
        //def = _defence;
        //attk = _attk;
        //shield = _shield;

        //nanoBotCost = nCost;
    }

 public FunctionEntry(Level level, Label label, Types.RECORD formals, Types.Type result)
 {
     Level = level;
     Label = label;
     Formals = formals;
     Result = result;
 }

 public PrismFightersInformation(short subAreaId, Types.ProtectedEntityWaitingForHelpInfo waitingForHelpInfo, Types.CharacterMinimalPlusLookInformations[] allyCharactersInformations, Types.CharacterMinimalPlusLookInformations[] enemyCharactersInformations)
 {
     this.subAreaId = subAreaId;
     this.waitingForHelpInfo = waitingForHelpInfo;
     this.allyCharactersInformations = allyCharactersInformations;
     this.enemyCharactersInformations = enemyCharactersInformations;
 }

 public void VirtualMachineStart(Types.SuspendPolicy suspendPolicy, RequestId requestId, ThreadId threadId)
 {
     ThreadReference thread = VirtualMachine.GetMirrorOf(threadId);
     EventRequest request = VirtualMachine.EventRequestManager.GetEventRequest(EventKind.VirtualMachineStart, requestId);
     ThreadEventArgs e = new ThreadEventArgs(VirtualMachine, (SuspendPolicy)suspendPolicy, request, thread);
     VirtualMachine.EventQueue.OnVirtualMachineStart(e);
 }

 public TaxCollectorMovementMessage(bool hireOrFire, Types.TaxCollectorBasicInformations basicInfos, int playerId, string playerName)
 {
     this.hireOrFire = hireOrFire;
     this.basicInfos = basicInfos;
     this.playerId = playerId;
     this.playerName = playerName;
 }

 public FightResultTaxCollectorListEntry(short outcome, sbyte wave, Types.FightLoot rewards, int id, bool alive, byte level, Types.BasicGuildInformations guildInfo, int experienceForGuild)
     : base(outcome, wave, rewards, id, alive)
 {
     this.level = level;
     this.guildInfo = guildInfo;
     this.experienceForGuild = experienceForGuild;
 }

 public Preset(sbyte presetId, sbyte symbolId, bool mount, Types.PresetItem[] objects)
 {
     this.presetId = presetId;
     this.symbolId = symbolId;
     this.mount = mount;
     this.objects = objects;
 }

 public GameFightCompanionInformations(int contextualId, Types.EntityLook look, Types.EntityDispositionInformations disposition, sbyte teamId, sbyte wave, bool alive, Types.GameFightMinimalStats stats, short[] previousPositions, sbyte companionGenericId, byte level, int masterId)
     : base(contextualId, look, disposition, teamId, wave, alive, stats, previousPositions)
 {
     this.companionGenericId = companionGenericId;
     this.level = level;
     this.masterId = masterId;
 }

        /// <summary>
        /// Creates an <see cref="IntegerType"/> instance.
        /// </summary>
        /// <param name="module"></param>
        /// <param name="name"></param>
        /// <param name="enumerator"></param>
        public IntegerType(IModule module, string name, Symbol type, ISymbolEnumerator symbols)
            : base (module, name)
        {
            Types? t = GetExactType(type);
            type.Assert(t.HasValue, "Unknown symbol for unsigned type!");
            _type = t.Value;

            _isEnumeration = false;

            Symbol current = symbols.NextNonEOLSymbol();
            if (current == Symbol.OpenBracket)
            {
                _isEnumeration = true;
                symbols.PutBack(current);
                _map = Lexer.DecodeEnumerations(symbols);
            }
            else if (current == Symbol.OpenParentheses)
            {
                symbols.PutBack(current);
                _ranges = Lexer.DecodeRanges(symbols);
                current.Assert(!_ranges.IsSizeDeclaration, "SIZE keyword is not allowed for ranges of integer types!");
            }
            else
            {
                symbols.PutBack(current);
            }
        }

 public SlaveSwitchContextMessage(int summonerId, int slaveId, Types.SpellItem[] slaveSpells, Types.CharacterCharacteristicsInformations slaveStats)
 {
     this.summonerId = summonerId;
     this.slaveId = slaveId;
     this.slaveSpells = slaveSpells;
     this.slaveStats = slaveStats;
 }

    public static void AddPoint(float numberPoint, Types type)
    {
        if (LevelManager.player.IsDead ()) // Empêcher de récupérer des sous/xp après la mort
            return;

        Multiplier multiplier;

        // On multiplie s'il y a lieu
        if( multipliers.TryGetValue( type, out multiplier ) ) {
            numberPoint *= multiplier.value;
        }
        else if( Types.All != type && multipliers.TryGetValue( Types.All, out multiplier ) ) {
            numberPoint *= multiplier.value;
        }

        // On ajoute les points au bon endroit
        if (Types.Coin == type) {
            // Tentative de multiplication des points par rapport aux talents
            if (Random.Range (0, 100) < leafDouble) {
                numberPoint *= powerLeafDouble;
            }
            score += numberPoint;
            // On compte une pièce supplémentaire
            leaf++;
        } else if (Types.Experience == type) {
            experience += numberPoint;
        }
    }

	    //---------------------------------------------------------------------

	    private Release(Types type,
	                    int   number)
	    {
	        this.type = type;
	        this.number = number;
	        this.build = ((int) type) + number;
	    }

 public MountClientData(bool sex, bool isRideable, bool isWild, bool isFecondationReady, double id, int model, int[] ancestor, int[] behaviors, string name, int ownerId, double experience, double experienceForLevel, double experienceForNextLevel, sbyte level, int maxPods, int stamina, int staminaMax, int maturity, int maturityForAdult, int energy, int energyMax, int serenity, int aggressivityMax, int serenityMax, int love, int loveMax, int fecondationTime, int boostLimiter, double boostMax, int reproductionCount, int reproductionCountMax, Types.ObjectEffectInteger[] effectList)
 {
     this.sex = sex;
     this.isRideable = isRideable;
     this.isWild = isWild;
     this.isFecondationReady = isFecondationReady;
     this.id = id;
     this.model = model;
     this.ancestor = ancestor;
     this.behaviors = behaviors;
     this.name = name;
     this.ownerId = ownerId;
     this.experience = experience;
     this.experienceForLevel = experienceForLevel;
     this.experienceForNextLevel = experienceForNextLevel;
     this.level = level;
     this.maxPods = maxPods;
     this.stamina = stamina;
     this.staminaMax = staminaMax;
     this.maturity = maturity;
     this.maturityForAdult = maturityForAdult;
     this.energy = energy;
     this.energyMax = energyMax;
     this.serenity = serenity;
     this.aggressivityMax = aggressivityMax;
     this.serenityMax = serenityMax;
     this.love = love;
     this.loveMax = loveMax;
     this.fecondationTime = fecondationTime;
     this.boostLimiter = boostLimiter;
     this.boostMax = boostMax;
     this.reproductionCount = reproductionCount;
     this.reproductionCountMax = reproductionCountMax;
     this.effectList = effectList;
 }

 public GameFightTaxCollectorInformations(int contextualId, Types.EntityLook look, Types.EntityDispositionInformations disposition, sbyte teamId, sbyte wave, bool alive, Types.GameFightMinimalStats stats, short[] previousPositions, short firstNameId, short lastNameId, byte level)
     : base(contextualId, look, disposition, teamId, wave, alive, stats, previousPositions)
 {
     this.firstNameId = firstNameId;
     this.lastNameId = lastNameId;
     this.level = level;
 }

 public GameFightEndMessage(int duration, short ageBonus, short lootShareLimitMalus, Types.FightResultListEntry[] results)
 {
     this.duration = duration;
     this.ageBonus = ageBonus;
     this.lootShareLimitMalus = lootShareLimitMalus;
     this.results = results;
 }