private IDetailsViewUpdater CreateCornerUpdater(IBlueprintBuilder builder,
                                                        IControlAssigner controlAssigner,
                                                        IWorldObject[,] tiles, Coordinate direction)
        {
            var cornerDetails = new IWorldObject[builder.Dimensions.Y, builder.Dimensions.X];
            var cornerFactory = CreateCornerFactory(builder);
            var cornerUpdates = CornerUpdates(direction);

            return(new BlockDetailsViewUpdater(
                       builder, tiles, cornerDetails, cornerFactory, controlAssigner, cornerUpdates));
        }
        private IDetailsViewUpdater CreateCoreUpdater(IBlueprintBuilder builder,
                                                      IControlAssigner controlAssigner,
                                                      IWorldObject[,] tiles)
        {
            var coreDetails = new IWorldObject[builder.Dimensions.Y, builder.Dimensions.X];

            var coreUpdates = new List <FacingPosition>();

            coreUpdates.Add(new FacingPosition(Coordinates.Zero, Coordinates.Zero));

            return(new BlockDetailsViewUpdater(builder, tiles, coreDetails,
                                               new IgnoreFacingContextWorldObjectFactory(new WorldObjectFactory(blockCoreFactory)),
                                               controlAssigner, coreUpdates));
        }
Beispiel #3
0
 public BlockDetailsViewUpdater(IBlueprintBuilder blueprintBuilder,
                                IWorldObject[,] tiles,
                                IWorldObject[,] details,
                                IFacingContextWorldObjectFactory detailFactory,
                                IControlAssigner controller,
                                IEnumerable <FacingPosition> relativeDetailUpdates)
 {
     this.blueprintBuilder      = blueprintBuilder;
     this.tiles                 = tiles;
     this.details               = details;
     this.detailFactory         = detailFactory;
     this.controller            = controller;
     this.relativeDetailUpdates = relativeDetailUpdates;
 }
        private IDetailsViewUpdater CreateEdgeUpdater(IBlueprintBuilder builder,
                                                      IControlAssigner controlAssigner,
                                                      IWorldObject[,] tiles, Coordinate direction)
        {
            var edgeDetails = new IWorldObject[builder.Dimensions.Y, builder.Dimensions.X];

            var edgeUpdates = new List <FacingPosition>();

            edgeUpdates.Add(new FacingPosition(direction, Coordinates.Zero));
            edgeUpdates.Add(new FacingPosition(direction, -direction));

            var edgeFactory = CreateEdgeFactory(builder);

            return(new BlockDetailsViewUpdater(builder, tiles, edgeDetails, edgeFactory, controlAssigner, edgeUpdates));
        }
 public ViewModel(IBlueprintBuilder builder,
                  ObjectTable objectTable,
                  IFactory <IActivateableWorldObject> blockFactory,
                  IFactory <IActivateableWorldObject, IShipComponent> shipComponentFactory,
                  IFactory <IActivateableWorldObject> pipeLinkFactory,
                  IFactory <IWorldObject, ICurve> pipeFactory,
                  IControlAssigner controller)
 {
     this.builder              = builder;
     this.objectTable          = objectTable;
     this.blockFactory         = blockFactory;
     this.shipComponentFactory = shipComponentFactory;
     this.pipeLinkFactory      = pipeLinkFactory;
     this.pipeFactory          = pipeFactory;
     this.controller           = controller;
 }