예제 #1
0
        public static void SetCursor(HitPoint hitPoint)
        {
            Cursor cursor = Cursors.Arrow;

            if (hitPoint == HitPoint.Left)
            {
                cursor = Cursors.SizeWE;
            }
            if (hitPoint == HitPoint.Top)
            {
                cursor = Cursors.SizeNS;
            }
            if (hitPoint == HitPoint.Right)
            {
                cursor = Cursors.SizeWE;
            }
            if (hitPoint == HitPoint.Bottom)
            {
                cursor = Cursors.SizeNS;
            }
            if (hitPoint == HitPoint.Center)
            {
                cursor = Cursors.Hand;
            }
            Mouse.SetCursor(cursor);
            //Log.Debug("SetCursor", "cursor:" + cursor);
        }
예제 #2
0
    // Token: 0x06002009 RID: 8201 RVA: 0x000993A8 File Offset: 0x000975A8
    public override void Shoot(Ray ray, out CmunePairList <BaseGameProp, ShotPoint> hits)
    {
        hits = null;
        Vector3    direction    = WeaponDataManager.ApplyDispersion(ray.direction, this._view, this._supportIronSight);
        int        projectileId = base.Controller.NextProjectileId();
        RaycastHit raycastHit;

        if (Physics.Raycast(ray.origin, direction, out raycastHit, 1000f, (!base.Controller.IsLocal) ? UberstrikeLayerMasks.ShootMaskRemotePlayer : UberstrikeLayerMasks.ShootMask))
        {
            HitPoint     point     = new HitPoint(raycastHit.point, TagUtil.GetTag(raycastHit.collider));
            BaseGameProp component = raycastHit.collider.GetComponent <BaseGameProp>();
            if (component)
            {
                hits = new CmunePairList <BaseGameProp, ShotPoint>(1);
                hits.Add(component, new ShotPoint(raycastHit.point, projectileId));
            }
            this.Decorator.PlayImpactSoundAt(point);
        }
        else
        {
            raycastHit.point = ray.origin + ray.direction * 1000f;
        }
        if (this.Decorator)
        {
            this.Decorator.ShowShootEffect(new RaycastHit[]
            {
                raycastHit
            });
        }
        base.OnHits(hits);
    }
예제 #3
0
    void OnMouseDown()
    {
        if (active)
        {
            Instantiate(
                Resources.Load("vfx_trap"),
                new Vector3(transform.position.x, 3f, transform.position.z),
                Quaternion.AngleAxis(90f, new Vector3(1f, 0f, 0f))
                );
            active = false;
            GetComponent <Renderer>().material.color = new Color(0.0F, 0.0F, 0.0F);
            Invoke("Rearm", 5f);

            foreach (GameObject o in objectsInside)
            {
                if (o != null)
                {
                    HitPoint hp = o.GetComponent <HitPoint>();
                    if (hp != null)
                    {
                        hp.hp -= damages;
                    }
                }
            }
        }
    }
예제 #4
0
        private void FindTarget()
        {
            if (this.target == null)
            {
                var enemies = GameObject.FindObjectsOfType <HitPoint>();

                var nearestTarget = (HitPoint) default;

                float dist = Mathf.Infinity;

                foreach (var e in enemies)
                {
                    float d         = Vector3.Distance(this.transform.position, e.transform.position);
                    var   magnitude = (e.transform.position - this.transform.position).magnitude;

                    if ((nearestTarget == null || d < dist) && magnitude < this.Range)
                    {
                        nearestTarget = e;
                        dist          = d;
                    }
                }

                this.target = nearestTarget;
            }
        }
예제 #5
0
    private void GenerateLineCast(GameObject viewpoint, Vector2 direction)
    {
        HitPoint hitPoint = new HitPoint();

        RaycastHit2D[] rayCastHits2D;
        rayCastHits2D = Physics2D.RaycastAll(viewpoint.transform.position, direction);
        if (rayCastHits2D.Length > 0)
        {
            if ((rayCastHits2D[0].point - new Vector2(viewpoint.transform.position.x, viewpoint.transform.position.y)).magnitude < range)
            {
                hitPoint.location = rayCastHits2D[0].point;
                // find the index of obstacle in the hit point
                foreach (OBSTACLE.Obstacle obstacle in ObstaclesLine)
                {
                    if (HelpFunction.isInObstacle(hitPoint.location, obstacle.obstaclePoints))
                    {
                        hitPoint.obstacleIndex = obstacle.index;
                        break;
                    }
                }
                addPointToCriticalList(hitPoint);
            }
            else
            {
                hitPoint.location      = new Vector2(viewpoint.transform.position.x, viewpoint.transform.position.y) + direction.normalized * range;
                hitPoint.obstacleIndex = -1;
                addPointToCriticalList(hitPoint);
            }
            if (!bMesh)
            {
                GenerateVisibilityEffectWithLine(viewpoint, hitPoint.location);
            }
        }
    }
예제 #6
0
        private void SetClosestPoint(List <HitPoint> points, out bool isEmptyBelow, out bool isEmptyAbove)
        {
            isEmptyAbove = true;
            float topPoint    = transform.position.y + (transform.localScale.y / 2);
            float bottomPoint = transform.position.y - (transform.localScale.y / 2);

            closestPoint = new HitPoint(new Vector3(), 10000);

            foreach (var obj in points.GetRange(180, 180))
            {
                if (obj.Degree <= 180)
                {
                    continue;
                }

                var result = Mathf.Abs(transform.position.x - obj.Vector3.x);
                if (result <= closestPoint.Distance)
                {
                    closestPoint = new HitPoint(obj.Vector3, result);
                    var index = obj.Degree == 0 ? 0 : obj.Degree == 180 ? 180 : 360 - obj.Degree;

                    if (topPoint > points[index].Vector3.y)
                    {
                        closestPointAbove         = new HitPoint(new Vector3(transform.position.x, points[index].Vector3.y));
                        closestPointAboveTopPoint = new HitPoint(new Vector3(transform.position.x, topPoint));
                        isEmptyAbove = false;
                    }
                }
            }

            isEmptyBelow = !(closestPoint.Vector3.y <= bottomPoint);
        }
예제 #7
0
파일: Boss.cs 프로젝트: LD32-Tutti/Tutti
 // Use this for initialization
 void Awake()
 {
     rigidBody  = GetComponent <Rigidbody>();
     hitPoints  = gameObject.GetComponent <HitPoint>();
     scaleBase  = transform.localScale;
     uiGameOver = GameObject.Find("GameOverCanvas");
 }
예제 #8
0
        /// <summary>
        /// Calculates the colour of a point that is "seen" by a given ray
        /// </summary>
        /// <param name="ray">The ray used to "see"</param>
        /// <param name="random">An instance of <see cref="Random"/></param>
        /// <param name="recursionDepth">How many times the ray will be reflected</param>
        /// <returns>A vector containing the linear colour values in (R, G, B) order.</returns>
        public Vector3 CalculateColour(Ray ray, Random random, int recursionDepth)
        {
            HitPoint hitPoint = SceneObjects.FindClosestHitPoint(ray);
            Vector3  colour   = Colour.Black;

            if (hitPoint != null)
            {
                colour = hitPoint.Material.Emissive;
                if (recursionDepth > 0)
                {
                    Vector3 n = hitPoint.Normal;
                    Vector3 randomVector;
                    do
                    {
                        randomVector = random.NextVector3() * 2 - Vector3.One;
                    } while(randomVector.Length() > 1);
                    if (Vector3.Dot(randomVector, n) < 0)
                    {
                        randomVector = Vector3.Negate(randomVector);
                    }
                    Vector3 adjustedPosition = hitPoint.Position - ray.Direction * HIT_POINT_ADJUSTMENT;
                    Ray     newRay           = new Ray(adjustedPosition, randomVector);
                    float   lambert          = Vector3.Dot(randomVector, n);
                    Vector3 BRDF             = hitPoint.Material.Diffuse;
                    colour += CalculateColour(newRay, random, recursionDepth - 1) * lambert * BRDF;
                    colour /= 1 / (2 * (float)Math.PI);
                }
            }
            return(colour);
        }
        void AssociatedObject_MouseLeftButtonDown(object sender, System.Windows.Input.MouseButtonEventArgs e)
        {
            Point point = e.GetPosition(rect);

            hitPoint = RectangleHelper.HitTest(point, rect);

            if (canvas == null)
            {
                canvas = (Canvas)VisualTreeHelper.GetParent(this.AssociatedObject);
            }

            FrameworkElement element = AssociatedObject as FrameworkElement;

            if (hitPoint != HitPoint.None)
            {
                height = rect.ActualHeight;
                width  = rect.ActualWidth;

                rect.Stroke = new SolidColorBrush(Color);
                if (rect.StrokeThickness <= 0 && Thickness > 0)
                {
                    rect.StrokeThickness = Thickness;
                }

                isDragging   = true;
                mouseOffset  = e.GetPosition(AssociatedObject);
                mouseOffset2 = e.GetPosition(canvas);
                AssociatedObject.CaptureMouse();
            }
            else
            {
                rect.Stroke          = borderBrush;
                rect.StrokeThickness = borderThickness;
            }
        }
예제 #10
0
    // Start is called before the first frame update
    void Awake()
    {
        // references initialization
        input        = new PlayerInput();
        camera       = Camera.main.transform;
        anim         = GetComponentInChildren <Animator>();
        visualScript = GetComponentInChildren <PlayerAnimator>();
        collider     = GetComponent <Collider>();
        hpbar        = GameObject.FindGameObjectWithTag("Hpbar").GetComponent <HitPoint>();

        // key registration
        input.Player.Attack.performed += _ => Attack();
        input.Player.Dash.performed   += _ => Dash(new Vector2(input.Player.HorizontalMove.ReadValue <float>(), input.Player.VerticalMove.ReadValue <float>()));

        // value initialization
        moveSpeedMax = moveSpeed;
        isAttacking  = false;
        attackedEnemy.Clear();
        immuneEnemy.Clear();
        shouldAttack      = false;
        canAttack         = false;
        canRegisterAttack = false;
        isDashing         = false;
        canRegisterDash   = false;

        //debug
        // Time.timeScale = 0.2f;
    }
예제 #11
0
        public static HitPoint HitTest(Point point, Rectangle rect)
        {
            double   thickness = rect.StrokeThickness;
            HitPoint hitPoint  = HitPoint.None;

            if (point.X <= thickness && point.X >= 0)
            {
                hitPoint = HitPoint.Left;
            }
            else if (point.Y <= thickness && point.X >= 0)
            {
                hitPoint = HitPoint.Top;
            }
            else if (point.X >= rect.ActualWidth - thickness && point.X <= rect.ActualWidth + thickness)
            {
                hitPoint = HitPoint.Right;
            }
            else if (point.Y >= rect.ActualHeight - thickness && point.Y <= rect.ActualHeight + thickness)
            {
                hitPoint = HitPoint.Bottom;
            }
            else if (point.X > thickness && point.X < rect.ActualWidth - thickness &&
                     point.Y > thickness && point.Y < rect.ActualHeight - thickness)
            {
                hitPoint = HitPoint.Center;
            }
            return(hitPoint);
        }
예제 #12
0
    public void OnHit(Vector3 pos, float amount)
    {
        timeSinceHit = 0;

        var p = new HitPoint(amount, pos);

        p.Parent = this;
    }
예제 #13
0
        public void ダメージがオーバーしてもHPはマイナスにならない()
        {
            var hp0 = new HitPoint(100);
            var dmg = new Damage(9999);
            var hp1 = dmg.GetDamagedHitPoint(hp0);

            Assert.That(hp1.value, Is.Not.Negative);
        }
예제 #14
0
        public void ダメージ分HPが減る()
        {
            var hp0 = new HitPoint(100);
            var dmg = new Damage(60);
            var hp1 = dmg.GetDamagedHitPoint(hp0);

            Assert.That(hp1.value, Is.EqualTo(40));
        }
예제 #15
0
    //在新游戏开始时被调用
    void Awake()
    {
        Instance = this;

        ///初始化面板
        HP          = 5;
        hpText.text = HP.ToString();
    }
예제 #16
0
        public static HitPoint retrieveHitPoint(RaycastHit hit)
        {
            HitPoint hitPoint = new HitPoint();

            hitPoint.position = hit.point;
            hitPoint.normal   = hit.normal;
            return(hitPoint);
        }
예제 #17
0
 public WeaponStaff()
 {
     _minDamage  = 20;
     _maxDamage  = 55;
     Name        = "Staff";
     Description = "Good in close combat, but can prove unreliable against metal weapons.";
     Icon        = new Image();
     HitPoints   = new HitPoint((_maxDamage + _minDamage) / 2);
 }
예제 #18
0
 public WeaponNunchucks()
 {
     _minDamage  = 35;
     _maxDamage  = 65;
     Name        = "Nunchucks";
     Description = "A fast, light weapon. Requires much skill to be used efficiently.";
     Icon        = new Image();
     HitPoints   = new HitPoint((_maxDamage + _minDamage) / 2);
 }
예제 #19
0
 public WeaponHeavySword()
 {
     _minDamage  = 75;
     _maxDamage  = 100;
     Name        = "Heavy Sword";
     Description = "A heavy, powerful weapon. Does much damage, but is slow to wield.";
     Icon        = new Image();
     HitPoints   = new HitPoint((_maxDamage + _minDamage) / 2);
 }
예제 #20
0
 public WeaponElfBow()
 {
     _minDamage  = 20;
     _maxDamage  = 85;
     Name        = "Bow and Arrow";
     Description = "An excellent long range weapon. Mostly uneffective in close combat. This weapon requires a decent amout of skill to be used accurately.";
     Icon        = new Image();
     HitPoints   = new HitPoint((_maxDamage + _minDamage) / 2);
 }
예제 #21
0
 public WeaponSword()
 {
     _minDamage  = 55;
     _maxDamage  = 75;
     Name        = "Sword";
     Description = "A fast weapon, excellent in close combat.";
     Icon        = new Image();
     HitPoints   = new HitPoint((_maxDamage + _minDamage) / 2);
 }
예제 #22
0
 protected void ShootAt(HitPoint enemy)
 {
     fireCooldownLeft -= Time.deltaTime;
     if (fireCooldownLeft <= 0 && !isAttacking)
     {
         fireCooldownLeft = fireCooldown;
         this.isAttacking = true;
         this.Animator.SetTrigger("Attack");
     }
 }
예제 #23
0
 void Start()
 {
     PutWeaponInHand();
     SetRuntimeAnimatorController();
     SetHealthPoints();
     hitPoint             = GetComponentInChildren <HitPoint>();
     weaponDamageCollider = GetComponentInChildren <WeaponHook>();
     anim        = GetComponent <Animator>();
     audioSource = GetComponent <AudioSource>();
 }
    public void Enable()
    {
        player.enabled = true;
        MainObject     = currentSkin.InitSkin();
        // MainObject.transform.localScale = Vector2.zero;
        targetPrefab = currentSkin.TargetObject;
        player.SetHitObject(currentSkin.HitObject, 4);

        currentColor = currentSkin.GetColor();

        MainObject.transform.Find("Main").GetComponent <SpriteRenderer>().color = currentColor;

        dir = Random.value > .5f ? 1 : -1;
        if (lvl.canSlowDown)
        {
            StartCoroutine(ChangeSpeed());
            speed = 0;
        }
        else
        {
            speed = lvl.maxSpeed;
        }
        pointAngles = new List <HitPoint>();

        var coinCount = 2f;
        var startPos  = spawner.position;

        for (int i = 0; i < 18; i++)
        {
            if (Random.value < levelCoefficient)
            {
                var g    = Instantiate(targetPrefab, spawner.position, spawner.rotation, MainObject.transform);
                var hito = new HitPoint(g, 360 - spawner.eulerAngles.z);

                GameObject coin = null;
                if (coinCount > 0 && Random.value > .7f)
                {
                    coinCount--;
                    var coinObj = Instantiate(coinPrefab, spawner.position - spawner.transform.up / 2f, spawner.rotation, MainObject.transform);
                    // coinObj.transform.localScale = Vector3.one * 2;
                    hito.SetCoin(coinObj);
                }

                pointAngles.Add(hito);
            }
            spawner.RotateAround(Vector3.zero, Vector3.forward, 20);
        }

        spawner.position = startPos;
        spawner.rotation = Quaternion.identity;

        score = PrefsManager.CurrentScore;
        OnUpdateScore(score);
    }
예제 #25
0
        public static HitPoint GetDamagedHitPoint(this Damage damage, HitPoint original)
        {
            var remain = original.value - damage.value;

            if (remain < 0)
            {
                remain = 0;
            }

            return(new HitPoint(remain));
        }
    // Token: 0x0600200C RID: 8204 RVA: 0x000994D4 File Offset: 0x000976D4
    public override void Shoot(Ray ray, out CmunePairList <BaseGameProp, ShotPoint> hits)
    {
        Dictionary <BaseGameProp, ShotPoint> dictionary = new Dictionary <BaseGameProp, ShotPoint>(this.ShotgunGauge);
        HitPoint hitPoint = null;

        RaycastHit[] array        = new RaycastHit[this.ShotgunGauge];
        int          projectileId = base.Controller.NextProjectileId();
        int          num          = 1000;

        for (int i = 0; i < this.ShotgunGauge; i++)
        {
            Vector3    direction = WeaponDataManager.ApplyDispersion(ray.direction, this._view, false);
            RaycastHit raycastHit;
            if (Physics.Raycast(ray.origin, direction, out raycastHit, (float)num, (!base.Controller.IsLocal) ? UberstrikeLayerMasks.ShootMaskRemotePlayer : UberstrikeLayerMasks.ShootMask))
            {
                if (hitPoint == null)
                {
                    hitPoint = new HitPoint(raycastHit.point, TagUtil.GetTag(raycastHit.collider));
                }
                BaseGameProp component = raycastHit.collider.GetComponent <BaseGameProp>();
                if (component)
                {
                    ShotPoint shotPoint;
                    if (dictionary.TryGetValue(component, out shotPoint))
                    {
                        shotPoint.AddPoint(raycastHit.point);
                    }
                    else
                    {
                        dictionary.Add(component, new ShotPoint(raycastHit.point, projectileId));
                    }
                }
                array[i] = raycastHit;
            }
            else
            {
                array[i].point  = ray.origin + ray.direction * 1000f;
                array[i].normal = raycastHit.normal;
            }
        }
        this.Decorator.PlayImpactSoundAt(hitPoint);
        hits = new CmunePairList <BaseGameProp, ShotPoint>(dictionary.Count);
        foreach (KeyValuePair <BaseGameProp, ShotPoint> keyValuePair in dictionary)
        {
            hits.Add(keyValuePair.Key, keyValuePair.Value);
        }
        if (this.Decorator)
        {
            this.Decorator.ShowShootEffect(array);
        }
        base.OnHits(hits);
    }
예제 #27
0
    void Start()
    {
        hitPoint = GetComponent<HitPoint>();
        tankMove = GetComponent<TankMove>();
        fireCannon = GetComponent<FireCannon>();
        zoomImage = GameObject.Find("ZoomImage");
        respawn = GameObject.Find("Respawn").GetComponent<Text>();
        respawnTextTime = GameObject.Find("RespawnTime").GetComponent<Text>();

        if (pv.isMine)
        {
            Camera.main.GetComponent<SmoothCam>().target = camPivot;  //메인 카메라에 추가된 스크립트에 추적 대상을 연결
        }
    }
예제 #28
0
        /// <summary>
        /// Finds the closest hit point for a given ray among all the objects in this container.
        /// Returns the closest hit point. Null if none is found.
        /// </summary>
        /// <param name="ray">Ray for which the hit points should be found</param>
        /// <returns>The closest hit point. Null if none is found.</returns>
        public HitPoint FindClosestHitPoint(Ray ray)
        {
            HitPoint closestHitPoint = null;

            foreach (ISceneObject sceneObject in sceneObjects)
            {
                HitPoint hitPoint = sceneObject.CalculateHitPoint(ray);
                if (hitPoint != null && (closestHitPoint == null || hitPoint?.Lambda < closestHitPoint?.Lambda))
                {
                    closestHitPoint = hitPoint;
                }
            }
            return(closestHitPoint);
        }
예제 #29
0
        public HitPointParser(string filename)
        {
            map = new Beatmap(filename);

            if (map.GetTag("general", "mode") == "3")
            {
                throw new ArgumentException("Error, mania mode parsing not supported");
            }

            List <HitPoint> hitpointbuffer = new List <HitPoint>();

            string[] hitobjectids = map.GetSection("hitobjects");

            for (int i = 0; i < hitobjectids.Length; i++)
            {
                try
                {
                    GenericHitObject hobject = new GenericHitObject(hitobjectids[i], map);

                    int[] positions = hobject.GetHitLocations();
                    int[] times     = hobject.GetHitTimes();

                    if (positions.Length != times.Length)
                    {
                        throw new Exception("Error: position and times array mismatched in size\n" +
                                            "positions.Length: " + positions.Length + "\n" +
                                            "times.Length: " + times.Length + "\n" +
                                            "index: " + i);
                    }

                    //Add a new HitPoint for every hit position and time
                    for (int j = 0; j < positions.Length; j++)
                    {
                        HitPoint point = new HitPoint(positions[j], times[j], 0, 0);
                        hitpointbuffer.Add(point);
                    }
                }
                catch (Exception e)
                {
                    //This is zero-indexed, so the first object is object=0
                    throw new Exception(e.Message + "\nobject=" + i + "\n" + GetMetadata("title") + ": " + GetMetadata("version"), e);
                }
            }

            hitpoints = hitpointbuffer.ToArray();
        }
예제 #30
0
        private void LookAtTarget()
        {
            this.targetDirection = this.target.transform.position - this.transform.position;

            if (this.targetDirection.magnitude > this.Range)
            {
                this.target = null;
                return;
            }

            var lookRotation = Quaternion.LookRotation(this.targetDirection);

            var rotation = Quaternion.Lerp(
                this.RotationPart.transform.rotation,
                lookRotation,
                Time.deltaTime * this.RotationSpeed).eulerAngles;

            this.RotationPart.transform.rotation = Quaternion.Euler(0, rotation.y, 0);
        }
예제 #31
0
        //Reference: http://docs.unity3d.com/ScriptReference/RaycastHit-triangleIndex.html
        //Reference: http://answers.unity3d.com/questions/50846/how-do-i-obtain-the-surface-normal-for-a-point-on.html
        public static HitPoint retrieveHitTriangleOnMesh(RaycastHit hit)
        {
            MeshCollider meshCollider = hit.collider as MeshCollider;

            if (meshCollider == null || meshCollider.sharedMesh == null)
            {
                return(null);
            }

            HitPoint hitPoint = new HitPoint();
            Mesh     mesh     = meshCollider.sharedMesh;

            Vector3[] vertices     = mesh.vertices;
            Vector3   p0           = vertices[mesh.triangles[hit.triangleIndex * 3 + 0]];
            Vector3   p1           = vertices[mesh.triangles[hit.triangleIndex * 3 + 1]];
            Vector3   p2           = vertices[mesh.triangles[hit.triangleIndex * 3 + 2]];
            Transform hitTransform = hit.collider.transform;

            p0 = hitTransform.TransformPoint(p0);
            p1 = hitTransform.TransformPoint(p1);
            p2 = hitTransform.TransformPoint(p2);

            hitPoint.position = p0;         //hit.barycentricCoordinate;

            //Vector3 n0 = mesh.normals[mesh.triangles[hit.triangleIndex * 3 + 0]];
            //Vector3 n1 = mesh.normals[mesh.triangles[hit.triangleIndex * 3 + 1]];
            //Vector3 n2 = mesh.normals[mesh.triangles[hit.triangleIndex * 3 + 2]];
            //Vector3 interpolatedNormal = n0 * hitTriangle.position.x + n1 * hitTriangle.position.y + n2 * hitTriangle.position.z;
            //interpolatedNormal.Normalize();
            //hitTriangle.normal = hit.transform.TransformDirection(interpolatedNormal);

            hitPoint.normal = Vector3.Cross(p1 - p0, p2 - p0);

            //if(drawDebug)
            //{
            //	Debug.DrawLine(p0, p1);
            //	Debug.DrawLine(p1, p2);
            //	Debug.DrawLine(p2, p0);
            //	Debug.DrawRay(hitPoint.position, hitPoint.normal);
            //}

            return(hitPoint);
        }
예제 #32
0
 void Awake()
 {
     player = GameObject.Find("Player");
     hitpoint = GetComponent<HitPoint>();
     anim = GetComponent<Animator>();
 }
예제 #33
0
 public void SetStart(HitPoint startPosition, int startDirection)
 {
     if(CurrentHitpoint!=null) throw new InvalidOperationException("Initial position was already set!");
     CurrentHitpoint = startPosition;
     Direction = startDirection;
 }
예제 #34
0
 /// <summary>
 /// Checks if the player will hit a wall in the next move
 /// </summary>
 /// <param name="player">The player to check</param>
 /// <param name="nextMove">The next move of the player</param>
 /// <returns>true, if the player hits a wall in the next move, else false</returns>
 private bool CheckPlayerHitWall(Player player, HitPoint nextMove)
 {
     if(nextMove.HitWall(MainPanel.GameScoreboardX, MainPanel.GameHeight)) {
         player.PlayerState.Died = true;
         Debug.WriteLine(player.Name +" died! (WallHit @ "+nextMove+")");
         return true;
     }
     return false;
 }
예제 #35
0
 /// <summary>
 /// Checks if the next move of the player collides with another player
 /// </summary>
 /// <param name="player">The player to check</param>
 /// <param name="nextMove">The next move of this player</param>
 /// <returns>true, if the player will collide with another player, else false</returns>
 private bool CheckPlayerHitPlayer(Player player, HitPoint nextMove)
 {
     bool hit = false;
     foreach (Player colCheckPlayer in Players) {
         PlayerState colPlayerState = colCheckPlayer.PlayerState;
         foreach (HitPoint colCheckHitpoint in colPlayerState.HitBox) {
             if(nextMove.Hit(colCheckHitpoint)) {
                 if(colCheckPlayer != player || (colCheckPlayer == player && Environment.TickCount - colCheckHitpoint.Created > TICK_SELF_IMMUNITY)) {
                     hit = true;
                     break;
                 }
             }
         }
         if (hit) {
             Debug.WriteLine(player.Name + " died! (PlayerHit " + colCheckPlayer.Name + " @ Positions: " + player.PlayerState.CurrentHitpoint + "  ///  " + colCheckPlayer.PlayerState.CurrentHitpoint + ")");
             player.PlayerState.Died = true;
             return true;
         }
     }
     return false;
 }
예제 #36
0
 private void CalculateHoleChance(Player player, HitPoint nextMove)
 {
     PlayerState state = player.PlayerState;
     if(_gameOptions.Holes && (state.DrawHoleStartTick != 0 || Random.NextDouble() < PlayerState.PROBABILITY_DRAW_HOLES_START)) {
         if(state.DrawHoleStartTick == 0) {
             state.DrawHoleStartTick = Environment.TickCount;
             state.DrawHoleStopTick = Environment.TickCount +
                                      Random.Next(PlayerState.MIN_HOLE_SIZE_IN_TICKS, PlayerState.MAX_HOLE_SIZE_IN_TICKS);
         } else if(Environment.TickCount > state.DrawHoleStopTick) {
             state.DrawHoleStartTick = 0;
             state.DrawHoleStopTick = 0;
         }
         nextMove.Enabled = false;
     }
     player.PlayerState.AddHitPoint(nextMove);
 }
예제 #37
0
 public StartPosition(HitPoint startPos, int startDirection)
 {
     StartPos = startPos;
     StartDirection = startDirection;
 }
예제 #38
0
 public void AddHitPoint(HitPoint p)
 {
     CurrentHitpoint = p;
     HitBox.Add(p);
 }