
# The Active Developer: Blending Steps with Code

## Embracing Movement in the World of Code

The journey towards the 10,000 steps a day goal finds its roots in 1960s Japan, thanks to Dr. Yoshiro Hatano's research.
Initially a strategy to market pedometers, Dr. Hatano's findings illuminated the considerable health benefits tied to
this daily activity target. Over the decades, further studies have reinforced the importance of such physical engagement
for enhancing overall well-being.

In the realm of software engineering, where sedentary periods dominate, integrating this walking target can not only
boost health but also invigorate productivity and boost mental clarity.

For me, living in sunny San Diego has helped motivate me to get outside and walk every day, even if it's just for 30 
minutes or so. I hope I can help you do the same!

## Walking Towards Well-being and Innovation

The act of walking, particularly reaching the milestone of 10,000 steps daily, offers multifaceted benefits:

### Cardiovascular Health

Consistent walking is key in regulating blood pressure and strengthening heart health. Notably, a 2019 "JAMA" study
linked higher step counts to reduced mortality risk from all causes.

### Weight Management

As a natural weight control method, walking 10,000 steps can burn an estimated 400 to 500 calories, influenced by
individual factors such as pace and body mass.

### Mental Clarity

Physical activity, including walking, serves as a potent antidote to depression and anxiety, providing a necessary
mental break for software engineers amidst debugging and deadlines.

### Creative Sparks

Stanford University's research underscores walking's role in enhancing creative thought—crucial for engineers crafting
innovative solutions.

Personal experiences affirm that simple adjustments, like switching work positions, can rejuvenate focus and creativity.

## Striding Without Straying from Your Screen

Incorporating more steps into a developer's day requires creativity and a bit of strategy:

- **Scheduled Strolls**: Taking short walks during breaks, whether inside or outdoors, significantly contributes to your
  step tally. I find it really helpful to take these at a time of frustration or when you need to think through a
  problem.
- **Meetings in Motion**: Opt for walking meetings to boost steps and inspire creativity. This works well for meetings
  that won't involve screen sharing. However, this isn't always going to work.
- **Commute Creatively**: Whether it's part of your commute or choosing a farther parking spot, every step counts
  towards your daily goal.
- **Movement Reminders**: Use technology to your advantage with apps or smartwatches that remind you to move if you've
  been inactive.
- **Dynamic Desks**: Lastly and my personal favorite, a standing desk with a mini treadmill underneath. This setup makes
  achieving 10k steps in a day much easier. It's a bit of an investment and it takes some time to get used to typing while
  walking but in my opinion it's worth it.

## Navigating the Path to 10,000 Steps

Reaching a 10,000-step daily goal might seem formidable, especially for those juggling tight schedules or remote work.
However, setting realistic milestones and gradually increasing your step count can make this goal attainable.

Another thing I personally have found super helpful is using the Apple Health app to track steps. I put their widget on
the first page of my Iphone so that I am always thinking of it. 

<img src="/assets/blog/10k-steps/apple_health_widget.jpg" class="inline-image" style="border: 0;">

## The Step-Forward Mindset for Software Engineers

For software engineers, embarking on the 10,000-steps-a-day challenge is more than a health goal—it's a step towards
enhanced mental acuity, creativity, and overall job satisfaction. While the target might seem ambitious, starting with
smaller, achievable goals can lead to significant health and wellness benefits. The journey towards integrating movement
into a coding lifestyle is not just about the steps taken but the positive shifts in health, productivity, and
well-being that come with it.

Now get walkin!



The Active Developer: How to Walk 10,000 Steps a Day Without Leaving Your Code Behind


# Technical Dive into Procedural Room Generation and Connection in Maps

In this post, we explore the technical aspects of generating and connecting rooms procedurally within a map, a key
technique in game development and simulations to create dynamic and varied environments.

# Procedural Generation: An Overview

Procedural generation refers to the algorithmic creation of data with randomness, widely used for generating maps in
games. This method allows for a high degree of variability, ensuring that each map is unique. The core principle
involves using algorithms and randomness to layout elements like rooms, corridors, and obstacles.

Note: The matrix has three dimensions to it so we can denote depth in the map. Full definitions of helper functions can be found at the end of the page.

# Initializing the Map

The first step in our procedural generation process is initializing the map with a base tile, typically representing the
ground:

```python
def init_map(initial_tile=TILE_TYPES['Ground']):
  # initialize the map with 0 values
  matrix = np.full((MAP_SIZE, MAP_SIZE, MAP_DEPTH), 0)
  for x in range(MAP_SIZE):
    for y in range(MAP_SIZE):
      # place ground tile type on the entirety of the lowest "depth"
      place_tile(matrix, initial_tile, [y, x])
  return matrix
```

This function creates a 3D NumPy array representing our map, filling it with an initial tile type, ensuring we have a
starting point for adding more complex structures.

# Room Generation

Rooms are generated using the `create_rooms` function, which randomly determines their number, size, and position:

```python
def create_rooms(game_map, num_rooms, obstruction_tile, ground_tile, local_rand):
  # keep track of created rooms
  rooms = []
  for _ in range(num_rooms):
    rooms.append(create_room(game_map, local_rand, obstruction_tile))
  # remove walls that overlap w/ each other
  solve_room_overlap(game_map, rooms, ground_tile)

  # connect the rooms
  rooms = connect_rooms(game_map, rooms, obstruction_tile, ground_tile)
  return rooms
```

Each room is created and placed on the map ensuring it fits within the map boundaries. The `create_room` function is
responsible for the specifics of each room's dimensions and location.

# Handling Room Overlaps

<div>
The `solve_room_overlap` function addresses any overlaps between rooms, adjusting their positions or modifying walls to ensure each room is distinct. without these overlaps we would end up with many occurrences of rooms that look like so:
</div>
<div style="margin-bottom: 20px; text-align: center" class="img-bordered">
  <img style="width: 250px; height: 250px; margin: auto;" src="/assets/blog/procedural_maps/overlaps.png" class="img-bordered" alt="overlaps"/>
</div>

```python
def solve_room_overlap(game_map, rooms, tile_type):
  """for each room in rooms, check if overlap is present. if so, remove the overlapping sections of walls"""
  for i, room1 in enumerate(rooms):
    for room2 in rooms[i + 1:]:
      if rooms_overlap(room1, room2):
        remove_internal_walls(game_map, room1, room2, tile_type)

```

by removing the overlapping internal walls, we end up with something that makes sense

<div style="margin-bottom: 20px; text-align: center;">
<img style="width: 250px; height: 250px; margin: auto;" src="/assets/blog/procedural_maps/overlap_solved.png" class="img-bordered" alt="overlaps_solved"/>
</div>

# Connecting Rooms

The connect_rooms function weaves the rooms together by creating corridors or paths, making the map navigable:

```python
def connect_rooms(game_map, rooms, wall_tile, ground_tile):
  """for each room, find the closest room in rooms, then draw a line connecting each room's midpoint"""
  while len(rooms) > 1:
    room = rooms.pop(0)
    closest_room = find_closest_room(room, rooms)
    if closest_room:
      create_hallway(game_map, room, closest_room, wall_tile, ground_tile)
  return rooms
```

<div style="margin-top: 20px; text-align: center; display: flex; justify-content: center;">
    <img style="width: 250px; height: 250px; margin: auto;" src="/assets/blog/procedural_maps/connected_overlap_solved.png" class="img-bordered" alt="overlaps"/>
    <img style="width: 250px; height: 250px; margin: auto;" src="/assets/blog/procedural_maps/connected.png" class="img-bordered" alt="overlaps"/>
</div>

This function ensures each room is connected to at least one other room, using the create_hallway function to lay down
the paths.

# Conclusion

Through this technical exploration, we've seen how procedural generation can be harnessed to create complex and varied
map layouts with interconnected rooms. This process, from initialization to visualization, showcases the power of
algorithmic content creation in crafting immersive game environments.

This example barely scratches the surface of what we can do with simple techniques.

<blockquote style="margin-left: 15px; margin-right: 15px;">
  <i>Give me a lever long enough and a fulcrum on which to place it, and I shall move the world.</i>

&mdash; <i>Archimedes</i>

</blockquote>

# Helper Functions

```python
def place_tile(game_map, tile, p, lvl=0):
  """
  place the given tile at the given location
  """
  if p[0] < 0 or p[1] < 0:
    # return if out of bounds of map
    return
  try:
    game_map[*p, lvl] = tile
  except IndexError:
    pass


def create_room(game_map, local_rand, tile_type):
  # randomly place a room outlined by the provided tiletype
  width = local_rand.randint(4, 10)
  height = local_rand.randint(4, 10)

  start_x = local_rand.randint(0, MAP_SIZE - width)
  start_y = local_rand.randint(0, MAP_SIZE - height)

  for i in range(width):
    for j in range(height):
      x = start_x + i
      y = start_y + j
      if i == 0 or j == 0 or i == width - 1 or j == height - 1:
        place_tile(game_map, tile_type, [y, x])
  return start_x, start_y, width, height


def rooms_overlap(room1, room2):
  if isinstance(room1, list) and isinstance(room2, list) and isinstance(room1[0], list):
    # Both rooms are defined as lists of 4 points where each point is [y, x]
    # Extract the points
    tl1, tr1, br1, bl1 = room1
    tl2, tr2, br2, bl2 = room2

    # Check for overlap
    return (
      tl1[0] <= br2[0] and br1[0] >= tl2[0] and  # Check vertical overlap
      tl1[1] <= br2[1] and br1[1] >= tl2[1]  # Check horizontal overlap
    )
  else:
    # Unpack room parameters
    x1, y1, w1, h1 = room1
    x2, y2, w2, h2 = room2

    # Check for overlap
    return (x1 < x2 + w2 and x1 + w1 > x2 and
            y1 < y2 + h2 and y1 + h1 > y2)


def remove_internal_walls(game_map, room1, room2, tile_type):
  # Modify the walls of room1 and room2 that are internal after the overlap
  def modify_walls(start_x, start_y, width, height):
    for i in range(width):
      for j in range(height):
        if 0 < i < width - 1 and 0 < j < height - 1:
          x = start_x + i
          y = start_y + j
          place_tile(game_map, tile_type, [y, x])

  # Unpack room parameters
  modify_walls(*room1)
  modify_walls(*room2)


def find_closest_room(room, rooms):
  # Find the closest room to the given room
  closest_room = None
  room_vertices = get_room_vertices(room)
  for other_room in rooms:
    if rooms_overlap(room, other_room):
      continue
    other_room_vertices = get_room_vertices(other_room)

    # find min distance between vertices
    distances = []
    for point_1 in room_vertices:
      for point_2 in other_room_vertices:
        distances.append(abs(math.dist(point_1, point_2)))
    min_distance = min(*distances)

    # closer room has been found
    if not closest_room or min_distance < closest_room[0]:
      closest_room = [min_distance, other_room]
  if closest_room:
    return closest_room[1]
  return None


def create_hallway(room1, room2, wall_tile, ground_tile, game_map):
  # Assuming room format is (start_x, start_y, width, height)
  x1, y1, w1, h1 = room1
  x2, y2, w2, h2 = room2

  # Midpoints of the rooms
  mid_x1, mid_y1 = x1 + w1 // 2, y1 + h1 // 2
  mid_x2, mid_y2 = x2 + w2 // 2, y2 + h2 // 2

  # Decide the direction of the hallway (horizontal or vertical first)
  horizontal_first = abs(mid_x1 - mid_x2) > abs(mid_y1 - mid_y2)

  # Create the hallway
  if horizontal_first:
    # Create horizontal part
    for x in range(min(mid_x1, mid_x2), max(mid_x1, mid_x2) + 1):
      place_tile(game_map, ground_tile, [mid_y1, x])

    # Create vertical part
    for y in range(min(mid_y1, mid_y2), max(mid_y1, mid_y2) + 1):
      place_tile(game_map, ground_tile, [y, mid_x2])
  else:
    # Create vertical part
    for y in range(min(mid_y1, mid_y2), max(mid_y1, mid_y2) + 1):
      place_tile(game_map, ground_tile, [y, mid_x1])

    # Create horizontal part
    for x in range(min(mid_x1, mid_x2), max(mid_x1, mid_x2) + 1):
      place_tile(game_map, ground_tile, [mid_y2, x])

def get_room_vertices(room):
    # Unpack room parameters
    x1, y1, w1, h1 = room
    return [
        (x1, y1),            # top left
        (x1 + w1, y1),       # top right
        (x1 + w1, y1 + h1),  # bot right
        (x1, y1 + h1),       # bot left
    ]
```


Procedural Maps

### _"The intersection of technology and humanity is where magic happens. It’s not just about the code; it’s about how it touches lives."_ - Steve Jobs

If Steve Jobs believed in the harmonious blend of technology and humanity, 
then our story is no different. Our journey began with a simple idea: if we 
can make it, why not? Today, I want to share the story of four internal 
projects that began as ideas and transformed into tools that are not just 
efficient, but genuinely fun.



## MGMT2: Tracking, Efficiency, and a Bit of Bitcoin Magic
<div style="max-width: 450px;" class="img-bordered">
    <img src="/assets/images/articles/mgmt2.jpg">
</div>

Our passion lies in collecting achievements and milestones. MGMT2 is our 
tool designed to help our teammates track their achievements and, here's 
the cool part, their share of our Bitcoin treasure. Remember when we 
snagged some Bitcoin for our balance sheet? In about two years, that's 
going to be a delightful bonus for our team. Imagine making something as 
intangible as Bitcoin tangible for our employees. That's MGMT2 for you.

## GitHub Streak Tracker: Code, Commit, Repeat

<div class="img-bordered">
    <img src="/assets/images/articles/git-streak-tracker.jpg">
</div>

Seeing a growing GitHub streak is satisfying. With our 
[GitHub Streak Tracker](https://git-streak-tracker.herokuapp.com/), designed 
exclusively for iOS, you're not just encouraged to commit daily, but it 
becomes a part of your daily ritual. It's like having a personal 
cheerleader, reminding you of your coding journey and pushing you to 
achieve more.

## PropConnect.io: Simplifying Property Management

<div class="img-bordered">
    <img src="/assets/images/articles/propconnect.jpg">
</div>


Managing properties can be challenging. We created 
[PropConnect.io](https://propconnect.io/) to make property management 
a breeze. With direct text-based communication between tenants and vendors 
and comprehensive oversight, property managers can step back from the 
tedious tasks and focus on what truly matters: growing their portfolio 
or even just taking a well-deserved break.



## Brexyl: Monster Mayhem and Mischief in the Arena

<iframe 
  width="560" 
  height="315" 
  src="https://streamable.com/e/pp7rnm"
  frameborder="0"
  allowfullscreen></iframe>

Dive into an adrenaline-pumping arena where strategy meets action. Brexyl 
is our take on the game dynamics similar to Minion Masters. Spawn monsters 
from the cards you draw and watch them battle in an arena. Protect your main 
building, or it's game over. And if you're in the mood for some playful 
teasing, drop a giant "7" on your opponent. It might do nothing, but the 
laughs you get are priceless!

For this project we're using [Godot 4.1](https://godotengine.org/), a free and
open source game engine. It's a great tool for creating 2D and 3D games
and has a very active community. We've also chosen to leverage .NET
with Godot's C# support.

### Wrapping Up

Innovation doesn't always begin in a boardroom. Sometimes, it starts with a 
simple idea or a desire to make things better. If you're looking to create 
something groundbreaking or something that resonates with people - reach 
out to us. We're always ready for the next big challenge.

Having fun: Our internal projects

<br></br>
<div style="width: 100%; text-align: center;">
  <a href="https://reactnative.dev/">
      <img 
        src="/assets/blog/futuristic_ckc_building.png" 
        alt="CKC Building" 
        style="border: 0; border-radius: 0; margin: 0 auto;"
      >
  </a>
</div>

Nestled in the scenic beauty of Coeur d'Alene, Idaho, our app development company 
has been thriving since 2012. We are a team of passionate developers, designers, 
and innovators who love what we do and where we do it from.




<div style="width: 100%; text-align: center;">
  <a href="https://reactnative.dev/">
      <img src="/assets/blog/react_native_header_logo.svg" alt="React Native" style="max-width: 320px; border: 0; margin: 0 auto;">
  </a>
</div>


## Our Love for React Native

Our love for [React Native](https://reactnative.dev/) is no secret. This open-source 
mobile application framework has been our go-to tool for creating most of our 
applications. We've even developed our own base project, lovingly named 
[Skeletor](https://github.com/ckc-org/skeletor), which serves as the backbone for 
many of our projects. Skeletor allows us to streamline our process and deliver 
high-quality applications to our clients.

## Evolution into Game Development

While we started as an app development company, our passion for creating engaging 
experiences has led us to venture into the realm of game development. We've had 
the opportunity to work on a variety of exciting projects, each one pushing our 
creative and technical boundaries.

## VR Skydiving Simulator

One of our notable projects is a VR Skydiving simulator, available on 
[Oculus](https://www.oculus.com/experiences/rift/2552134034912884/). This game 
was developed by one of our engineers, an ex-NASA intern, who built a whole 
physics engine for the simulator. The result is an incredibly immersive experience 
that gives users the adrenaline rush of skydiving without leaving the ground. 
This project showcases our commitment to creating user-centric experiences that 
push the boundaries of technology.

## MacroAir Project

<div style="width: 100%; text-align: center;">
  <a href="https://reactnative.dev/">
      <img 
        src="/assets/blog/macroair_airviz_modeler.png" 
        alt="MacroAir Airviz Modeler" 
        style="border: 0; border-radius: 0; margin: 0 auto;"
      >
  </a>
</div>

Another project we're proud of is MacroAir, a tool for visualizing fan air movement. 
We're using [Babylon.JS](https://www.babylonjs.com/), a powerful, beautiful, 
simple, and open 3D engine, to create an awesome 3D modeler in JavaScript. 
This project is a testament to our ability to leverage cutting-edge technology 
to solve real-world problems and deliver value to our clients.

## Twitch-Integrated Godot Game

One of our ongoing projects is a Twitch-integrated game developed in 
[Godot](https://godotengine.org/). This project is a testament to our commitment 
to innovation and our desire to create games that not only entertain but also 
engage the community in new and exciting ways.

## Our Latest Project: A Cat Roleplaying Game

Our latest venture is a cat roleplaying game that we're incredibly excited about. 
This project, [Paw Borough](https://www.pawborough.net/), allows us to combine 
our love for gaming with our love for our feline friends. 

We've made significant optimizations in our cat generation process, improving from 
generating one cat per second to a hundred cats per second. This means we're able 
to generate around 10 million cats per day on a single processor! 

This wasn't an easy task, but we believe in doing things that are important, 
even if the odds are not in our favor. We're working hard to create a game 
that is not only fun to play but also captures the quirky and lovable nature of cats. 

We're proud to share that Paw Borough was funded for approximately $90k on 
[Kickstarter](https://www.kickstarter.com/projects/tbpt/paw-borough-the-feline-virtual-browser-rpg)! 
This is a testament to the support and love we've received from our community.

## Conclusion

From our humble beginnings in Coeur d'Alene to our expansion into San Diego and 
Spokane, our journey has been nothing short of exciting. We've evolved from an 
app development company into a game development company, and we can't wait to 
see what the future holds. 

We're grateful for the opportunities we've had to work on such diverse projects 
and are excited to continue creating unique and engaging experiences for our users. 
Our approach has always been to deliver first and then iterate, because we believe 
that done is better than perfect. 

We're a team of badass developers growing year-over-year, and we're just getting started.

The Active Developer: How to Walk 10,000 Steps a Day Without Leaving Your Code Behind

The Active Developer: Blending Steps with Code...

Procedural Maps

Procedural Maps

Having fun: Our internal projects

Having fun: Our internal projects

From the Heart of Coeur d'Alene: The Journey of an App Development Company

From the Heart of Coeur d'Alene: The Journey of an App Development Company