public static FoodType GetFoodType(SeedType s) { switch (s) { case SeedType.APPLE_SEED: return(FoodType.APPLE); case SeedType.CARROT_SEED: return(FoodType.CARROT); case SeedType.WHEAT_SEED: return(FoodType.WHEAT); case SeedType.POTATO_SEED: return(FoodType.POTATO); case SeedType.TOMATO_SEED: return(FoodType.TOMATO); case SeedType.ORANGE_SEED: return(FoodType.ORANGE); case SeedType.CHERRY_SEED: return(FoodType.CHERRY); default: return(0); } }
public void TreePlanting(string tag) { hit = Physics2D.Raycast(Camera.main.ScreenToWorldPoint(Input.mousePosition), Vector2.zero); if (hit.transform != null && hit.transform.tag == tag) { Debug.Log(hit.transform.tag); if (seedType == SeedType.FristSeed) { isStart = true; fristTreeItem.SetActive(false); seedIsGet[0] = true; buttonGO[0].SetActive(true); buttonGO[0].GetComponent <SeedItemBtn>().StartCD(); } else { buttonGO[(int)seedType].GetComponent <SeedItemBtn>().StartCD(); if (IsVariation(ref seedType)) { //变异音效 //变异UI提示 //显示对应Btn,开始CD buttonGO[(int)seedType].SetActive(true); } buttonGO[(int)seedType].GetComponent <SeedItemBtn>().StartCD(); } index.SetActive(false); Instantiate(Resources.Load <GameObject>("Prefabs/" + treePrefabName[(int)seedType]), new Vector3(hit.point.x, hit.point.y, -1), Quaternion.identity); seedType = SeedType.None; } }
public static String GetName(SeedType s) { switch (s) { case SeedType.APPLE_SEED: return("Apple Seed"); case SeedType.CARROT_SEED: return("Carrot Seed"); case SeedType.WHEAT_SEED: return("Wheat Seed"); case SeedType.POTATO_SEED: return("Potato Seed"); case SeedType.TOMATO_SEED: return("Tomato Seed"); case SeedType.ORANGE_SEED: return("Orange Seed"); case SeedType.CHERRY_SEED: return("Cherry Seed"); default: return("A seed"); } }
public static long GetGrowTime(SeedType s) { switch (s) { case SeedType.APPLE_SEED: return(ItemConstants.MEDIUM_GROW_TIME); case SeedType.CARROT_SEED: return(ItemConstants.MEDIUM_GROW_TIME); case SeedType.WHEAT_SEED: return(ItemConstants.SHORT_GROW_TIME); case SeedType.POTATO_SEED: return(ItemConstants.MEDIUM_GROW_TIME); case SeedType.TOMATO_SEED: return(ItemConstants.LONG_GROW_TIME); case SeedType.ORANGE_SEED: return(ItemConstants.MEDIUM_GROW_TIME); case SeedType.CHERRY_SEED: return(ItemConstants.LONG_GROW_TIME); default: return(0); } }
private void HandleMoundAction(Collider overlap) { Mound mound = overlap.GetComponent <Mound>(); if (mound) { if (mound.isReadyToHarvest) { animator.SetTrigger("Action"); SeedType harvested = mound.GetHarvested(); Debug.Log(harvested); Text scoreUI = GameObject.FindWithTag("Score").GetComponentInChildren <Text>(); scoreUI.text = (int.Parse(scoreUI.text) + rewards[harvested]).ToString(); // prevent death seedSelector.ResetHealth(); return; } if (mound.seedType != SeedType.None && mound.growTime > 0) { // seed is busy growing return; } SeedType plantedSeed = seedSelector.PlantSeed(); if (plantedSeed != SeedType.None) { // plant new seed animator.SetTrigger("Action"); mound.AddSeed(plantedSeed); } } }
private void IntiBasicSetting() { FilterSheetText.Text = Global.FilterSheets; StartLoadFoldercheckBox.Checked = Global.StartLoadFolder; LoadDataCheckBox.Checked = Global.LoadData; ResFolderText.Text = Global.ResFolder; IsDataBaseCheckBox.Checked = Global.IsDataBase; IsDisorderCheckBox.Checked = Global.IsDisorder; IsResEncCheckBox.Checked = Global.IsResEnc; SeedType type = Global.DisEncType; switch (type) { case SeedType.Version: SelectSeedType(VersionCheckBox); break; case SeedType.CRC32: SelectSeedType(CRC32CheckBox); break; case SeedType.MD5: SelectSeedType(MD5CheckBox); break; case SeedType.SHA1: SelectSeedType(SHA1CheckBox); break; default: break; } }
public void PlayerPlant(Player pg, FieldBlock block) { SeedType st = pg.GetInventory().getCurrentSeed().Get().GetX(); block.Plant(st); pg.GetInventory().RemoveSeed(st); }
public Seed(string song, string artist, string id) { seedType = SeedType.Song; songName = song; artistName = artist; SeedID = id; }
//----------------------------------------------------------------------------- // Constructors //----------------------------------------------------------------------------- public Seed(SeedType type) { this.type = type; // Flags for seed's dropped from satchel EnablePhysics( PhysicsFlags.HasGravity | PhysicsFlags.DestroyedOutsideRoom | PhysicsFlags.DestroyedInHoles); /* // Flags for seed Projectiles EnablePhysics( PhysicsFlags.DestroyedOutsideRoom | PhysicsFlags.CollideWorld | PhysicsFlags.ReboundSolid | PhysicsFlags.HalfSolidPassable | PhysicsFlags.LedgePassable); */ Physics.CollisionBox = new Rectangle2F(-1, -1, 2, 2); Physics.SoftCollisionBox = new Rectangle2F(-1, -1, 2, 2); graphics.DrawOffset = new Point2I(-4, -6); centerOffset = new Point2I(0, -2); }
private string DirectoryForSeedType(SeedType seedType) { var seedDirectory = string.Empty; switch (seedType) { case SeedType.LANGUAGE: seedDirectory = "Language"; break; case SeedType.SETTING: seedDirectory = "Setting"; break; default: break; } if (!string.IsNullOrWhiteSpace(seedDirectory)) { return($"{_env.ContentRootPath}/Data/Seeds/{seedDirectory}/"); } return(string.Empty); }
public void FillDummy(int playerCount, int seedCount, SeedType type, int aParam) { List <CompetitionPlayerInfo> players = new List <CompetitionPlayerInfo>(); Random rnd = new Random(); for (int i = 0; i < playerCount; i++) { CompetitionPlayerInfo player = new CompetitionPlayerInfo(); player.Id = i + 1; player.NickName = "Player " + (i + 1).ToString("d2"); player.RatingBeforeCompetition = 1500 + rnd.Next(-100, 100); players.Add(player); } SetPlayersList(players.ToArray()); int[] seed = new int[seedCount]; for (int i = 0; i < seed.Length; i++) { if (i % 2 == 0) { seed[i] = i / 2 + 1; } else { seed[i] = (seed.Length + 1 + i) / 2; } } SetSeedingOrder(seed, type, aParam); }
private void CheckEnvironment() { if (_env == null) { return; } switch (_env.EnvironmentName) { case "Development": SeedType = SeedType.Dev; break; case "PreProduction": SeedType = SeedType.PreProd; break; case "Production": SeedType = SeedType.Prod; break; default: SeedType = SeedType.Dev; break; } }
// Token: 0x06001AB8 RID: 6840 RVA: 0x000724B0 File Offset: 0x000706B0 internal SeederServerContext(NetworkChannel channel, MonitoredDatabase database, Guid?targetServerGuid, SeedType seedType) { this.m_channel = channel; this.m_databaseGuid = database.DatabaseGuid; this.DatabaseName = database.DatabaseName; this.SeedType = seedType; this.m_targetServerGuid = targetServerGuid; if (database.Config.IsPassiveCopy) { this.m_fPassiveSeeding = true; switch (seedType) { case SeedType.Database: this.m_passiveSeedingSourceContext = PassiveSeedingSourceContextEnum.Database; break; case SeedType.Catalog: this.m_passiveSeedingSourceContext = PassiveSeedingSourceContextEnum.Catalogue; break; } } else { this.m_passiveSeedingSourceContext = PassiveSeedingSourceContextEnum.None; } if (!TestSupport.IsCatalogSeedDisabled()) { string indexSystemName = FastIndexVersion.GetIndexSystemName(this.m_databaseGuid); this.indexSeederSource = new IndexSeeder(indexSystemName); } }
public void AddSeed(SeedType type) { if (type != SeedType.None && seedType == SeedType.None) { seedType = type; if (type == SeedType.MuscleMelon) { endGrowTime = MuscleMelonGrowTime; currentSeedAnimation = "MuscleMelon_Plant"; } else if (type == SeedType.SkinBean) { endGrowTime = SkinBeanGrowTime; currentSeedAnimation = "SkinBean_Plant"; } else if (type == SeedType.LiverBerry) { endGrowTime = LiverBerryGrowTime; currentSeedAnimation = "LiverBerry_Plant"; } else if (type == SeedType.Brainapple) { endGrowTime = BrainappleGrowTime; currentSeedAnimation = "Brainapple_Plant"; } } }
public static double GetPrice(SeedType s) { switch (s) { case SeedType.APPLE_SEED: return(300); case SeedType.CARROT_SEED: return(30); case SeedType.WHEAT_SEED: return(10); case SeedType.POTATO_SEED: return(50); case SeedType.TOMATO_SEED: return(100); case SeedType.ORANGE_SEED: return(500); case SeedType.CHERRY_SEED: return(1000); default: return(0); } }
//----------------------------------------------------------------------------- // Overridden methods //----------------------------------------------------------------------------- public override void OnSeedHit(SeedType seedType, SeedEntity seed) { if (seedType == SeedType.Ember && !Properties.GetBoolean("lit", false)) { Light(); seed.Destroy(); } }
//----------------------------------------------------------------------------- // Overridden methods //----------------------------------------------------------------------------- public override void OnSeedHit(SeedType seedType, SeedEntity seed) { if (seedType == SeedType.Mystery && !isActivated) { isActivated = true; sparkleIndex = 0; timer = 0; } }
public void RemoveSeed(SeedType type) { seeds[type]--; if (seeds[type] == -1) { throw new System.InvalidOperationException(); } }
public SeedImpl(SeedType st) { this.st = st; this.ss = SeedState.PLANTED; this.growTime = SeedTypeMethods.GetGrowTime(st); this.ofWhichFood = SeedTypeMethods.GetFoodType(st); WaitGrow(); }
//----------------------------------------------------------------------------- // Internal methods //----------------------------------------------------------------------------- private Seed DropSeed(SeedType type) { Seed seed = ThrowSeed(type); seed.Position = Player.Center; seed.Physics.Velocity = Vector2F.Zero; seed.Physics.ZVelocity = 0.0f; return(seed); }
public override int GetHashCode() { var hashCode = -514544316; hashCode = hashCode * -1521134295 + SeedType.GetHashCode(); hashCode = hashCode * -1521134295 + Seed.GetHashCode(); hashCode = hashCode * -1521134295 + EqualityComparer<Dictionary<SettingType, SettingValue>>.Default.GetHashCode(Settings); hashCode = hashCode * -1521134295 + EqualityComparer<List<RandoItemRO>>.Default.GetHashCode(CollectedItems); return hashCode; }
public SeedType GetHarvested() { SeedType returnType = seedType; seedType = SeedType.None; growTime = 0; isReadyToHarvest = false; animator.Play(currentSeedAnimation, 0, 0); return(returnType); }
private void MoveTop(SeedType type) { foreach (SeedType seedType in activeSeed.ToArray()) { if (!seedType.Equals(type)) { MoveBottom(seedType); } } }
public Boolean PlayerBuy(Player pg, SeedType st, int quantity) { if (pg.GetMoney() >= SeedTypeMethods.GetPrice(st) * quantity) { pg.GetInventory().AddSeeds(st, quantity); pg.DecreaseMoney(SeedTypeMethods.GetPrice(st) * quantity); return(true); } return(false); }
public async void FindPath(string input, SeedType inputType, BIP0039.WordLists wl, string pass, string extra, InputType extraType) { report.Init(); BIP0032 bip32 = null; if (inputType == SeedType.BIP39) { try { bip32 = new BIP0039(input, wl, pass); } catch (Exception ex) { report.Fail($"Could not instantiate BIP-39 instance. Error: {ex.Message}"); return; } } else if (inputType == SeedType.Electrum) { try { bip32 = new ElectrumMnemonic(input, wl, pass); } catch (Exception ex) { report.Fail($"Could not instantiate ElectrumMnemonic instance. Error: {ex.Message}"); return; } } else if (inputType == SeedType.XPRV || inputType == SeedType.XPUB) { try { bip32 = new BIP0032(input); return; } catch (Exception ex) { report.Fail($"Could not instantiate BIP-32 instance. Error: {ex.Message}"); } } else { report.Fail("Undefined input type."); return; } Debug.Assert(bip32 is not null); // TODO: Derive child keys at different known paths to see which one matches the extra input report.Finalize(); }
public PlantSource(Flower parent, SeedType type) { if (!parent.Plant.SeedTypes.Contains(type)) { throw new ArgumentOutOfRangeException("type", "Растение не размножется таким способом."); } _parent = parent; _plant = parent.Plant; _type = type; }
public GameObject GetSeed(SeedType _ST) { GameObject seedObject = new GameObject(); seedObject.transform.position = seedPos; SpriteRenderer newSprite = seedObject.AddComponent <SpriteRenderer>(); newSprite.sprite = _ST.sprites[ec.terrainID]; seedObject.name = _ST.name; return(seedObject); }
public async Task <SeedType> Get(int id) { SeedType temp = _seedTypes.Where(x => x.Id == id).FirstOrDefault(); await Task.Run(() => { //Retrieve the SeedType by id from the database or api async }); return(temp); }
public IPropertyValueInterceptor GetInterceptor(SeedType type) { if (!_catalog.ContainsKey(type)) { return(null); } else { return(_catalog[type]); } }
public void AddInterceptor(SeedType t, IPropertyValueInterceptor interceptor) { if (!_catalog.ContainsKey(t)) { _catalog.Add(t, interceptor); } else { _catalog[t] = interceptor; } }
private void MoveBottom(SeedType type) { foreach (SeedType s in activeSeed.ToArray()) { if (s.Equals(type)) { activeSeed.Remove(s); activeSeed.Add(s); } } }
//----------------------------------------------------------------------------- // Constructors //----------------------------------------------------------------------------- public Seed(SeedType type) : base(type) { // Physics. Physics.CollisionBox = new Rectangle2F(-1, -1, 2, 2); Physics.SoftCollisionBox = new Rectangle2F(-1, -1, 2, 2); EnablePhysics( PhysicsFlags.HasGravity | PhysicsFlags.DestroyedOutsideRoom | PhysicsFlags.DestroyedInHoles); // Graphics. Graphics.DepthLayer = DepthLayer.InAirSeed; Graphics.DrawOffset = new Point2I(-4, -6); centerOffset = new Point2I(0, -2); }
// Update is called once per frame void Update () { // Plant if (GameManager.Instance.state == GameManager.GameState.Playing) { if (Input.GetButtonDown ("P1_A")) { switch (currentSeed) { case SeedType.Red: case SeedType.Yellow: case SeedType.White: if (currentTile.GetComponent<PlantTile> ().GetIsInUse () == false) { if(seeds[(int)currentSeed] > 0) { currentTile.GetComponent<PlantTile>().SetIsInUse(true); currentTile.GetComponent<PlantTile>().PlantFlower(currentSeed); seeds[(int)currentSeed]--; StartCoroutine (Plant(0.25f)); RenderSeeds(); } } break; case SeedType.Water: if (currentTile.GetComponent<PlantTile> ().GetIsInUse () == true) { StartCoroutine (Water(0.4f)); } break; } } //Weapon Toggle if (Input.GetButtonDown ("P1_R1")) { int nextSeed = ((int)currentSeed + 1); currentSeed = nextSeed >= seeds.Count ? 0 : (SeedType)nextSeed; RenderSeeds (); } else if (Input.GetButtonDown ("P1_L1")) { int nextSeed = ((int)currentSeed - 1); currentSeed = nextSeed < 0 ? (SeedType)(seeds.Count-1) : (SeedType)nextSeed; RenderSeeds (); } } }
//----------------------------------------------------------------------------- // Constructors //----------------------------------------------------------------------------- public SeedProjectile(SeedType type, bool reboundOffWalls) : base(type) { // Physics. Physics.CollisionBox = new Rectangle2F(-1, -5, 2, 1); Physics.SoftCollisionBox = new Rectangle2F(-1, -5, 2, 1); EnablePhysics( PhysicsFlags.DestroyedOutsideRoom | PhysicsFlags.CollideWorld | PhysicsFlags.HalfSolidPassable | PhysicsFlags.LedgePassable); this.reboundOffWalls = reboundOffWalls; if (reboundOffWalls) Physics.Flags |= PhysicsFlags.ReboundSolid; // Graphics. Graphics.DepthLayer = DepthLayer.InAirSeed; Graphics.DrawOffset = new Point2I(-4, -6); centerOffset = new Point2I(0, -2); }
//Return the default grow count, plus a small variation public static int getGrowCount(SeedType seedType) { if(seedType == SeedType.NULL) { return GRASS_GROW_COUNT + RandomNumber.RandomInteger((GRASS_GROW_COUNT / 10)); } else { switch(seedType) { case SeedType.CORN: return CORN_GROW_COUNT + RandomNumber.RandomInteger((CORN_GROW_COUNT / 20)); case SeedType.PUMPKIN: return PUMPKIN_GROW_COUNT + RandomNumber.RandomInteger((PUMPKIN_GROW_COUNT / 4)); default: return 1; } } }
//----------------------------------------------------------------------------- // Constructor //----------------------------------------------------------------------------- public SeedEntity(SeedType type) { this.type = type; }
public static InteractionType GetSeedInteractionType(SeedType seedType) { return (InteractionType) ((int) InteractionType.EmberSeed + (int) seedType); }
private Entity CreateEffect(SeedType seedType, bool satchelEffect, Vector2F effectPosition) { Entity effectEntity = null; // Create the seed's effect. if (seedType == SeedType.Ember) { effectEntity = new Fire(); AudioSystem.PlaySound(GameData.SOUND_FIRE); } else if (seedType == SeedType.Scent) { if (satchelEffect) { effectEntity = new ScentPod(); AudioSystem.PlaySound(GameData.SOUND_SCENT_SEED_POD); } else { effectEntity = new Effect(GameData.ANIM_EFFECT_SEED_SCENT, DepthLayer.EffectSeed); AudioSystem.PlaySound(GameData.SOUND_SCENT_SEED); } } else if (seedType == SeedType.Mystery) { effectEntity = new Effect(GameData.ANIM_EFFECT_SEED_MYSTERY, DepthLayer.EffectSeed); AudioSystem.PlaySound(GameData.SOUND_MYSTERY_SEED); } else if (seedType == SeedType.Pegasus) { effectEntity = new Effect(GameData.ANIM_EFFECT_SEED_PEGASUS, DepthLayer.EffectSeed); AudioSystem.PlaySound(GameData.SOUND_FIRE); } else if (seedType == SeedType.Gale) { effectEntity = new EffectGale(satchelEffect); AudioSystem.PlaySound(GameData.SOUND_GALE_SEED); } RoomControl.SpawnEntity(effectEntity, effectPosition); return effectEntity; }
//----------------------------------------------------------------------------- // Internal methods //----------------------------------------------------------------------------- private Seed DropSeed(SeedType type) { Seed seed = ThrowSeed(type); seed.Position = Player.Center; seed.Physics.Velocity = Vector2F.Zero; seed.Physics.ZVelocity = 0.0f; return seed; }
//Return the name of a seedType's vine or stalk public static String getStemType(SeedType seedType) { switch(seedType) { case SeedType.CORN: return "stalks"; case SeedType.PUMPKIN: return "vines"; default: return "stems"; } }
//Does this crop spread? public static bool spreadingCrop(SeedType seedType) { switch(seedType) { case SeedType.CORN: return false; case SeedType.PUMPKIN: return true; default: return false; } }
private Seed ThrowSeed(SeedType type) { Seed seed = new Seed(type); Vector2F velocity = Directions.ToVector(Player.Direction); Vector2F pos = Player.Origin + (velocity * 4.0f); Player.RoomControl.SpawnEntity(seed, pos, Player.ZPosition + 6); seed.Physics.Velocity = velocity * 0.75f; Player.Graphics.PlayAnimation(GameData.ANIM_PLAYER_THROW); Player.BeginBusyState(10); return seed; }
//----------------------------------------------------------------------------- // Interaction Methods //----------------------------------------------------------------------------- // Called when a seed of the given type hits this tile. public virtual void OnSeedHit(SeedType type, SeedEntity seed) { }