コード例 #1
0
ファイル: LevelEditor.cs プロジェクト: piptstc/Laser_Lab
    private void DrawProperties(LaserLabObject obj)
    {
        SerializedObject   serialObj = new SerializedObject(obj);
        SerializedProperty prop      = serialObj.GetIterator();

        GUI.enabled = false;
        prop.NextVisible(true);
        EditorGUILayout.PropertyField(prop);
        GUI.enabled = true;
        while (prop.NextVisible(true))
        {
            bool isPrefabData = System.Attribute.GetCustomAttribute(obj.GetType().GetField(prop.name), typeof(PrefabDataAttribute)) != null;
            if (isPrefabData)
            {
                GUI.enabled = false;
            }
            EditorGUILayout.PropertyField(prop);
            GUI.enabled = true;
        }
        if (serialObj.ApplyModifiedProperties())
        {
            if (obj is IRefreshable)
            {
                (obj as IRefreshable).Refresh();
            }
        }
    }
コード例 #2
0
ファイル: LevelEditor.cs プロジェクト: piptstc/Laser_Lab
    private Texture FindIcon(LaserLabObject obj)
    {
        if (obj is BoardObject)
        {
            return(boardObjectIcons[findIndex(boardObjectTypes, obj.GetType())]);
        }
        else if (obj is WallObject)
        {
            return(wallObjectIcons[findIndex(wallObjectTypes, obj.GetType())]);
        }

        return(null);
    }
コード例 #3
0
 public Vector2Int FindObject(LaserLabObject obj)
 {
     for (int i = -1; i <= Width; i++)
     {
         for (int j = -1; j <= Height; j++)
         {
             Vector2Int pos = new Vector2Int(i, j);
             if (obj == GetLaserLabObject(pos))
             {
                 return(pos);
             }
         }
     }
     return(new Vector2Int(-1, -1));
 }
コード例 #4
0
ファイル: GameManager.cs プロジェクト: piptstc/Laser_Lab
    private void RecursiveLaserPath(ref List <Laser> lasers, Laser current, int index, int max)
    {
        lasers.Add(current);

        if (index >= max)
        {
            return;
        }

        if (current.red + current.green + current.blue < .01f)
        {
            return;
        }

        Vector2Int origin = current.origin;

        int        distance  = 1;
        Vector2Int direction = current.GetDirectionVector();

        while (true)
        {
            LaserLabObject nextObject = level.board.GetLaserLabObject(origin + (direction * distance));
            if (nextObject && nextObject is ILaserTarget)
            {
                current.length = distance;
                ILaserTarget nextTarget = nextObject as ILaserTarget;
                Laser[]      nextLasers = nextTarget.OnLaserHit(current);

                for (int i = 0; i < nextLasers.Length; i++)
                {
                    nextLasers[i].origin = nextTarget.GetPosition();
                    RecursiveLaserPath(ref lasers, nextLasers[i], index + 1, max);
                }

                return;
            }

            distance++;
        }
    }
コード例 #5
0
ファイル: GameManager.cs プロジェクト: piptstc/Laser_Lab
    private void MouseEvents()
    {
        RaycastHit hit;

        if (Physics.Raycast(Camera.main.ScreenPointToRay(Input.mousePosition), out hit))
        {
            LaserLabObject target = hit.collider.GetComponent <LaserLabObject>();

            if (target != null)
            {
                if (target != previousHover)
                {
                    if (previousHover != null)
                    {
                        previousHover.OnHoverExit();
                    }
                    target.OnHoverEnter();
                    previousHover = target;
                }

                if (target is BoardObject)
                {
                    BoardObject boardObject = target as BoardObject;
                    Vector2Int  pos         = boardObject.getPos();
                    if (Input.GetMouseButtonDown(0))
                    {
                        if (boardObject.CanRotate)
                        {
                            boardObject.Rotate();
                            CalculateLaserPaths();
                            audioPlayer.PlayClip(rotateSound);
                        }
                        else
                        {
                            audioPlayer.PlayClip(dropSound);
                        }

                        SelectObject(-1);
                    }
                    else if (Input.GetMouseButtonDown(1))
                    {
                        if (boardObject.CanMove)
                        {
                            boardObject.Pickup();
                            level.board.SetBoardObject(pos, null);
                            AddToUnplaced(boardObject);
                            audioPlayer.PlayClip(pickupSound);
                        }
                        else
                        {
                            SelectObject(-1);
                            audioPlayer.PlayClip(dropSound);
                        }
                    }

                    if (selectedObjectIndex > -1)
                    {
                        SelectedObject.SetPreview(false);
                    }
                }
                else if (target is FloorTile)
                {
                    FloorTile  floor = target as FloorTile;
                    Vector2Int pos   = floor.getPos();
                    if (Input.GetMouseButtonDown(0))
                    {
                        if (!level.board.GetBoardObject(pos) && selectedObjectIndex != -1)
                        {
                            Place(pos);
                            audioPlayer.PlayClip(placeSound);
                        }
                        else
                        {
                            SelectObject(-1);
                        }
                    }
                    else if (Input.GetMouseButtonDown(1))
                    {
                        audioPlayer.PlayClip(dropSound);
                        SelectObject(-1);
                    }

                    if (selectedObjectIndex > -1)
                    {
                        if (level.board.GetBoardObject(pos))
                        {
                            SelectedObject.SetPreview(false);
                        }
                        else
                        {
                            SelectedObject.SetPreview(true);
                            SelectedObject.Move(pos);
                        }
                    }
                }
                else if (target is WallObject)
                {
                    WallObject wall = target as WallObject;
                    Vector2Int pos  = wall.getPos();

                    if ((Input.GetMouseButtonDown(0) || Input.GetMouseButtonDown(1)) && selectedObjectIndex > -1)
                    {
                        audioPlayer.PlayClip(dropSound);
                        SelectObject(-1);
                    }

                    if (selectedObjectIndex > -1)
                    {
                        SelectedObject.SetPreview(false);
                    }
                }
            }
            else
            {
                if (previousHover != null)
                {
                    previousHover.OnHoverExit();
                    previousHover = null;
                }

                if (Input.GetMouseButtonDown(0) || Input.GetMouseButtonDown(1))
                {
                    SelectObject(-1);
                    audioPlayer.PlayClip(dropSound);
                }

                if (selectedObjectIndex > -1)
                {
                    SelectedObject.SetPreview(false);
                }
            }
        }
        else
        {
            if (previousHover != null)
            {
                previousHover.OnHoverExit();
                previousHover = null;
            }

            if (selectedObjectIndex > -1)
            {
                SelectedObject.SetPreview(false);
            }

            if (Input.GetMouseButtonDown(0) || Input.GetMouseButtonDown(1))
            {
                SelectObject(-1);
            }
        }
    }