C# Position类代码示例

    public void Swapped()
    {
        if (checknum != 0)
        {
            Position[] send = new Position[2];
            send[0] = my_number;
            send[1] = checkicon[0].GetComponent<CIcon>().my_number;

            PM.ChangePosition(send);

            Position temp = my_number;
            my_number = checkicon[0].GetComponent<CIcon>().my_number;
            checkicon[0].GetComponent<CIcon>().my_number = temp;

            Vector3 temp_pos = saved_position;
            saved_position = checkicon[0].GetComponent<CIcon>().saved_position;
            checkicon[0].GetComponent<CIcon>().saved_position = temp_pos;

            temp_pos = disappear_pos;
            disappear_pos = checkicon[0].GetComponent<CIcon>().disappear_pos;
            checkicon[0].GetComponent<CIcon>().disappear_pos = temp_pos;

            SlowReturn();
            checkicon[0].GetComponent<CIcon>().SlowReturn();
        }
    }

 private void ClosePosition()
 {
     if (_position == null)
         return;
     Trade.Close(_position);
     _position = null;
 }

        protected override void TickCore(Entity host, RealmTime time, ref object state)
        {
            int cool = (int) state;

            if (cool <= 0)
            {
                if (host.HasConditionEffect(ConditionEffectIndex.Stunned)) return;

                Position target = new Position
                {
                    X = host.X + (float) (range*Math.Cos(angle.Value)),
                    Y = host.Y + (float) (range*Math.Sin(angle.Value)),
                };
                host.Owner.Timers.Add(new WorldTimer(0, (world, t) =>
                {
                    Entity entity = Entity.Resolve(world.Manager, child);
                    entity.Move(target.X, target.Y);
                    (entity as Enemy).Terrain = (host as Enemy).Terrain;
                    world.EnterWorld(entity);
                }));
                cool = coolDown.Next(Random);
            }
            else
                cool -= time.thisTickTimes;

            state = cool;
        }

        public void SamePositionsAreEqualWithOperator()
        {
            var sut = new Position(1, 1, 1);
            var sut2 = new Position(1, 1, 1);

            Assert.That(sut == sut2);
        }

        public uint CreateSkillAoE(Skills skill, Vector2 direction, Position position)
        {
            SkillAoE skillAoE;
            Movement movement;
            Sprite sprite;
            Collideable collideable;
            uint eid = Entity.NextEntity();

            position.EntityID = eid;
            position.Center += direction * 70;

            switch (skill)
            {
                default:
                    throw new Exception("Not a AoE skill");
            }

            collideable = new Collideable()
            {
                EntityID = eid,
                Bounds = new CircleBounds(position.Center, position.Radius),
            };

            game.SkillAoEComponent.Add(eid, skillAoE);
            game.MovementComponent.Add(eid, movement);
            game.PositionComponent.Add(eid, position);
            game.SpriteComponent.Add(eid, sprite);
            game.CollisionComponent.Add(eid, collideable);
            return eid;
        }

        protected override bool TickCore(RealmTime time)
        {
            var dist = range;
            var player = GetNearestEntity(ref dist, null);
            if (player != null)
            {
                var chr = Host as Character;
                var target = new Position
                {
                    X = player.X,
                    Y = player.Y
                };

                chr.Owner.BroadcastPacket(new ShowEffectPacket
                {
                    EffectType = EffectType.Throw,
                    Color = new ARGB(0xffffbf00),
                    TargetId = Host.Self.Id,
                    PosA = target
                }, null);

                chr.Owner.Timers.Add(new WorldTimer(1500, (world, t) =>
                {
                    var entity = Entity.Resolve(objType);
                    entity.Move(target.X, target.Y);
                    (entity as Enemy).Terrain = (chr as Enemy).Terrain;
                    world.EnterWorld(entity);
                }));
            }
            return true;
        }

        public void DifferentPositionsAreNotEqualWithOperator()
        {
            var sut = new Position(1, 1, 1);
            var sut2 = new Position(1, 1, 0);

            Assert.That(sut != sut2);
        }

        public override IList<Chunk> GetChunks(VisitorContext context, string path)
        {
            context.SyntaxProvider = this;
            context.ViewPath = path;

            var sourceContext = CreateSourceContext(context.ViewPath, context.ViewFolder);
            var position = new Position(sourceContext);

            var result = _grammar.Nodes(position);
            if (result.Rest.PotentialLength() != 0)
            {
                ThrowParseException(context.ViewPath, position, result.Rest);
            }

            context.Paint = result.Rest.GetPaint();

            var nodes = result.Value;
            foreach (var visitor in BuildNodeVisitors(context))
            {
                visitor.Accept(nodes);
                nodes = visitor.Nodes;
            }

            var chunkBuilder = new ChunkBuilderVisitor(context);
            chunkBuilder.Accept(nodes);
            return chunkBuilder.Chunks;
        }

		void CheckValidBeginAndEndDrawPositions(Position beginDrawPos, Position endDrawPos)
		{
			// We draw from upper left to lower right
			Assert.IsTrue(beginDrawPos.Row <= endDrawPos.Row);
			if (beginDrawPos.Row == endDrawPos.Row)
				Assert.IsTrue(beginDrawPos.Column < endDrawPos.Column);
		}

        private void TestPopup_Click_1(object sender, EventArgs e)
        {
            Position arg = new Position(111,2,DateTime.Now);

            ShowWindowIfNewPosition(arg,
                (decision) => label1.Text = "Handling user decision fired!");
        }

		/// <summary>
		/// Creates a new instance using the specified start and end points.
		/// </summary>
		/// <param name="minimum">The starting point of the interpolated series.</param>
		/// <param name="maximum">The ending point of the interpolated series.</param>
		/// <param name="count">The number of points to calculate between the start and end.</param>
		/// <remarks>This constructor provides a way to define the bounds of the interpolator,
		/// as well as its number of points.  A higher level of points yield a smoother
		/// result but take longer to iterate through.</remarks>
		////[CLSCompliant(false)]
		public Interpolator2D(Position minimum, Position maximum, int count)
		{
			Count = count;
			_Minimum = minimum;
			_Maximum = maximum;
			Recalculate();
		}

		public FunctionCall(Position position, List<ActualParam>/*!*/ parameters, List<TypeRef>/*!*/ genericParams)
			: base(position)
		{
			Debug.Assert(parameters != null);

			this.callSignature = new CallSignature(parameters, genericParams);
		}

        private string GenerateLink(ISmartContent smartContent, IPublishingContext publishingContext, out Position position)
        {
            position = Position.Footer;

            string culture = Thread.CurrentThread.CurrentCulture.Name;
            if (culture.Contains("-"))
                culture = culture.Replace("-", "_");

            var stringWriter = new StringWriter();
            stringWriter.WriteLine("<script type=\"text/javascript\">");

            stringWriter.WriteLine("var flattr_uid = '{0}';", _settings.FlattrId);
            stringWriter.WriteLine("var flattr_tle = '{0}';", publishingContext.PostInfo.Title);
            stringWriter.WriteLine("var flattr_dsc = '{0}';", publishingContext.PostInfo.Contents);
            stringWriter.WriteLine("var flattr_cat = 'text';");
            stringWriter.WriteLine("var flattr_lng = '{0}';", culture);
            stringWriter.WriteLine("var flattr_tag = '';");
            stringWriter.WriteLine("var flattr_url = '{0}';", publishingContext.PostInfo.Permalink);
            stringWriter.WriteLine("var flattr_hide = 'false';");

            if (_settings.CompactMode)
                stringWriter.WriteLine("var flattr_btn = 'compact';");

            stringWriter.WriteLine("</script>");
            stringWriter.WriteLine("<script type=\"text/javascript\" src=\"http://api.flattr.com/button/load.js\"></script>");

            return stringWriter.ToString();
        }

        public void DeserializeTest()
        {
            Position position = new Position
              {
            Title = Constants.Position_Title
              };

              Company company = new Company
              {
            Name = Constants.Company_Name
              };

              Job expected = new Job
              {
            Id = Constants.Job_Id,
            Position = position,
            Company = company
              };

              Job actual = LinkedIn.Utility.Utilities.DeserializeXml<Job>(this.jobRequest);

              Assert.AreEqual(expected.Id, actual.Id);
              Assert.AreEqual(expected.Position.Title, actual.Position.Title);
              Assert.AreEqual(expected.Company.Name, actual.Company.Name);
        }

        protected override bool TickCore(RealmTime time)
        {
            var chr = Host as Character;
            Position target = new Position()
            {
                X = Host.Self.X,
                Y = Host.Self.Y
            };
            target.X += (float)Math.Cos(angle) * range;
            target.Y += (float)Math.Sin(angle) * range;
            chr.Owner.BroadcastPacket(new ShowEffectPacket()
            {
                EffectType = EffectType.Throw,
                Color = new ARGB(0xffffbf00),
                TargetId = Host.Self.Id,
                PosA = target
            }, null);
            chr.Owner.Timers.Add(new WorldTimer(1500, (world, t) =>
            {
                Entity entity = Entity.Resolve(objType);
                entity.Move(target.X, target.Y);
                (entity as Enemy).Terrain = (chr as Enemy).Terrain;
                world.EnterWorld(entity);
            }));

            return true;
        }