Concept:

Sim-Ants / DigDug style game created in a large disk, mario-galaxy style world. -Decided to go with a grid for now, sphere math was taking way too long.

Both red and black ants will share the same underground world

Initially the game will focus more on the under-ground aspect and building an impenetrable ant-cave and focus less on the above ground aspects.

Development process, Asterisk indicates complete:

*1. Create the 2D underground world.

- 2d
- destructable, player
- basic types:
```
  -Dirt
```
```
  -Empty
```
```
  -Surface
```
```
  -Barrier
```

*2. Create basics

- Player
- Ants
- Basic AI
- Camera following
- Player control
```
  - D-Pad
```

  - Touch, simple (broke this after I made the surface.

/ - Touch, dijkstra

*3. Create surface world

- Link to underground
- Objects (Rocks, Food), carryable by Player / Ants
- Object spawns (food on surface).

*4. Basic ant functions

- hp / death / not sure for now - extended statistics (not sure what these are)
- Food / Eating
- Pickup / Drop logic (i.e. stacks of food)
- Queen / Egg production
- Egg / Hatch (i.e. Game loop that checks underground for growing eggs.)
- Collision detection (Grid, patch knows when ant is on it
- Patch feramone level
- optional display of feramone level (make a bool that toggles if this is displayed or not).

A.I.
- Ant action AI's:

  -Wander
= limit number of turns the ant can make?

  -Queen, egg production
  -Forage
= ant prefers stronger chemical trail
= chemical trail deteriorates over time

  -Attack (patch knows who is on it, if red + black ant, fight).
  -Defend
  -Follow (player, etc?)
  -???

Tunnel design

```
  -simple/random
  -more interesting?
```

Gameplay,
- Enemy Creatures
  - spider
  - worm
  - pill bug
  - pit bug
- Enemy Events
  - foot
  - lawnmower
- Ant Types / stats / AI
  - Worker
  - Breeder
  - Soldiers
  - Queen
- Scores
- Ant combat.
- Win conditions
- levels
Polish
- Terrain themes / textures (outdoors, patio, kitchen, leg, etc)
- Object models: -dirt -barriers -???
- Sound Effects
- Background Music
Wants
- 3D surface (tiles have a height)
  - this would require an extra rotation for objects drawn on the surface, so that they are parallel to the ground.
- 3D surface objects -grass that goes up into camera -rocks that join with adjacent rocks to make a big rock.

NOTE: The below was determined to be too much work for too little reward, the effect was not as impressive as hoped for so it was scraped for a plain old 2D array rendered on a 3D plane.

Underground world data structure.

The world is a flat donut, with an unpassable "rock" core at the bottom. The donut is broken down into SLICES. A slice is a logical entity which can be loaded in parts. Slices are stitched together to adjacent slices Each slice is loaded in entirety in such a way that only 2 slices need to be loaded at once for display purposes. Each slice is a 2D array. It does not taper out towards the bottom, as the bottom is "rock" it can be spoofed.

Each slice is broken down into squares which can be: -dirt (clearable) -cleared (walkable, objects may be placed, can be buried) -unpassable (i.e. rock)

DSAnts

Install / Use

README

NOTE: The below was determined to be too much work for too little reward, the effect was not as impressive as hoped for so it was scraped for a plain old 2D array rendered on a 3D plane.