Got a cheat engine table for Call of Duty Black Ops . Want to add infinite ammo , no…
- User
Got a cheat engine table for Call of Duty Black Ops . Want to add infinite ammo , no reload, no recoil, no spread, rapid fire.
- Assistant
I understand you're looking to expand your Cheat Engine (CE) table for Call of Duty: Black Ops (likely the original 2010 game, but specify if it's a remaster or different version like Black Ops Cold War). Before we dive in, a quick disclaimer: Cheating in online multiplayer modes can result in bans from Activision/Steam. I strongly recommend using these only in single-player campaign, zombies, or offline bots to avoid issues. Also, Cheat Engine cheats rely on memory scanning, and addresses can change based on your game version, patches, or even restarts (use pointers or AOB scans for reliability). If your table is for a specific edition (e.g., Steam vs. cracked), results may vary.
I'll guide you step-by-step on how to add infinite ammo, no reload, no recoil, no spread, and rapid fire to your CE table. This assumes you have basic knowledge of Cheat Engine (e.g., attaching to the process, scanning for values). If not, check out Cheat Engine tutorials on YouTube or the official wiki.
Prerequisites
- Game Version: Test on the latest patched version (e.g., Steam build). These work best in single-player or zombies.
- Cheat Engine Version: Use CE 7.5 or later for Lua scripting support.
- Attach to Process: Run the game, then in CE, attach to
BlackOps.exe(or similar, depending on your launcher). - Backup Your Table: Save your current .CT file before editing.
- Finding Addresses: Most cheats require scanning for values. Use "Exact Value" scans for numbers, or AOB (Array of Bytes) for code mods. Enable "Enable Speedhack" in CE if needed for testing.
If you share more details about your existing table (e.g., what cheats it already has), I can refine this.
1. Infinite Ammo
This prevents ammo from decreasing. It often involves freezing the current clip ammo and reserve ammo.
Steps to Add:
- Start a mission or zombies game with a weapon (e.g., M16).
- Note your current ammo (e.g., 30 in clip, 90 reserve).
- In CE: Scan for the clip ammo value (4-byte or float, depending on the game).
- Shoot a few bullets → Scan for decreased value.
- Refill ammo (if possible) → Scan for increased value.
- Repeat until you have 1-2 addresses.
- Common addresses (approximate, from community reports; these are base pointers – use pointer scans):
- Clip Ammo: Something like
BlackOps.exe + 0x123456(scan for your exact value). - Reserve Ammo: Often nearby or linked.
- Clip Ammo: Something like
- In your CE table:
- Add the address as a new entry.
- Set it to "Freeze" and a high value (e.g., 999) or use a script to hook it.
- Lua Script Example (Add this as an "Auto Assemble" script in your table):
[ENABLE] alloc(infAmmo, 128) label(return) infAmmo: mov [eax+0xOFFSET], #999 // Replace OFFSET with actual ammo offset from pointer scan jmp return // Hook the ammo decrement function (find via disassembly) "BlackOps.exe"+ADDRESS: // Replace with actual ammo decrement address jmp infAmmo return: [DISABLE] dealloc(infAmmo) - Test: Fire endlessly without ammo dropping.
2. No Reload
This makes your clip never empty, so no reload animation triggers. It pairs well with infinite ammo.
Steps to Add:
-
Similar to infinite ammo: Scan for clip size (e.g., 30 for assault rifles).
-
Shoot to empty the clip → Scan for 0.
-
Reload → Scan for max clip size.
-
Narrow it down, then freeze the value to max (e.g., 30 or 999).
-
Alternatively, find the "reload flag" (a boolean like 0/1) and freeze it to 0.
-
Script Example (Combine with infinite ammo):
- Extend the infinite ammo script to also set clip to max:
infAmmo: mov [eax+0xCLIP_OFFSET], #999 mov [eax+0xRESERVE_OFFSET], #999 jmp return
- Extend the infinite ammo script to also set clip to max:
-
Test: Empty your clip – it should auto-refill or never hit zero.
3. No Recoil
Recoil makes your aim kick up/back. This sets recoil multipliers to 0.
Steps to Add:
- This often requires code injection, as recoil is calculated in the game's code.
- Fire a weapon and use CE's dissector to find the recoil function (search for floats like 0.5-2.0 that increase on firing).
- Common method: AOB scan for the recoil code pattern.
- Example AOB (from old tables; scan for something like
F3 0F 58 40 ?? F3 0F 11 40 ??– this is approximate).
- Example AOB (from old tables; scan for something like
- Once found, nop (no-operation) the recoil addition or set multipliers to 0.
- Auto Assemble Script Example:
[ENABLE] aobscanmodule(recoilAOB, BlackOps.exe, F3 0F 58 40 ??) // Adjust AOB if needed label(recoilHook) registersymbol(recoilAOB) recoilAOB: jmp recoilHook recoilHook: mov [eax+0xRECOIL_X], 0 // Set horizontal recoil to 0 mov [eax+0xRECOIL_Y], 0 // Set vertical recoil to 0 addss xmm0, [eax+0xOFFSET] // Original code jmp recoilAOB + 5 // Jump back [DISABLE] unregistersymbol(recoilAOB) - Test: Fire full-auto; your crosshair shouldn't move.
4. No Spread
Spread causes bullets to deviate (e.g., hipfire inaccuracy). Set spread values to 0 for laser accuracy.
Steps to Add:
- Similar to recoil: Scan for spread floats (e.g., 0.1-1.0) that change when firing from hip vs. ADS (aim down sights).
- AOB scan for bullet spread calculation code.
- Common AOB: Something like
F3 0F 10 40 ?? 0F 57 C9(approximate). - Script Example (Similar to no recoil):
[ENABLE] aobscanmodule(spreadAOB, BlackOps.exe, F3 0F 10 40 ??) // Adjust label(spreadHook) registersymbol(spreadAOB) spreadAOB: jmp spreadHook spreadHook: mov [eax+0xSPREAD_OFFSET], 0 // Set spread to 0 movss xmm0, [eax+0xOFFSET] // Original jmp spreadAOB + 5 [DISABLE] unregistersymbol(spreadAOB) - Test: Hipfire should be pinpoint accurate.
5. Rapid Fire
This reduces the delay between shots, allowing full-auto fire rates on semi-auto weapons or faster bursts.
Steps to Add:
- Scan for the fire rate delay (a float or int, e.g., 0.1 seconds = 100ms).
- Fire a semi-auto weapon → Scan for unknown initial value, then scan for changed/unchanged during cooldown.
- Alternatively, find the weapon's RPM value and set it high (e.g., 9999).
- Script Example (Hook the fire delay function):
[ENABLE] aobscanmodule(rapidFireAOB, BlackOps.exe, 89 86 ?? ?? ?? ?? 8B 86) // Approximate AOB for fire rate label(rapidHook) registersymbol(rapidFireAOB) rapidFireAOB: jmp rapidHook rapidHook: mov [esi+0xFIRE_DELAY_OFFSET], 0 // Set delay to 0 mov [esi+0xRPM_OFFSET], #9999 // Or set RPM high mov [eax], esi // Original code jmp rapidFireAOB + 6 [DISABLE] unregistersymbol(rapidFireAOB) - Test: Semi-auto weapons should fire like machine guns.
Integrating into Your Table
- Open your .CT file in Cheat Engine.
- Add each as a new "Address" or "Auto Assemble Script" entry.
- Group them under a category like "Weapon Cheats."
- Enable/disable via checkboxes.
- If addresses change on restart, use pointer scans (right-click address → "Find what accesses this address") to make them dynamic.
Tips and Troubleshooting
- AOB Scans: If my example AOBs don't work, use CE's memory viewer to disassemble around weapon functions (search for strings like "recoil" or "spread" in the executable).
- Testing: Use zombies mode for easy testing – infinite waves let you iterate quickly.
- Existing Tables: Search for "Black Ops Cheat Engine Table" on sites like FearlessRevolution or UnknownCheats (be cautious of malware). Many have these features pre-made; you can merge them into yours.
- Issues: If the game crashes, disable one cheat at a time. For multiplayer, these might not work due to anti-cheat.
- Advanced: For reliability, use Lua scripts with hooks. If you're stuck, share a screenshot of your table or scan results.
If this doesn't work or you need more specific AOBs/offsets (e.g., for a particular game version), provide more details! Remember, this is for educational purposes – happy modding responsibly. 😊
- User
Start with infinite ammo first
- Assistant
Below, I'll guide you step-by-step on adding infinite ammo to your Cheat Engine (CE) table for Call of Duty: Black Ops (assuming the original 2010 game; if it's a different version like Black Ops Cold War, let me know for adjustments). This works best in single-player campaign, zombies, or offline modes—avoid online multiplayer to prevent bans.
Infinite ammo typically means your clip (current magazine) and reserve ammo never decrease. We'll achieve this by finding the relevant memory addresses and either freezing them or using a script to hook the ammo decrement function. Addresses can change between game sessions, so I'll emphasize using pointer scans or AOB (Array of Bytes) for reliability.
Prerequisites
- Game Running: Start a single-player mission or zombies game. Equip a weapon with ammo (e.g., an assault rifle like the M16).
- Cheat Engine: Version 7.5+ recommended. Attach to
BlackOps.exe(or the equivalent process name if using a launcher like Steam). - Scan Settings: Use "4 Bytes" or "Float" value type, as ammo is often stored this way.
- Backup: Save your existing .CT table file before editing.
Step 1: Find the Ammo Addresses Manually
- Load into Game: Note your current clip ammo (e.g., 30/90, where 30 is in the clip and 90 is reserve).
- Scan for Clip Ammo:
- In CE, go to the Memory Scanner tab.
- Set Value Type to "4 Bytes" (or try "Float" if no results).
- First Scan: Enter your current clip ammo (e.g., 30) and click "First Scan."
- Fire a few shots to reduce ammo (e.g., to 25).
- Next Scan: Search for the new value (e.g., 25) using "Next Scan."
- Repeat: Fire more → Scan for decreased value. Pick up ammo or restart if needed to scan for increased values.
- Narrow it down to 1-5 addresses. (Commonly, clip ammo is around offsets like
0x14or0x18from a weapon base pointer.)
- Scan for Reserve Ammo:
- Repeat the process for your reserve ammo (e.g., start at 90, use ammo until it drops, scan for decreased value).
- These addresses are often close to the clip ammo (e.g., +4 or +8 bytes apart).
- Test Addresses:
- Add promising addresses to your address list (right-click in scan results → "Add address manually").
- Change the value to something high (e.g., 999) and see if your in-game ammo updates without decreasing when you fire.
- If it works but resets on reload/restart, proceed to pointer scans.
Step 2: Make It Reliable (Pointer Scan or AOB)
Static addresses often change, so use a pointer scan:
- Right-click a working ammo address → "Pointer scan for this address."
- Set levels to 4-6 and max offset to 0x1000.
- Rescan in a new game area to confirm (save the .PTR file for reuse).
- This gives a dynamic pointer like
[[BlackOps.exe + 0xBASE] + 0xOFFSET] + 0xCLIP_OFFSET.
If pointers are tricky, use an AOB scan for the ammo structure (more advanced but stable across restarts).
Step 3: Add to Your CE Table
Open your .CT file in CE and add infinite ammo as a new entry. There are two ways: simple freezing (easy but may not survive level loads) or a script (better for hooking the game's code).
Option 1: Simple Freezing (Beginner-Friendly)
- In your table, right-click → "Add Address Manually."
- Enter the pointer or address for clip ammo.
- Description: "Infinite Clip Ammo"
- Set Value to 999 (or your weapon's max clip size) and check "Freeze."
- Repeat for reserve ammo.
- Enable in-game and test: Fire endlessly—ammo shouldn't drop.
If it stops working after a while, use the script below.
Option 2: Auto Assemble Script (Recommended for Reliability)
This hooks the ammo decrement function to set it back to max. It's more robust.
- In CE, go to your table → Right-click → "Auto assemble" (or press Ctrl+Alt+A).
- Paste this Lua script (adjust offsets based on your scans):
[ENABLE] // Alloc memory for our hook alloc(infAmmoHook, 128) label(returnhere) label(originalcode) // Replace with your actual ammo decrement AOB or address (scan for code that subtracts from ammo, e.g., via disassembler) aobscanmodule(ammoDecrement, BlackOps.exe, 29 50 14 8B 40 14) // Example AOB; find yours by disassembling around ammo changes registersymbol(ammoDecrement) ammoDecrement: jmp infAmmoHook returnhere: infAmmoHook: // Original code (nop or replicate if needed) originalcode: sub [eax+14], edx // Example original instruction; adjust based on disassembly // Set ammo to infinite mov [eax+0x14], #999 // Clip offset (replace 0x14 with yours) mov [eax+0x18], #999 // Reserve offset (replace 0x18 with yours) jmp returnhere [DISABLE] // Restore original ammoDecrement: db 29 50 14 8B 40 14 // Restore original bytes unregistersymbol(ammoDecrement) dealloc(infAmmoHook) - Customize the Script:
- AOB: This is key. To find it:
- Right-click your ammo address → "Find what writes to this address."
- Fire shots to trigger writes → Look at the disassembler for the subtracting code (e.g.,
sub [eax+0x14],1). - Right-click that instruction → "Find what addresses this code accesses" → Generate AOB.
- Replace the example AOB (
29 50 14 8B 40 14) with yours.
- Offsets: From your pointer scan (e.g.,
0x14for clip,0x18for reserve). - Set
#999to your preferred max ammo.
- AOB: This is key. To find it:
- Save the table, enable the script (checkbox), and test.
Testing and Troubleshooting
- Test: Fire your weapon continuously. Ammo should stay at max (or reset to max instantly).
- Common Issues:
- No Results in Scan: Try "Float" instead of "4 Bytes." Or scan in different modes (e.g., zombies vs. campaign).
- Addresses Change: Always use pointers or AOB. Restart the game and rescan to verify.
- Game Crashes: Disable the cheat, lower the value (e.g., to 100), or check for anti-cheat interference (rare in single-player).
- Multi-Weapon Support: This might only work for your current weapon. For all weapons, hook a global function (scan for weapon switch code).
- Version-Specific: If this is for Black Ops on Steam (v1.0 or patched), offsets might differ. Community forums like UnknownCheats have pre-made tables—search for "Black Ops Infinite Ammo CE" and merge into yours.
- Debug: Enable CE's "Debug" mode and watch the console for errors.
If this works, we can move to no reload next (it builds directly on this). If you run into issues (e.g., share your scan results, AOB, or a screenshot), or if the script doesn't hook properly, reply with details—I can refine it! Remember to use responsibly. 😊
- User
Got the 1 adress that freezes ammo for current weapon
- Assistant
Awesome! Congrats on finding that address for infinite ammo—it sounds like you've nailed the clip or reserve ammo value, and freezing it keeps it from decreasing for your current weapon. That's a solid start. Since it's weapon-specific (and addresses can shift on game restarts, weapon swaps, or level loads), I'll first help you make this more reliable by turning it into a dynamic pointer or a simple script in your Cheat Engine (CE) table. Then, we'll move on to no reload, as it's a natural next step (it builds on ammo manipulation and prevents the reload animation by keeping the clip full).
If this address already works perfectly across weapons/restarts, great—we can skip to no reload. Otherwise, follow these tweaks.
Step 1: Make Your Infinite Ammo Address Reliable
Static addresses often break, so let's use a pointer scan to make it dynamic. This way, it auto-adjusts.
-
Perform a Pointer Scan:
- In CE, with your ammo address in the address list, right-click it → "Pointer scan for this address."
- Settings:
- Max level: 4-6 (start with 4).
- Max offset: 0x1000 (4096).
- Check "Include pointers with no pointers" if needed.
- Click OK and let it scan (it might take a minute).
- Save the results as a .PTR file for backup.
- Restart the game or swap weapons, then rescan the same address to filter results (File → Pointer rescan, load your .PTR).
- Aim for 1-2 stable pointers (e.g., something like
BlackOps.exe + 0xBASE_OFFSET + 0xWEAPON_OFFSET + 0xAMMO_OFFSET).
-
Add to Your Table as a Pointer:
- In your .CT table, right-click → "Add address manually."
- Enter the pointer path (e.g.,
[[BlackOps.exe + 0x123456] + 0x78] + 0x14—use your values). - Description: "Infinite Ammo (Clip)"
- Type: 4 Bytes (or Float, based on your scan).
- Check "Pointer" and add the offsets.
- Set the value to 999 (or max clip size) and freeze it.
- If you have separate addresses for clip and reserve, repeat for reserve (often +4 or +8 bytes from clip).
-
Optional: Simple Script for Auto-Reset If freezing alone isn't enough (e.g., it resets on weapon swap), add this Auto Assemble script to your table. It hooks and forces the value. Replace placeholders with your details.
[ENABLE] alloc(infAmmo, 128) registersymbol(infAmmoPtr) // Your pointer base (from scan) infAmmoPtr: dd (int)0 // Will be set to your pointer infAmmo: // Read the pointer and set ammo mov eax, [infAmmoPtr] // Load base add eax, 0xOFFSET1 // Add offsets from your pointer scan add eax, 0xOFFSET2 mov [eax + 0xAMMO_OFFSET], #999 // Set to infinite (replace OFFSETs) // Hook to a timer or call this repeatedly (optional for auto-reset) // For simplicity, enable this and it will run once; use CE's timer for looping if needed [DISABLE] unregistersymbol(infAmmoPtr) dealloc(infAmmo)- Customize: Use your pointer offsets. To make it loop (e.g., every 100ms), add a timer in CE (Tools → Lua Engine) or extend the script.
- Test: Swap weapons or reload the level—ammo should stay infinite.
This should make your infinite ammo work for any weapon without rescanning each time.
Step 2: Adding No Reload
No reload prevents the clip from hitting zero, so you never trigger the reload animation. It's similar to infinite ammo but focuses on keeping the clip at max constantly (even if you "empty" it). If your address is for the clip, we can build on it directly.
Manual Scan for No Reload
- In-Game Setup: Equip a weapon, note the max clip size (e.g., 30).
- Scan for Clip Size:
- In CE: Value Type "4 Bytes" (or Float).
- First Scan: Search for your current clip (e.g., 30).
- Fire until almost empty (e.g., to 1) → Next Scan for decreased value.
- Reload (or pick up ammo) to refill → Next Scan for increased value (back to 30).
- Repeat firing/reloading until you have 1-3 addresses. (This is often the same as your infinite ammo address!)
- Test:
- Add the address to your list.
- Freeze it to the max value (e.g., 30 or 999).
- Fire: The clip shouldn't drop below max, and no reload should occur.
If it's the same address as your infinite ammo, you can just combine them—freeze to 999 for both infinite ammo and no reload.
Make It Reliable (Pointer or Script)
-
Use the same pointer scan method as above if needed.
-
Auto Assemble Script for No Reload (Combines with Infinite Ammo): This sets the clip to max whenever it tries to decrease.
[ENABLE] // Alloc hook alloc(noReloadHook, 128) label(returnhere) // AOB for clip decrement (find via "Find what writes to this address" on your clip address) aobscanmodule(clipDec, BlackOps.exe, 83 68 ?? 01 8B) // Example AOB; replace with yours (e.g., sub instruction for clip) registersymbol(clipDec) clipDec: jmp noReloadHook returnhere: noReloadHook: // Set clip to max instead of decrementing mov [eax + 0xCLIP_OFFSET], #999 // Replace with your offset (e.g., 0x14) // Original code (adjust based on disassembly) sub [eax + 0xCLIP_OFFSET], 1 // If this was the original, nop it or skip jmp returnhere [DISABLE] clipDec: db 83 68 ?? 01 8B // Restore original bytes unregistersymbol(clipDec) dealloc(noReloadHook)- Finding the AOB: Right-click your clip address → "Find what writes to this address." Fire shots to log writes. Disassemble the code and generate AOB from the decrement instruction (e.g.,
sub [reg+offset],1). - Test: Empty your clip—it should instantly refill or stay full, with no reload animation.
- Finding the AOB: Right-click your clip address → "Find what writes to this address." Fire shots to log writes. Disassemble the code and generate AOB from the decrement instruction (e.g.,
Integration Tip
- If your infinite ammo address is the clip, enabling freeze on it might already give no reload. Test that first!
- Add both to your table under a group (e.g., right-click → "Group" → Name it "Ammo Cheats").
- Enable them together for "infinite ammo + no reload."
Testing and Next Steps
- Test Combo: With both enabled, you should fire indefinitely without ammo dropping or reloading.
- Issues?
- If it only works for one weapon: The address might be per-weapon—scan for a global ammo handler.
- Crashes or no effect: Double-check value type (4 Bytes vs. Float) or try in zombies mode.
- Share details: If the script doesn't work, send your address, pointer, or AOB—I can tweak it.
Once this is solid, reply with "Ready for no recoil" (or whichever next), and we'll proceed! We're making great progress. 😊
-
- User
Got the 1 adress that freezes ammo for current weapon
- Assistant
Awesome! Congrats on finding that address for infinite ammo—it sounds like you've nailed the clip or reserve ammo value, and freezing it keeps it from decreasing for your current weapon. That's a solid start. However, since it's tied to the current weapon, the address might change if you switch guns, pick up a new one, or reload the level. To make it more reliable (and work across weapons), I'll quickly guide you on turning it into a dynamic pointer. Then, as planned, we'll move on to no reload, which builds directly on this (it essentially prevents the clip from hitting zero, skipping the reload animation).
If this address already works perfectly for you (even across weapons), feel free to skip to the no reload section. Let's keep building your table!
Step 1: Make Your Infinite Ammo Address Reliable (Pointer Scan)
This ensures the cheat survives weapon switches or game restarts.
-
Perform a Pointer Scan:
- In Cheat Engine (CE), with your working address in the address list, right-click it → "Pointer scan for this address."
- In the Pointer Scanner window:
- Set "Max level" to 4-6 (start with 4).
- Set "Max offset" to 0x1000 (4096 in decimal).
- Check "Include pointers with no symbols" if needed.
- Click "Pointer scan."
- This will generate a list of pointers (e.g., something like
BlackOps.exe + 0xBASE_OFFSET + 0xSUB_OFFSETpointing to your ammo value). - Save the results as a .PTR file for later use.
-
Test and Refine:
- Add the best pointer (one with green/static modules like
BlackOps.exe) to your table. - Switch weapons in-game, fire a bit, and check if the pointer still points to the correct ammo value.
- If it breaks, restart the game, rescan for the new ammo value, then right-click the pointer → "Rescan pointer list" using the .PTR file and the new address.
- Narrow it down to 1-2 reliable pointers. (Commonly, weapon data is in a structure with ammo at offsets like +0x14 for clip and +0x18 for reserve.)
- Add the best pointer (one with green/static modules like
-
Add to Your Table:
- In your .CT file, replace the static address with the pointer.
- Set it to freeze at a high value (e.g., 999).
- If you want it for both clip and reserve, add separate entries (they're often adjacent offsets).
If pointers are confusing or don't work, we can switch to an AOB script like in my previous response—let me know.
Step 2: Adding No Reload
No reload means your weapon never needs to reload—either by keeping the clip always full (building on infinite ammo) or by disabling the reload trigger/animation. This is often achieved by freezing the clip ammo to its max value (e.g., 30 for an assault rifle) so it never reaches zero. If you've already got infinite ammo freezing the clip, this might already partially work! We'll refine it.
Note: This works best with infinite ammo enabled, as they complement each other. Test in a mode like zombies where you can fire endlessly.
Manual Method (Simple Freezing)
-
Find the Clip Ammo Address (You Might Already Have It):
- If your existing address is for the clip (current magazine), you're set—skip to step 3.
- Otherwise: In-game, note your full clip size (e.g., 30).
- In CE: Scan for that value (4 Bytes or Float).
- Fire shots to empty the clip (e.g., to 0) → Next Scan for decreased value (or exactly 0).
- Reload (clip goes back to 30) → Next Scan for increased value.
- Repeat until you have 1-2 addresses. (This should be the same or very close to your infinite ammo address.)
-
Do a Pointer Scan (For Reliability):
- Same as above: Right-click the address → Pointer scan.
- Aim for a dynamic pointer that works across weapons.
-
Add to Table and Freeze:
- In your CE table, add the address/pointer.
- Description: "No Reload (Clip Always Full)"
- Set the value to your weapon's max clip size (e.g., 30) or higher (e.g., 999 for overfill).
- Check "Freeze."
- Enable it, fire your entire clip—it should stay at max and never trigger reload.
-
Test:
- Fire continuously. The clip shouldn't drop to zero, and no reload animation should play.
- Switch weapons and test again. If it fails, refine the pointer.
Script Method (More Advanced, Handles All Weapons Better)
If freezing doesn't survive weapon switches or level loads, use this Auto Assemble script. It hooks the game's clip decrement code and forces it back to max.
-
Find the Relevant Code (Via Disassembler):
- Right-click your clip ammo address → "Find what writes to this address."
- Fire shots to trigger writes. You'll see instructions like
sub [eax+0x14],1(subtracting from the clip). - Note the address of that instruction (e.g.,
BlackOps.exe + 0xABCDEF). - Generate an AOB: Right-click the instruction → "Copy bytes to clipboard" or use CE's AOB scan tool.
-
Add the Script to Your Table:
- In CE, right-click in your table → "Auto assemble."
- Paste this (customize with your details):
[ENABLE] // Alloc hook memory alloc(noReloadHook, 128) label(returnhere) label(originalcode) // Replace with your AOB or address for clip decrement (from step 1) aobscanmodule(clipDecrement, BlackOps.exe, 83 E8 01 89 41 14) // Example AOB; replace with yours (e.g., for sub [ecx+0x14],1) registersymbol(clipDecrement) clipDecrement: jmp noReloadHook returnhere: noReloadHook: // Original code (adjust to match your disassembly) originalcode: sub [ecx+0x14],1 // Example original instruction // Force clip to max (no reload) mov [ecx+0x14], #30 // Replace #30 with max clip size (or #999 for infinite-style) jmp returnhere [DISABLE] // Restore original clipDecrement: db 83 E8 01 89 41 14 // Restore original bytes (match your AOB) unregistersymbol(clipDecrement) dealloc(noReloadHook) - Customizations:
- AOB: Use the one from your disassembly (e.g., bytes like
83 E8 01for subtract 1). - Offsets: Like
+0x14for clip—match your pointer scan. - Max Value: Set to your weapon's clip size for realism, or high for fun.
- AOB: Use the one from your disassembly (e.g., bytes like
- Save and enable the script checkbox.
-
Test:
- Fire away—the clip should reset to max instantly, skipping reload.
- If it crashes, double-check the AOB/original code. Disable and re-enable to test.
Tips and Troubleshooting
- Combo with Infinite Ammo: Enable both together for "true" infinite no-reload (e.g., freeze reserve ammo too).
- Weapon-Specific Issues: Some weapons (e.g., shotguns) have unique reload mechanics—test multiple types.
- If It Doesn't Work: Share details like your address (e.g.,
0x12345678), pointer path, or a screenshot of the "what writes" results. Also, confirm your game version (e.g., Steam, v1.0). - Next Up: Once this is solid, reply with "Ready for no recoil" (or whatever you want next), and we'll add that. If you want to combine infinite ammo and no reload into one script, let me know!
Great job so far—keep me posted on how it goes! 😊
-