Exemplo n.º 1
0
        public override void Initialize()
        {
            if (Farm != null)
            {
                if (Farm.Voxel.IsValid)
                {
                    Tree = new Select(new Sequence(
                                          ActHelper.CreateEquipmentCheckAct(Agent, "Tool", ActHelper.EquipmentFallback.NoFallback, "Hoe"),
                                          new GetResourcesOfType(Agent, new List <ResourceTypeAmount> {
                        new ResourceTypeAmount(Farm.SeedType, 1)
                    })
                    {
                        BlackboardEntry = "stashed-resources"
                    },
                                          new Domain(Validate, new GoToVoxelAct(Farm.Voxel, PlanAct.PlanType.Adjacent, Creature.AI)),
                                          new Domain(Validate, new StopAct(Creature.AI)),
                                          new Domain(Validate, new Wrap(FarmATile)),
                                          new Wrap(Cleanup)), new Wrap(Cleanup));
                }
            }

            base.Initialize();
        }
Exemplo n.º 2
0
        public BuildZoneAct(CreatureAI agent, BuildZoneOrder buildRoom) :
            base(agent)
        {
            Name      = "Build BuildRoom " + buildRoom.ToString();
            Resources = buildRoom.ListRequiredResources();
            BuildRoom = buildRoom;
            if (BuildRoom.ResourcesReservedFor != null && BuildRoom.ResourcesReservedFor.IsDead)
            {
                BuildRoom.ResourcesReservedFor = null;
            }

            Tree = new Sequence(new Select(new Domain(buildRoom.MeetsBuildRequirements() || buildRoom.ResourcesReservedFor != null, true),
                                           new Domain(!buildRoom.MeetsBuildRequirements() && (buildRoom.ResourcesReservedFor == null || buildRoom.ResourcesReservedFor == Agent), new Sequence(new Wrap(Reserve), new GetResourcesWithTag(Agent, Resources)
            {
                BlackboardEntry = "zone_resources"
            })),
                                           new Domain(buildRoom.MeetsBuildRequirements() || buildRoom.ResourcesReservedFor != null, true)),
                                new Domain(() => IsRoomBuildOrder(buildRoom) && !buildRoom.IsBuilt && !buildRoom.IsDestroyed && ValidResourceState(),
                                           new Sequence(
                                               ActHelper.CreateEquipmentCheckAct(agent, "Tool", ActHelper.EquipmentFallback.NoFallback, "Hammer"),
                                               SetTargetVoxelFromRoomAct(buildRoom, "ActionVoxel"),
                                               new GoToNamedVoxelAct("ActionVoxel", PlanAct.PlanType.Adjacent, Agent),
                                               new Wrap(PutResources),
                                               new Wrap(WaitForResources)
            {
                Name = "Wait for resources..."
            },
                                               new Wrap(() => Creature.HitAndWait(true, () => 1.0f, () => buildRoom.BuildProgress,
                                                                                  () => buildRoom.BuildProgress += agent.Stats.BuildSpeed / buildRoom.VoxelOrders.Count * 0.5f,
                                                                                  () => MathFunctions.RandVector3Box(buildRoom.GetBoundingBox()), ContentPaths.Audio.Oscar.sfx_ic_dwarf_craft, () => !buildRoom.IsBuilt && !buildRoom.IsDestroyed))
            {
                Name = "Build room.."
            },
                                               new CreateRoomAct(Agent, buildRoom)
                                               , new Wrap(OnFailOrCancel))) | new Wrap(OnFailOrCancel)
                                );
        }
Exemplo n.º 3
0
        public override MaybeNull <Act> CreateScript(Creature creature)
        {
            if (Library.GetVoxelType(VoxType).HasValue(out VoxelType voxtype))
            {
                var resource = creature.World.ListResources().Where(r => Library.GetResourceType(r.Key).HasValue(out var res) && voxtype.CanBuildWith(res)).FirstOrDefault();

                if (resource.Key == null)
                {
                    return(null);
                }

                var resources = new ResourceTypeAmount(resource.Value.Type, 1);

                return(new Select(
                           new Sequence(
                               ActHelper.CreateEquipmentCheckAct(creature.AI, "Tool", ActHelper.EquipmentFallback.NoFallback, "Hammer"),
                               new FailMessage(creature.AI, new GetResourcesOfType(creature.AI, new List <ResourceTypeAmount>()
                {
                    resources
                })
                {
                    BlackboardEntry = "stashed-resource"
                },
                                               "Couldn't locate the correct resources!"),
                               new Domain(() => Validate(creature.AI, Voxel, resources),
                                          new GoToVoxelAct(Voxel, PlanAct.PlanType.Radius, creature.AI, 4.0f)),
                               new PlaceVoxelAct(Voxel, creature.AI, "stashed-resource", VoxType)),
                           new Wrap(creature.RestockAll))
                {
                    Name = "Build Voxel"
                });
            }
            else
            {
                return(null);
            }
        }
Exemplo n.º 4
0
        public override void Initialize()
        {
            var unreserveAct = new Wrap(UnReserve);
            var time         = 3 * (ItemType.Craft_BaseCraftTime / Creature.AI.Stats.Intelligence);
            var getResources = new Select(
                new Domain(() => Des.HasResources || Des.ResourcesReservedFor != null,
                           new Always(Status.Success)),
                new Domain(() => !Des.HasResources && (Des.ResourcesReservedFor == Agent || Des.ResourcesReservedFor == null),
                           new Sequence(
                               new Select(
                                   new Sequence(
                                       new Wrap(ReserveResources),
                                       new GetResourcesOfApparentType(Agent, RawMaterials)
            {
                BlackboardEntry = "stashed-materials"
            }),
                                   (new Wrap(UnReserve))),
                               new Always(Status.Fail))),
                new Domain(() => Des.HasResources || Des.ResourcesReservedFor != null,
                           new Always(Status.Success)));

            if (!String.IsNullOrEmpty(ItemType.Craft_Location))
            {
                Tree = new Select(new Sequence(
                                      new Wrap(() => Creature.FindAndReserve(ItemType.Craft_Location, "craft-location")),
                                      new ClearBlackboardData(Agent, "ResourcesStashed"),
                                      getResources,
                                      new Select(new Domain(ResourceStateValid,
                                                            new Sequence(
                                                                ActHelper.CreateEquipmentCheckAct(Agent, "Tool", ActHelper.EquipmentFallback.AllowDefault, "Hammer"),
                                                                new GoToTaggedObjectAct(Agent)
                {
                    Teleport             = true,
                    TeleportOffset       = new Vector3(0.5f, 0.0f, 0),
                    ObjectBlackboardName = "craft-location",
                    CheckForOcclusion    = true
                },
                                                                new Wrap(() => DestroyResources(() => Agent.Position + MathFunctions.RandVector3Cube() * 0.5f)),
                                                                new Wrap(WaitForResources)
                {
                    Name = "Wait for resources."
                },
                                                                new Wrap(() => Creature.HitAndWait(true,
                                                                                                   () => 1.0f,         // Max Progress
                                                                                                   () => Des.Progress, // Current Progress
                                                                                                   () =>
                {                                                                                                      // Increment Progress
                    var location = Creature.AI.Blackboard.GetData <GameComponent>(ItemType.Craft_Location);

                    float workstationBuff = 1.0f;
                    if (location != null)
                    {
                        Creature.Physics.Face(location.Position);
                        if (location.GetComponent <SteamPipes.BuildBuff>().HasValue(out var buff))
                        {
                            workstationBuff = buff.GetBuffMultiplier();
                        }
                    }

                    // Todo: Account for environment buff & 'anvil' buff.

                    Des.Progress += (Creature.Stats.BuildSpeed * workstationBuff) / ItemType.Craft_BaseCraftTime;
                },