alysbrooks-public/games/isometric-park-fna Commit - r522:07e6179554d0

alysbrooks-public » games » isometric-park-fna

Commit `r522:07e6179554d0` public

parent | child

Description:

Update Cell to follow C# convention while I'm here.

Commit status:

[Not Reviewed]

References:

m6-tiles-and-trees

Diff options:

| |

Comments:

0 Commit comments 0 Inline Comments

Unresolved TODOs:

There are no unresolved TODOs

Add another comment

r522:07e6179554d0 - Sat, 22 Jan 2022 23:47:09

isometric-park-fna/CellMap.cs ¶ +15 -16

                          {
                              foreach (Cell cell in row)
                              {
-                                 if (cell.hasTree)
+                                 if (cell.HasTree)
                                  {
                                      yield return cell;
                                  }
                          {
                              foreach (Cell cell in row)
                              {
-                                 if (cell.hasTree)
+                                 if (cell.HasTree)
                                  {
                                      yield return cell;
                                  }
                          int count = 0;
                          foreach (Cell neighbor in this.iterate_neighbors(x, y))
                          {
-                             if (neighbor.hasTree) {
+                             if (neighbor.HasTree) {
                                  count++;
                              }
                          }
                      public class Cell
                      {
-                         // public Boolean _hasTree = false;
-                         public CellStatus status {
+                         public CellStatus Status {
                              get;
                              private set;
                          }
                          public String StatusAdjective {
                              get {
-                                 return this.status.ToString().Replace("Tree", "");
+                                 return this.Status.ToString().Replace("Tree", "");
                              }
                          }
                              }
                          }
-                         public Boolean hasTree {
+                         public Boolean HasTree {
                              get {
-                                 return this.status == CellStatus.LivingTree;
+                                 return this.Status == CellStatus.LivingTree;
                              }
                          }
-                         public DateTime planted;
+                         public DateTime Planted;
-                         public void addTree(DateTime datetime, TreeType type) {
-                             this.status = CellStatus.LivingTree;
+                         public void AddTree(DateTime datetime, TreeType type) {
+                             this.Status = CellStatus.LivingTree;
-                             this.planted = datetime;
+                             this.Planted = datetime;
                              this.Type = type;
                          }
-                         public void removeTree() {
-                             this.status = CellStatus.Clear;
+                         public void RemoveTree() {
+                             this.Status = CellStatus.Clear;
                          }
-                         public void markTreeDead() {
-                             this.status = CellStatus.DeadTree;
+                         public void MarkTreeDead() {
+                             this.Status = CellStatus.DeadTree;
                          }
                      }
                  }

isometric-park-fna/Engines/SimulationBridgeEngine.cs ¶ +4 -4

                                      var squares = HasComponent<AreaComponent>(entity) ? GetComponent<AreaComponent>(entity).squares : this.all_squares;
                                      var removed = 0;
                                      var added = 0;
-                                     var tree_squares = squares.Where((square) => simulation.map.cells[(int)square.X][(int)square.Y].hasTree);
+                                     var tree_squares = squares.Where((square) => simulation.map.cells[(int)square.X][(int)square.Y].HasTree);
                                      var to_remove = Math.Abs(delta.deltaTrees.Value);
                                      //calculate the probability in order to get the expected number of removed trees
                                      foreach (var square in tree_squares)
                                      {
                                          var cell = simulation.map.cells[(int)square.X][(int)square.Y];
-                                         if (cell.hasTree
+                                         if (cell.HasTree
                                                  && random_generator.NextDouble() < probability)
                                          {
                                              if (delta.deltaTrees.Value < 0)
                                              {
-                                                 cell.removeTree();
+                                                 cell.RemoveTree();
                                                  removed++;
                                              }
                                              else if (delta.deltaTrees.Value > 0)
                                              {
              				    var random_type = random_generator.Next(0, 1);
-                                                 cell.addTree(this.simulation.DateTime, (CellMap.TreeType)random_type);
+                                                 cell.AddTree(this.simulation.DateTime, (CellMap.TreeType)random_type);
                                                  added++;
                                              }
                                          }

isometric-park-fna/Engines/Spawners/GameSpawner.cs ¶ +1 -1

              			int random_type = random_generator.Next(0, 2);
-                                     cell.addTree(random_date, (TreeType)random_type);
+                                     cell.AddTree(random_date, (TreeType)random_type);
                                  }
                              }
                          }

isometric-park-fna/FNAGame.cs ¶ +4 -4

                              {
                                  for (int j = 0; j < this.simulation.map.MapWidth; j += 1)
                                  {
-                                     if (this.simulation.map.cells[i][j].hasTree)
+                                     if (this.simulation.map.cells[i][j].HasTree)
                                      {   //until we actually simulate:
                                          if (this.simulation.map.cells[i][j].Type == TreeType.GenericDeciduous) {
                                          drawTileAt(i, j, 142, 2);
                                          //     drawTileAt(i, j, 142, 2);
                                          // }
                                      }
-                                     else if (this.simulation.map.cells[i][j].status == CellStatus.DeadTree) {
+                                     else if (this.simulation.map.cells[i][j].Status == CellStatus.DeadTree) {
                                          drawTileAt(i, j, 141, 2);
                                          // System.Console.WriteLine(String.Format("Drew Dead Tree at {0},{1}", i, j));
                                      }
                          if (MathUtils.BetweenExclusive(this.mouseGrid.X, 0, this.squaresAcross)
                                  && MathUtils.BetweenExclusive(this.mouseGrid.Y, 0, this.squaresAcross))
                          {
-                             has_tree = this.simulation.map.cells[(int)this.mouseGrid.X][(int)this.mouseGrid.Y].hasTree;
+                             has_tree = this.simulation.map.cells[(int)this.mouseGrid.X][(int)this.mouseGrid.Y].HasTree;
                          }
                          String status_left = "";
                          if (MathUtils.BetweenExclusive(this.mouseGrid.X, -1, this.simulation.map.MapWidth)
                                  && MathUtils.BetweenExclusive(this.mouseGrid.Y, -1, this.simulation.map.MapHeight))
                          {
-                             var treeStatus = this.simulation.map.cells[(int)this.mouseGrid.X][(int)this.mouseGrid.Y].status;
+                             var treeStatus = this.simulation.map.cells[(int)this.mouseGrid.X][(int)this.mouseGrid.Y].Status;
                              var treeStatusAdjective = this.simulation.map.cells[(int)this.mouseGrid.X][(int)this.mouseGrid.Y].StatusAdjective;
                              var treeType = this.simulation.map.cells[(int)this.mouseGrid.X][(int)this.mouseGrid.Y].TypeName;
                              if (treeStatus != CellStatus.Clear)

isometric-park-fna/Simulation.cs ¶ +12 -12

                      public int crowded_trees
                      {
                          get {
-                             return this.map.iterate_cells_with_neighbors(7).Where(c => c.hasTree).Count();
+                             return this.map.iterate_cells_with_neighbors(7).Where(c => c.HasTree).Count();
                          }
                      }
                      public int dead_trees
                      {
                          get {
-                             return this.map.iterate_cells().Where(c => (c.status == CellStatus.DeadTree)).Count();
+                             return this.map.iterate_cells().Where(c => (c.Status == CellStatus.DeadTree)).Count();
                          }
                      }
                      public float healthy_percent
                      {
                          get {
-                             return (float)(this.map.tree_count - this.map.iterate_cells_with_neighbors(7).Where(c => c.hasTree).Count()) / this.map.tree_count * 100;
+                             return (float)(this.map.tree_count - this.map.iterate_cells_with_neighbors(7).Where(c => c.HasTree).Count()) / this.map.tree_count * 100;
                          }
                      }
                      {
                          get
                          {
-                             return this.map.iterate_cells().Where(c => c.hasTree).Select(c => (this.DateTime - c.planted).Days / 365.0).Average();
+                             return this.map.iterate_cells().Where(c => c.HasTree).Select(c => (this.DateTime - c.Planted).Days / 365.0).Average();
                          }
                      }
                      {
                          get
                          {
-                             return this.map.iterate_cells().Where(c => c.hasTree).Select(c => (this.DateTime - c.planted).Days / 365.0).Max();
+                             return this.map.iterate_cells().Where(c => c.HasTree).Select(c => (this.DateTime - c.Planted).Days / 365.0).Max();
                          }
                      }
                              if (random.NextDouble() > SPONTANEOUS_NEW_TREE_CHANCE)
                              {
                                  var random_type = random.Next(0, 2);
-                                 cell.addTree(this.DateTime, (TreeType)random_type);
+                                 cell.AddTree(this.DateTime, (TreeType)random_type);
                              }
                          }
                              if (random.NextDouble() > NEIGHBOR_NEW_TREE_CHANCE)
                              {
                                  var random_type = random.Next(0, 2);
-                                 cell.addTree(this.DateTime, (TreeType)random_type);
+                                 cell.AddTree(this.DateTime, (TreeType)random_type);
                                  new_planted += 1;
                              }
                          }
                          {
                              if (random.NextDouble() > NEIGHBOR_CROWDS_TREE_CHANCE)
                              {
-                                 cell.markTreeDead();
+                                 cell.MarkTreeDead();
                                  crowded_out += 1;
                              }
                          }
                              int x = random.Next(0, this.map.MapWidth);
                              Cell chosen_cell = this.map.cells[x][y];
-                             if (!chosen_cell.hasTree) {
+                             if (!chosen_cell.HasTree) {
                                  var random_type = random.Next(0, 2);
-                                 chosen_cell.addTree(this.DateTime, (TreeType)random_type);
+                                 chosen_cell.AddTree(this.DateTime, (TreeType)random_type);
                                  trees_to_plant -= 1;
                              }
                          }
                          int trees_to_clear = this.tree_clearing;
-                         foreach (Cell cell in this.map.iterate_cells_with_neighbors(7).Where(c => c.hasTree))
+                         foreach (Cell cell in this.map.iterate_cells_with_neighbors(7).Where(c => c.HasTree))
                          {
                              if (trees_to_clear > 0) {
-                                 cell.removeTree();
                                  trees_to_clear -= 1;
+                                 cell.RemoveTree();
                              }
                          }

Write
Preview

You need to be logged in to leave comments. Login now

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository permissions settings

Sign in to your account

Author

r522:07e6179554d0 - Sat, 22 Jan 2022 23:47:09

Sign in to your account

Commit r522:07e6179554d0 public

Author

r522:07e6179554d0 - Sat, 22 Jan 2022 23:47:09

Commit `r522:07e6179554d0` public