public ApplicationTreeItem(Application app, TreeModel model, TreeType treeType)
: base(app, null, model, 0)
{
Name = "Application";
IsExpanded = true;
_treeType = treeType;
}
public BattleTree(GlobalFlags globalFlags, TreeType treeType)
{
currentIndex = 0;
treeNodeDictionary = new Dictionary<long, BattleTreeNode>();
this.globalFlags = globalFlags;
this.treeType = treeType;
}
public BinTree(int ThreadId, TreeType treeType)
{
// the following intended to ensure the console output was legible...
//Console.SetOut(TextWriter.Synchronized(Console.Out));
m_TreeType = treeType;
m_pRoot = null;
m_Random = new Random();
}
public TreeItem(string path, string mode, TreeType type, int size, string sha, Uri url)
{
Path = path;
Mode = mode;
Type = type;
Size = size;
Sha = sha;
Url = url;
}
public PresentationSourceTreeItem(PresentationSource presentationSource, TreeModel model, TreeType treeType)
: base(presentationSource, null, model, 0)
{
Name = "PresentationSource";
IsExpanded = true;
_treeType = treeType;
_presentationSource = presentationSource;
}
public TreeviewH(string header, TreeType type)
{
this.currentHeader = header;
this.Header = header;
this.IsExpanded = true;
this.Tag = type;
this.FontWeight = FontWeights.Normal;
//this.MouseUp += new System.Windows.Input.MouseButtonEventHandler(MainWindow.actionClick);
this.ContextMenu = MainWindow.main.Resources["ActionContextMenu"] as ContextMenu;
}
/// <summary>
/// Initializes a new instance of the <see cref="TreeElementService"/> class.
/// </summary>
public TreeElementService(TreeType treeType)
{
_treeType = treeType;
FindRootElements();
_refreshTreeTimer = new DispatcherTimer(DispatcherPriority.Background) {Interval = TimeSpan.FromMilliseconds(500)};
_refreshTreeTimer.Tick += OnRefreshTree;
_refreshTreeTimer.Start();
}
public TreeThread(int ThreadId, TreeType treeType, int[] count)
{
// attempt to synchronize the console output
//Console.SetOut(TextWriter.Synchronized(Console.Out));
mA_Count = count;
m_BinTree = new BinTree(ThreadId, treeType);
m_id = ThreadId;
Mv_Thread = new Thread( new ThreadStart(this.ThreadStart));
Mv_Thread.Start( );
Console.Out.WriteLine("Started Thread: " + m_id);
}
public ITree GetTree(TreeType treeType)
{
ITree returnedTree = null;
foreach (var item in trees)
{
if (treeType == item.Type)
{
returnedTree = item;
break;
}
}
return returnedTree;
}
public void FindParts(TreeType type = TreeType.TechMananger)
{
var partCollectionViewModel = MainSideBar.PartsListBox.DataContext
as PartCollectionViewModel;
if (partCollectionViewModel == null) return;
partCollectionViewModel.LoadParts(Settings.Default.KspPath);
var sidebar = MainSideBar.DataContext as TechTreeViewModel;
if (sidebar == null) return;
sidebar.PartCollectionViewModel = partCollectionViewModel;
_treeData.PartCollectionViewModel = partCollectionViewModel;
foreach (var node in _treeData.TechTree)
{
node.PopulateParts(partCollectionViewModel, type);
}
}
public static TreeNode CreateTree(TreeType type)
{
switch (type)
{
case TreeType.CompleteTree:
return(CreateCompleteTree());
case TreeType.NotCompleteTree:
return(CreateNotCompleteTree());
case TreeType.NoRightChildTree:
return(CreateNoRightChildTree());
case TreeType.NoLeftChildTree:
return(CreateNoLeftChildTree());
default:
return(null);
}
}
private void AddTree(int usedTilesNb, out int usedTiles)
{
usedTiles = usedTilesNb;
TreeItem[] trees = items.Where(x => !Objectifs.ContainsKey(x.type) && x.type != TreeType.Nothing).ToArray();
if (trees.Length > 0)
{
int i = Random.Range(0, trees.Length);
TreeType type = trees[i].type;
int number = Random.Range(items[i].maxInstanceForWin / 2 + 1, items[i].maxInstanceForWin);
usedTiles += number;
if (usedTiles > 22)
{
GetComponent <InventoryManager>().items[(int)TreeType.SwapTree - 1].count += 3;
return;
}
Objectifs.Add(type, number);
}
}
public static int CountLight(Board board, TreeType treeType)
{
return(board.Tiles.Where((kvp) => {
(_, int value) = kvp;
if (Tile.TreeTypeIs(value, treeType) && Tile.ProducesLight(value))
{
Console.Write(">>>Counting Light: ");
}
return Tile.TreeTypeIs(value, treeType) && Tile.ProducesLight(value);
})
.Aggregate(
0,
(l, p) => {
Console.WriteLine($"Total:{l} || (Hex:{p.Key.ToString()}, code: {p.Value}) || height:{Tile.GetPieceHeight( p.Value )} > {Tile.GetShadowHeight( p.Value )} ==> {Tile.GetLight( p.Value )}");
return l + Tile.GetLight(p.Value);
}
));
}
public Tree(WorldGrid _world, Cell _cell, Vector2 _position)
{
position = _position;
worldGrid = _world;
cell = _cell;
ressourceConsumer = new RessourceConsumer();
ressourceConsumer.createTypes = RessourceType.None;
ressourceConsumer.consumTypes = RessourceType.Blue | RessourceType.Green;
ressourceConsumer.OnRessourceConsumed += new RessourceConsumer.RessourceEvent(ressourceConsumer_OnRessourceConsumed);
ressourceConsumer.OnRessourceCreated += new RessourceConsumer.RessourceEvent(ressourceConsumer_OnRessourceCreated);
cell.ressourceConsumer = ressourceConsumer;
type = _world.lifeLayer.treeTypes[ Random.Range(0, _world.lifeLayer.treeTypes.Length) ];
maxLevel = type.growthCount - 1;
animOffset = Random.value;
worldGrid.trees.Add(this);
}
private void WriteType(TreeType node)
{
if (node is AbstractNode abstractNode)
{
_writer.WriteLine(" public abstract partial class {0} : {1}", node.Name, node.Base);
_writer.WriteLine(" {");
for (int i = 0, n = abstractNode.Fields.Count; i < n; i++)
{
var field = abstractNode.Fields[i];
if (IsNodeOrNodeList(field.Type))
{
_writer.WriteLine(" public abstract {0}{1} {2} {{ get; }}", "", field.Type, field.Name);
}
}
_writer.WriteLine(" }");
}
else if (node is Node nd)
{
_writer.WriteLine(" public partial class {0} : {1}", node.Name, node.Base);
_writer.WriteLine(" {");
WriteKinds(nd.Kinds);
var valueFields = nd.Fields.Where(n => !IsNodeOrNodeList(n.Type)).ToList();
var nodeFields = nd.Fields.Where(n => IsNodeOrNodeList(n.Type)).ToList();
for (int i = 0, n = nodeFields.Count; i < n; i++)
{
var field = nodeFields[i];
_writer.WriteLine(" public {0}{1}{2} {3} {{ get; }}", "", "", field.Type, field.Name);
}
for (int i = 0, n = valueFields.Count; i < n; i++)
{
var field = valueFields[i];
_writer.WriteLine(" public {0}{1}{2} {3} {{ get; }}", "", "", field.Type, field.Name);
}
_writer.WriteLine(" }");
}
}
public void InstantiateSeed(TreeType seedType)
{
GameObject prefab = null;
switch (seedType)
{
case TreeType.APPLE_TREE:
prefab = appleTreeSeedPrefab;
break;
case TreeType.OAK:
prefab = oakTreeSeedPrefab;
break;
case TreeType.PINE_TREE:
prefab = pineTreeSeedPrefab;
break;
}
Instantiate(prefab, gameObject.transform.position, gameObject.transform.rotation);
}
private void UpdateType()
{
if ((isHometree && neighbors.Count == 0) || !isHometree)
{
int sum = locationValue + levelOffset;
if (sum > 5)
{
sum = 5;
}
if (sum < 0)
{
graph.Remove(gameObject);
}
else
{
nodeValue = sum;
type = (TreeType)(sum);
TemporaryBackgroundUpdate();
}
}
}
protected HandlerStatement(TreeType type, Expression name, Location commaLocation, Expression delegateExpression, Span span, IList <Comment> comments) : base(type, span, comments)
{
Debug.Assert(type == TreeType.AddHandlerStatement || type == TreeType.RemoveHandlerStatement);
if (name == null)
{
throw new ArgumentNullException("name");
}
if (delegateExpression == null)
{
throw new ArgumentNullException("delegateExpression");
}
SetParent(name);
SetParent(delegateExpression);
_Name = name;
_CommaLocation = commaLocation;
_DelegateExpression = delegateExpression;
}
public void VerifyRangeSmallTree(TreeType type)
{
BinaryTree <long, string> testTree = TreeFactory(type);
testTree.Add(4, "4");
testTree.Add(2, "2");
testTree.Add(8, "8");
testTree.Add(3, "3");
testTree.Add(1, "1");
testTree.Add(6, "6");
string a = BuildTestString(testTree.Range(3, 100));
Assert.Equal("3_4_6_8", a.ToString());
a = BuildTestString(testTree.Range(0, 100));
Assert.Equal("1_2_3_4_6_8", a);
a = BuildTestString(testTree.Range(3, 7));
Assert.Equal("3_4_6", a.ToString());
}
public void VerifyRangeSmallTreeRightOnly(TreeType type)
{
BinaryTree <long, string> testTree = TreeFactory(type);
testTree.Add(1, "1");
testTree.Add(2, "2");
testTree.Add(3, "3");
testTree.Add(4, "4");
testTree.Add(5, "5");
testTree.Add(6, "6");
string a = BuildTestString(testTree.Range(3, 5));
Assert.Equal("3_4_5", a.ToString());
//string a = BuildTestString(testTree.Range(0, 100));
//Assert.Equal("1_2_3_4_5_6", a);
//a = BuildTestString(testTree.Range(3, 5));
//Assert.Equal("3_4_5", a.ToString());
}
static public TreeTypeData Get(TreeType type)
{
switch (type)
{
case TreeType.Normal:
return(new TreeTypeData
{
height = .25f,
radius = .0625f
});
case TreeType.Old:
return(new TreeTypeData
{
height = .25f * Mathf.Pow(scale, 2f),
radius = .0625f * Mathf.Pow(scale, 1f)
});
default:
return(Get(TreeType.Normal));
}
}
private string GetCustomTagLoadPath(int tagValue, TreeType treeType)
{
var tag = GetRawTagFromValue(tagValue);
switch (treeType)
{
case TreeType.CustomLayer:
case TreeType.CustomEmptyLayer:
{
return uuebTags.layerInfos.Where(t => t.layerName == tag).Select(t => t.loadPath).FirstOrDefault();
}
case TreeType.Content_Img:
case TreeType.Content_Text:
{
return uuebTags.contents.Where(t => t.contentName == tag).Select(t => t.loadPath).FirstOrDefault();
}
default:
{
throw new Exception("unexpected tree type:" + treeType + " of tag:" + tag);
}
}
}
public static ITree getTreeFromFile(string path,TreeType treeType, GlobalFlags gf)
{
ITree t = null;
List<ITreeNode> treeNodeList = null;
switch (treeType)
{
case TreeType.World:
WorldTree worldTree = new WorldTree(gf, treeType);
treeNodeList = getTreeNodeListFromFile(path,treeType);
worldTree.treeNodeDictionary = getWorldTreeNodeFromList(treeNodeList);
worldTree.currentIndex = treeNodeList[0].index;
t = worldTree;
break;
case TreeType.Zone:
ZoneTree zoneTree = new ZoneTree(gf, treeType);
treeNodeList = getTreeNodeListFromFile(path,treeType);
zoneTree.treeNodeDictionary = getZoneTreeNodeFromList(treeNodeList);
zoneTree.currentIndex = treeNodeList[0].index;
t = zoneTree;
break;
case TreeType.Dialog:
DialogTree dialogTree = new DialogTree(gf, treeType);
treeNodeList = getTreeNodeListFromFile(path,treeType);
dialogTree.treeNodeDictionary = getDialogTreeNodeFromList(treeNodeList);
dialogTree.currentIndex = treeNodeList[0].index;
t = dialogTree;
break;
case TreeType.Quest:
QuestTree questTree = new QuestTree(gf, treeType);
treeNodeList = getTreeNodeListFromFile(path,treeType);
questTree.treeNodeDictionary = getQuestTreeNodeFromList(treeNodeList);
questTree.currentIndex = treeNodeList[0].index;
t = questTree;
break;
default:
break;
}
return t;
}
public void UpdateTreeItem(TreeType item)
{
foreach (Terrain terrain in terrains)
{
foreach (TreePrefab p in item.prefabs)
{
//Not yet added
if (p.index >= terrain.terrainData.treePrototypes.Length)
{
continue;
}
if (p.prefab == null)
{
continue;
}
if (terrain.terrainData.treePrototypes[p.index] == null)
{
continue;
}
//Note only works when creating these copies :/
TreePrototype[] treePrototypes = terrain.terrainData.treePrototypes;
TreePrototype t = new TreePrototype();
t.prefab = p.prefab;
treePrototypes[p.index] = t;
terrain.terrainData.treePrototypes = treePrototypes;
}
#if UNITY_EDITOR
UnityEditor.EditorUtility.SetDirty(terrain);
UnityEditor.EditorUtility.SetDirty(terrain.terrainData);
#endif
}
}
public AbsTree Get(TreeType type) {
List<AbsTree> subPool = null;
pool.TryGetValue(type, out subPool);
if ( subPool != null ) {
foreach ( AbsTree m in subPool ) {
if ( m.CanBeReused() ) {
m.gameObject.SetActive(true);
return m;
}
}
foreach ( var s in seeds ) {
if ( type == s.type ) {
var t = Instantiate(s.prefab);
t.transform.parent = subPool[0].transform.parent;
var _t = t.GetComponent<AbsTree>();
subPool.Add(_t);
return _t;
}
}
}
throw new UnityException("Invalid tree type : " + type);
}
public void PlaceTree(TreeType tree_type, int x, int y, Growth tree_growth)
{
if (!ValidIndex(x, y))
{
throw new UnityException("wtf ? x,y= " + x + "," + y);
}
VisualTree tree = null;
var seed = MonoRefCenter.instance.Get(tree_type);
if (seed == null)
{
throw new UnityException("wtf ? type= " + tree_type);
}
tree = Instantiate <VisualTree>(seed);
trees[x, y] = tree;
tree.transform.SetParent(transform);
tree.Init(Pos(x, y), x, y);
// tree set growth
}
protected override int PerformInternal()
{
if (_map.GetBlock(_x, _y, _z) != Block.Plant) //superflous task added by grass scanner or deleted plant. just forget it
{
return(0);
}
TreeType type = TypeByBlock(_map.GetBlock(_x, _y, _z - 1));
if (TreeType.NoGrow == type)
{
return(0);
}
short height = (short)_r.Next(4, 7);
if (CanGrow(height))
{
MakeTrunks(height, type);
}
return(0); //non-repeating task
}
public static float CalculateTreeDensity(TreeType treeType, int temperature, int humidity, int y)
{
switch (treeType)
{
case TreeType.Oak:
return(RangeProbability(humidity, 4f, 15f, 15f, 15f));
case TreeType.Birch:
return(RangeProbability(humidity, 4f, 15f, 15f, 15f));
case TreeType.Spruce:
return(RangeProbability(humidity, 4f, 15f, 15f, 15f));
case TreeType.TallSpruce:
return(RangeProbability(humidity, 4f, 15f, 15f, 15f));
case TreeType.Mimosa:
return(0.03f);
default:
return(0f);
}
}
public static float CalculateTreeProbability(TreeType treeType, int temperature, int humidity, int y)
{
switch (treeType)
{
case TreeType.Oak:
return(RangeProbability(temperature, 4f, 10f, 15f, 15f) * RangeProbability(humidity, 6f, 8f, 15f, 15f) * RangeProbability(y, 0f, 0f, 82f, 87f));
case TreeType.Birch:
return(RangeProbability(temperature, 5f, 9f, 9f, 14f) * RangeProbability(humidity, 3f, 15f, 15f, 15f) * RangeProbability(y, 0f, 0f, 82f, 87f));
case TreeType.Spruce:
return(RangeProbability(temperature, 0f, 0f, 6f, 10f) * RangeProbability(humidity, 3f, 10f, 11f, 12f));
case TreeType.TallSpruce:
return(0.25f * RangeProbability(temperature, 0f, 0f, 6f, 10f) * RangeProbability(humidity, 9f, 11f, 15f, 15f) * RangeProbability(y, 0f, 0f, 95f, 100f));
case TreeType.Mimosa:
return(RangeProbability(temperature, 2f, 4f, 12f, 14f) * RangeProbability(humidity, 0f, 0f, 4f, 6f));
default:
return(0f);
}
}
public LeveledGraph <long, long> BuildUsersSocialGraph(IUser user, TreeType treeType)
{
var graph = new LeveledGraph <long, long>();
var downloadQueue = new SortedSet <long>();
downloadQueue.Add(user.Id);
var friendsOfFriends = DownloadFriendsIds(downloadQueue);
foreach (var friendsList in friendsOfFriends)
{
var friendId = friendsList.Key;
var friendsOfFriend = friendsList.Value;
graph.AddVertex(user.Id, user.Id, treeType == TreeType.Normal ? 0 : 100);
foreach (var friend in friendsOfFriend)
{
graph.AddVertex(friend, friend, treeType == TreeType.Normal ? 1 : 100 - 1);
if (treeType == TreeType.Normal)
{
graph.AddEdge(friendsList.Key, friend);
}
else
{
graph.AddEdge(friend, friendsList.Key);
}
downloadQueue.Add(friend);
}
}
graph.Depth = 1;
return(graph);
}
public static StackPanel getTreeWithImage(string header, TreeType type,string img,string id)
{
Image i = new Image();
var uriSource = new Uri(@"/IscraperBuilder;component/img/" + img, UriKind.Relative);
i.Source = new BitmapImage(uriSource);
i.Height = 15;
i.Width = 15;
i.Margin = new System.Windows.Thickness(0, 0, 0, 0);
i.SnapsToDevicePixels = true;
i.Opacity = 0.5;
i.Tag = id;
StackPanel panel = new StackPanel();
//panel.MinWidth = 200;
panel.Tag = type;
panel.Orientation = Orientation.Horizontal;
panel.Margin = new System.Windows.Thickness(0, 0, 0, 0);
panel.HorizontalAlignment = System.Windows.HorizontalAlignment.Stretch;
panel.VerticalAlignment = VerticalAlignment.Top;
// panel.MouseLeftButtonDown += new System.Windows.Input.MouseButtonEventHandler(MainWindow.actionClick);
panel.Tag = id;
TextBlock t = new TextBlock();
t.Text = header;
t.Tag = type;
t.Margin = new System.Windows.Thickness(0,5,0,0);
t.FontWeight = FontWeights.Normal;
t.Height = 15;
t.Foreground = new SolidColorBrush(Colors.Black);
t.Tag = id;
panel.Children.Add(i);
panel.Children.Add(t);
return panel;
}
protected SignatureDeclaration(
TreeType type,
AttributeBlockCollection attributes,
ModifierCollection modifiers,
Location keywordLocation,
SimpleName name,
TypeParameterCollection typeParameters,
ParameterCollection parameters,
Location asLocation,
AttributeBlockCollection resultTypeAttributes,
TypeName resultType,
Span span,
IList <Comment> comments
) :
base(
type,
attributes,
modifiers,
span,
comments
)
{
SetParent(name);
SetParent(typeParameters);
SetParent(parameters);
SetParent(resultType);
SetParent(resultTypeAttributes);
_KeywordLocation = keywordLocation;
_Name = name;
_TypeParameters = typeParameters;
_Parameters = parameters;
_AsLocation = asLocation;
_ResultTypeAttributes = resultTypeAttributes;
_ResultType = resultType;
}
private static List<ITreeNode> getTreeNodeListFromFile(string path, TreeType treeType)
{
List<ITreeNode> treeNodeList = new List<ITreeNode>();
string fileTxt = File.ReadAllText(path);
var nodeList = ParseHelper.getSplitList(fileTxt, "----");
foreach(var node in nodeList)
{
treeNodeList.Add(getTreeNode(node,treeType));
}
return treeNodeList;
}
void Start()
{
size = Random.Range(1,101);
_myTransform = transform;
if (treeType == null)
{
treeType = TreeType.Oak;
}
if (size <= 100 && size >= 90)
{
_myTransform.localScale = new Vector3(5,1.5f,5);
lootSize = 20;
}
else if (size >= 75)
{
_myTransform.localScale = new Vector3(4, 1.3f, 4);
lootSize = 15;
}
else if (size >= 55)
{
_myTransform.localScale = new Vector3(3, 1.1f, 3);
lootSize = 10;
}
else if (size >= 35)
{
_myTransform.localScale = new Vector3(2, 1, 2);
lootSize = 7;
}
else
{
_myTransform.localScale = new Vector3(1, 1, 1);
lootSize = 5;
}
}
private static ITreeNode getTreeNodeFromDataStr(string nodeDataStr, TreeType treeType)
{
var dataList = ParseHelper.getSplitList(nodeDataStr, Environment.NewLine);
ITreeNode node = null;
switch(treeType)
{
case TreeType.World:
var worldTreeNode = new WorldTreeNode(Int64.Parse(dataList[0]), dataList[1], null, null, (WorldNodeContent)getTreeNodeContentFromStr(dataList[2], treeType));
node = worldTreeNode;
break;
case TreeType.Zone:
var zoneTreeNode = new ZoneTreeNode(Int64.Parse(dataList[0]), dataList[1], null, null, (ZoneNodeContent)getTreeNodeContentFromStr(dataList[2], treeType));
node = zoneTreeNode;
break;
case TreeType.Dialog:
var dialogTreeNode = new DialogTreeNode(Int64.Parse(dataList[0]), dataList[1], null, null, (DialogNodeContent)getTreeNodeContentFromStr(dataList[2], treeType));
node = dialogTreeNode;
break;
case TreeType.Quest:
var questTreeNode = new QuestTreeNode(Int64.Parse(dataList[0]), dataList[1], null, null, (QuestNodeContent)getTreeNodeContentFromStr(dataList[2], treeType));
node = questTreeNode;
break;
case TreeType.Battle:
var battleTreeNode = new BattleTreeNode(Int64.Parse(dataList[0]), dataList[1], null, null, (BattleNodeContent)getTreeNodeContentFromStr(dataList[2], treeType));
node = battleTreeNode;
break;
case TreeType.Info:
var infoTreeNode = new InfoTreeNode(Int64.Parse(dataList[0]), dataList[1], null, null, (InfoNodeContent)getTreeNodeContentFromStr(dataList[2], treeType));
node = infoTreeNode;
break;
default: break;
}
if (dataList.Count > 3)
{
node.flagSetList = getFlagSetFromDataStr(dataList[3]);
}
if (dataList.Count > 4)
{
node.actionList = getTreeNodeActionListFromDataStr(dataList[4]);
}
return node;
}
private static ITreeNode getTreeNodeFromDataStr(string nodeDataStr, TreeType treeType)
{
var dataList = ParseHelper.getSplitList(nodeDataStr, Environment.NewLine);
ITreeNode node = null;
switch (treeType)
{
case TreeType.World:
var worldTreeNode = new WorldTreeNode(Int64.Parse(dataList[0]), dataList[1], null, null, (WorldNodeContent)getTreeNodeContentFromStr(dataList[2], treeType));
node = worldTreeNode;
break;
case TreeType.Zone:
var zoneTreeNode = new ZoneTreeNode(Int64.Parse(dataList[0]), dataList[1], null, null, (ZoneNodeContent)getTreeNodeContentFromStr(dataList[2], treeType));
node = zoneTreeNode;
break;
case TreeType.Dialog:
var dialogTreeNode = new DialogTreeNode(Int64.Parse(dataList[0]), dataList[1], null, null, (DialogNodeContent)getTreeNodeContentFromStr(dataList[2], treeType));
node = dialogTreeNode;
break;
case TreeType.Quest:
var questTreeNode = new QuestTreeNode(Int64.Parse(dataList[0]), dataList[1], null, null, (QuestNodeContent)getTreeNodeContentFromStr(dataList[2], treeType));
node = questTreeNode;
break;
case TreeType.Battle:
var battleTreeNode = new BattleTreeNode(Int64.Parse(dataList[0]), dataList[1], null, null, (BattleNodeContent)getTreeNodeContentFromStr(dataList[2], treeType));
node = battleTreeNode;
break;
case TreeType.Info:
var infoTreeNode = new InfoTreeNode(Int64.Parse(dataList[0]), dataList[1], null, null, (InfoNodeContent)getTreeNodeContentFromStr(dataList[2], treeType));
node = infoTreeNode;
break;
case TreeType.Store:
var storeTreeNode = new StoreTreeNode(Int64.Parse(dataList[0]), dataList[1], null, null, (StoreNodeContent)getTreeNodeContentFromStr(dataList[2], treeType));
node = storeTreeNode;
break;
case TreeType.Cutscene:
var cutsceneTreeNode = new CutsceneTreeNode(Int64.Parse(dataList[0]), dataList[1], null, null, (CutsceneNodeContent)getTreeNodeContentFromStr(dataList[2], treeType));
node = cutsceneTreeNode;
break;
default: break;
}
if (dataList.Count > 3)
{
node.flagSetList = getFlagSetFromDataStr(dataList[3]);
}
if (dataList.Count > 4)
{
node.actionList = getTreeNodeActionListFromDataStr(dataList[4]);
}
return(node);
}
public static void SetTreeType(TreeType type)
{
TreeType = type;
}
public void SpawnTree(TreeType item)
{
if (item.collisionCheck)
{
RebuildCollisionCacheIfNeeded();
}
item.instanceCount = 0;
RefreshTreePrefabs();
float height, worldHeight, normalizedHeight;
foreach (Terrain terrain in terrains)
{
List <TreeInstance> treeInstanceCollection = new List <TreeInstance>(terrain.terrainData.treeInstances);
//Clear all existing instances first
for (int i = 0; i < treeInstanceCollection.Count; i++)
{
foreach (TreePrefab prefab in item.prefabs)
{
treeInstanceCollection.RemoveAll(x => x.prototypeIndex == prefab.index);
}
}
InitializeSeed(item.seed);
item.spawnPoints = PoissonDisc.GetSpawnpoints(terrain, item.distance, item.seed + seed);
foreach (Vector3 pos in item.spawnPoints)
{
//InitializeSeed(item.seed + index);
//Relative position as 0-1 value
Vector2 normalizedPos = terrain.GetNormalizedPosition(pos);
if (item.collisionCheck)
{
//Check for collision
if (InsideOccupiedCell(terrain, pos, normalizedPos))
{
continue;
}
}
InitializeSeed(item.seed + (int)pos.x + (int)pos.z);
//Skip if failing global probability check
if (((Random.value * 100f) <= item.probability) == false)
{
continue;
}
TreePrefab prefab = SpawnerBase.GetProbableTree(item);
//Failed probability checks entirely
if (prefab == null)
{
continue;
}
terrain.SampleHeight(normalizedPos, out height, out worldHeight, out normalizedHeight);
if (item.rejectUnderwater && worldHeight < waterHeight)
{
continue;
}
//Check height
if (worldHeight < item.heightRange.x || worldHeight > item.heightRange.y)
{
continue;
}
if (item.slopeRange.x > 0 || item.slopeRange.y < 90f)
{
float slope = terrain.GetSlope(normalizedPos, false);
//Reject if slope check fails
if (!(slope >= (item.slopeRange.x + 0.001f) && slope <= (item.slopeRange.y)))
{
continue;
}
}
if (item.curvatureRange.x > 0 || item.curvatureRange.y < 1f)
{
float curvature = terrain.SampleConvexity(normalizedPos);
//0=concave, 0.5=flat, 1=convex
curvature = TerrainSampler.ConvexityToCurvature(curvature);
if (curvature < item.curvatureRange.x || curvature > item.curvatureRange.y)
{
continue;
}
}
//Reject based on layer masks
Vector2Int texelIndex = terrain.SplatmapTexelIndex(normalizedPos);
float spawnChance = 0f;
if (item.layerMasks.Count == 0)
{
spawnChance = 100f;
}
foreach (TerrainLayerMask layer in item.layerMasks)
{
Texture2D splat = terrain.terrainData.GetAlphamapTexture(GetSplatmapID(layer.layerID));
Color color = splat.GetPixel(texelIndex.x, texelIndex.y);
int channel = layer.layerID % 4;
float value = SampleChannel(color, channel);
if (value > 0)
{
value = Mathf.Clamp01(value - layer.threshold);
}
value *= 100f;
spawnChance += value;
}
InitializeSeed((int)pos.x * (int)pos.z);
if ((Random.value <= spawnChance) == false)
{
continue;
}
//Passed all conditions, add instance
TreeInstance treeInstance = new TreeInstance();
treeInstance.prototypeIndex = prefab.index;
treeInstance.position = new Vector3(normalizedPos.x, normalizedHeight, normalizedPos.y);
treeInstance.rotation = Random.Range(0f, 359f) * Mathf.Deg2Rad;
float scale = Random.Range(item.scaleRange.x, item.scaleRange.y);
treeInstance.heightScale = scale;
treeInstance.widthScale = scale;
treeInstance.color = Color.white;
treeInstance.lightmapColor = Color.white;
treeInstanceCollection.Add(treeInstance);
item.instanceCount++;
}
item.spawnPoints.Clear();
#if UNITY_2019_1_OR_NEWER
terrain.terrainData.SetTreeInstances(treeInstanceCollection.ToArray(), false);
#else
terrain.terrainData.treeInstances = treeInstanceCollection.ToArray();
#endif
}
for (int i = 0; i < item.prefabs.Count; i++)
{
onTreeRespawn?.Invoke(item.prefabs[i]);
}
}
private static Dictionary <string, int> GetSpeciesList(WaterDemand waterDemand, TreeType type)
{
switch (waterDemand)
{
case WaterDemand.High when type == TreeType.Deciduous:
return(Tree.DeciduousHigh);
case WaterDemand.High when type == TreeType.Coniferous:
return(Tree.ConiferousHigh);
case WaterDemand.Medium when type == TreeType.Deciduous:
return(Tree.DeciduousMedium);
case WaterDemand.Medium when type == TreeType.Coniferous:
return(Tree.ConiferousMedium);
case WaterDemand.Low when type == TreeType.Deciduous:
return(Tree.DeciduousLow);
default:
throw new ArgumentOutOfRangeException();
}
}
public void setTreeType(TreeType Tree)
{
Trees = Tree;
}
public void Update(TreeType treetype)
{
repository.Update(treetype);
}
public static int GetTreeLeavesValue(TreeType treeType)
{
return(m_treeLeavesByType[(int)treeType]);
}
public static ReadOnlyList <TerrainBrush> GetTreeBrushes(TreeType treeType)
{
return(new ReadOnlyList <TerrainBrush>(m_treeBrushesByType[(int)treeType]));
}
public static int GetTreeTrunkValue(TreeType treeType)
{
return(m_treeTrunksByType[(int)treeType]);
}
public void createTree(PlayerSprite player, TreeType treeType, String name, int price)
{
// check and decrease seeds of players here
if (seedCollection.collectedSeedCount >= price &&
!treeCollection.HasTreeAtPosition(player.worldPosition.X))
{
treeCollection.CreateTree(player.worldPosition, treeType, false, name);
seedCollection.collectedSeedCount -= price;
}
}
public void PopulateParts(
PartCollectionViewModel pc,
TreeType type = TreeType.TechMananger)
{
switch (type)
{
case TreeType.ATC:
foreach (var part in pc.PartCollection)
{
if (part.TechRequired == TechId)
{
_parts.Add(part);
}
}
break;
case TreeType.TechMananger:
var partTable = new Dictionary<string, PartViewModel>();
foreach (var part in pc.PartCollection)
{
try
{
if (!partTable.ContainsKey(part.PartName))
{
partTable.Add(part.PartName, part);
}
else
{
var duplicate = partTable[part.PartName];
var existString = String.Format(" - Existing part: {0} ({1})", duplicate.PartName, duplicate.FileName);
Logger.Error(
"PartLoader: Error while storing part \"{0}\" " +
"({1}) into PartCollection - {2}{3}",
part.PartName,
part.FileName,
"Part already exists",
existString);
}
}
catch (Exception e)
{
Logger.Error(
"PartLoader: Error while storing part \"{0}\" " +
"({1}) into PartCollection - {2}",
part.PartName,
part.FileName,
e.Message);
}
}
foreach (var part in _techNode.Parts)
{
if (partTable.ContainsKey(part))
{
_parts.Add(partTable[part]);
pc.PartCollection.Remove(partTable[part]);
}
else
{
var tmpPart = new Part(part)
{
Title = part,
TechRequired = TechId,
Category = "(Unknown)"
};
_parts.Add(new PartViewModel(tmpPart));
}
}
break;
}
}
private static List<ITreeNode> getTreeNodeListFromString(string data, TreeType treeType)
{
List<ITreeNode> treeNodeList = new List<ITreeNode>();
var nodeList = ParseHelper.getSplitList(data, "----");
foreach (var node in nodeList)
{
treeNodeList.Add(getTreeNode(node, treeType));
}
return treeNodeList;
}
public NTree(Node node, TreeType type, Point startingPosition)
{
Node = node;
Type = type;
Node.Position = startingPosition;
children = new List<NTree>();
}
public BinTree(int ThreadId, TreeType treeType)
{
m_TreeType = treeType;
m_pRoot = null;
m_Random = new Random();
}
/// <summary>
/// Generate a tree at any location
/// </summary>
/// <param name="type">Type of tree to generate</param>
/// <param name="pos">Location to generate the tree</param>
public void GenerateTree(TreeType type, Vector3S pos)
{
switch ( type ) {
case TreeType.Big:
case TreeType.Fat:
case TreeType.NotchBig:
case TreeType.NotchSmall:
case TreeType.Small:
case TreeType.Thin:
break;
}
}
public TreeThread(int ThreadId, TreeType treeType, int[] count)
{
mA_Count = count;
m_BinTree = new BinTree(ThreadId, treeType);
m_id = ThreadId;
Mv_Thread = new Thread( new ThreadStart(this.ThreadStart));
Mv_Thread.Start( );
Console.Out.WriteLine("Started Thread: " + m_id);
}
public static ITree getTreeFromString(string data, TreeType treeType, GlobalFlags gf)
{
ITree t = null;
List<ITreeNode> treeNodeList = null;
switch (treeType)
{
case TreeType.World:
WorldTree worldTree = new WorldTree(gf, treeType);
treeNodeList = getTreeNodeListFromString(data, treeType);
worldTree.treeNodeDictionary = getWorldTreeNodeFromList(treeNodeList);
worldTree.currentIndex = treeNodeList[0].index;
t = worldTree;
break;
case TreeType.Zone:
ZoneTree zoneTree = new ZoneTree(gf, treeType);
treeNodeList = getTreeNodeListFromString(data, treeType);
zoneTree.treeNodeDictionary = getZoneTreeNodeFromList(treeNodeList);
zoneTree.currentIndex = treeNodeList[0].index;
t = zoneTree;
break;
case TreeType.Dialog:
DialogTree dialogTree = new DialogTree(gf, treeType);
treeNodeList = getTreeNodeListFromString(data, treeType);
dialogTree.treeNodeDictionary = getDialogTreeNodeFromList(treeNodeList);
dialogTree.currentIndex = treeNodeList[0].index;
t = dialogTree;
break;
case TreeType.Quest:
QuestTree questTree = new QuestTree(gf, treeType);
treeNodeList = getTreeNodeListFromString(data, treeType);
questTree.treeNodeDictionary = getQuestTreeNodeFromList(treeNodeList);
questTree.currentIndex = treeNodeList[0].index;
t = questTree;
break;
case TreeType.Battle:
BattleTree battleTree = new BattleTree(gf, treeType);
treeNodeList = getTreeNodeListFromString(data, treeType);
battleTree.treeNodeDictionary = getBattleTreeNodeFromList(treeNodeList);
battleTree.currentIndex = treeNodeList[0].index;
t = battleTree;
break;
case TreeType.Info:
InfoTree infoTree = new InfoTree(gf, treeType);
treeNodeList = getTreeNodeListFromString(data, treeType);
infoTree.treeNodeDictionary = getInfoTreeNodeFromList(treeNodeList);
infoTree.currentIndex = treeNodeList[0].index;
t = infoTree;
break;
default:
break;
}
return t;
}
public BinTree(int ThreadId, TreeType treeType)
{
m_TreeType = treeType;
m_pRoot = null;
m_Random = new Random();
}
private static ITreeNode getTreeNode(string str, TreeType treeType)
{
var nodePartList = ParseHelper.getSplitList(str, "--");
var nodeDataStr = nodePartList[0];
var linkDataStr = nodePartList[1];
ITreeNode td = getTreeNodeFromDataStr(nodeDataStr, treeType);
td.branchList = getTreeBranchListFromDataStr(linkDataStr);
return td;
}
public static ITree getTreeFromString(string data, TreeType treeType, GlobalFlags gf)
{
ITree t = null;
List <ITreeNode> treeNodeList = null;
switch (treeType)
{
case TreeType.World:
WorldTree worldTree = new WorldTree(gf, treeType);
treeNodeList = getTreeNodeListFromString(data, treeType);
worldTree.treeNodeDictionary = getWorldTreeNodeFromList(treeNodeList);
worldTree.currentIndex = treeNodeList[0].index;
t = worldTree;
break;
case TreeType.Zone:
ZoneTree zoneTree = new ZoneTree(gf, treeType);
treeNodeList = getTreeNodeListFromString(data, treeType);
zoneTree.treeNodeDictionary = getZoneTreeNodeFromList(treeNodeList);
zoneTree.currentIndex = treeNodeList[0].index;
t = zoneTree;
break;
case TreeType.Dialog:
DialogTree dialogTree = new DialogTree(gf, treeType);
treeNodeList = getTreeNodeListFromString(data, treeType);
dialogTree.treeNodeDictionary = getDialogTreeNodeFromList(treeNodeList);
dialogTree.currentIndex = treeNodeList[0].index;
t = dialogTree;
break;
case TreeType.Quest:
QuestTree questTree = new QuestTree(gf, treeType);
treeNodeList = getTreeNodeListFromString(data, treeType);
questTree.treeNodeDictionary = getQuestTreeNodeFromList(treeNodeList);
questTree.currentIndex = treeNodeList[0].index;
t = questTree;
break;
case TreeType.Battle:
BattleTree battleTree = new BattleTree(gf, treeType);
treeNodeList = getTreeNodeListFromString(data, treeType);
battleTree.treeNodeDictionary = getBattleTreeNodeFromList(treeNodeList);
battleTree.currentIndex = treeNodeList[0].index;
t = battleTree;
break;
case TreeType.Info:
InfoTree infoTree = new InfoTree(gf, treeType);
treeNodeList = getTreeNodeListFromString(data, treeType);
infoTree.treeNodeDictionary = getInfoTreeNodeFromList(treeNodeList);
infoTree.currentIndex = treeNodeList[0].index;
t = infoTree;
break;
case TreeType.Store:
StoreTree storeTree = new StoreTree(gf, treeType);
treeNodeList = getTreeNodeListFromString(data, treeType);
storeTree.treeNodeDictionary = getStoreTreeNodeFromList(treeNodeList);
storeTree.currentIndex = treeNodeList[0].index;
t = storeTree;
break;
case TreeType.Cutscene:
CutsceneTree cutsceneTree = new CutsceneTree(gf, treeType);
treeNodeList = getTreeNodeListFromString(data, treeType);
cutsceneTree.treeNodeDictionary = getCutsceneTreeNodeFromList(treeNodeList);
cutsceneTree.currentIndex = treeNodeList[0].index;
t = cutsceneTree;
break;
default:
break;
}
return(t);
}
private static ITreeNodeContent getTreeNodeContentFromStr(string contentStr, TreeType treeType)
{
var contentList = ParseHelper.getSplitList(contentStr,";");
switch(treeType)
{
case TreeType.World:
return new WorldNodeContent() {linkIndex=Int64.Parse(contentList[0]), zoneName=contentList[1], description=contentList[2],avatar=contentList[3],x=Int32.Parse(contentList[4]),y=Int32.Parse(contentList[5]) };
case TreeType.Zone:
return new ZoneNodeContent() { linkIndex = Int64.Parse(contentList[0]), nodeName = contentList[1], nodeType = getZoneNodeTypeFromStr(contentList[2]), description = contentList[3], icon = contentList[4], x = Int32.Parse(contentList[5]), y = Int32.Parse(contentList[6]) };
case TreeType.Dialog:
return new DialogNodeContent() {linkIndex = Int64.Parse(contentList[0]), speaker=contentList[1],portrait=contentList[2], text=contentList[3] };
case TreeType.Quest:
return new QuestNodeContent() { flagName = contentList[0], description = contentList[1] };
case TreeType.Battle:
return getBattleNodeContentFromStr(contentStr);
case TreeType.Info:
return getInfoNodeContentFromStr(contentStr);
default:
return null;
}
}
public void Insert(TreeType treetype)
{
repository.Insert(treetype);
}
/// <summary>
/// Displays the controls contents.
/// </summary>
protected override void DisplayControlsContents()
{
GUILayout.FlexibleSpace();
GUILayout.BeginHorizontal(); {
GUILayout.Label("Select Type:", m_mainText);
m_selectedTreeType = (TreeType)(GUILayout.SelectionGrid(
((int)m_selectedTreeType)-1,
m_treeTypeSelectors,
m_treeTypeSelectors.Length,
m_styles.smallButton
)+1);
} GUILayout.EndHorizontal();
GUILayout.FlexibleSpace();
// call base implementation
base.DisplayControlsContents();
}
private void MakeTrunks( short height, TreeType type )
{
for ( short i = 0; i < height; ++i ) {
_map.QueueUpdate( new BlockUpdate( null, _x, _y, ( short )( _z + i ), Block.Log ) );
}
if ( TreeType.Normal == type )
TreeGeneration.MakeNormalFoliage( _world, new Vector3I( _x, _y, _z ), height + 1 );
else
TreeGeneration.MakePalmFoliage( _world, new Vector3I( _x, _y, _z ), height );
}
public static void GenerateTree(Player p, ushort x, ushort z, ushort y, TreeType type, bool gothrough = false)
{
byte air = Block.BlockList.AIR,
sap = Block.BlockList.SAPLING,
trunk = Block.BlockList.WOOD,
leaf = Block.BlockList.LEAVES,
green = Block.BlockList.GREEN_CLOTH;
#region Normal
if (type == TreeType.Classic) {
byte height = (byte)MathUtils.Random.Next(5, 8);
short top = (short)(height - MathUtils.Random.Next(2, 4));
ushort xxx, yyy, zzz;
for (ushort yy = 0; yy < top + height - 1; yy++) { //trunk
if (!gothrough && p.Level.GetBlock(x, z, (ushort)(y + yy)) != air && p.Level.GetBlock(x, z, (ushort)(y + yy)) != sap) { continue; }
p.Level.BlockChange(new Vector3D(x, z, y + yy), trunk);
}
for (short xx = (short)-top; xx <= top; ++xx) {
for (short yy = (short)-top; yy <= top; ++yy) {
for (short zz = (short)-top; zz <= top; ++zz) {
short Dist = (short)(Math.Sqrt(xx * xx + yy * yy + zz * zz));
if (Dist < top + 1) {
if (MathUtils.Random.Next((int)(Dist)) < 2) {
try {
xxx = (ushort)(x + xx);
yyy = (ushort)(y + yy + height);
zzz = (ushort)(z + zz);
if ((xxx != x || zzz != z || yy >= top - 1) && (gothrough || p.Level.GetBlock(xxx, zzz, yyy) == air)) {
p.Level.BlockChange(new Vector3D(xxx,zzz,yyy), leaf);
}
}
catch { }
}
}
}
}
}
//p.Level.BlockChange(x, z, y, trunk);
}
#endregion
#region Notchy
if (type == TreeType.Notch) {
byte dist, tile, height = (byte)MathUtils.Random.Next(3, 7), top = (byte)(height - 2);
short xx, yy, zz;
ushort xxx, yyy, zzz;
for (yy = 0; yy <= height; yy++) {
yyy = (ushort)(y + yy);
tile = p.Level.GetBlock(x, z, yyy);
if (gothrough || tile == air || (yyy == y && tile == sap)) { p.Level.BlockChange(x, z, yyy, trunk, p); }
}
for (yy = top; yy <= height + 1; yy++) {
dist = yy > height - 1 ? (byte)1 : (byte)2;
for (xx = (short)-dist; xx <= dist; xx++) {
for (zz = (short)-dist; zz <= dist; zz++) {
xxx = (ushort)(x + xx);
zzz = (ushort)(z + zz);
yyy = (ushort)(y + yy);
tile = p.Level.GetBlock(xxx, zzz, yyy);
if ((xxx == x & zzz == z && yy <= height) || (!gothrough && tile != air)) { continue; }
if (Math.Abs(xx) == dist && Math.Abs(zz) == dist) {
if (yy > height) { continue; }
if (MathUtils.Random.Next(2) == 0) { p.Level.BlockChange(xxx, zzz, yyy, leaf, p); }
}
else { p.Level.BlockChange(xxx, zzz, yyy, leaf, p); }
}
}
}
p.Level.BlockChange(x, z, y, trunk, p);
}
#endregion
#region Swamp
if (type == TreeType.Swamp) {
byte dist,tile, height = (byte)MathUtils.Random.Next(4, 8), top = (byte)(height - 2);
short xx,yy,zz;
ushort xxx,yyy,zzz;
for (yy = 0; yy <= height; yy++) {
yyy = (ushort)(y + yy);
tile = p.Level.GetBlock(x, z, yyy);
if (gothrough || tile == air || (yyy == y && tile == sap)) { p.Level.BlockChange(x, z, yyy, trunk, p); }
}
for (yy = top; yy <= height + 1; yy++) {
dist = yy > height - 1 ? (byte)2 : (byte)3;
for (xx = (short)-dist; xx <= dist; xx++) {
for (zz = (short)-dist; zz <= dist; zz++) {
xxx = (ushort)(x + xx);
yyy = (ushort)(y + yy);
zzz = (ushort)(z + zz);
tile = p.Level.GetBlock(xxx, zzz, yyy);
if ((xxx == x && zzz == z && yy <= height) || (!gothrough && tile != air)) { continue; }
if (Math.Abs(xx) == dist && Math.Abs(zz) == dist) {
if (yy > height) { continue; }
if (MathUtils.Random.Next(2) == 0) { p.Level.BlockChange(xxx, zzz, yyy, leaf, p); }
}
else { p.Level.BlockChange(xxx, zzz, yyy, leaf, p); }
}
}
}
}
#endregion
#region Bush
if (type == TreeType.Bush) {
short top = (short)2;
ushort xxx, yyy, zzz;
for (ushort yy = 0; yy < 2; yy++) {
if (!gothrough && p.Level.GetBlock(x, z, (ushort)(y + yy)) != air && p.Level.GetBlock(x, z, (ushort)(y + yy)) != sap) { continue; }
p.Level.BlockChange(new Vector3D(x, z, y + yy), trunk);
}
int rand = MathUtils.Random.Next(2);
for (short xx = (short)-top; xx <= top; ++xx) {
for (short yy = rand == 0 ? (short)0 : (short)-top; yy <= top; ++yy) {
for (short zz = (short)-top; zz <= top; ++zz) {
short Dist = (short)(Math.Sqrt(xx * xx + yy * yy + zz * zz));
if (Dist < top + 1) {
if (MathUtils.Random.Next((int)(Dist)) < 2) {
try {
xxx = (ushort)(x + xx);
yyy = rand == 0 ? (ushort)(y + yy) : (ushort)(y + yy + 1);
zzz = (ushort)(z + zz);
if ((xxx != x || zzz != z || yy >= top - 1) && (gothrough || p.Level.GetBlock(xxx, zzz, yyy) == air)) { p.Level.BlockChange(new Vector3D(xxx, zzz, yyy), leaf); }
}
catch { }
}
}
}
}
}
p.Level.BlockChange(x, z, y, trunk, p);
}
#endregion
#region Pine
if (type == TreeType.Pine) {
byte height = (byte)MathUtils.Random.Next(6, 8), top = (byte)(height - 2), distance = (byte)2, tile;
short xx, yy, zz;
ushort xxx, yyy, zzz;
for (yy = 0; yy <= height; yy++) {
yyy = (ushort)(y + yy);
tile = p.Level.GetBlock(x, z, yyy);
if (gothrough || tile == air || (yyy == y && tile == sap)) { p.Level.BlockChange(x, z, yyy, trunk, p); }
}
for (yy = 0; yy <= (short)(height + 2); yy++) {
if (yy == 0) { continue; }
if (yy == 1 && MathUtils.Random.Next(2) == 1) { continue; }
if (yy == (height + 2)) {
if (MathUtils.Random.Next(2) == 1) { continue; }
p.Level.BlockChange(x, z, (ushort)(y + yy), leaf, p); continue;
}
distance = distance == 2 ? (byte)1 : (byte)2;
if ((ushort)(yy) >= height) { distance = 1; }
for (xx = (short)-distance; xx <= (short)distance; xx++) {
for (zz = (short)-distance; zz <= (short)distance; zz++) {
xxx = (ushort)(x + xx);
zzz = (ushort)(z + zz);
yyy = (ushort)(y + yy);
tile = p.Level.GetBlock(xxx, zzz, yyy);
if ((xxx == x & zzz == z && yy <= height) || (!gothrough && tile != air)) { continue; }
if (yy == height && height % 2 == 0) { continue; }
if (Math.Abs(xx) == (short)distance && Math.Abs(zz) == (short)distance) { continue; }
else { p.Level.BlockChange(xxx, zzz, yyy, leaf, p); }
}
}
}
}
#endregion
#region Cactus
if (type == TreeType.Cactus) {
byte height = (byte)MathUtils.Random.Next(3, 6);
ushort yy;
for (yy = 0; yy <= height; yy++) {
if (gothrough || p.Level.GetBlock((ushort)x,(ushort)z, (ushort)(y+yy)) == air) { p.Level.BlockChange(x, z, (ushort)(y + yy), green, p); }
}
int ix = 0, iz = 0;
switch (MathUtils.Random.Next(1, 3)) {
case 1: ix = -1; break;
case 2:
default: iz = -1; break;
}
for (yy = height; yy <= MathUtils.Random.Next(height + 2, height + 5); yy++) {
if (gothrough || p.Level.GetBlock(x + ix, z + iz, y + yy) == air) { p.Level.BlockChange((ushort)(x + ix), (ushort)(z + iz), (ushort)(y + yy), green, p); }
}
for (yy = height; yy <= MathUtils.Random.Next(height + 2, height + 5); yy++) {
if (gothrough || p.Level.GetBlock(x + ix, z + iz, y + yy) == air) { p.Level.BlockChange((ushort)(x - ix), (ushort)(z - iz), (ushort)(y + yy), green, p); }
}
}
#endregion
}
