flags / reactor-3 Goto Github PK

Some key things to remember:

• Overall "health" is determined by the collective status of all limbs combined.
• Severe damage to vital limbs is fatal, regardless of overall health.
• The removal/damage of non-vital limbs can still be fatal if not handled properly (bleeding not stopped, etc.)
• The healing of certain injuries involves using specific items, like a bandage to stop bleeding or pair of pliers to remove a bullet.

See title.

Items should be grouped under what container they are in.

Should the items being worn show up on this screen also? If so, where?

After two or three entries, lines begin to disappear before finally reappearing.

Freshly created maps via maps.create_map() suffer no drop in FPS, while the same map loaded from disk runs 10-15 frames slower.

Thoughts: The render_map() function could be rewritten in Cython if needed, but it is clear there is some trickery happening in load_map().

Replace all print statements with calls to logging.

For use in action delays.

Since it's possible to log character-specific events, NPC dialog can be procedurally generated.

Ex.: "I recently had a terrible fall and bruised my legs!"

1. Have a backpack
2. Pick up a pair of shoes and a t-shirt
3. Check equip screen (you should see both the shoes and t-shirt)
4. Drop the backpack
5. The shoes are gone but the t-shirt remains

Happens regardless of what the items are.

Create a function that grabs the actual pain a limb is causing, taking pain tolerance, either adjusted or artificial (via meds), into account.

1. Have backpack, wear t-shirt
2. Pick up t-shirt, place in backpack
3. Take off t-shirt, drop
4. Wear t-shirt in backpack
5. Drop backpack

The current way of creating menus does not allow us the amount of control needed to display more complicated menus. The following changes are proposed:

• Adding a default "MENU_ITEM" dictionary that holds all data for menu items. Keys would include:
  • icon (optional)
  • menu index (where on the menu?)
  • key
  • values
• A better way to handle ACTIVE_MENU, or at least a way to get and change ACTIVE_MENU values without changing them directly

1. Place some items in a backback
2. Open equip menu to see items, close it
3. Take off backpack
4. Equip backpack from ground
5. Open equip menu, items from backpack are missing
6. Open inventory screen

I have no idea what is causing this crash. I have a feeling it involves the items not being added in from the pickupitem action.

It should also be noted that the crash can happen in different places, but the same general method is used.

Dependencies, supported Python versions, Cython...

Character backgrounds...?

Functions in graphics.py, like draw_menus(), should be moved to their related modules (menus.py in this case.)

Two things need to be done:

1. Automatically compiling Cython modules on able machines.
2. A way to track what version a Cython module is, so it can be recompiled when it is outdated.

Number 2 can be avoided if the compilation is done every run. Otherwise the check needs to be done via some kind of variable (VERSION, for example.)

When picking up items, give the player a choice between:

1. Pick up and sort (5 ticks)
2. Pick up quickly (2 ticks)

Item removal feels muddy at best.

For example, life.remove_item_from_inventory needs serious examination to determine if it's the best plan of attack in terms of actually doing what it says it does. Bits like _holding['holding'].remove(id) say a lot, as they access the limb's data without going to another function first, which might be okay...?

That said, the function is a good solution if you just want an item gone. That alone might make up for its shortcomings.

On item removal, delete any references to the item in menu/action entries.

Since they are each on a surface, should we only draw them once?

Self-explanatory.

To make it easier to draw in 3D.

...or maybe it's a feature?

Current body-part system is over-complicated and slow.

Simply store all body parts in one key (body) and rewrite all limb-related functions in life.py.

Containers can currently hold an infinite amount.

Not entirely sure if this will speed things up or not.

1. Would the Cython-compiled render_map be sped up?
2. The pure Python implementation should see a speed increase (iterator vs. look-up.)

Doc strings!

When referring to inventory items in argument names, use id. If the item is being addressed directly, use item.

Double check to make sure container capacities are telling the truth about their size. All functions related to adding/removing items from containers should be handled, but just in case...

When an item is inside a backpack and the backpack is dropped, the item keeps its ID. Will this give us an issue in the future?

For portability, all graphics calls should be wrapped into functions that then point to library-specific draw calls. Benchmark.

Swing over to move_camera(pos).

Currently it is difficult to display messages as a result of the player's action. For example, printing "you picked up a..." in the message box involves wrapping the functions related to picking up and storing items and making calls to gfx.message. This makes attaching the player's input to the action system difficult.

Solution would be to create a logging-like function for tracking the movement of every character, then having only player-related ones print to the message window.

Create an item spawner that randomly selects and places X number of items from a list on the map in a user-specified radius. This should only happen once (with new games.)

Read from menu['index'] instead.

1. Put on t-shirt
2. Put on backpack over t-shirt
3. You can take the t-shirt off without taking the backpack off

Items are stored in order, so it'd be a simple iteration through the equipped items on that part of the body. Putting those items back on is a different story.

Allow the map maker to place both individual or random tiles from a group.

Zombies will resurrect on death 2 or 3 times, finally dying (for good) on the the last one.

The item's position is not updated when held.

1. Drop item
2. Pick up and hold item
3. Move somewhere else on the map
4. Throw item

There should be a way to view strips of land from the side.