For a more in depth look at how to actually code an externalio, check here.

Why use externals?
Well personally I prefer externals cuz they're more fun, and you have to do some more work to accomplish certain features. We've all seen legit AA on internals, right? Ever seen it on an external? Probably not. (I have cuz my cutie ice is p100 coder) That's the fun in externals for me, taking internal features and creating them in an external setting.

How do Externals work?
Well, externals operate by reading and writing memory, sometimes allocating and/or executing, but I won't go into that. Reading and writing memory in c++ is quite simple, since you have some great functions called RPM and WPM. Feel free to read the MSDN on them to understand what those parameters do. Now if you're oldschool and slightly retarded, you can gladly use those default functions, but if you're smart and care about your code and sanity, you can write a thing called a wrapper function. This is achieved in c++ by using a beautiful thing called a template. (Feel free to check out the elixir source, or ice's reboot of it to check out how I use templates to make WPM and RPM easier) As you obviously read in the page about wrapper functions, their purpose is to make the calling of subroutines (RPM or WPM in this case)easier for the coder.

How To Offsets in Externals?
Well honestly, it really isn't much different than anything else. Personally I prefer declaring my offsets as std::ptrdiff_t but it's also perfectly acceptable to declare them as DWORD (although I constantly argue with ice about the properness of said convention), or if you're really gay, since all of those previously mentioned things boil down to being ints, you could declare your offsets as int, but this again has different implications and I won't start a whole debate on how std::ptrdiff_t is the obviously better and correct choice. Now that we've got this out of the way, we can actually get to the offset part of this section. Offsets can be gotten via netvar managers (for netvars... obviously), and other offsets, such as dwClientState or dwForceAttack, can be gotten via something we call sig scanning. Alternatively, you could get your netvar offsets directly from IDA and PROPERLY DECLARE THEM AS CONSTEXPR.

How 2 Mek Legit AA Men?
Well, basically the same way as internally. Contrary to popular belief, you can hook things externally. (It's a wonderful thing called SHELLCODE) Essentially, shellcode is the hex version of what the ASM code of a certain function would look like. So with this in mind, let's start our p100 legit aa. Basically, first you need the shellcode for createmove (you can find that ez pz), next you need to do some math to figure out the size of the actual instructions of your shellcode. Next you allocate the necessary memory for your shellcode, at the place in memory where you need it executed (see VirtualAllocEx for allocation and sig scanning for location). Either now, but better off before all of this, you might want to know what the VFunc for this bullshit is, correct? I mean you gotta hook this sucker somehow. Basically, RPM the table, do p100 math with the index to find the location of the actual function (VTable + sizeof( DWORD ) * Index;) Then allow the memory region to be RWE'd with VirtualProtectEx. Now once you execute your 100% self written functions, you can make your external AA. All you gotta do is set that bSendPacket and set your angles and boom, anti aim :dab: (the reason for fake angles is beyond just bsendpacket, it has to do with usercmd execution but whatever, no one cares) .

Conclusion
Be sure to read the things I linked, since they're good resources to learn from. This isn't meant to be a step by step guide as to how you make your next external p2c, cuz I'm already doing that :P. This should just give you a little insight as to how externals work compared to internals, as well as project my std::ptrdiff_t propaganda.