void loadframe(int fr) {
        List<game_obj> gos = new List<game_obj>();
        foreach(game_obj go in p1.active_game_objs) {
            gos.Add(go);
        }
        foreach(game_obj go in p2.active_game_objs) {
            gos.Add(go);
        }
        foreach(game_obj go in gos) {
            go.load_frame(fr);
        }
        p1.load_frame(fr);
        p2.load_frame(fr);
    }
    void new_savestate() {
        p1.sim_frame = local_frame;
        p2.sim_frame = local_frame;
        p1.save_state();
        p2.save_state();
        List<game_obj> goos = new List<game_obj>();
        foreach(game_obj go in p1.active_game_objs) {
            goos.Add(go);
        }
        foreach(game_obj go in p2.active_game_objs) {
            goos.Add(go);
        }
        foreach(game_obj go in goos) {
            go.sim_frame = local_frame;
            go.save_state();
        }

    }
    void overwrite_savestate(int f) {
        p1.sim_frame = f;
        p2.sim_frame = f;
        p1.frame_save();
        p2.frame_save();
        List<game_obj> goos = new List<game_obj>();
        foreach(game_obj go in p1.active_game_objs) {
            goos.Add(go);
        }
        foreach(game_obj go in p2.active_game_objs) {
            goos.Add(go);
        }
        foreach(game_obj go in goos) {
            go.sim_frame = f;
            go.frame_save();
        }

    }
    /*

Start Program:
    [Initialize Variables]

    loop:

    [Update Network]
    [Update Synchronization]
    if [Time Synced] then
        [Normal Update]
    goto loop

End Program
    */
    int MAX_ROLLBACK_FRAMES = 30;
    int FRAME_ADVANTAGE_LIMIT = 6;
    int INITAL_FRAME = 10;

    int local_frame = 0;
    int remote_frame = 0;
    int sync_frame = 0;
    int remote_frame_advantage = 0;

    byte last_remote_input = 0;

    List<inputframe> inputframes = new List<inputframe>();
    /*
    MAX_ROLLBACK_FRAMES     := Any Positive Integer         # Specifies the maximum number of frames that can be resimulated
    FRAME_ADVANTAGE_LIMIT   := Any Positive Integer         # Specifies the number of frames the local client can progress ahead of the remote client before time synchronizing.
    INITAL_FRAME            := Any Integer                  # Specifies the initial frame the game starts in. Cannot rollback before this frame.

    [Initialize Variables]
    local_frame   := INITAL_FRAME                       # Tracks the latest updates frame.
    remote_frame  := INITAL_FRAME                       # Tracks the latest frame received from the remote client
    sync_frame    := INITAL_FRAME                       # Tracks the last frame where we synchronized the game state with the remote client. Never rollback before this frame.
    remote_frame_advantage := 0                         # Latest frame advantage received from the remote client.


    photonView.RPC("getInput", PhotonTargets.Others, i.my_input, i.myframe);
    PhotonNetwork.SendOutgoingCommands();

    */
    void rlbk_update_input(inputframe i) {
    /*
        [Update Input]
        Predict the remote player's input if not available yet.
        Setup the local player and remote player's input for use in [Update Game]
    */
        if(i.remote_input == 0) {
            if(last_remote_input!=0) {
                i.predicted_input = last_remote_input;
            }
            else {
                i.predicted_input = 50;
            }

        }
        give_inputs(localPlayer(),i.local_input);

        if(i.remote_input != 0) {
            give_inputs(localPlayer().enemy,i.remote_input);
        }
        else {
            give_inputs(localPlayer().enemy,i.predicted_input);
        }
    }

    void rlbk_execute_rollbacks() {
    /*
        [Execute Rollbacks]
        [Restore Game State]
        select inputs from (sync_frame + 1) through local_frame     # Use all the inputs since the last sync frame until the current frame to simulate
            [Rollback Update]
    */
        loadframe(sync_frame);

        for(int i = sync_frame+1; i <= local_frame; i++) {
            foreach(inputframe inp in inputframes) {
                if(inp.myframe == i) {
                    /*
                    [Update Input]
                    [Update Game]
                    [Store Game State]
                    */
                    rlbk_update_input(inp);
                    rlbk_update_game(i);
                    overwrite_savestate(i);
                }
            }
        }

    }

    void rlbk_update_game(int fr) {
        p1.sim_frame = fr;
        p2.sim_frame = fr;
        p1.frame_update(fr);
        p2.frame_update(fr);
    }
    bool rlbk_timesynced() {
    /*
    bool [Time Synced]
        Let local_frame_advantage = local_frame - remote_frame                                   # How far the client is ahead of the last reported frame by the remote client
        Let frame_advantage_difference = local_frame_advantage - remote_frame_advantage          # How different is the frame advantage reported by the remote client and this one.
        local_frame_advantage < MAX_ROLLBACK_FRAMES AND frame_advantage_difference <= FRAME_ADVANTAGE_LIMIT     # Only allow the local client to get so far ahead of remote.

    */
        int local_frame_advantage = local_frame - remote_frame;
        int frame_advantage_difference = local_frame_advantage - remote_frame_advantage;

        return local_frame_advantage < MAX_ROLLBACK_FRAMES && frame_advantage_difference <= FRAME_ADVANTAGE_LIMIT;
    }

    byte localbyteinput = 0;

    void rlbk_normalupdate() {
    /*
    [Normal Update]
        Increment local_frame
        [Get Local Player Input]
        [Send input to remote client]

        [Update Input]
        [Update Game]
        [Store Game State]
    */
        local_frame++;
        localbyteinput = byte_input(localPlayer());
        inputframe lfi = rlbk_get_local_player_input();
        rlbk_send_input_to_remote_client();

        rlbk_update_input(lfi);
        rlbk_update_game(local_frame);

        new_savestate();

    }

    void rlbk_send_input_to_remote_client() {
        //    Send the input and the local_frame to the remote client so it arrives asap.
        photonView.RPC("getInput", PhotonTargets.Others, localbyteinput, local_frame);
        PhotonNetwork.SendOutgoingCommands();
    }

    inputframe rlbk_get_local_player_input() {
        //Read the joystick/pad/keyboard for the local player and store it, associating it with local_frame

        inputframe ii=null;
        foreach(inputframe i in inputframes) {
            if(i.myframe == local_frame) {
                ii = i;
            }
        }
        if(ii == null) {
            ii = new inputframe();
            inputframes.Add(ii);
            ii.predicted_input = last_remote_input;
            ii.myframe = local_frame;
        }

        ii.local_input = localbyteinput;
        return ii;

    }



    bool rlbk_rollback_condition() {
    /*
        bool [Rollback Condition]
        local_frame > sync_frame AND remote_frame > sync_frame      # No need to rollback if we don't have a frame after the previous sync frame to synchronize to.
    */
        return local_frame > sync_frame && remote_frame > sync_frame;
    }
    void rlbk_updatenetwork() {
   /* [Update Network]
        Let remote_frame = latest frame received from the remote client
        Let remote_frame_advantage = (local_frame - remote_frame) sent from the remote client
    */
        remote_frame = online_frame;
        remote_frame_advantage = (local_frame - remote_frame);
    }
    class inputframe {
        public int myframe=0;
        public byte local_input=0;
        public byte predicted_input=0;
        public byte remote_input = 0;
    }
    void rlbk_determinesyncframe() {
    /*
    [Determine the sync_frame]
        Let final_frame = remote_frame                                          # We will only check inputs until the remote_frame, since we don't have inputs after.
        if remote_frame > local_frame then final_frame = local_frame           # Incase the remote client is ahead of local, don't check past the local frame.
        select frames from (sync_frame + 1) through final_frame and find the first frame where predicted and remote inputs don't match
            if found then
                sync_frame = found frame - 1        # The found frame is the first frame where inputs don't match, so assume the previous frame is synchronized.
            else
                sync_frame = final_frame            # All remote inputs matched the predicted inputs since the last synchronized frame.
    */
        int final_frame = remote_frame;
        if(remote_frame > local_frame) {
            final_frame = local_frame;
        }

        inputframe oic = null; // find the oldest incorrect input frame

        foreach(inputframe inp in inputframes) {
            if(inp.myframe >= sync_frame+1 && inp.myframe <= final_frame) {
                if(inp.remote_input != inp.predicted_input) {
                    if(oic == null) {
                        oic = inp;
                    }
                    else {
                        if(inp.myframe < oic.myframe) {
                            oic = inp;
                        }
                    }
                }
            }
        }

        if(oic != null) {
            sync_frame = oic.myframe - 1;
        }
        else {
            sync_frame = final_frame;
        }


    }
    void rlbk_updatesync() {
    /*
    [Update Synchronization]
        [Determine the sync_frame]
        if [Rollback Condition] then
            [Execute Rollbacks]
    */
        rlbk_determinesyncframe();
        if(rlbk_rollback_condition() == true) {
            rlbk_execute_rollbacks();
        }
    }

    void rlbk_init() {
        local_frame = INITAL_FRAME;
        remote_frame = INITAL_FRAME;
        sync_frame = INITAL_FRAME;
        remote_frame_advantage = 0;
    }
    void online_sendinput() {

       /* if(playingonline==false) {
            photonView.RPC("startgame", PhotonTargets.Others);
            Debug.Log("nope " + local_frame);
            return;
        }*/

        if(timer_synced==false) {

            countups=0;
            syncTimers();
            rlbk_init();

        }
        rlbk_updatenetwork();
        rlbk_updatesync();

        if(rlbk_timesynced() == true) {
            rlbk_normalupdate();
            dotimer();
            List<inputframe> deads = new List<inputframe>();
            foreach(inputframe i in inputframes) {
                if(i.myframe < local_frame - MAX_ROLLBACK_FRAMES - 1) {
                    deads.Add(i);
                }
            }
            foreach(inputframe d in deads) {
                inputframes.Remove(d);
            }
        }

        gameui();

    }

    [PunRPC]
    void onlineready() {
        character_select_online();

    }
    /*[PunRPC]
    void startgame() {
        playingonline=true;
    }*/
    [PunRPC]
    void closeroom() {
        if(PhotonNetwork.connected==true && in_game==true) {
            online_disconnect();
            gametomenu();
            reset_game();
        }

    }
    [PunRPC]
    void pickchar(int gx, int gy) {
        localPlayer().enemy.myc.online_char_sel(gx,gy);
    }

    int online_frame=0;
    [PunRPC]
    void getInput(byte input1, int theframe) {
        online_frame = theframe;
        last_remote_input = input1;

        bool bb=false;
        foreach(inputframe i in inputframes) {
            if(i.myframe == theframe) {
                i.remote_input = input1;
                bb=true;
            }
        }
        if(bb == false) {
            inputframe i = new inputframe();
            inputframes.Add(i);
            i.myframe = theframe;
            i.remote_input = input1;
            i.predicted_input = input1;
        }

    }