def simultaneous_fight(self, my_mappings, node_ip, predictions, origin_ntp):
        """
        TCP hole punching algorithm. It uses network time servers to
        synchronize two nodes to connect to each other on their
        predicted remote ports at the exact same time.

        One thing to note is how sensitive TCP hole punching is to
        timing. To open a successful connection both sides need to
        have their SYN packets cross the NAT before the other side's
        SYN arrives. Round-trip time for connections is 0 - 1000ms
        depending on proximity. That's a very small margin of error
        for hole punching, hence using NTP.

        See "TCP Hole Punching" http://www.ietf.org/rfc/rfc5128.txt
        and http://en.wikipedia.org/wiki/TCP_hole_punching
        for more details.
        """

        # Get current network time accurate to
        # ~50 ms over WAN (apparently.)
        p = request_priority_execution()
        log.debug("Getting NTP")
        if self.sys_clock is not None:
            our_ntp = self.sys_clock.time()
        else:
            our_ntp = get_ntp()
        log.debug("Our ntp = " + str(our_ntp))
        if our_ntp is None:
            return 0

        # Synchronize code execution to occur at their NTP time + delay.
        current = float(our_ntp)
        future = float(origin_ntp) + float(self.ntp_delay)
        sleep_time = future - current

        # Check sleep time:
        log.debug("Waiting for fight")
        if sleep_time < 0:
            log.debug("We missed the meeting! It happened " + str(-sleep_time) +
                      "seconds ago!")
            return 0

        if sleep_time >= 300:
            log.debug("Future sleep time is too great!")
            return 0

        busy_wait(sleep_time)
        release_priority_execution(p)

        log.debug("At fight")
        """
        Time.sleep isn't guaranteed to sleep for the time specified
        which could cause synchronisation to be off between nodes
        and different OS' as per the discretion of the task scheduler.
        A busy wait is used to increase the accuracy of sleep.
        http://stackoverflow.com/questions/17499837/python-time-sleep-vs-busy-wait-accuracy
        http://stackoverflow.com/questions/1133857/how-accurate-is-pythons-time-sleep
        """

        # Can you dodge my special?
        """
        Making this algorithm "multi-threaded" has the potential to
        ruin predicted mappings for delta type NATs and NATs that
        have no care for source ports and assign incremental
        ports no matter what.
        """
        threads = []
        log.debug("Mapping len " + str(len(my_mappings)))
        for mapping in my_mappings:
            # Tried all predictions.
            prediction_len = len(predictions)
            if not prediction_len:
                break

            # Throw punch.
            prediction = predictions[0]
            if self.nat_type == "delta":
                self.throw_punch([mapping["sock"], node_ip, prediction])
            else:
                # Thread params.
                args = ([
                    mapping["sock"],
                    node_ip,
                    prediction
                ], 20)

                # Start thread.
                t = Thread(
                    target=self.throw_punch,
                    args=args
                )
                threads.append(t)
                t.start()

            predictions.remove(prediction)

        # Wait for threads to finish.
        for t in threads:
            t.join()

        return 1