CS2-PlayerModelChanger/Cache.cs at master · samyycX/CS2-PlayerModelChanger · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
using CounterStrikeSharp.API.Core;

namespace PlayerModelChanger;

public class ModelCache
{

    public ulong steamid { get; set; }
    public string? t_model { get; set; }
    public string? ct_model { get; set; }
    public bool t_permission_bypass { get; set; }
    public bool ct_permission_bypass { get; set; }
}

public class MeshgroupPreferenceCache
{
    public ulong steamid { get; set; }
    public required string model { get; set; }
    public List<int> meshgroups { get; set; } = new();

}

public class SkinPreferenceCache
{
    public ulong steamid { get; set; }
    public required string model { get; set; }
    public int skin { get; set; }
}

public class ModelCacheManager
{
    private List<ModelCache> _Cache = new List<ModelCache>();
    private List<MeshgroupPreferenceCache> _MeshgroupPreferenceCache = new List<MeshgroupPreferenceCache>();
    private List<SkinPreferenceCache> _SkinPreferenceCache = new List<SkinPreferenceCache>();

    private IStorage _Storage;
    public ModelCacheManager(IStorage storage)
    {
        this._Storage = storage;
    }
    public void ResyncCache()
    {
        var data = _Storage.GetCaches();
        _Cache = data.Item1;
        _MeshgroupPreferenceCache = data.Item2;
    }

    public void SetAllTModels(string tmodel, bool permissionBypass)
    {
        _Cache.ForEach(model => { model.t_model = tmodel; model.t_permission_bypass = permissionBypass; });
    }
    public void SetAllCTModels(string ctmodel, bool permissionBypass)
    {
        _Cache.ForEach(model => { model.ct_model = ctmodel; model.ct_permission_bypass = permissionBypass; });
    }
    public void SetAllModels(string tmodel, string ctmodel, bool permissionBypass)
    {
        _Cache.ForEach(model => { model.t_model = tmodel; model.ct_model = ctmodel; model.t_permission_bypass = permissionBypass; model.ct_permission_bypass = permissionBypass; });
    }
    public List<ulong> GetAllPlayers()
    {
        return _Cache.Select(model => model.steamid).ToList();
    }
    public void SetPlayerModel(ulong steamid, string modelIndex, Side side, bool permissionBypass)
    {
        var obj = _Cache.Find(model => model.steamid == steamid);

        if (obj == null)
        {
            var modelcache = new ModelCache
            {
                steamid = steamid
            };
            _Cache.Add(modelcache);
            obj = modelcache;
        }
        Utils.ExecuteSide(side,
            null,
            () => { obj.t_model = modelIndex; obj.t_permission_bypass = permissionBypass; },
            () => { obj.ct_model = modelIndex; obj.ct_permission_bypass = permissionBypass; }
        );

    }

    public ModelCache? GetPlayerModelCache(CCSPlayerController player)
    {
        return _Cache.Find(model => model.steamid == player!.AuthorizedSteamID!.SteamId64);
    }

    public void AddMeshgroupPreference(ulong steamid, string modelIndex, int meshgroup)
    {
        var obj = _MeshgroupPreferenceCache.Find(model => model.steamid == steamid && model.model == modelIndex);
        if (obj == null)
        {
            obj = new MeshgroupPreferenceCache
            {
                steamid = steamid,
                model = modelIndex,
                meshgroups = new List<int>()
            };
            _MeshgroupPreferenceCache.Add(obj);
        }
        obj.meshgroups.Add(meshgroup);
    }

    public List<int> GetMeshgroupPreference(ulong steamid, string modelIndex)
    {
        var obj = _MeshgroupPreferenceCache.Find(model => model.steamid == steamid && model.model == modelIndex);
        if (obj == null)
        {
            return new List<int>();
        }
        return obj.meshgroups;
    }

    public void RemoveMeshgroupPreference(ulong steamid, string modelIndex, int meshgroup)
    {
        var obj = _MeshgroupPreferenceCache.Find(model => model.steamid == steamid && model.model == modelIndex);
        if (obj == null)
        {
            return;
        }
        obj.meshgroups.Remove(meshgroup);
    }

    public void UpdateSkinPerference(ulong steamid, string modelIndex, int skin)
    {
        var obj = _SkinPreferenceCache.Find(model => model.steamid == steamid && model.model == modelIndex);
        if (obj == null)
        {
            obj = new SkinPreferenceCache { steamid = steamid, model = modelIndex, skin = skin };
        }
        obj.skin = skin;
    }

    public int GetSkinPreference(ulong steamid, string modelIndex)
    {
        var obj = _SkinPreferenceCache.Find(model => model.steamid == steamid && model.model == modelIndex);
        if (obj == null)
        {
            return 0;
        }
        return obj.skin;
    }

}