Beispiel #1
0
 /// <summary>
 /// Determines whether a <see cref="MethodCall"/> should be called.
 /// </summary>
 /// <param name="next_method">The <see cref="MethodCall"/> about to be called.</param>
 /// <param name="parameters">Extra data about the call location.</param>
 /// <returns>True if the call should be called.</returns>
 public bool EvaluateMethodCall(MethodCall next_method, CallLocationParameters parameters) => number_of_attempts == parameters.attempted_splices_since_last_splice;
Beispiel #2
0
        // Functions
        /// <summary>
        /// Generates all the changes in the touch (could be computationally intensive).  Called once when <see cref="TouchBase.changes"/> is accessed.
        /// </summary>
        public override Change[] ComputeChanges()
        {
            List <Change> changes = new List <Change> ();

            int method_call_length = method_calls == null ? 1 : method_calls.Length;
            int basic_call_length  = basic_calls == null ? 1 : basic_calls.Length;

            int max_lead_length = method_calls == null ?
                                  start_method.lead_length :
                                  Math.Max(start_method.lead_length, method_calls.Select(x => x.method.lead_length).Max());

            List <Change> [] change_states = new List <Change> [method_call_length * basic_call_length * max_lead_length];

            for (int i = 0; i < change_states.Length; i++)
            {
                change_states [i] = new List <Change> ();
            }

            margin_calls           = new Dictionary <int, char> ();
            right_hand_calls       = new Dictionary <int, string> ();
            lead_head_line_indices = new List <int> ();

            right_hand_calls.Add(-1, "Go " + start_method.title);

            int lead_index        = 0;
            int sub_lead_index    = 0;
            int call_index        = 0;
            int method_call_index = 0;

            int sub_splice_change_index = 0;
            int sub_splice_lead_index   = 0;

            int attempted_calls_since_last_call     = 0;
            int attempted_splices_since_last_splice = 0;

            int absolute_change_index = 0;

            CallPoint current_callpoint = null;

            Change current_change = Change.Rounds(stage);
            Method current_method = start_method;

            while (true)
            {
                #region Update calls
                if (current_callpoint == null)
                {
                    // Not in a call => Could be starting a call
                    if (basic_calls != null && basic_calls.Length > 0)
                    {
                        BasicCall basic_call = basic_calls [call_index];
                        Call      call       = basic_call.call;

                        if ((sub_lead_index - call.from + 1) % call.every == 0)
                        {
                            CallLocationParameters call_location_parameters = new CallLocationParameters(current_method, current_change, absolute_change_index, sub_lead_index, lead_index, attempted_calls_since_last_call, attempted_splices_since_last_splice, this);

                            if (basic_call.call_location.EvaluateBasicCall(call, call_location_parameters))
                            {
                                current_callpoint = new CallPoint(call, absolute_change_index);

                                attempted_calls_since_last_call = 0;

                                if (!call.is_plain)
                                {
                                    margin_calls.Add(absolute_change_index, call.preferred_notation);
                                }
                            }
                            else
                            {
                                attempted_calls_since_last_call += 1;
                            }
                        }
                    }
                }
                else
                {
                    // In a call, so could be stopping a call
                    if (absolute_change_index > current_callpoint.end_index)
                    {
                        sub_lead_index += current_callpoint.call.cover;

                        if (sub_lead_index >= current_method.place_notations.Length)
                        {
                            lead_head_line_indices.Add(absolute_change_index - 1);

                            sub_lead_index = 0;
                            lead_index    += 1;
                        }

                        call_index += 1;
                        if (call_index >= basic_calls.Length)
                        {
                            call_index = 0;
                        }

                        current_callpoint = null;
                    }
                }
                #endregion

                #region Update change (transposition)
                PlaceNotation notation;
                if (current_callpoint == null)
                {
                    notation = current_method.place_notations [sub_lead_index];
                }
                else
                {
                    notation = current_callpoint.GetNotationAtIndex(absolute_change_index);

                    if (notation == null)
                    {
                        notation = current_method.place_notations [sub_lead_index + absolute_change_index - current_callpoint.start_index];
                    }
                }

                current_change = current_change.Transpose(notation);

                // Add change to list
                changes.Add(current_change);
                #endregion

                #region Update method splicing calls
                if (method_calls != null && method_calls.Length > 0)
                {
                    MethodCall current_method_call = method_calls [method_call_index];

                    if (sub_lead_index == current_method.lead_length + current_method_call.splice_start_index - 1)
                    {
                        CallLocationParameters parameters = new CallLocationParameters(current_method, current_change, absolute_change_index, sub_lead_index, lead_index, attempted_calls_since_last_call, attempted_splices_since_last_splice, this);

                        if (current_method_call.location.EvaluateMethodCall(current_method_call, parameters))
                        {
                            current_method = current_method_call.method;

                            method_call_index += 1;

                            sub_lead_index = current_method_call.splice_end_index - 1;                             // Set to splice_end_index - 1, because later in this iteration of the while loop, 1 will be added to it, to get splice_end_index.

                            // Make sure that lead ends get counted even if there was a splice over the lead end.
                            if (current_method_call.splice_end_index == 0)
                            {
                                sub_lead_index = current_method.lead_length - 1;
                            }

                            sub_splice_change_index = 0;
                            sub_splice_lead_index   = 0;

                            attempted_splices_since_last_splice = 0;

                            right_hand_calls.Add(absolute_change_index, current_method.title);

                            if (method_call_index >= method_calls.Length)
                            {
                                method_call_index = 0;
                            }
                        }
                        else
                        {
                            attempted_splices_since_last_splice += 1;
                        }
                    }
                }
                #endregion

                #region Stop if it comes to rounds (to whatever is the target change is)
                if (current_change == target_change)
                {
                    // Add a final lead end.
                    int lead_index_to_check = sub_lead_index + 1;
                    if (current_callpoint != null && absolute_change_index == current_callpoint.end_index)
                    {
                        lead_index_to_check = sub_lead_index + current_callpoint.call.cover;
                    }

                    // Quickly check whether or not this is valid
                    bool is_valid = true;
                    if (rounds_checks == RoundsCheckLocations.AnyBackstroke && Utils.Mod(changes.Count, 2) == 1)
                    {
                        is_valid = false;
                    }
                    if (rounds_checks == RoundsCheckLocations.OnlyLeadEnds && lead_index_to_check != current_method.lead_length)
                    {
                        is_valid = false;
                    }

                    if (is_valid)
                    {
                        if (lead_index_to_check == current_method.lead_length)
                        {
                            lead_head_line_indices.Add(absolute_change_index);
                        }

                        comes_round = true;

                        break;
                    }
                }
                #endregion

                #region Update indices & lead ends.
                if (current_callpoint == null)
                {
                    sub_lead_index += 1;

                    if (sub_lead_index >= current_method.place_notations.Length)
                    {
                        lead_head_line_indices.Add(absolute_change_index);

                        sub_lead_index         = 0;
                        sub_splice_lead_index += 1;

                        lead_index += 1;
                    }
                }

                absolute_change_index   += 1;
                sub_splice_change_index += 1;
                #endregion

                #region Stop if touch goes on forever.  If 100,000,000 changes are reached, then the code will stop.
                List <Change> change_state_list = change_states [call_index + basic_call_length * (method_call_index + method_call_length * sub_lead_index)];

                if (change_state_list.Contains(current_change))
                {
                    comes_round = false;

                    break;
                }

                change_state_list.Add(current_change);

                // It should never get this far
                if (absolute_change_index > 1e4)
                {
                    throw new YourPealRingersDiedOfExhaustionException("Broke the laws of human endurance and got to 100,000,000 changes without coming round.");
                }
                #endregion
            }

            return(changes.ToArray());
        }
Beispiel #3
0
 /// <summary>
 /// Determines whether a <see cref="BasicCall"/> should be called.
 /// </summary>
 /// <param name="call">The call about to be called.</param>
 /// <param name="parameters">Extra data about the call location.</param>
 /// <returns>True if the call should be called.</returns>
 public bool EvaluateBasicCall(Call call, CallLocationParameters parameters) => number_of_attempts == parameters.attempted_calls_since_last_call;
Beispiel #4
0
 /// <summary>
 /// This should return true if the given data should result in a method splice being called.
 /// </summary>
 /// <param name="next_method">The method being spliced to.</param>
 /// <param name="parameters">The location of the potential call.</param>
 /// <returns>True if the method splice should happen here.</returns>
 public bool EvaluateMethodCall(MethodCall next_method, CallLocationParameters parameters)
 {
     throw new NotImplementedException();
 }
Beispiel #5
0
            /// <summary>
            /// This should return true if the given data should result in a call being called.
            /// </summary>
            /// <param name="call">The call that would be called.</param>
            /// <param name="parameters">The location where the call would be called.</param>
            /// <returns>True if the call should be called.</returns>
            public bool EvaluateBasicCall(Call call, CallLocationParameters parameters)
            {
                Change end_change = parameters.start_change * call.overall_transposition;

                return(end_change.IndexOf(parameters.touch.conductor_bell) == call.GetCallingPositionIndex(calling_position));
            }
Beispiel #6
0
 /// <summary>
 /// This should return true if the given data should result in a method splice being called.
 /// </summary>
 /// <param name="next_method">The method being spliced to.</param>
 /// <param name="parameters">The location of the potential call.</param>
 /// <returns>Always true.</returns>
 public bool EvaluateMethodCall(MethodCall next_method, CallLocationParameters parameters) => true;
Beispiel #7
0
 /// <summary>
 /// This should return true if the given data should result in a call being called.
 /// </summary>
 /// <param name="call">The call that would be called.</param>
 /// <param name="parameters">The location where the call would be called.</param>
 /// <returns>Always true</returns>
 public bool EvaluateBasicCall(Call call, CallLocationParameters parameters) => true;