csgo wall hack - using VAMemory so it will get VAC for sure

crappy-csgo-walls.cs

using System;
using System.Threading;
using System.Diagnostics;

namespace csgo_walls {

    public class Glow {
        public static int Client;
        public static string process = "csgo";

        public static void Main()
        {

            VAMemory vam = new VAMemory(process);
            vam.CheckProcess();

            if (GetModuleAddress())
            {

                while (true)
                {
                    GlowStruct Enemy = new GlowStruct()
                    {
                        r = 1,
                        g = 0,
                        b = 0,
                        a = 1,
                        rwo = true,
                        rwuo = true
                    };

                    GlowStruct Team = new GlowStruct()
                    {
                        r = 0,
                        g = 0,
                        b = 1,
                        a = 1,
                        rwo = true,
                        rwuo = true
                    };

                    int address;
                    int i = 1;

                    do
                    {
                        address = Client + Offsets.oLocalPlayer;
                        int Player = vam.ReadInt32((IntPtr)address);

                        address = Player + Offsets.oTeam;
                        int MyTeam = vam.ReadInt32((IntPtr)address);

                        address = Client + Offsets.oEntityList + (i - 1) * 0x10;
                        int EntityList = vam.ReadInt32((IntPtr)address);

                        address = EntityList + Offsets.oTeam;
                        int HisTeam = vam.ReadInt32((IntPtr)address);

                        address = EntityList + Offsets.oDormat;
  
                        if (!vam.ReadBoolean((IntPtr)address))
                        {
                            address = EntityList + Offsets.oGlowIndex;

                            int GlowIndex = vam.ReadInt32((IntPtr)address);

                            if (MyTeam == HisTeam)
                            {
                                address = Client + Offsets.oGlowObject;
                                int GlowObject = vam.ReadInt32((IntPtr)address);

                                int calculation = GlowIndex * 0x38 + 0x4;
                                int current = GlowObject + calculation;
                                vam.WriteFloat((IntPtr)current, Team.r);

                                calculation = GlowIndex * 0x38 + 0x8;
                                current = GlowObject + calculation;
                                vam.WriteFloat((IntPtr)current, Team.g);

                                calculation = GlowIndex * 0x38 + 0xC;
                                current = GlowObject + calculation;
                                vam.WriteFloat((IntPtr)current, Team.b);

                                calculation = GlowIndex * 0x38 + 0x10;
                                current = GlowObject + calculation;
                                vam.WriteFloat((IntPtr)current, Team.a);

                                calculation = GlowIndex * 0x38 + 0x24;
                                current = GlowObject + calculation;
                                vam.WriteBoolean((IntPtr)current, Team.rwo);

                                calculation = GlowIndex * 0x38 + 0x25;
                                current = GlowObject + calculation;
                                vam.WriteBoolean((IntPtr)current, Team.rwuo);
                            }
                            else
                            {
                                address = Client + Offsets.oGlowObject;
                                int GlowObject = vam.ReadInt32((IntPtr)address);

                                int calculation = GlowIndex * 0x38 + 0x4;
                                int current = GlowObject + calculation;
                                vam.WriteFloat((IntPtr)current, Enemy.r);

                                calculation = GlowIndex * 0x38 + 0x8;
                                current = GlowObject + calculation;
                                vam.WriteFloat((IntPtr)current, Enemy.g);

                                calculation = GlowIndex * 0x38 + 0xC;
                                current = GlowObject + calculation;
                                vam.WriteFloat((IntPtr)current, Enemy.b);

                                calculation = GlowIndex * 0x38 + 0x10;
                                current = GlowObject + calculation;
                                vam.WriteFloat((IntPtr)current, Enemy.a);

                                calculation = GlowIndex * 0x38 + 0x24;
                                current = GlowObject + calculation;
                                vam.WriteBoolean((IntPtr)current, Enemy.rwo);

                                calculation = GlowIndex * 0x38 + 0x25;
                                current = GlowObject + calculation;
                                vam.WriteBoolean((IntPtr)current, Enemy.rwuo);
                            }
                        }

                        i++;
                    } while (i < 65);

                    Thread.Sleep(10);
                }
            }
        }

        static bool GetModuleAddress()
        {

            try
            {
                Process[] p = Process.GetProcessesByName(process);

                if (p.Length > 0)
                {
                    foreach (ProcessModule m in p[0].Modules)
                    {
                        if (m.ModuleName == "client.dll")
                        {
                            Client = (int)m.BaseAddress;
                            return true;
                        }
                    }

                    return true;
                }
                else
                {
                    Console.WriteLine("not found.");
                    return false;
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex);
                return false;
            }
        }

        public struct GlowStruct
        {
            public float r;
            public float g;
            public float b;
            public float a;
            public bool rwo;
            public bool rwuo;
        }

        public class Offsets
        {
            public static int oLocalPlayer = 0x174;
            public static int oTeam = 0xF0;
            public static int oEntityList = 0x4A57EA4;
            public static int oDormat = 0xE9;
            public static int oGlowIndex = 0xA310;
            public static int oGlowObject = 0x04F6DAD4; 
        }

    }
}