protected override DrawOp GetDrawOp(DrawArgs dArgs)
{
string[] args = dArgs.Message.SplitSpaces(3);
Tree tree = Tree.Find(args[0]);
if (tree == null)
{
tree = new NormalTree();
}
int size;
if (args.Length > 1 && int.TryParse(args[1], out size))
{
Player p = dArgs.Player;
string opt = args[0] + " tree size";
if (!CommandParser.GetInt(p, args[1], opt, ref size, tree.MinSize, tree.MaxSize))
{
return(null);
}
}
else
{
size = -1;
}
TreeDrawOp op = new TreeDrawOp();
op.Tree = tree; op.Size = size;
return(op);
}
public override void Use(Player p, string message)
{
string[] parts = message.SplitSpaces(3);
DrawArgs dArgs = new DrawArgs();
dArgs.size = -1;
Tree tree = Tree.Find(parts[0]);
if (tree == null)
{
dArgs.brushMsg = message;
tree = new NormalTree();
}
dArgs.tree = tree;
int size;
if (parts.Length > 1 && int.TryParse(parts[1], out size))
{
if (size < tree.MinSize)
{
Player.Message(p, "Value must be {0} or above for {1} trees.", tree.MinSize, parts[0]); return;
}
if (size > tree.MaxSize)
{
Player.Message(p, "Value must be {0} or below for {1} trees.", tree.MaxSize, parts[0]); return;
}
dArgs.size = size;
dArgs.brushMsg = parts.Length >= 3 ? parts[2] : ""; // type value brush
}
else
{
dArgs.brushMsg = parts.Length >= 2 ? parts[1] : ""; // type brush
}
if (!CheckBrush(p, dArgs.brushMsg))
{
return;
}
Player.Message(p, "Select where you wish your tree to grow");
p.MakeSelection(1, "Selecting location for %STree", dArgs, DoTree);
}
public static void DoShrub(Level lvl, ref Check C)
{
Random rand = lvl.physRandom;
ushort x, y, z;
lvl.IntToPos(C.b, out x, out y, out z);
if (lvl.physics > 1) //Adv physics kills flowers and mushroos in water/lava
{
ActivateablePhysics.CheckNeighbours(lvl, x, y, z);
}
if (!lvl.Config.GrowTrees)
{
C.data.Data = PhysicsArgs.RemoveFromChecks; return;
}
if (C.data.Data < 20)
{
if (rand.Next(20) == 0)
{
C.data.Data++;
}
return;
}
lvl.SetTile(x, y, z, Block.Air);
Tree tree = Tree.Find(lvl.Config.TreeType);
if (tree == null)
{
tree = new NormalTree();
}
tree.SetData(rand, tree.DefaultSize(rand));
tree.Generate(x, y, z, (xT, yT, zT, bT) =>
{
if (!lvl.IsAirAt(xT, yT, zT))
{
return;
}
lvl.Blockchange(xT, yT, zT, (ExtBlock)bT);
});
C.data.Data = PhysicsArgs.RemoveFromChecks;
}
public static void DoShrub(Level lvl, ref Check C)
{
Random rand = lvl.physRandom;
ushort x, y, z;
lvl.IntToPos(C.b, out x, out y, out z);
if (lvl.physics > 1) //Adv physics kills flowers and mushroos in water/lava
{
AirPhysics.PhysAir(lvl, lvl.PosToInt((ushort)(x + 1), y, z));
AirPhysics.PhysAir(lvl, lvl.PosToInt((ushort)(x - 1), y, z));
AirPhysics.PhysAir(lvl, lvl.PosToInt(x, y, (ushort)(z + 1)));
AirPhysics.PhysAir(lvl, lvl.PosToInt(x, y, (ushort)(z - 1)));
AirPhysics.PhysAir(lvl, lvl.PosToInt(x, (ushort)(y + 1), z));
}
if (!lvl.growTrees)
{
C.data.Data = PhysicsArgs.RemoveFromChecks; return;
}
if (C.data.Data < 20)
{
if (rand.Next(20) == 0)
{
C.data.Data++;
}
return;
}
lvl.SetTile(x, y, z, Block.air);
Tree tree = new NormalTree();
tree.SetData(rand);
tree.Output(x, y, z, (xT, yT, zT, bT) =>
{
if (lvl.GetTile(xT, yT, zT) == Block.air)
{
lvl.Blockchange(xT, yT, zT, bT);
}
});
C.data.Data = PhysicsArgs.RemoveFromChecks;
}
public override void Use(Player p, string message)
{
if (Player.IsSuper(p))
{
MessageInGameOnly(p); return;
}
string[] parts = message.SplitSpaces(2);
string brushMsg = parts.Length >= 2 ? parts[1] : "";
Tree tree = Tree.Find(parts[0]);
if (tree == null)
{
brushMsg = message;
tree = new NormalTree();
}
DrawArgs dArgs = default(DrawArgs);
dArgs.tree = tree;
dArgs.brushMsg = brushMsg;
Player.Message(p, "Select where you wish your tree to grow");
p.MakeSelection(1, dArgs, DoTree);
}
void SpawnTrees()
{
for (int i = 0; i < NewWorldData.countDictionary[TerrainSettingType.NormalTree]; i++)
{
NormalTreeGenerationData treeGenData = new NormalTreeGenerationData {
widthRange = defaultTreeWidthFromTo
, heightRange = defaultTreeHeightFromTo
, radius = Random.Range(1.0f, 1.5f)
, segmentHeight = 1.6f
, childLevels = 1
, branchesAmountRange = NormalTree.GetDefaultTreeBrachesAmount()
, nestedTreeAmountRange = NormalTree.GetDefaultTreeNestedTreesAmount()
};
SpawnTree(treeGenData, true);
}
for (int i = 0; i < NewWorldData.countDictionary[TerrainSettingType.TallTree]; i++)
{
SpawnTallTree(true);
}
for (int i = 0; i < NewWorldData.countDictionary[TerrainSettingType.ChristmasTree]; i++)
{
SpawnChristmasTree(true);
}
}
static void ProcessTrees( ForesterArgs args, IList<Tree> treeList ) {
TreeShape[] shapeChoices;
switch( args.Shape ) {
case TreeShape.Stickly:
shapeChoices = new[]{ TreeShape.Normal,
TreeShape.Bamboo,
TreeShape.Palm };
break;
case TreeShape.Procedural:
shapeChoices = new[]{ TreeShape.Round,
TreeShape.Cone };
break;
default:
shapeChoices = new[] { args.Shape };
break;
}
for( int i = 0; i < treeList.Count; i++ ) {
TreeShape newShape = shapeChoices[args.Rand.Next( 0, shapeChoices.Length )];
Tree newTree;
switch( newShape ) {
case TreeShape.Normal:
newTree = new NormalTree();
break;
case TreeShape.Bamboo:
newTree = new BambooTree();
break;
case TreeShape.Palm:
newTree = new PalmTree();
break;
case TreeShape.Round:
newTree = new RoundTree();
break;
case TreeShape.Cone:
newTree = new ConeTree();
break;
case TreeShape.Rainforest:
newTree = new RainforestTree();
break;
case TreeShape.Mangrove:
newTree = new MangroveTree();
break;
default:
throw new ArgumentException( "Unknown tree shape type" );
}
newTree.Copy( treeList[i] );
if( args.MapHeightLimit ) {
int height = newTree.Height;
int yBase = newTree.Pos[1];
int mapHeight = args.Map.Height;
int foliageHeight;
if( args.Shape == TreeShape.Rainforest ) {
foliageHeight = 2;
} else {
foliageHeight = 4;
}
if( yBase + height + foliageHeight > mapHeight ) {
newTree.Height = mapHeight - yBase - foliageHeight;
}
}
if( newTree.Height < 1 ) newTree.Height = 1;
newTree.Prepare();
treeList[i] = newTree;
}
}
void GenNonLavaColumn(ushort x, ushort y, ushort z, Level Lvl, int index)
{
if (y > LiquidLevel)
{
int pos = x + Lvl.Width * (z + y * Lvl.Length);
for (ushort yy = 0; y - yy >= 0; yy++)
{
if (args.SimpleColumns)
{
Lvl.blocks[pos] = Block.Sand;
}
else if (overlay[index] < 0.72f)
{
if (args.IslandColumns) //increase sand height for island
{
if (y > LiquidLevel + 2)
{
if (yy == 0)
{
Lvl.blocks[pos] = Block.Grass; //top layer
}
else if (yy < 3)
{
Lvl.blocks[pos] = Block.Dirt; //next few
}
else
{
Lvl.blocks[pos] = Block.Stone; //ten rock it
}
}
else
{
Lvl.blocks[pos] = Block.Sand; //SAAAND extra for islands
}
}
else
{
if (yy == 0)
{
Lvl.blocks[pos] = Block.Grass;
}
else if (yy < 3)
{
Lvl.blocks[pos] = Block.Dirt;
}
else
{
Lvl.blocks[pos] = Block.Stone;
}
}
}
else
{
Lvl.blocks[pos] = Block.Stone;
}
pos -= Lvl.Width * Lvl.Length;
}
if (args.GenFlowers && overlay[index] < 0.25f)
{
switch (rng.Next(12))
{
case 10:
Lvl.SetTile(x, (ushort)(y + 1), z, Block.Rose); break;
case 11:
Lvl.SetTile(x, (ushort)(y + 1), z, Block.Dandelion); break;
default:
break;
}
}
if (args.GenTrees && overlay[index] < 0.65f && overlay2[index] < treeDens)
{
if (Lvl.IsAirAt(x, (ushort)(y + 1), z))
{
if (Lvl.GetBlock(x, y, z) == Block.Grass || args.UseCactus)
{
if (rng.Next(13) == 0 && !Tree.TreeCheck(Lvl, x, y, z, treeDist))
{
Tree tree = null;
if (args.UseCactus)
{
tree = new CactusTree();
}
else
{
tree = new NormalTree();
}
tree.SetData(rng, tree.DefaultSize(rng));
tree.Generate(x, (ushort)(y + 1), z, (xT, yT, zT, bT) =>
{
if (Lvl.IsAirAt(xT, yT, zT))
{
Lvl.SetTile(xT, yT, zT, bT);
}
});
}
}
}
}
}
else //Must be on/under the water line then
{
int pos = x + Lvl.Width * (z + LiquidLevel * Lvl.Length);
for (ushort yy = 0; LiquidLevel - yy >= 0; yy++)
{
if (LiquidLevel - yy > y)
{
Lvl.blocks[pos] = Block.StillWater; //better fill the water above me
}
else if (LiquidLevel - yy > y - 3)
{
byte block = overlay[index] < 0.75f ? Block.Sand : Block.Gravel; // sand on top
Lvl.blocks[pos] = block;
}
else
{
Lvl.blocks[pos] = Block.Stone;
}
pos -= Lvl.Width * Lvl.Length;
}
}
}
static void ProcessTrees(ForesterArgs args, IList <Tree> treelist)
{
TreeShape[] shapeChoices;
switch (args.Shape)
{
case TreeShape.Stickly:
shapeChoices = new[] { TreeShape.Normal,
TreeShape.Bamboo,
TreeShape.Palm };
break;
case TreeShape.Procedural:
shapeChoices = new[] { TreeShape.Round,
TreeShape.Cone };
break;
default:
shapeChoices = new[] { args.Shape };
break;
}
for (int i = 0; i < treelist.Count; i++)
{
TreeShape newshape = shapeChoices[args.Rand.Next(0, shapeChoices.Length)];
Tree newTree;
switch (newshape)
{
case TreeShape.Normal:
newTree = new NormalTree();
break;
case TreeShape.Bamboo:
newTree = new BambooTree();
break;
case TreeShape.Palm:
newTree = new PalmTree();
break;
case TreeShape.Round:
newTree = new RoundTree();
break;
case TreeShape.Cone:
newTree = new ConeTree();
break;
case TreeShape.Rainforest:
newTree = new RainforestTree();
break;
case TreeShape.Mangrove:
newTree = new MangroveTree();
break;
default:
throw new ArgumentException("Unknown tree shape type");
}
newTree.Copy(treelist[i]);
if (args.MapHeightLimit)
{
int height = newTree.Height;
int ybase = newTree.Pos[1];
int mapHeight = args.Map.Height;
int foliageHeight;
if (args.Shape == TreeShape.Rainforest)
{
foliageHeight = 2;
}
else
{
foliageHeight = 4;
}
if (ybase + height + foliageHeight > mapHeight)
{
newTree.Height = mapHeight - ybase - foliageHeight;
}
}
if (newTree.Height < 1)
{
newTree.Height = 1;
}
newTree.Prepare();
treelist[i] = newTree;
}
}
void ProcessTrees(List<Tree> treelist)
{
TreeShape[] shape_choices;
switch (args.SHAPE)
{
case TreeShape.Stickly:
shape_choices = new TreeShape[]{ TreeShape.Normal,
TreeShape.Bamboo,
TreeShape.Palm};
break;
case TreeShape.Procedural:
shape_choices = new TreeShape[]{ TreeShape.Round,
TreeShape.Cone };
break;
default:
shape_choices = new TreeShape[] { args.SHAPE };
break;
}
for (int i = 0; i < treelist.Count; i++)
{
TreeShape newshape = shape_choices[args.rand.Next(0, shape_choices.Length)];
Tree newtree;
switch (newshape)
{
case TreeShape.Normal:
newtree = new NormalTree();
break;
case TreeShape.Bamboo:
newtree = new BambooTree();
break;
case TreeShape.Palm:
newtree = new PalmTree();
break;
case TreeShape.Round:
newtree = new RoundTree();
break;
case TreeShape.Cone:
newtree = new ConeTree();
break;
case TreeShape.Rainforest:
newtree = new RainforestTree();
break;
case TreeShape.Mangrove:
newtree = new MangroveTree();
break;
default:
throw new ArgumentException();
}
newtree.Copy(treelist[i]);
if (args.MAPHEIGHTLIMIT)
{
int height = newtree.height;
int ybase = newtree.pos[1];
int mapheight = args.inMap.MapSizeZ;
int foliageheight;
if (args.SHAPE == TreeShape.Rainforest)
{
foliageheight = 2;
}
else
{
foliageheight = 4;
}
if (ybase + height + foliageheight > mapheight)
{
newtree.height = mapheight - ybase - foliageheight;
}
}
if (newtree.height < 1) newtree.height = 1;
newtree.Prepare();
treelist[i] = newtree;
}
}
void ProcessTrees(List <Tree> treelist)
{
TreeShape[] shape_choices;
switch (args.SHAPE)
{
case TreeShape.Stickly:
shape_choices = new TreeShape[] { TreeShape.Normal,
TreeShape.Bamboo,
TreeShape.Palm };
break;
case TreeShape.Procedural:
shape_choices = new TreeShape[] { TreeShape.Round,
TreeShape.Cone };
break;
default:
shape_choices = new TreeShape[] { args.SHAPE };
break;
}
for (int i = 0; i < treelist.Count; i++)
{
TreeShape newshape = shape_choices[args.rand.Next(0, shape_choices.Length)];
Tree newtree;
switch (newshape)
{
case TreeShape.Normal:
newtree = new NormalTree();
break;
case TreeShape.Bamboo:
newtree = new BambooTree();
break;
case TreeShape.Palm:
newtree = new PalmTree();
break;
case TreeShape.Round:
newtree = new RoundTree();
break;
case TreeShape.Cone:
newtree = new ConeTree();
break;
case TreeShape.Rainforest:
newtree = new RainforestTree();
break;
case TreeShape.Mangrove:
newtree = new MangroveTree();
break;
default:
throw new ArgumentException();
}
newtree.Copy(treelist[i]);
if (args.MAPHEIGHTLIMIT)
{
int height = newtree.height;
int ybase = newtree.pos[1];
int mapheight = args.inMap.MapSizeZ;
int foliageheight;
if (args.SHAPE == TreeShape.Rainforest)
{
foliageheight = 2;
}
else
{
foliageheight = 4;
}
if (ybase + height + foliageheight > mapheight)
{
newtree.height = mapheight - ybase - foliageheight;
}
}
if (newtree.height < 1)
{
newtree.height = 1;
}
newtree.Prepare();
treelist[i] = newtree;
}
}
