Exemple #1
0
        private global::StrawberryShake.EntityId? UpdateIGetHero_HeroEntity(
            global::System.Text.Json.JsonElement? obj,
            global::System.Collections.Generic.ISet <global::StrawberryShake.EntityId> entityIds)
        {
            if (!obj.HasValue)
            {
                return(null);
            }

            global::StrawberryShake.EntityId entityId = _extractId(obj.Value);
            entityIds.Add(entityId);


            if (entityId.Name.Equals("GetHero_Hero_Droid", global::System.StringComparison.Ordinal))
            {
                DroidEntity entity = _entityStore.GetOrCreate <DroidEntity>(entityId);
                entity.Name      = DeserializeNonNullableString(global::StrawberryShake.Transport.Http.JsonElementExtensions.GetPropertyOrNull(obj.Value, "name"));
                entity.AppearsIn = DeserializeEpisodeArray(global::StrawberryShake.Transport.Http.JsonElementExtensions.GetPropertyOrNull(obj.Value, "appearsIn"));

                return(entityId);
            }

            if (entityId.Name.Equals("GetHero_Hero_Human", global::System.StringComparison.Ordinal))
            {
                HumanEntity entity = _entityStore.GetOrCreate <HumanEntity>(entityId);
                entity.Name      = DeserializeNonNullableString(global::StrawberryShake.Transport.Http.JsonElementExtensions.GetPropertyOrNull(obj.Value, "name"));
                entity.AppearsIn = DeserializeEpisodeArray(global::StrawberryShake.Transport.Http.JsonElementExtensions.GetPropertyOrNull(obj.Value, "appearsIn"));

                return(entityId);
            }

            throw new global::System.NotSupportedException();
        }
Exemple #2
0
 private void OnDanceChange(HumanEntity entity)
 {
     entity.Room.EachUser(
         roomSession =>
     {
         roomSession.Router.GetComposer <DanceStatusMessageComposer>()
         .Compose(roomSession, entity.Id, entity.Dance);
     });
 }
Exemple #3
0
        public TileExplorationResults ExploreTile(HumanEntity entity, WorldTile tile)
        {
            var results = new TileExplorationResults();

            //Determine tile properties
            RevealTile(entity, tile);
            //Determine foraging haul
            results.ExplorationInventory = ForageTile(entity, tile);
            //Determine events (lost, special, etc...)
            DetermineExplorationEvents(entity, tile, results);
            //Determine effects of events
            return(results);
        }
Exemple #4
0
    private void LookAtMainPlayerOnInteraction()
    {
        //npc 转向对着人物
        if (m_NpcTmpVO.DialogueTurn == 1)
        {
            GameplayProxy gamePlayProxy = GameFacade.Instance.RetrieveProxy(ProxyName.GameplayProxy) as GameplayProxy;
            HumanEntity   mainPlayer    = gamePlayProxy.GetEntityById <HumanEntity>(gamePlayProxy.GetMainPlayerUID());

            Transform mptf = (mainPlayer != null) ? mainPlayer.GetSkinTransform() : null;

            if (mptf)
            {
                GetSkinTransform().DOLookAt(new Vector3(mptf.position.x, GetSkinTransform().position.y, mptf.position.z), 0.5f).SetAutoKill(true);
            }
        }
    }
Exemple #5
0
 private void RevealSavanna(WorldTile tile, HumanEntity entity)
 {
     tile.TileResourceData.Bark = CalculateResourceAvailabilityMultiplier(
         1f);
     tile.TileResourceData.Berries = CalculateResourceAvailabilityMultiplier(
         1f);
     tile.TileResourceData.SmallAnimals = CalculateResourceAvailabilityMultiplier(
         1.5f);
     tile.TileResourceData.LargeAnimals = CalculateResourceAvailabilityMultiplier(
         1.5f);
     tile.TileResourceData.CactusStuffs = CalculateResourceAvailabilityMultiplier(
         1.5f);
     tile.TileResourceData.Birds = CalculateResourceAvailabilityMultiplier(
         1.25f);
     tile.TileResourceData.Fruit = CalculateResourceAvailabilityMultiplier(
         0.75f);
     tile.TileResourceData.Grasses = CalculateResourceAvailabilityMultiplier(
         1.5f);
     tile.TileResourceData.LongLeaf = CalculateResourceAvailabilityMultiplier(
         0.75f);
     tile.TileResourceData.SmallLeaf = CalculateResourceAvailabilityMultiplier(
         1f);
     tile.TileResourceData.BroadLeaf = CalculateResourceAvailabilityMultiplier(
         0.25f);
     tile.TileResourceData.Mosses = CalculateResourceAvailabilityMultiplier(
         0.25f);
     tile.TileResourceData.Nuts = CalculateResourceAvailabilityMultiplier(
         .75f);
     tile.TileResourceData.LargeRocks = CalculateResourceAvailabilityMultiplier(
         1f);
     tile.TileResourceData.SmallRocks = CalculateResourceAvailabilityMultiplier(
         1f);
     tile.TileResourceData.Seeds = CalculateResourceAvailabilityMultiplier(
         .2f);
     tile.TileResourceData.Sticks = CalculateResourceAvailabilityMultiplier(
         1f);
     tile.TileResourceData.Weeds = CalculateResourceAvailabilityMultiplier(
         1f);
     tile.TileResourceData.Wood = CalculateResourceAvailabilityMultiplier(
         1f);
 }
Exemple #6
0
        private void RevealTile(HumanEntity entity, WorldTile tile)
        {
            var biomeType = tile.TerrainData.BiomeType;

            switch (biomeType)
            {
            case BiomeType.Desert:
                RevealDesert(tile, entity);
                break;

            case BiomeType.Savanna:
                RevealSavanna(tile, entity);
                break;

            case BiomeType.TropicalRainforest:
                break;

            case BiomeType.Grassland:
                break;

            case BiomeType.Woodland:
                break;

            case BiomeType.SeasonalForest:
                break;

            case BiomeType.TemperateRainforest:
                break;

            case BiomeType.BorealForest:
                break;

            case BiomeType.Tundra:
                break;

            case BiomeType.Ice:
                break;
            }
        }
Exemple #7
0
        private void DetermineExplorationEvents(HumanEntity entity, WorldTile tile,
                                                TileExplorationResults explorationResults)
        {
            var roll = 0f;
            var baseExplorationTime = GetExplorationTime(tile, entity);

            //Do we get lost?
            roll = random.NextFloatInRange(0f, .5f);
            roll = roll + DetermineTileLostAndSpecialDiscoveryModifier(tile);
            if (roll > entity.AdjustedNavigationSkill)
            {
                //Lost, what happened to us based on our survival skill?
            }
            roll = random.NextFloatInRange(0f, .5f);
            roll = roll + DetermineTileLostAndSpecialDiscoveryModifier(tile, true);
            if (roll < entity.AdjustedExplorationSkill)
            {
                //We made a special discovery
            }

            DetermineCatastrophe(tile, entity, explorationResults);
        }
Exemple #8
0
    /// <summary>
    /// 获取主玩家皮肤节点
    /// </summary>
    /// <returns></returns>
    public Transform GetMainPlayerSkinTransform()
    {
        CfgEternityProxy cfgEternityProxy = GameFacade.Instance.RetrieveProxy(ProxyName.CfgEternityProxy) as CfgEternityProxy;

        if (!cfgEternityProxy.IsSpace())
        {
            HumanEntity humanEntity = GetEntityById <HumanEntity>(GetMainPlayerUID());
            if (humanEntity != null)
            {
                return(humanEntity.GetSkinTransform());
            }
        }
        else
        {
            SpacecraftEntity spacecraftEntity = GetEntityById <SpacecraftEntity>(GetMainPlayerUID());
            if (spacecraftEntity != null)
            {
                return(spacecraftEntity.GetSkinTransform());
            }
        }

        return(null);
    }
Exemple #9
0
        private Inventory ForageTile(HumanEntity entity)
        {
            var inventory    = new Inventory();
            var resourceHaul = 0;

            ////Bark
            //resourceHaul = CalculateResourceHaul(12f, tile.TileResourceData.Bark, entity.AdjustedForagingSkill);
            //for (int i = 0; i < resourceHaul; i++)
            //{
            //    inventory.AddMaterial(new Bark());
            //}
            ////Berries
            //resourceHaul = CalculateResourceHaul(24f, tile.TileResourceData.Berries, entity.AdjustedForagingSkill);
            //for (int i = 0; i < resourceHaul; i++)
            //{
            //    inventory.AddMaterial(new Berries());
            //}
            ////Bone
            //resourceHaul = CalculateResourceHaul(8f, tile.TileResourceData.SmallAnimals, entity.AdjustedForagingSkill);
            //for (int i = 0; i < resourceHaul; i++)
            //{
            //    inventory.AddMaterial(new Bone() { Size = Resource.ResourceSize.Small });
            //}
            //resourceHaul = CalculateResourceHaul(8f, tile.TileResourceData.LargeAnimals, entity.AdjustedForagingSkill);
            //for (int i = 0; i < resourceHaul; i++)
            //{
            //    inventory.AddMaterial(new Bone() { Size = Resource.ResourceSize.Large });
            //}
            ////Cactus
            //resourceHaul = CalculateResourceHaul(12f, tile.TileResourceData.CactusStuffs, entity.AdjustedForagingSkill);
            //for (int i = 0; i < resourceHaul; i++)
            //{
            //    inventory.AddMaterial(new Cactus());
            //}
            ////Egg
            //resourceHaul = CalculateResourceHaul(6f, tile.TileResourceData.Birds, entity.AdjustedForagingSkill);
            //for (int i = 0; i < resourceHaul; i++)
            //{
            //    inventory.AddMaterial(new Egg());
            //}
            ////Fruit
            //resourceHaul = CalculateResourceHaul(12f, tile.TileResourceData.Fruit, entity.AdjustedForagingSkill);
            //for (int i = 0; i < resourceHaul; i++)
            //{
            //    inventory.AddMaterial(new Fruit());
            //}
            ////Grass
            //resourceHaul = CalculateResourceHaul(24f, tile.TileResourceData.Grasses, entity.AdjustedForagingSkill);
            //for (int i = 0; i < resourceHaul; i++)
            //{
            //    inventory.AddMaterial(new Grass());
            //}
            ////Hide
            //resourceHaul = CalculateResourceHaul(2f, tile.TileResourceData.SmallAnimals, entity.AdjustedForagingSkill);
            //for (int i = 0; i < resourceHaul; i++)
            //{
            //    inventory.AddMaterial(new Hide() { Size = Resource.ResourceSize.Small });
            //}
            //resourceHaul = CalculateResourceHaul(2f, tile.TileResourceData.LargeAnimals, entity.AdjustedForagingSkill);
            //for (int i = 0; i < resourceHaul; i++)
            //{
            //    inventory.AddMaterial(new Hide() { Size = Resource.ResourceSize.Large });
            //}
            ////Broad Leaf
            //resourceHaul = CalculateResourceHaul(24f, tile.TileResourceData.BroadLeaf, entity.AdjustedForagingSkill);
            //for (int i = 0; i < resourceHaul; i++)
            //{
            //    inventory.AddMaterial(new BroadLeaf());
            //}
            ////Long Leaf
            //resourceHaul = CalculateResourceHaul(24f, tile.TileResourceData.LongLeaf, entity.AdjustedForagingSkill);
            //for (int i = 0; i < resourceHaul; i++)
            //{
            //    inventory.AddMaterial(new LongLeaf());
            //}
            ////Small Leaf
            //resourceHaul = CalculateResourceHaul(24f, tile.TileResourceData.SmallLeaf, entity.AdjustedForagingSkill);
            //for (int i = 0; i < resourceHaul; i++)
            //{
            //    inventory.AddMaterial(new SmallLeaf());
            //}
            ////Lose Fur
            //resourceHaul = CalculateResourceHaul(4f, tile.TileResourceData.LargeAnimals, entity.AdjustedForagingSkill);
            //for (int i = 0; i < resourceHaul; i++)
            //{
            //    inventory.AddMaterial(new LoseFur());
            //}
            ////Meat
            //resourceHaul = CalculateResourceHaul(2f, tile.TileResourceData.SmallAnimals, entity.AdjustedForagingSkill);
            //for (int i = 0; i < resourceHaul; i++)
            //{
            //    inventory.AddMaterial(new Meat() { Size = Resource.ResourceSize.Small });
            //}
            //resourceHaul = CalculateResourceHaul(4f, tile.TileResourceData.LargeAnimals, entity.AdjustedForagingSkill);
            //for (int i = 0; i < resourceHaul; i++)
            //{
            //    inventory.AddMaterial(new Meat() { Size = Resource.ResourceSize.Large });
            //}
            ////Moss
            //resourceHaul = CalculateResourceHaul(6f, tile.TileResourceData.Mosses, entity.AdjustedForagingSkill);
            //for (int i = 0; i < resourceHaul; i++)
            //{
            //    inventory.AddMaterial(new Moss());
            //}
            ////Nuts
            //resourceHaul = CalculateResourceHaul(18f, tile.TileResourceData.Nuts, entity.AdjustedForagingSkill);
            //for (int i = 0; i < resourceHaul; i++)
            //{
            //    inventory.AddMaterial(new Nuts());
            //}
            ////Rocks
            //resourceHaul = CalculateResourceHaul(24f, tile.TileResourceData.SmallRocks, entity.AdjustedForagingSkill);
            //for (int i = 0; i < resourceHaul; i++)
            //{
            //    inventory.AddMaterial(new Rock() { Size = Resource.ResourceSize.Small });
            //}
            //resourceHaul = CalculateResourceHaul(12f, tile.TileResourceData.LargeRocks, entity.AdjustedForagingSkill);
            //for (int i = 0; i < resourceHaul; i++)
            //{
            //    inventory.AddMaterial(new Rock() { Size = Resource.ResourceSize.Large });
            //}
            ////Roots
            //resourceHaul = CalculateResourceHaul(24f, tile.TileResourceData.Roots, entity.AdjustedForagingSkill);
            //for (int i = 0; i < resourceHaul; i++)
            //{
            //    inventory.AddMaterial(new Roots());
            //}
            ////Seeds
            //resourceHaul = CalculateResourceHaul(24f, tile.TileResourceData.Seeds, entity.AdjustedForagingSkill);
            //for (int i = 0; i < resourceHaul; i++)
            //{
            //    inventory.AddMaterial(new Seeds());
            //}
            ////Sticks
            //resourceHaul = CalculateResourceHaul(24f, tile.TileResourceData.Sticks, entity.AdjustedForagingSkill);
            //for (int i = 0; i < resourceHaul; i++)
            //{
            //    inventory.AddMaterial(new Stick());
            //}
            ////Teeth
            //resourceHaul = CalculateResourceHaul(12f, tile.TileResourceData.SmallAnimals, entity.AdjustedForagingSkill);
            //for (int i = 0; i < resourceHaul; i++)
            //{
            //    inventory.AddMaterial(new Teeth() { Size = Resource.ResourceSize.Small });
            //}
            //resourceHaul = CalculateResourceHaul(12f, tile.TileResourceData.LargeAnimals, entity.AdjustedForagingSkill);
            //for (int i = 0; i < resourceHaul; i++)
            //{
            //    inventory.AddMaterial(new Teeth() { Size = Resource.ResourceSize.Large });
            //}
            ////Weeds
            //resourceHaul = CalculateResourceHaul(24f, tile.TileResourceData.Weeds, entity.AdjustedForagingSkill);
            //for (int i = 0; i < resourceHaul; i++)
            //{
            //    inventory.AddMaterial(new Weed());
            //}
            ////Wood
            //resourceHaul = CalculateResourceHaul(12f, tile.TileResourceData.Wood, entity.AdjustedForagingSkill);
            //for (int i = 0; i < resourceHaul; i++)
            //{
            //    inventory.AddMaterial(new Wood());
            //}

            return(inventory);
        }
Exemple #10
0
        private static float GetExplorationTime(WorldTile tile, HumanEntity entity)
        {
            var biomeType  = tile.TerrainData.BiomeType;
            var heightType = tile.TerrainData.HeightType;
            //Adjustment will be either posative or negative based on various conditions.  Negative will lessen the time
            //spent exploring this tile.
            var adjustment = 0f;

            var compass = (ItemCompass)entity.EntityInventory.GetInventoryObjectOfType(typeof(ItemCompass));

            if (compass != null)
            {
                adjustment -= compass.Quality;
            }

            var result = 0f;

            if (heightType == HeightType.River)
            {
                result  = 5f;
                result -= (entity.AdjustedSwimmingSkill - 1) * 2;
            }
            else if (heightType >= HeightType.Rock)
            {
            }
            else
            {
                switch (biomeType)
                {
                case BiomeType.Desert:
                    result = 8f;
                    break;

                case BiomeType.Savanna:
                    result = 12f;
                    break;

                case BiomeType.TropicalRainforest:
                    result = 24f;
                    break;

                case BiomeType.Grassland:
                    result = 10f;
                    break;

                case BiomeType.Woodland:
                    result = 10f;
                    break;

                case BiomeType.SeasonalForest:
                    result = 24f;
                    break;

                case BiomeType.TemperateRainforest:
                    result = 30f;
                    break;

                case BiomeType.BorealForest:
                    result = 20f;
                    break;

                case BiomeType.Tundra:
                    result = 12f;
                    break;

                case BiomeType.Ice:
                    result = 12f;
                    break;
                }
            }

            return(result + adjustment);
        }
Exemple #11
0
        private void DetermineCatastrophe(WorldTile tile, HumanEntity entity,
                                          TileExplorationResults explorationResults)
        {
            var severityPercent = random.NextFloatInRange(0f, 1f);
            var roll            = 0f;
            var biomeType       = tile.TerrainData.BiomeType;
            var heightType      = tile.TerrainData.HeightType;

            var elapsedTime = 0f;
            var healthLost  = 0f;
            var fatigueLost = 0f;
            var moraleLost  = 0f;

            if (heightType == HeightType.River)
            {
                //TODO: Account for river.
            }
            else if (heightType >= HeightType.Rock)
            {
                roll = random.NextFloatInRange(0f, .5f);
                var mountainCatastrophe = false;
                if (heightType > HeightType.Rock)
                {
                    if (roll + .5f > entity.AdjustedMountaineeringSkill)
                    {
                        mountainCatastrophe = true;
                    }
                }
                else
                {
                    if (roll + .45f > entity.AdjustedMountaineeringSkill)
                    {
                        mountainCatastrophe = true;
                    }
                }
                if (mountainCatastrophe)
                {
                    explorationResults.ExplorationEntries.Add(
                        new ExplorationStoryEntry()
                    {
                        Title       = "The mountains were not kind.",
                        Description = "During your exploration in the mountains you suffered a fall and were injured."
                    });

                    elapsedTime = MathUtilities.GetFloatAtPercentBetween(3f, 24f, severityPercent);
                    healthLost  = MathUtilities.GetFloatAtPercentBetween(1f, 3f, severityPercent);
                    fatigueLost = MathUtilities.GetFloatAtPercentBetween(1f, 3f, severityPercent);
                    moraleLost  = MathUtilities.GetFloatAtPercentBetween(2f, 4f, severityPercent);
                }
            }
            else
            {
                roll = random.NextFloatInRange(0f, 1f);
                switch (biomeType)
                {
                case BiomeType.Desert:
                    if (roll > .9f)
                    {
                        explorationResults.ExplorationEntries.Add(
                            new ExplorationStoryEntry()
                        {
                            Title       = "The desert was not kind.",
                            Description = "During your exploration in the desert you were stung by an extremely poisonous snake and grew ill."
                        });

                        elapsedTime = MathUtilities.GetFloatAtPercentBetween(1f, 6f, severityPercent);
                        healthLost  = MathUtilities.GetFloatAtPercentBetween(.5f, 1f, severityPercent);
                        fatigueLost = MathUtilities.GetFloatAtPercentBetween(1f, 2f, severityPercent);
                        moraleLost  = MathUtilities.GetFloatAtPercentBetween(1f, 2f, severityPercent);
                    }
                    break;

                case BiomeType.Savanna:
                    if (roll > .9f)
                    {
                    }
                    break;

                case BiomeType.TropicalRainforest:
                    break;

                case BiomeType.Grassland:
                    break;

                case BiomeType.Woodland:
                    break;

                case BiomeType.SeasonalForest:
                    break;

                case BiomeType.TemperateRainforest:
                    break;

                case BiomeType.BorealForest:
                    break;

                case BiomeType.Tundra:
                    break;

                case BiomeType.Ice:
                    break;
                }
            }
            explorationResults.ElapsedTimeHours += elapsedTime;
            entity.Health  -= healthLost;
            entity.Fatigue -= fatigueLost;
            entity.Morale  -= moraleLost;
        }
Exemple #12
0
 private void OnHumanEntityCreation(HumanEntity entity)
 {
     entity.OnDanceChange += OnDanceChange;
 }
 public static void SpawnMessenger()
 {
     Vector3 vector;
     if (AManager<DesignManager>.getInstance().edgeRoads.Count == 0)
     {
         return;
     }
     int num = UnityEngine.Random.Range(0, 4);
     if (num == 0 && !AManager<DesignManager>.getInstance().edgeRoadSouth)
     {
         return;
     }
     if (num == 1 && !AManager<DesignManager>.getInstance().edgeRoadNorth)
     {
         return;
     }
     if (num == 2 && !AManager<DesignManager>.getInstance().edgeRoadEast)
     {
         return;
     }
     if (num == 3 && !AManager<DesignManager>.getInstance().edgeRoadWest)
     {
         return;
     }
     vector = AManager<DesignManager>.getInstance().edgeRoads[UnityEngine.Random.Range(0, AManager<DesignManager>.getInstance().edgeRoads.Count - 1)].world + Vector3.up * AManager<ChunkManager>.getInstance().voxelSize;
     //UnitManager.getInstance().AddHumanUnit();
     Debug.Log(vector);
     HumanEntity humanEntity = AManager<AssetManager>.getInstance().InstantiateUnit<HumanEntity>();
     int gender = UnityEngine.Random.Range(0, 100);
     humanEntity.gender = gender <= 50 ? APlayableEntity.Gender.Female: APlayableEntity.Gender.Male;
     humanEntity.unitName = "Messenger";
     humanEntity.fatigue = 1f;
     humanEntity.hunger = 0f;
     humanEntity.maxHP = 100f;
     humanEntity.hitpoints = 100f;
     humanEntity.coordinate = Coordinate.FromWorld(vector);
     humanEntity.faction = AManager<WorldManager>.getInstance().MigrantFaction;
     humanEntity.spottedTimer = 600000f;
     humanEntity.addProfession(new Messenger(humanEntity, 0));
     humanEntity.SetProfession(typeof(Messenger));
     humanEntity.interruptTask(new TaskMoveToHall(humanEntity));
     UnitManager.getInstance().visitors.Add(humanEntity.transform);
     messengerEntity = humanEntity;
     isAwaitingResults = true;
     day = AManager<TimeManager>.getInstance().day;
     GUIManager.getInstance().AddTextLine("A messenger has arrived." , humanEntity.transform, true);
 }
 void Start()
 {
     this.playerEntity = ((PlayerSync)transform.root.GetComponentInChildren<PlayerSync>()).Entity;
     entityList.Add(this.playerEntity.ID, this.playerEntity);
     PlayerEvent.onPlayerSync += onPlayerSync;
 }
 public void SetEntity(HumanEntity entity)
 {
     this.entity = entity;
 }
 public static void CreateProjectile(HumanEntity humanEntity,string type)
 {
     projectiles.AddLast(new ProjectileEntity(humanEntity.ID, humanEntity.Rotation, type, false));
 }
 // Use this for initialization
 void Start()
 {
     this.humanEntity = ((PlayerSync)transform.root.GetComponentInChildren<PlayerSync>()).Entity;
 }