public void NonEmpty()
{
HashDigest <SHA256> blockHash = new Random().NextHashDigest <SHA256>();
// Note that here Unicode strings are used on purpose:
IImmutableDictionary <string, IValue> states = ImmutableDictionary <string, IValue> .Empty
.Add("foo甲", null)
.Add("bar乙", default(Null))
.Add("baz丙", new Text("a value 값"));
var blockStates = new BlockStates(blockHash, states);
var signer = new PrivateKey();
NetMQMessage msg = blockStates.ToNetMQMessage(
signer,
new Peer(signer.PublicKey, default),
new AppProtocolVersion(
1,
new Bencodex.Types.Integer(0),
ImmutableArray <byte> .Empty,
default(Address)));
Assert.Equal(Message.CommonFrames + 2 + 3 * 3, msg.FrameCount);
TestUtils.AssertBytesEqual(
blockHash,
new HashDigest <SHA256>(msg[Message.CommonFrames].Buffer));
Assert.Equal(
states.Count,
msg[Message.CommonFrames + 1].ConvertToInt32());
var parsed = new BlockStates(msg.Skip(Message.CommonFrames).ToArray());
TestUtils.AssertBytesEqual(blockHash, parsed.BlockHash);
Assert.Equal(states, parsed.States);
}
public Taiga2Generator(int treeHeight, bool vines, PlantsType treeType)
{
_minTreeHeight = treeHeight;
_vines = vines;
_wood = BlockStates.Wood(WoodType.Spruce);
_leaves = BlockStates.Leaves(LeaveType.Spruce);
}
protected async Task GenerateOre(IWorld world, ChunkWorldPos chunkWorldPos, GeneratorSettings settings)
{
var oreGenerator = GrainFactory.GetGrain <IMinableGenerator>(0);
await oreGenerator.Generate(world, chunkWorldPos, BlockStates.Dirt(), settings.DirtCount, settings.DirtSize, settings.DirtMinHeight, settings.DirtMaxHeight);
await oreGenerator.Generate(world, chunkWorldPos, BlockStates.Gravel(), settings.GravelCount, settings.GravelSize, settings.GravelMinHeight, settings.GravelMaxHeight);
await oreGenerator.Generate(world, chunkWorldPos, BlockStates.Granite(), settings.GraniteCount, settings.GraniteSize, settings.GraniteMinHeight, settings.GraniteMaxHeight);
await oreGenerator.Generate(world, chunkWorldPos, BlockStates.Diorite(), settings.DioriteCount, settings.DioriteSize, settings.DioriteMinHeight, settings.DioriteMaxHeight);
await oreGenerator.Generate(world, chunkWorldPos, BlockStates.Andesite(), settings.AndesiteCount, settings.AndesiteSize, settings.AndesiteMinHeight, settings.AndesiteMaxHeight);
await oreGenerator.Generate(world, chunkWorldPos, BlockStates.CoalOre(), settings.CoalCount, settings.CoalSize, settings.CoalMinHeight, settings.CoalMaxHeight);
await oreGenerator.Generate(world, chunkWorldPos, BlockStates.IronOre(), settings.IronCount, settings.IronSize, settings.IronMinHeight, settings.IronMaxHeight);
await oreGenerator.Generate(world, chunkWorldPos, BlockStates.GoldOre(), settings.GoldCount, settings.GoldSize, settings.GoldMinHeight, settings.GoldMaxHeight);
await oreGenerator.Generate(world, chunkWorldPos, BlockStates.DiamondOre(), settings.DiamondCount, settings.DiamondSize, settings.DiamondMinHeight, settings.DiamondMaxHeight);
await oreGenerator.Generate(world, chunkWorldPos, BlockStates.RedstoneOre(), settings.RedstoneCount, settings.RedstoneSize, settings.RedstoneMinHeight, settings.RedstoneMaxHeight);
await oreGenerator.Generate(world, chunkWorldPos, BlockStates.LapisLazuliOre(), settings.LapisCount, settings.LapisSize, settings.LapisCenterHeight - settings.LapisSpread, settings.LapisCenterHeight + settings.LapisSpread);
}
public void Null()
{
HashDigest <SHA256> blockHash = new Random().NextHashDigest <SHA256>();
var blockStates = new BlockStates(blockHash, null);
var signer = new PrivateKey();
NetMQMessage msg = blockStates.ToNetMQMessage(
signer,
new Peer(signer.PublicKey, default),
new AppProtocolVersion(
1,
new Bencodex.Types.Integer(0),
ImmutableArray <byte> .Empty,
default(Address)));
Assert.Equal(Message.CommonFrames + 2, msg.FrameCount);
TestUtils.AssertBytesEqual(
blockHash,
new HashDigest <SHA256>(msg[Message.CommonFrames].Buffer));
Assert.Equal(-1, msg[Message.CommonFrames + 1].ConvertToInt32());
var parsed = new BlockStates(msg.Skip(Message.CommonFrames).ToArray());
TestUtils.AssertBytesEqual(blockHash, parsed.BlockHash);
Assert.Null(parsed.States);
}
public override Task OnActivateAsync()
{
if (this.GetPrimaryKeyLong() == (long)BiomeId.Savanna)
{
BiomeProperties.BaseHeight = 0.125f;
BiomeProperties.HeightVariation = 0.05f;
BiomeProperties.Temperature = 1.2f;
BiomeProperties.Rainfall = 0.0f;
BiomeProperties.EnableSnow = false;
BiomeProperties.WaterColor = 16777215;
BiomeProperties.EnableRain = false;
}
TopBlock = BlockStates.GrassBlock();
FillerBlock = BlockStates.Dirt();
PlantsList.Add(PlantsType.TallGrass);
PlantsList.Add(PlantsType.AcaciaTree);
PassiveMobList.Add(MobType.Cow);
PassiveMobList.Add(MobType.Sheep);
PassiveMobList.Add(MobType.Horse);
MonsterList.Add(MobType.Creeper);
MonsterList.Add(MobType.Skeleton);
MonsterList.Add(MobType.Zombie);
MonsterList.Add(MobType.Spider);
return(Task.CompletedTask);
}
public async override Task OnActivateAsync()
{
await base.OnActivateAsync();
_wood = BlockStates.Wood(WoodType.Jungle);
_leaves = BlockStates.Leaves(LeaveType.Jungle);
}
public async override Task OnActivateAsync()
{
await base.OnActivateAsync();
_wood = BlockStates.Wood2(Wood2Type.Acacia);
_leaves = BlockStates.Leaves2(Leave2Type.Acacia);
}
protected void DigBlock(ChunkColumnStorage chunk, Biome biome, int x, int y, int z, int chunkX, int chunkZ, bool foundTop, BlockState state, BlockState up)
{
BlockState top = biome._topBlock;
BlockState filler = biome._fillerBlock;
if (CanReplaceBlock(state, up) ||
state == top ||
state == filler)
{
// y<10放置岩浆
if (y < 10)
{
// 设置为岩浆
chunk[x, y, z] = BlockStates.Lava();
}
else
{
// 设置为空气
chunk[x, y, z] = BlockStates.Air();
if (up.Id == (uint)BlockId.Sand)
{
// 如果上面的方块是沙子则替换为沙石
chunk[x, y + 1, z] = BlockStates.Sandstone();
}
if (foundTop && chunk[x, y - 1, z] == filler)
{
// 如果挖开了顶层方块则把下面的方块设置为biome顶层方块
chunk[x, y - 1, z] = top;
}
}
}
}
public async Task TestFurnaceRecipeMatcher()
{
var loader = new FurnaceRecipeLoader();
using (var sr = new StreamReader(File.OpenRead(Path.Combine(RootDir, "furnace.txt"))))
{
await loader.LoadRecipes(sr);
}
var matcher = new FurnaceRecipeMatcher(loader.Recipes, loader.Fuels);
var recipe = matcher.FindRecipe(
new Slot {
BlockId = (short)BlockStates.Wood().Id, ItemCount = 1
});
var fuel = matcher.FindFuel(
new Slot {
BlockId = (short)BlockStates.Wood().Id, ItemCount = 1
});
Assert.NotNull(recipe);
Assert.Equal(ItemStates.Coal(CoalType.Charcoal), new ItemState {
Id = (uint)recipe.Output.BlockId, MetaValue = (uint)recipe.Output.ItemDamage
});
Assert.Equal((short)BlockStates.Wood().Id, fuel.Slot.BlockId);
}
public async override Task OnActivateAsync()
{
await base.OnActivateAsync();
_wood = BlockStates.JungleLog();
_leaves = BlockStates.JungleLeaves(JungleLeavesDistanceType.Distance1, JungleLeavesPersistentType.False);
}
public TaigaGenerator(int treeHeight, bool vines, PlantsType treeType)
{
_minTreeHeight = treeHeight;
_vines = vines;
_wood = BlockStates.SpruceLog();
_leaves = BlockStates.SpruceLeaves(SpruceLeavesDistanceType.Distance1, SpruceLeavesPersistentType.False);
}
public async Task <bool> FinishedDigging(IEntity entity, IGrainFactory grainFactory, IWorld world, BlockWorldPos position, BlockState blockState, long usedTick, GameMode gameMode)
{
if (!blockState.IsSameId(BlockStates.Bedrock()))
{
var newState = BlockStates.Air();
await world.SetBlockState(grainFactory, position, newState);
// 产生 Pickup
if (gameMode.ModeClass != GameMode.Class.Creative)
{
var chunk = position.ToChunkWorldPos();
var finder = grainFactory.GetGrain <ICollectableFinder>(world.MakeAddressByPartitionKey(chunk));
var blockHandler = BlockHandler.Create((BlockId)blockState.Id);
var droppedSlot = blockHandler.DropBlock(ItemId, blockState);
if (!droppedSlot.IsEmpty)
{
await finder.SpawnPickup(position + new Vector3(0.5f, 0.5f, 0.5f), new[] { droppedSlot }.AsImmutable());
}
}
return(true);
}
return(false);
}
public static bool IsMobCollided(this BlockState state)
{
return(!state.IsSameId(BlockStates.Air()) &&
!state.IsSameId(BlockStates.Grass()) &&
!state.IsSameId(BlockStates.LargeFlowers()) &&
!state.IsSameId(BlockStates.Poppy()) &&
!state.IsSameId(BlockStates.Dandelion()));
}
public Biome(BiomeProperties properties, GeneratorSettings genSettings)
{
_genSettings = genSettings;
_name = properties.BiomeName;
_biomeId = properties.BiomeId;
_baseHeight = properties.BaseHeight;
_heightVariation = properties.HeightVariation;
_temperature = properties.Temperature;
_rainfall = properties.Rainfall;
_waterColor = properties.WaterColor;
_enableSnow = properties.EnableSnow;
_enableRain = properties.EnableRain;
_dirtGen = new MinableGenerator(
BlockStates.Dirt(),
genSettings.DirtSize);
_gravelOreGen = new MinableGenerator(
BlockStates.Gravel(),
genSettings.GravelSize);
_graniteGen = new MinableGenerator(
BlockStates.Stone(StoneType.Granite),
genSettings.GraniteSize);
_dioriteGen = new MinableGenerator(
BlockStates.Stone(StoneType.Diorite),
genSettings.DioriteSize);
_andesiteGen = new MinableGenerator(
BlockStates.Stone(StoneType.Andesite),
genSettings.AndesiteSize);
_coalGen = new MinableGenerator(
BlockStates.CoalOre(),
genSettings.CoalSize);
_ironGen = new MinableGenerator(
BlockStates.IronOre(),
genSettings.IronSize);
_goldGen = new MinableGenerator(
BlockStates.GoldOre(),
genSettings.GoldSize);
_redstoneGen = new MinableGenerator(
BlockStates.RedstoneOre(),
genSettings.RedstoneSize);
_diamondGen = new MinableGenerator(
BlockStates.DiamondOre(),
genSettings.DiamondSize);
_lapisGen = new MinableGenerator(
BlockStates.LapisLazuliOre(),
genSettings.LapisSize);
_treesPerChunk = 0; // mc 0
_extraTreeChance = 0.05F; // mc 0.05F
_grassPerChunk = 10;
_flowersPerChunk = 4;
_mushroomsPerChunk = 0;
_deadBushPerChunk = 2;
_reedsPerChunk = 50;
_cactiPerChunk = 10;
}
public static bool CanMobStand(this BlockState state)
{
return(!state.IsSameId(BlockStates.Air()) &&
!state.IsSameId(BlockStates.Grass()) &&
!state.IsSameId(BlockStates.Water()) &&
!state.IsSameId(BlockStates.LargeFlowers()) &&
!state.IsSameId(BlockStates.Poppy()) &&
!state.IsSameId(BlockStates.Dandelion()));
}
private async Task PlaceVine(IWorld world, Random random, BlockWorldPos pos, VineType vineType)
{
var block = await world.GetBlockStateUnsafe(this.GrainFactory, pos);
if (random.Next(3) > 0 && block.IsAir())
{
await world.SetBlockStateUnsafe(this.GrainFactory, pos, BlockStates.Vine(vineType.East, vineType.North, vineType.South, vineType.Up, vineType.West));
}
}
public Taiga2Generator(int treeHeight, bool vines, PlantsType treeType)
{
_minTreeHeight = treeHeight;
_vines = vines;
_wood = BlockStates.SpruceLog();
// TODO distance should use the distance to the nearest log
_leaves = BlockStates.SpruceLeaves(SpruceLeavesDistanceType.Distance1, SpruceLeavesPersistentType.False);
}
private async Task PlaceAt(IWorld world, BlockWorldPos pos, PlantsType type)
{
if (type == PlantsType.DoubleTallgrass)
{
await world.SetBlockStateUnsafe(this.GrainFactory, pos, BlockStates.Grass(GrassType.TallGrass));
await world.SetBlockStateUnsafe(this.GrainFactory, pos.Up(), BlockStates.Grass(GrassType.TallGrass));
}
}
protected async Task SetIfStone(IWorld world, ChunkWorldPos chunkWorldPos, BlockWorldPos pos, BlockState state)
{
if (pos.Y >= 0 &&
pos.Y < 255 &&
(await GetBlock(world, chunkWorldPos, pos)) == BlockStates.Stone())
{
// replace as ore
await SetBlock(world, chunkWorldPos, pos, state);
}
}
public static bool CanSustainCacti(BlockState state)
{
if (state == BlockStates.Sand())
{
return(true);
}
else
{
return(false);
}
}
public Sprite GetSprite(BlockStates state)
{
switch (state)
{
default:
return(null);
case BlockStates.Normal:
return(m_Normal);
case BlockStates.LeftTopMissing:
return(m_LeftTopMissing);
case BlockStates.RightTopMissing:
return(m_RightTopMissing);
case BlockStates.LeftBottomMissing:
return(m_LeftBottomMissing);
case BlockStates.RightBottomMissing:
return(m_RightBottomMissing);
case BlockStates.OnlyBottom:
return(m_OnlyBottom);
case BlockStates.OnlyTop:
return(m_OnlyTop);
case BlockStates.OnlyLeft:
return(m_OnlyLeft);
case BlockStates.OnlyRight:
return(m_OnlyRight);
case BlockStates.DiagonalLeftBottomRightTop:
return(m_DiagonalLeftBottomRightTop);
case BlockStates.DiagonalRightBottomLeftTop:
return(m_DiagonalRightBottomLeftTop);
case BlockStates.OnlyLeftTop:
return(m_OnlyLeftTop);
case BlockStates.OnlyRightTop:
return(m_OnlyRightTop);
case BlockStates.OnlyLeftBottom:
return(m_OnlyLeftBottom);
case BlockStates.OnlyRightBottom:
return(m_OnlyRightBottom);
}
}
public bool CanFlowerGrow(PlantsType type, ChunkColumnStorage chunk, BlockChunkPos pos)
{
if (chunk[pos.X, pos.Y - 1, pos.Z] == BlockStates.GrassBlock() ||
chunk[pos.X, pos.Y - 1, pos.Z] == BlockStates.Dirt())
{
return(true);
}
else
{
return(false);
}
}
/******************** State Modifiers & Behaviors ********************/
// Block is in this state if it is falling
// Entered from: Block creation or surrounding block destruction
// Exits to: Still()
void Falling()
{
// check if the block has come to a rest
if (rigid.velocity.magnitude <= SLEEPING_THRESHOLD)
{
state = BlockStates.STILL;
return;
}
// block is still falling, any logic that needs to be performed can be put here.
// At the moment, I can't think of anything the block needs to do when it is falling though
}
public static bool IsSoil(BlockState state)
{
if (state == BlockStates.Dirt() ||
state == BlockStates.GrassBlock())
{
return(true);
}
else
{
return(false);
}
}
// When a block is not moving, or not just previously moving
// Entered from: Falling()
// Exits to: Falling(), OnDestroy() (indirectly)
void Still()
{
// the block is moving again, so transition to the falling state
if (rigid.velocity.magnitude > SLEEPING_THRESHOLD)
{
if (tag != "Rockets" || tag == "Core")
{
state = BlockStates.FALLING;
}
return;
}
}
public void IsSameIdTest()
{
BlockState state1 = BlockStates.Dirt();
BlockState state2 = BlockStates.Dirt();
BlockState state3 = BlockStates.Wood(WoodType.Birch);
BlockState state4 = BlockStates.Wood(WoodType.Oak);
Assert.True(state1 == state2);
Assert.False(state1 == state3);
Assert.False(state3.IsSameId(state2));
Assert.True(state3.IsSameId(state4));
}
public void IsSameIdTest()
{
BlockState state1 = BlockStates.Dirt();
BlockState state2 = BlockStates.Dirt();
BlockState state3 = BlockStates.BirchLog();
BlockState state4 = BlockStates.OakLog();
Assert.True(state1 == state2);
Assert.False(state1 == state3);
Assert.False(state3.IsSameId(state2));
Assert.False(state3.IsSameId(state4));
}
public static bool CanSustainTree(PlantsType type, BlockState state)
{
if (state == BlockStates.Dirt() ||
state == BlockStates.GrassBlock())
{
return(true);
}
else
{
return(false);
}
}
public async override Task OnActivateAsync()
{
await base.OnActivateAsync();
_minTreeHeight = _generatorSettings.TreeHeight;
_vines = _generatorSettings.TreeVine;
_treeType = _generatorSettings.PlantType;
if (_generatorSettings.PlantType == PlantsType.Spruce)
{
_wood = BlockStates.SpruceLog();
_leaves = BlockStates.SpruceLeaves(SpruceLeavesDistanceType.Distance1, SpruceLeavesPersistentType.False);
}
}
public async override Task OnActivateAsync()
{
await base.OnActivateAsync();
_minTreeHeight = _generatorSettings.TreeHeight;
_vines = _generatorSettings.TreeVine;
_treeType = _generatorSettings.PlantType;
if (_generatorSettings.PlantType == PlantsType.Spruce)
{
_wood = BlockStates.Wood(WoodType.Spruce);
_leaves = BlockStates.Leaves(LeaveType.Spruce);
}
}
