public TerrainFollow(MAVLinkInterface inInterface)
        {
            _interface = inInterface;

            log.Info("Subscribe to packets");
            subscription = _interface.SubscribeToPacketType(MAVLink.MAVLINK_MSG_ID.TERRAIN_REQUEST, ReceviedPacket);
        }
	void FixedUpdate()
	{
		NetworkClient newClient = ConnectionManager.GameServer.AcceptClient();
		if( newClient != null ) remoteClients.Add( newClient );

		int messageLength = 1;

		foreach( KeyValuePair<byte,byte> localPositionKey in localPositions.Keys ) 
		{
			outputBuffer[ messageLength ] = localPositionKey.Key;
			outputBuffer[ messageLength + 1 ] = localPositionKey.Value;
			Buffer.BlockCopy( BitConverter.GetBytes( localPositions[ localPositionKey ] ), 0, outputBuffer, messageLength + 2, sizeof(float) );

			messageLength += DATA_SIZE;
		}

		foreach( NetworkClient client in remoteClients )
		{
			if( client.ReceiveData( inputBuffer ) )
			{
				Buffer.BlockCopy( inputBuffer, 0, outputBuffer, messageLength, DATA_SIZE );

				KeyValuePair<byte,byte> remotePositionKey = new KeyValuePair<byte,byte>( inputBuffer[ 0 ], inputBuffer[ 1 ] );
				remotePositions[ remotePositionKey ] = BitConverter.ToSingle( inputBuffer, 2 );
			}

			messageLength += DATA_SIZE;
		}

		outputBuffer[ 0 ] = (byte) messageLength;

		foreach( NetworkClient client in remoteClients )
			client.SendData( outputBuffer );
	}
 public bool PosTest2()
 {
     bool retVal = true;
     TestLibrary.TestFramework.BeginScenario("Return the property get_Current in the IEnumerator 2");
     try
     {
         Dictionary<TestClass, TestClass> dictionary = new Dictionary<TestClass, TestClass>();
         TestClass Tkey1 = new TestClass();
         TestClass TVal1 = new TestClass();
         dictionary.Add(Tkey1, TVal1);
         Dictionary<TestClass, TestClass>.Enumerator enumer = dictionary.GetEnumerator();
         IEnumerator iEnumer = (IEnumerator)enumer;
         while(iEnumer.MoveNext())
         {
             object objCurrent = iEnumer.Current;
             KeyValuePair<TestClass, TestClass> keyVal = new KeyValuePair<TestClass, TestClass>(Tkey1, TVal1);
             if (!objCurrent.Equals(keyVal))
             {
                 TestLibrary.TestFramework.LogError("003", "the ExpectResult is not the ActualResult");
                 retVal = false;
             }
         }
     }
     catch (Exception e)
     {
         TestLibrary.TestFramework.LogError("004", "Unexpect exception:" + e);
         retVal = false;
     }
     return retVal;
 }
Example #4
0
        public HttpClientBuilder AcceptOctetStream()
        {
            var jsonAccept = new KeyValuePair<string, string>("accept", "application/octet-stream");
            _headers.Add(jsonAccept);

            return this;            
        }
Example #5
0
        /// <summary>
        ///     关系映射
        /// </summary>
        /// <param name="type">实体类Type</param>
        public FieldMap(Type type)
        {
            Type = type;
            MapList = new Dictionary<PropertyInfo, FieldState>();

            #region 变量属性

            // 循环Set的字段
            foreach (var fieldProperty in Type.GetProperties())
            {
                // 获取字段的特性
                var attField = fieldProperty.GetCustomAttributes(false);
                var fieldState = new FieldState();
                foreach (var attr in attField)
                {
                    // 数据类型
                    if (attr is DataTypeAttribute) { fieldState.DataType = (DataTypeAttribute)attr; continue; }
                    // 字段映射
                    if (attr is FieldAttribute) { fieldState.FieldAtt = (FieldAttribute)attr; continue; }
                    // 属性扩展
                    if (attr is PropertyExtendAttribute) { fieldState.PropertyExtend = ((PropertyExtendAttribute)attr).PropertyExtend; continue; }
                }

                if (fieldState.FieldAtt == null) { fieldState.FieldAtt = new FieldAttribute { Name = fieldProperty.Name }; }
                if (string.IsNullOrEmpty(fieldState.FieldAtt.Name)) { fieldState.FieldAtt.Name = fieldProperty.Name; }
                if (fieldState.FieldAtt.IsMap && fieldState.FieldAtt.IsPrimaryKey) { PrimaryState = new KeyValuePair<PropertyInfo, FieldState>(fieldProperty, fieldState); } else { fieldState.FieldAtt.IsPrimaryKey = false; }


                //添加属变量标记名称
                MapList.Add(fieldProperty, fieldState);
            }

            #endregion
        }
        public static Func<ShapePlacementContext, bool> BuildPredicate(Func<ShapePlacementContext, bool> predicate, KeyValuePair<string, string> term)
        {
            var expression = term.Value;
            switch (term.Key) {
                case "ContentPart":
                        return ctx => ctx.Content != null
                            && ctx.Content.ContentItem.Parts.Any(part => part.PartDefinition.Name == expression)
                            && predicate(ctx);
                case "ContentType":
                    if (expression.EndsWith("*")) {
                        var prefix = expression.Substring(0, expression.Length - 1);
                        return ctx => ((ctx.ContentType ?? "").StartsWith(prefix) || (ctx.Stereotype ?? "").StartsWith(prefix)) && predicate(ctx);
                    }
                    return ctx => ((ctx.ContentType == expression) || (ctx.Stereotype == expression)) && predicate(ctx);
                case "DisplayType":
                    if (expression.EndsWith("*")) {
                        var prefix = expression.Substring(0, expression.Length - 1);
                        return ctx => (ctx.DisplayType ?? "").StartsWith(prefix) && predicate(ctx);
                    }
                    return ctx => (ctx.DisplayType == expression) && predicate(ctx);
                case "Path":
                    var normalizedPath = VirtualPathUtility.IsAbsolute(expression)
                                             ? VirtualPathUtility.ToAppRelative(expression)
                                             : VirtualPathUtility.Combine("~/", expression);

                    if (normalizedPath.EndsWith("*")) {
                        var prefix = normalizedPath.Substring(0, normalizedPath.Length - 1);
                        return ctx => VirtualPathUtility.ToAppRelative(String.IsNullOrEmpty(ctx.Path) ? "/" : ctx.Path).StartsWith(prefix, StringComparison.OrdinalIgnoreCase) && predicate(ctx);
                    }

                    normalizedPath = VirtualPathUtility.AppendTrailingSlash(normalizedPath);
                    return ctx => (ctx.Path.Equals(normalizedPath, StringComparison.OrdinalIgnoreCase)) && predicate(ctx);
            }
            return predicate;
        }
Example #7
0
 private void CalculateColumns(List<FormatObjectProperty> row)
 {
     _fullWidth = OutputWriter.Columns - 1; // -1 because of newline
     if (_fullWidth <= 0)
     {
         _fullWidth = OutputWriter.DefaultColumns - 1;
     }
     var cols = row.Count;
     // make sure it fits
     if (2 * cols - 1 > _fullWidth)
     {
         cols = (_fullWidth + 1) / 2;
         string format = "Warning: {0} columns have to be omitted in this format" +
                         "as they don't fit the available width.";
         OutputWriter.WriteLine(String.Format(format, row.Count - cols));
     }
     int perColumn = (_fullWidth - cols + 1) / cols;
     int rest = _fullWidth - cols + 1 - perColumn * cols; // because of rounding
     _currentColumns = new KeyValuePair<string, int>[cols];
     for (int i = 0; i < cols; i++)
     {
         _currentColumns[i] = new KeyValuePair<string,int>(row[i].PropertyName,
                                              i < rest ? perColumn + 1 : perColumn);
     }
 }
Example #8
0
        /// <summary>
        /// 根据模板分析,并且返回已替换内容
        /// </summary>
        /// <param name="content"></param>
        /// <param name="regex"></param>
        /// <param name="modelInfo"></param>
        /// <param name="TransferFactory"></param>
        /// <returns></returns>
        public string AnalyAndReplace(string content, string regex, EntityInfo entity, Object obj, IExTransferFactory TransferFactory)
        {
            string Result = "";

            Dictionary<int, string> expresses = content.RegBaseDic(@regex); ;
            
            Dictionary<int, int> patternS_E = AnaUtil.Instance().GetKeyIndVal(expresses);

            Result += patternS_E.Count > 0 ? content.Substring(0, patternS_E.ElementAt(0).Key) : "";

            KeyValuePair<int, int> S_EPair = new KeyValuePair<int, int>();
            KeyValuePair<int, int> S_EPair2 = new KeyValuePair<int, int>();
            for (int i = 0; i < expresses.Count; i++)
            {
                Result += TransferFactory.CreateTransfer(expresses.ElementAt(i).Value).Transfer(expresses.ElementAt(i).Value, entity, obj);
                S_EPair = patternS_E.ElementAt(i);
                S_EPair2 = patternS_E.Count > (i + 1) ? patternS_E.ElementAt(i + 1) : patternS_E.ElementAt(i);

                Result += S_EPair2.Equals(S_EPair) ? "" : content.Substring(S_EPair.Value, S_EPair2.Key - S_EPair.Value);
            }
            Result += patternS_E.Count > 0 ? content.Substring(S_EPair.Value, content.Length - S_EPair.Value) : "";

            Result = patternS_E.Count == 0 ? content : Result;

            return Result;
        }
Example #9
0
        public void Create()
        {
            var p1 = new KeyValuePair<int, string>(42, "The answer");
            var p2 = KeyValuePair.Create(42, "The answer");

            Assert.AreEqual(p1, p2);
        }
        private void FindCurrentAlbum(string albumName)
        {
            albumName = albumName.ToUpper();

            if (!albumName.Equals(this.currentAlbum.Key))
            {
                if (this.Albums.ContainsKey(albumName))
                {
                    this.currentAlbum = new KeyValuePair<string, List<Music>>
                    (
                       albumName,
                       this.Albums[albumName]
                    );
                }
                else
                {
                    this.currentAlbum = new KeyValuePair<string, List<Music>>
                    (
                       albumName,
                       new List<Music>()
                    );

                    this.Albums.Add(this.currentAlbum);
                }
            }
        }
Example #11
0
        public override void Draw(SpriteBatch sb)
        {
            int spacingR = 50;
            int spacingB = 50;
            lock (World.PlayerInfo)
            {
                try
                {
                    sb.DrawString(TextureManager.Fonts["console"], "Lobby", new Vector2(
                        GameConst.SCREEN_WIDTH / 20, GameConst.SCREEN_HEIGHT / 20), Color.White);

                    var p =  new KeyValuePair<int, PlayerInfo>(World.gameId, World.PlayerInfo[World.gameId]);
                    DrawPlayerIcon(sb, p, ref spacingR, ref spacingB);

                    foreach (var player in World.PlayerInfo)
                    {
                        if (player.Key != World.gameId)
                        {
                            DrawPlayerIcon(sb, player, ref spacingR, ref spacingB);
                        }
                    }

                    Texture2D checkTexture = ready ? TextureManager.Map["check-true"] : TextureManager.Map["check-false"];
                    sb.Draw(checkTexture, checkRect, Color.White);
                }
                catch (Exception e) { }
            }

            base.Draw(sb);
        }
Example #12
0
        public string this[string key]
        {
            get
            {
                foreach (var entry in _records)
                {
                    if (entry.Key == key)
                    {
                        return entry.Value;
                    }
                }
                return null;
            }

            set
            {
                for (int i = 0; i < _records.Count; ++i )
                {
                    if (_records[i].Key == key)
                    {
                        _records[i] = new KeyValuePair<string, string>(key, value);
                        return;
                    }
                }
                _records.Add(new KeyValuePair<string, string>(key, value));
            }
        }
Example #13
0
        public override async Task<IEnumerable<KeyValuePair<string, NuGetVersion>>> GetLatestVersions(IEnumerable<string> packageIds, bool includePrerelease, bool includeUnlisted, CancellationToken token)
        {
            var results = new List<KeyValuePair<string, NuGetVersion>>();

            var tasks = new Stack<KeyValuePair<string, Task<IEnumerable<NuGetVersion>>>>();

            // fetch all ids in parallel
            foreach (var id in packageIds)
            {
                var task = new KeyValuePair<string, Task<IEnumerable<NuGetVersion>>>(id, GetVersions(id, includePrerelease, includeUnlisted, token));
                tasks.Push(task);
            }

            foreach (var pair in tasks)
            {
                // wait for the query to finish
                var versions = await pair.Value;

                if (versions == null
                    || !versions.Any())
                {
                    results.Add(new KeyValuePair<string, NuGetVersion>(pair.Key, null));
                }
                else
                {
                    // sort and take only the highest version
                    var latestVersion = versions.OrderByDescending(p => p, VersionComparer.VersionRelease).FirstOrDefault();

                    results.Add(new KeyValuePair<string, NuGetVersion>(pair.Key, latestVersion));
                }
            }

            return results;
        }
Example #14
0
 private GraphiteLine [] MakeGraphiteLines ( KeyValuePair<string, LatencyDatapointBox> latency )
 {
   if ( _calculateSumSquares )
   {
     return new GraphiteLine [] 
       {
         new GraphiteLine(RootNamespace + latency.Key + ".count", latency.Value.Count, Epoch),
         new GraphiteLine(RootNamespace + latency.Key + ".min", latency.Value.Min, Epoch),
         new GraphiteLine(RootNamespace + latency.Key + ".max", latency.Value.Max, Epoch),
         new GraphiteLine(RootNamespace + latency.Key + ".mean", latency.Value.Mean, Epoch),
         new GraphiteLine(RootNamespace + latency.Key + ".sum", latency.Value.Sum, Epoch),
         new GraphiteLine(RootNamespace + latency.Key + ".sumSquares", latency.Value.SumSquares, Epoch)
       };
   }
   else 
   {
     return new GraphiteLine [] 
       {
         new GraphiteLine(RootNamespace + latency.Key + ".count", latency.Value.Count, Epoch),
         new GraphiteLine(RootNamespace + latency.Key + ".min", latency.Value.Min, Epoch),
         new GraphiteLine(RootNamespace + latency.Key + ".max", latency.Value.Max, Epoch),
         new GraphiteLine(RootNamespace + latency.Key + ".mean", latency.Value.Mean, Epoch),
         new GraphiteLine(RootNamespace + latency.Key + ".sum", latency.Value.Sum, Epoch)
       };
   }
 }
        public MAVLinkSerialPort(MAVLinkInterface mavint, MAVLink.SERIAL_CONTROL_DEV port)
        {
            this.mavint = mavint;
            this.port = port;

            if (!mavint.BaseStream.IsOpen)
            {
                mavint.BaseStream.Open();
            }

            if (mavint.getHeartBeat().Length == 0)
            {
                throw new Exception("No valid heartbeats read from port");
            }

            if (subscription.Value != null)
                mavint.UnSubscribeToPacketType(subscription);

            subscription = mavint.SubscribeToPacketType(MAVLink.MAVLINK_MSG_ID.SERIAL_CONTROL, ReceviedPacket, true);

            bgdata = new Thread(mainloop);
            bgdata.Name = "MAVLinkSerialPort";
            bgdata.IsBackground = true;
            bgdata.Start();
        }
Example #16
0
		private static MethodInfo GetFromCache(MethodInfo methodInfo, Type type)
		{
			var key = new KeyValuePair<MethodInfo, Type>(methodInfo, type);
			MethodInfo method;
			cache.TryGetValue(key, out method);
			return method;
		}
        public void CreateMimeMessage()
        {
            var message = Mail.GetInstance();
            var attachment = System.IO.Path.GetTempFileName();
            var text = "this is a test";
            var html = "<b>This<\b> is a better test";
            var headers = new KeyValuePair<String, String>("custom", "header");
            message.AddAttachment(attachment);
            message.Text = text;
            message.Html = html;
            message.AddTo("[email protected]");
            message.From = new MailAddress("[email protected]");
            message.AddHeaders(new Dictionary<string, string>{{headers.Key, headers.Value}});
            message.EnableGravatar();

            var mime = message.CreateMimeMessage();

            var sr = new StreamReader(mime.AlternateViews[0].ContentStream);
            var result = sr.ReadToEnd();
            Assert.AreEqual(text, result);

            sr = new StreamReader(mime.AlternateViews[1].ContentStream);
            result = sr.ReadToEnd();
            Assert.AreEqual(html, result);

            result = mime.Headers.Get(headers.Key);
            Assert.AreEqual(headers.Value, result);

            result = mime.Headers.Get("X-Smtpapi");
            var expected = "{\"filters\" : {\"gravatar\" : {\"settings\" : {\"enable\" : \"1\"}}}}";
            Assert.AreEqual(expected, result);

            result = mime.Attachments[0].Name;
            Assert.AreEqual(Path.GetFileName(attachment), result);
        }
Example #18
0
 public OscMessage BuildJointMessage(Body body, KeyValuePair<JointType, Joint> joint)
 {
     var address = String.Format("/bodies/{0}/joints/{1}", body.TrackingId, joint.Key);
     var position = joint.Value.Position;
     //System.Diagnostics.Debug.WriteLine(address);
     return new OscMessage(address, position.X, position.Y, position.Z, joint.Value.TrackingState.ToString());
 }
 private static void resolveConflicts(KeyValuePair<string, object> attribute)
 {
     if (attribute.Key.Equals("physic_entity") && attribute.Value.Equals("rigid"))
     {
         entity.Replace("physic_entity = \"dynamic\"", "physic_entity = \"rigid\"");
     }
 }
Example #20
0
        static void Main(string[] args)
        {


            const int BIBLIOGRAPHY_ID = 1039;
            Myth kingOfIthaca = new Myth("Odysseus", "Ulysses");
            KeyValuePair<int, Myth> kvp = new KeyValuePair<int, Myth>(BIBLIOGRAPHY_ID, kingOfIthaca);

            Console.WriteLine("Key = {0}", kvp.Key);
            Console.WriteLine("Value = {0}", kvp.Value.GreekName);
            Console.WriteLine("Value = {0}", kvp.Value.RomanName);
            Console.ReadLine();



            List<string> collection = new List<string>();
            AddItems(collection);
            ShowItems(collection);
            RemoveItems(collection);
            ShowItems(collection);
            Console.ReadLine();

            List<Account> accountList = new List<Account>();

            accountList.Add(new Checking());
            accountList.Add(new Savings());
     

            foreach (Account item in accountList)
            {
                item.DisplayDetail();
            }
            
        }
Example #21
0
        public HttpClientBuilder AcceptJson()
        {
            var jsonAccept = new KeyValuePair<string, string>("accept", "application/json");
            _headers.Add(jsonAccept);

            return this;
        }
Example #22
0
 public RouteMatch(string[] orderedArgs, KeyValuePair<string, string>[] boundVars, string rawUrl)
 {
     this.OrderedArgs = orderedArgs;
     this.BoundVars = boundVars;
     this.QueryParams = null;
     this.RawUrl = rawUrl;
 }
        void IManageTimeouts.PopTimeout()
        {
            var pair = new KeyValuePair<DateTime, List<TimeoutData>>(DateTime.MinValue, null);
            var now = DateTime.UtcNow;

            lock (data)
            {
                if (data.Count > 0)
                {
                    var next = data.ElementAt(0);
                    if (next.Key - now < duration)
                    {
                        pair = next;
                        data.Remove(pair.Key);
                    }
                }
            }

            if (pair.Key == DateTime.MinValue)
            {
                Thread.Sleep(duration);
                return;
            }

            if (pair.Key > now)
                Thread.Sleep(pair.Key - now);

            DispatchTimeouts(pair.Value);
        }
        public static void SetErrorWithCount(this ErrorProvider ep, Control c, string message)
        {
            if (message == "")
            {
                if (ep.GetError(c) != "")
                {
                    _count--;

                    var ctrlRemove = new KeyValuePair<Control, string>();

                    foreach (var ctrl in _controles.Where(ctrl => ctrl.Key == c))
                    {
                        ctrlRemove = ctrl;
                    }

                    _controles.Remove(ctrlRemove);
                }
            }
            else
            {
                _count++;
                _controles.Add(new KeyValuePair<Control, string>(c, message));
            }

            ep.SetError(c, message);
        }
Example #25
0
 public void ThrowUpdateLanguage(KeyValuePair<int, string> language)
 {
     if (this.UpdateLanguage != null)
     {
         this.UpdateLanguage(this, new LanguageChangeEventArgs(language));
     }
 }
 public async Task<HttpResponseMessage> DeleteAsync(Uri uri, List<KeyValuePair<string, string>> headers)
 {
     HttpClient client = (HttpClient)null;
     HttpResponseMessage response = (HttpResponseMessage)null;
     HttpResponseMessage httpResponseMessage1;
     try
     {
         client = this.CreateClient();
         if (headers != null)
         {
             foreach (KeyValuePair<string, string> keyValuePair in headers)
             {
                 KeyValuePair<string, string> header = keyValuePair;
                 client.DefaultRequestHeaders.Add(header.Key, header.Value);
                 header = new KeyValuePair<string, string>();
             }
             //List<KeyValuePair<string, string>>.Enumerator enumerator = new List<KeyValuePair<string, string>>.Enumerator();
         }
         HttpResponseMessage httpResponseMessage = await client.DeleteAsync(uri);
         httpResponseMessage1 = httpResponseMessage;
     }
     finally
     {
         Memory.DisposeGarbage((IDisposable)response, (IDisposable)client);
     }
     return httpResponseMessage1;
 }
 public bool PosTest1()
 {
     bool retVal = true;
     TestLibrary.TestFramework.BeginScenario("Return the property get_Current in the IEnumerator 1");
     try
     {
         Dictionary<string, string> dictionary = new Dictionary<string, string>();
         dictionary.Add("str1", "helloworld");
         Dictionary<string, string>.Enumerator enumer = dictionary.GetEnumerator();
         IEnumerator iEnumer = (IEnumerator)enumer;
         while (iEnumer.MoveNext())
         {
             object objCurrent = iEnumer.Current;
             KeyValuePair<string, string> keyVal = new KeyValuePair<string, string>("str1", "helloworld");
             if (!objCurrent.Equals(keyVal))
             {
                 TestLibrary.TestFramework.LogError("001", "the ExpectResult is not the ActualResult");
                 retVal = false;
             }
         }
     }
     catch (Exception e)
     {
         TestLibrary.TestFramework.LogError("002", "Unexpect exception:" + e);
         retVal = false;
     }
     return retVal;
 }
        private void SetSwitchValue(KeyValuePair<string, string> commandSwitch) {
            // Find the property
            PropertyInfo propertyInfo = GetType().GetProperty(commandSwitch.Key, BindingFlags.Instance | BindingFlags.Public | BindingFlags.IgnoreCase);
            if (propertyInfo == null) {
                throw new InvalidOperationException(T("Switch \"{0}\" was not found", commandSwitch.Key).Text);
            }
            if (propertyInfo.GetCustomAttributes(typeof(OrchardSwitchAttribute), false).Length == 0) {
                throw new InvalidOperationException(T("A property \"{0}\" exists but is not decorated with \"{1}\"", commandSwitch.Key, typeof(OrchardSwitchAttribute).Name).Text);
            }

            // Set the value
            try {
                object value = Convert.ChangeType(commandSwitch.Value, propertyInfo.PropertyType);
                propertyInfo.SetValue(this, value, null/*index*/);
            }
            catch(Exception ex) {
                if (ex.IsFatal()) {
                    throw;
                } 
                string message = T("Error converting value \"{0}\" to \"{1}\" for switch \"{2}\"",
                    LocalizedString.TextOrDefault(commandSwitch.Value, T("(empty)")), 
                    propertyInfo.PropertyType.FullName, 
                    commandSwitch.Key).Text;
                throw new InvalidOperationException(message, ex);
            }
        }
	/// <summary>
	/// Proceeds the along path.
	/// </summary>
	/// <returns><c>true</c>, if progress along the path was made, <c>false</c> otherwise.</returns>
	protected bool ProceedAlongPath(GoapPlan _currentPlan)
	{
		//find the next GO on the currentPath
		GameObject targetTroct = _currentPlan.plannedPath.Value[0];

		Vector3 towardsTarget = (targetTroct.transform.position - core.actor.currentTrOct.transform.position).normalized;

		//is this actor facing the troct?
		if (towardsTarget == core.actor.transform.forward)
		{
			//if so, try move forwards
			if (core.actor.TryMoveForwards())
			{
				_currentPlan.plannedPath.Value.RemoveAt(0);

				//see if the target node has been reached
				if (_currentPlan.plannedPath.Value.Count == 0)
				{
					KeyValuePair<string, List<GameObject>> tempPath = new KeyValuePair<string, List<GameObject>>(_currentPlan.plannedPath.Key, null);
					_currentPlan.plannedPath = tempPath;
				}

				return true; //return a successful progression along the path
			}
			else
			{
				return false; // return an unsuccessful progression along the path
			}
		}
		else //turn to face the next TrOct
		{
			return core.actor.TryRotate(targetTroct.transform); //return the result of attempting to look at the next troct.
		}
	}
Example #30
0
 public static void AddMatchRequest(KeyValuePair<string,ClientServant> request)
 {
     lock(m_waiting_queue)
     {
         m_waiting_queue.Enqueue(request);
     }
 }