kerbaljeb / icarus Goto Github PK

Add support for functional tiles, starting with engines.

• Create an extendable framework that allows these tiles to be placed over structural tiles
• Each functional class should be able to load specific tile stats from JSON files
• Adding a new class should only need a minimum amount of code modification (ie. only register it in one place)
• Engine tiles should move the ship tile object by interacting with the ship's flight model system

Create a basic camera controller that allows for panning and zooming (look into using cinema cam). Also try to add zoom to map functionality, where if the user zooms out far enough the ships and other objects will be replaced with a more abstract map.

Camera
The camera controller should be able to:

• Zoom
• Pan
• Track target
• Focus on ship

Ship Control

• The player should be able to own multiple ships/ship fragments
• Double-clicking a ship should bring it under the player's direct control (assuming they own it)
• Player should only directly control one ship at a time
• Allow the player to issue high-level orders (ex. move to, attacked etc) with mouse clicks/drags

Provide some base code that can be expand to handle all server/client interactions.

Start by creating a demo that:

• The client should be able to move a block using arrow keys
• Multiple clients should be able to connect to the server
• All connected clients should be able to see the blocks from the other connected clients

Basically, a multiplayer game that lets players move blocks around. The Server/Client code should be easily extendable to handle more/different data.

Add the ability to save and load ships and games from the disk.

Ships

• Add a method to the tile manager to serialize the variant IDs of the currently stored tiles to a JSON File
• Add a method to the tile manager to update its internal data from a JSON file

Game

• Add a way to keep track of changes made to the map (damage, moved position/velocity)
• Add a method to serialize all of the information about the state of the game to a JSON file (position, velocity, damage)
• Add a method to deserialize all the info from the JSON file into a game scene
• Add a main menu that allows for saved games to be loaded

Expand the tile system to include weapons and create a flexible damage system.

Damage System

• Virtual Base Damage class with and 'apply damage' virtual method, that will apply damage to a tilemap
• Create a general damage class that will apply it's damage to a cell and if the cell is destroyed apply the remaining damage to the cell behind it

Weapons

• Create a weapons tile variant that has the following properties (or others if they make more sense)
  • Weapon range/damage falloff
  • Base damage
  • Fire rate
  • Projetile speed
• Create a weapons manager that can
  • Get all weapons from a tile manager
  • Manage targeting objects and firing weapons
  • Apply damage to the target (or tell the target to apply damage to its self)
• Create the following weapon variants
  • Rail gun (high damage, high range, hit scan, low fire rate)
  • Lasers (Low damage, med range, hit scan, continuous fire)
  • Auotcannons (Medium to high damage, short-range, high fire rate)

Develop an algorithm to procedurally generate maps for the game. This could be randomly dispersing planets/asteroids throughout the map or something more elaborate (could try to make is semi realistic or a more artistic interpretation).

Main requirements:

• All 'terrain' must be block based (ie. an asteroid would be a bunch of blocks grouped into a potato shape)
• Must generate the map based on a 'seed' (so generation is repeatable)

Make tiles damageable and create different classes of tiles with different stats.

• Damage tile(s) at a given location
• Load stats and textures from a json file
• Handle tile destruction and maybe deformation
• System should also allow for non structural tiles (ie. tiles with some functionality)
• Make a tile grid split into multiple objects if connecting tiles are destroyed
• Add ability to find the COM of a tile grid

Adds basic flight physic for a space ship, considering engine placement and power.

Sometimes the COM of mass is incorrectly calculated when a tilemap is split. Look at the Split function in the TileManger class.

Update the Shipbuilder to:

• Preview tiles before placed
• Tools for drawing lines and boxes
• Saving and loading of ship designs
• Pan and zoom camera
• Rotate parts while placing them
• Delete tiles with a hotkey (highlight red)
• Constrain window movement

Create AI enemies that are capable of moving and fighting the player.

NPCs

• Create several preset ship designs for NPCs

Movement

• https://natureofcode.com/book/chapter-6-autonomous-agents/

• http://www.red3d.com/cwr/steer/

• Get NPCs to be able to follow the player or move to a set point

• Should have idle behaviour, moving around within an area, when the player is not nearby

Combat

• NPCs should be able to fire weapons at the player

• Neutral NPCs should begin attacking the player if the player has attacked them

• Allied NPCs should assist the player in combat

Create a system that allows the user to place blocks on a grid.

The system must:

• Only use one gameobject for the whole grid
• Store data about each block (type, health, ect. - Should be extendable)
• Allow users to delete blocks
• Whole assembly (gameobject) should move as a single unit
• Provide an interface to set the data for each block
• Generate colliders

To Do:

• Create Rough Tileset
• Basic grid class
• Handle rotation and translation
• Get mouse presses
• Render Meshes based on grid class
• Delete/Add Blocks
• Collision Detection
• Test
• Document