示例#1
0
        private int mNextPreferedActiveConnectionIndex = 0; // the prefered active connection index according to the brick library

        /// <summary>
        /// Add a new named group which has the specified partNumber on the specifier layer, and connected it to
        /// the specified selectedItem (part or group) using the specified wanted connection for that new part.
        /// </summary>
        /// <param name="layer">The layer on which to add the group, and in which the selectedItem is selected</param>
        /// <param name="selectedItem">The single selected item (this can be a single part or a single group). This parameter cannot be null.</param>
        /// <param name="partNumber">The number of the named group to add</param>
        /// <param name="wantedConnexion">The connection index of the group to add that should be used to connect to the selected item, or -1 if you don't care.</param>
        public AddConnectGroup(LayerBrick layer, Layer.LayerItem selectedItem, string partNumber, int wantedConnexion)
        {
            // the selected item should not be null
            System.Diagnostics.Debug.Assert(selectedItem != null);

            // save the layer and construct the group
            mBrickLayer = layer;
            mGroup      = new Layer.Group(partNumber);
            // get the flat list of bricks from the hierarchical group
            mBricksInTheGroup = mGroup.getAllLeafItems();

            // get the connectable brick among the selection, and also the selected item (in case the selected item is a single group without connections points)
            LayerBrick.Brick selectedBrick = layer.getConnectableBrick();
            LayerBrick.Brick brickToConnectInAddedGroup = null;

            // check if we can attach the group to the unique selected object
            if ((selectedBrick != null) && selectedBrick.HasConnectionPoint)
            {
                // find the brick of the group that will be connected to the selected brick
                brickToConnectInAddedGroup = findBrickToConnectAndSetBestConnectionPointIndex(selectedItem, ref wantedConnexion);
            }

            // check if the brick to connect is valid and has connection point
            if ((brickToConnectInAddedGroup != null) && brickToConnectInAddedGroup.HasConnectionPoint)
            {
                // after setting the active connection point index from which this brick will be attached,
                // get the prefered index from the library
                mNextPreferedActiveConnectionIndex = BrickLibrary.Instance.getConnectionNextPreferedIndex(partNumber, wantedConnexion);

                // Compute the orientation of the bricks
                float newOrientation = AddConnectBrick.sGetOrientationOfConnectedBrick(selectedBrick, brickToConnectInAddedGroup);
                newOrientation -= brickToConnectInAddedGroup.Orientation;
                // Rotate all the bricks of the group first before translating
                RotateBrickOnPivotBrick rotateBricksAction = new RotateBrickOnPivotBrick(layer, mBricksInTheGroup, newOrientation, brickToConnectInAddedGroup);
                rotateBricksAction.MustUpdateBrickConnectivity = false;
                rotateBricksAction.redo();

                // compute the translation to add to all the bricks
                PointF translation = new PointF(selectedBrick.ActiveConnectionPosition.X - brickToConnectInAddedGroup.ActiveConnectionPosition.X,
                                                selectedBrick.ActiveConnectionPosition.Y - brickToConnectInAddedGroup.ActiveConnectionPosition.Y);
                mGroup.translate(translation);
            }
            else
            {
                // and just compute the position to the right of the selected item
                PointF position = selectedItem.Position;
                position.X     += selectedItem.DisplayArea.Width;
                mGroup.Position = position;

                // the reassing the selected brick with the first brick of the group if the selected item is a group
                // so that the brick index can correctly be set
                if (selectedItem.IsAGroup)
                {
                    selectedBrick = (selectedItem as Layer.Group).getAllLeafItems()[0] as LayerBrick.Brick;
                }
                else
                {
                    selectedBrick = selectedItem as LayerBrick.Brick;
                }
            }

            // set the index of the group in the list just after the selected brick
            if (selectedBrick != null)
            {
                mInsertIndex = layer.BrickList.IndexOf(selectedBrick) + 1;
            }
        }
示例#2
0
 public void addConnectBrick(string partNumber, int connexion)
 {
     BrickAddability canAdd = canAddBrick(partNumber);
     if (canAdd == BrickAddability.YES)
     {
         LayerBrick brickLayer = Map.sInstance.SelectedLayer as LayerBrick;
         if ((brickLayer != null) && (brickLayer.getConnectableBrick() != null))
         {
             // create the correct action depending if the part is a group or not
             Actions.Action action = null;
             if (BrickLibrary.Instance.isAGroup(partNumber))
                 action = new AddConnectGroup(brickLayer, partNumber, connexion);
             else
                 action = new AddConnectBrick(brickLayer, partNumber, connexion);
             // and add the action in the manager
             ActionManager.Instance.doAction(action);
         }
     }
     else
         giveFeedbackForNotAddingBrick(canAdd);
 }
示例#3
0
        public RotateBrick(LayerBrick layer, List <Layer.LayerItem> bricks, int rotateSteps, bool forceKeepLastCenter)
        {
            // compute the default rotation angle, used if no bricks in the list is connected to something else
            float angle = MapData.Layer.CurrentRotationStep * rotateSteps;

            // now check if we can find any brick in the list which is connected to another
            // brick not in the list: in that case we don't care about the rotation step,
            // we rotate the group of brick such as it can connect with its next connexion point.
            // we do this first because maybe it will invalidate the flag sLastCenterIsValid

            // first we gather all the free connections or those linked with bricks outside of the list of brick
            FreeConnectionSet externalConnectionSet  = new FreeConnectionSet();            // all the connection connected to external bricks
            FreeConnectionSet availableConnectionSet = new FreeConnectionSet();            // all the possible connections that can be used to link to one external brick

            foreach (Layer.LayerItem item in bricks)
            {
                LayerBrick.Brick brick = item as LayerBrick.Brick;
                if (brick.HasConnectionPoint)
                {
                    foreach (LayerBrick.Brick.ConnectionPoint connection in brick.ConnectionPoints)
                    {
                        if (connection.IsFree)
                        {
                            availableConnectionSet.add(connection);
                        }
                        else if (!bricks.Contains(connection.ConnectionLink.mMyBrick))
                        {
                            availableConnectionSet.add(connection);
                            externalConnectionSet.add(connection);
                        }
                    }
                }
            }

            // get the biggest group of external connection among all the available types, and also get its type
            int chosenConnexionType = BrickLibrary.ConnectionType.DEFAULT;
            List <LayerBrick.Brick.ConnectionPoint> externalConnectionList = externalConnectionSet.getBiggestList(out chosenConnexionType);

            // check if there is any external connection on which we should rotate
            if (externalConnectionList.Count > 0)
            {
                // in that case we don't use the static center
                sLastCenterIsValid = false;

                // for now, without a lot of imagination, take the first connection of the list
                mOldConnectionPoint = externalConnectionList[0];

                // store the connection position
                mConnexionPosition = mOldConnectionPoint.PositionInStudWorldCoord;

                // get the fixed brick, the external brick on the other side of the chosen connection
                LayerBrick.Brick fixedBrick   = mOldConnectionPoint.ConnectedBrick;
                int fixedBrickConnectionIndex = mOldConnectionPoint.ConnectionLink.Index;

                // get the same list but for available connections
                List <LayerBrick.Brick.ConnectionPoint> availableConnectionList = availableConnectionSet.getListForType(chosenConnexionType);

                // check in which direction and how many connection we should jump
                bool rotateCW = (rotateSteps < 0);
                int  nbSteps  = Math.Abs(rotateSteps);

                // get the index of the chosen connection in the available connection list
                int index = availableConnectionList.IndexOf(mOldConnectionPoint);
                // start from it then count forward or backward a certain number of connections
                // depending on the number of steps and the rotation direction
                if (rotateCW)
                {
                    index -= (nbSteps % availableConnectionList.Count);
                    if (index < 0)
                    {
                        index += availableConnectionList.Count;
                    }
                }
                else
                {
                    index += (nbSteps % availableConnectionList.Count);
                    if (index >= availableConnectionList.Count)
                    {
                        index -= availableConnectionList.Count;
                    }
                }
                // finally get the new connection from the chosen index
                mNewConnectionPoint = availableConnectionList[index];

                // compute the angle to rotate
                LayerBrick.Brick newConnectedBrick = mNewConnectionPoint.mMyBrick;
                angle = AddConnectBrick.sGetOrientationOfConnectedBrick(fixedBrick, fixedBrickConnectionIndex,
                                                                        newConnectedBrick, mNewConnectionPoint.Index) - newConnectedBrick.Orientation;
            }

            // then call the normal constructor
            commonConstructor(layer, bricks, angle, forceKeepLastCenter);
        }