BiomeExtractorsMod/BiomeExtractorsMod.cs at main · 435THz/BiomeExtractorsMod · 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
using BiomeExtractorsMod.Common.Configs;
using BiomeExtractorsMod.Content.TileEntities;
using System;
using System.Collections.Generic;
using System.IO;
using Terraria.ID;
using Terraria;
using Terraria.ModLoader;
using System.Linq;
using BiomeExtractorsMod.Common.Database;
using Terraria.DataStructures;
using BiomeExtractorsMod.Content.Tiles;

namespace BiomeExtractorsMod
{
    internal enum ClientMessageType {UPDATE_REQUEST, KILL_REQUEST}
    internal enum ServerMessageType {EXTRACTOR_REGISTER, EXTRACTOR_UPDATE, EXTRACTOR_REMOVE}


    public class BiomeExtractorsMod : Mod
    {
        public static BiomeExtractorsMod Instance => ModContent.GetInstance<BiomeExtractorsMod>();
        static string GetModName(SupportedMods mod) => Enum.GetName(typeof(SupportedMods), mod);
        enum SupportedMods
        {
            MagicStorage, CalamityMod, SubworldLibrary
        }

        static readonly private Dictionary<SupportedMods, bool> supportedModsLoaded = [];
        static internal bool MS_loaded => supportedModsLoaded[SupportedMods.MagicStorage] && ModContent.GetInstance<ConfigCompat>().MS;
        static internal bool SL_loaded => supportedModsLoaded[SupportedMods.SubworldLibrary];
        static internal bool CLM_loaded => supportedModsLoaded[SupportedMods.CalamityMod];

        private static readonly object LocBase = "Mods.BiomeExtractorsMod";

        private static string LocItemsCategory => $"{LocBase}.Items";
        public static string LocExtractorPrefix => $"{LocItemsCategory}.BiomeExtractorItem";
        public static string LocExtractorSuffix(string suffix) => $"{LocItemsCategory}.{suffix}ExtractorItem.DisplayName";
        private static string LocConfigCategory => $"{LocBase}.Config";
        public static string LocClientConfig => $"{LocConfigCategory}.ConfigClient";
        public static string LocCommonConfig => $"{LocConfigCategory}.ConfigCommon";
        public static string LocCompatConfig => $"{LocConfigCategory}.ConfigCompat";

        private static string LocTextCategory => $"{LocBase}.Text";
        public static string LocDiagnostics => $"{LocTextCategory}.Diagnostics";
        public static string LocPoolNames => $"{LocTextCategory}.PoolNames";
        public static string LocArticles => $"{LocTextCategory}.Articles";
        public static string LocTiers => $"{LocTextCategory}.Tiers";
        private static string LocMapCategory => $"{LocBase}.Map";
        public static string LocMapTileName => $"{LocMapCategory}.TileName";
        public static string LocIconInactive => $"{LocMapCategory}.IconInactive";
        public static string LocIconNoOutput => $"{LocMapCategory}.IconNoOutput";
        public static string LocIconError => $"{LocMapCategory}.IconError";

        public override void Load()
        {
            foreach(SupportedMods mod in Enum.GetValues(typeof(SupportedMods)))
                supportedModsLoaded[mod] = ModLoader.HasMod(GetModName(mod));
        }

        public override void HandlePacket(BinaryReader reader, int whoAmI)
        {
            if (Main.netMode == NetmodeID.MultiplayerClient)
            {
                ServerMessageType msgType = (ServerMessageType)reader.ReadByte();
                switch(msgType)
                {
                    case ServerMessageType.EXTRACTOR_REGISTER:
                        Point16 toAdd = new(reader.ReadInt16(), reader.ReadInt16());
                        int tier = reader.ReadInt32();
                        int style = reader.ReadInt32();
                        ExtractorState state = (ExtractorState)reader.ReadByte();
                        IconMapSystem.AddExtractorData(toAdd, tier, style, state);
                        break;
                    case ServerMessageType.EXTRACTOR_UPDATE:
                        Point16 toUpdate = new(reader.ReadInt16(), reader.ReadInt16());
                        ExtractorState newState = (ExtractorState)reader.ReadByte();
                        IconMapSystem.UpdateExtractorData(toUpdate, newState);
                        break;
                    case ServerMessageType.EXTRACTOR_REMOVE:
                        Point16 toRemove = new(reader.ReadInt16(), reader.ReadInt16());
                        IconMapSystem.RemoveExtractorData(toRemove);
                        break;
                }
            }
            else if (Main.netMode == NetmodeID.Server)
            {
                ClientMessageType msgType = (ClientMessageType)reader.ReadByte();
                switch (msgType)
                {
                    case ClientMessageType.KILL_REQUEST:
                        int x = reader.ReadInt32(), y = reader.ReadInt32();
                        if(TileUtils.TryGetTileEntityAs(x, y, out BiomeExtractorEnt ent))
                            ent.Kill(x, y);
                        break;
                    case ClientMessageType.UPDATE_REQUEST:
                        IEnumerable<BiomeExtractorEnt> extractors = TileEntity.ByPosition
                            .Where(pair => pair.Value is BiomeExtractorEnt)
                            .Select(pair => pair.Value as BiomeExtractorEnt);
                        List<BiomeExtractorEnt> toSend = extractors.ToList();
                        foreach (BiomeExtractorEnt extractor in toSend)
                            extractor.SendUpdatePacket(ServerMessageType.EXTRACTOR_UPDATE);
                        break;
                }
            }
        }

        public static void Debug(string message)
        {
            Instance.Logger.Debug(message);
        }
        public static void Debug(string message, Exception exception)
        {
            Instance.Logger.Debug(message, exception);
        }
    }
}