public static void StartBuilding(PrimitiveBuilding primitiveBuilding)
 {
     if (primitiveBuilding.GetBuildingType() == BuildingType.Infrastructure)
     {
         infrastructureBuildingComponent.StartBuilding(primitiveBuilding, true);
     }
     else
     {
         gameplayItemPlacingComponent.StartPlacing(primitiveBuilding);
     }
 }
        public void SetPrimitiveBuilding(PrimitiveBuilding building)
        {
            this.primitiveData = building;

            // Check to see if the primitive building reqires Beforebuild stuff
            IBuildingBeforeBuild buildingBeforeBuild = building as IBuildingBeforeBuild;

            if (buildingBeforeBuild != null)
            {
                buildingBeforeBuild.BeforeBuild(this);

                if (!buildingBeforeBuild.ContinueBuild())
                {
                    entity.destroy();
                    return;
                }
            }

            // Check to see if the primitive building wants a repeated texture renderer
            IBuildingRepeatedTextureRenderer buildingRepeatedTextureRenderer = building as IBuildingRepeatedTextureRenderer;

            if (buildingRepeatedTextureRenderer != null)
            {
                entity.addComponent(new BuildingRepeatedTextureRenderer(this, buildingRepeatedTextureRenderer.GetTexture()));
            }

            // Check to see if the primitive building wants a dynamic texture renderer
            IBuildingDynamicTexture buildingDynamicTextureRenderer = building as IBuildingDynamicTexture;

            if (buildingDynamicTextureRenderer != null)
            {
                entity.addComponent(new BuildingDynamicTextureRenderer(this, buildingDynamicTextureRenderer));
            }

            // Check to see if the primitive building wants a standard gameplay object renderer.
            IBuildingStandardGameplayRenderer buildingStandardGameplayRenderer = building as IBuildingStandardGameplayRenderer;

            if (buildingStandardGameplayRenderer != null)
            {
                entity.addComponent(new BuildingStandardGameplayRenderer(this, buildingStandardGameplayRenderer.GetTexture()));
            }

            // Check to see if the primitive building wishes to be consturcted instead of appear
            IBuildingRequiresConstruction buildingRequiresConstruction = building as IBuildingRequiresConstruction;

            if (buildingRequiresConstruction != null)
            {
                entity.addComponent(new UnderConstruction(this, buildingRequiresConstruction.GetTimeRequiredToBuild()));
            }
            else
            {
                Finish();
            }
        }
Exemplo n.º 3
0
        public void StartBuilding(PrimitiveBuilding primitivebuilding, bool shouldCarryOnAfterDragging)
        {
            if (BuildingController.IsDragging() || Zoning.ZoneController.IsDragging())
            {
                Nez.Console.DebugConsole.instance.log("We are already building, placing or zoning.");
                return;
            }

            this.primitivebuilding = primitivebuilding;
            StartDragging(shouldCarryOnAfterDragging);
        }
Exemplo n.º 4
0
        public Building PlaceBuilding(PrimitiveBuilding primitivebuilding, Vector2 tilePosition, Vector2 size)
        {
            this.primitivebuilding = primitivebuilding;
            List <Tile> tilesAffected = new List <Tile>();

            for (int x = 0; x < size.X; x++)
            {
                for (int y = 0; y < size.Y; y++)
                {
                    Tile t = WorldController.GetTileAt((int)tilePosition.X + x, (int)tilePosition.Y + y);
                    if (t == null)
                    {
                        continue;
                    }
                    tilesAffected.Add(t);
                }
            }

            return(PlaceBuilding(tilePosition, size, tilesAffected));
        }
Exemplo n.º 5
0
        public void StartPlacing(PrimitiveBuilding primitiveBuilding)
        {
            if (BuildingController.IsDragging() || Zoning.ZoneController.IsDragging())
            {
                Nez.Console.DebugConsole.instance.log("We are already building, placing or zoning.");
                return;
            }

            this.primitiveBuilding = primitiveBuilding;
            placingComponent.StartPlacing(primitiveBuilding.GetSize(), primitiveBuilding.CarryOnBuildingAfterPlacement(), false);

            if (entitySprite == null)
            {
                entitySprite = WorldController.SCENE.createEntity("GameplayItemPlacement sprite");
                sprite       = new Sprite();
                entitySprite.addComponent(sprite);
            }

            entitySprite.setEnabled(true);
            sprite.setSubtexture((primitiveBuilding as IBuildingStandardGameplayRenderer).GetTexture());
            sprite.setLocalOffset(new Vector2(sprite.width / 2, 0) - new Vector2(50, 0));
            placingComponent.ShouldCarryOnAfterPlaced(primitiveBuilding.CarryOnBuildingAfterPlacement());
        }
 public static Building PlaceBuilding(PrimitiveBuilding primitiveBuilding, Vector2 tilePosition, Vector2 tileSize)
 {
     return(infrastructureBuildingComponent.PlaceBuilding(primitiveBuilding, tilePosition, tileSize));
 }
Exemplo n.º 7
0
 // Called when the DraggingComponent has finished dragging
 public override void OnFinishedDragging()
 {
     primitivebuilding = null;
 }