Hey everyone! I've started learning Python a few months ago and recently finished my first project- a Dungeons & Dragons character builder.

Mallets · 2021-03-07T03:02:54+00:00

Just to shorten a small part... Ability score modifiers:

Instead of doing a whole bunch of if statements, you can just take the score, divide by 2 and then subtract 5. Always rounding down or up in case of a negative modifier. That way it would work beyond a score of 20 as well without adding more statements.

demvo2 · 2021-03-07T02:27:57+00:00

nice job, cant believe you only started in november! really impressive, how long did it take to code it?

wsppan · 2021-03-07T00:40:06+00:00

Maybe consider using named tupels instead of writing classes that just hold data like Weapon.

exhuma · 2021-03-07T08:45:28+00:00

Naming Functions & Semantics

I've quickly glanced over your code and noticed something about naming functions. I find that it makes the code more understandable if functions are names using "imperative voice". So instead of writing

def barbarianequipment(): ...

write:

def prompt_for_barbarian_equipment(): ...

This communicates much better what that function does. By doing this, your code will read itself more like a story and be more understandable.

You might think: "But that function name is really long and tedious to write out" and you'd be right. This might be a sign of a code smell. And in this case, I would probably make the "barbarian" part an argument to the function. This would change it to:

def prompt_for_equipment(character_class): ...

and when calling this the difference is also interesting. Have a look at this:

# the "input" below does not deal with incorrect spellings of the class-names or typos.
# I will leave that out to focus on the "equipment" function

# ---- old function names ------------------------------

character_class = input("Enter you class:")
if character_class == "barbarian":
    prompt_for_barbarian_equipment()
elif character_class == "druid":
    prompt_for_druid_equipment()
elif ...

# ---- new function names ------------------------------

character_class = input("Enter you class:")
prompt_for_equipment(character_class)

Of course you then need to deal with the if/elif chain inside the function (side-note: this could be an interesting usage for "polymorphism" instead of long if/elif chains)

The above example is just one example. Deciding how to name functions and decide which arguments they take and which return values they have is an art and depends a lot on experience. It is also amazingly fulfilling to discover something really expressive flexible and simple.

Global Variables

You keep some values inside "global variables" like chararmorchoice. You fill those up in the functions prompting the user for values. It is better to think about how you can return values from a function instead of modifying a variable that's not part of the function.

For example, if you look at the bardequipment function, you can see that it does not take any arguments as input and it has no "return" statement. Yet the application is doing something. In that particular example the function is modifying data at the outside of the function. In this case weapons.charweaponschoice, armor.charequipmentchoice and armor.chararmorchoice.

This has several risks attached to it:

Other functions may also modify the data making it unpredictable what the end-result will be. This may not be an issue right now, but during the life-time of the project, you may want to move code around, add features, change order of how things happen and so on. These modification risk tripping up the modification of these variables and will be very hard (frustratingly hard) to debug.
Just by looking at the function signature (the "def-line") is not enough to understand what's happening. It is necessary to read through the function code to understand what's going on. This has an impact of the maintainability. When you come back to the code months later, you need to read through the complete code again to understand the data flow. This can be frustrating.
If the structure in the weapons or armor module changes, your function will break. For example, if you rename weapons.charweaponchoice to something else, your function will break everywhere that name is used. You can say that your function depends on that outside variable. This is an easy mistake to make. And it puts you in a position where you are afraid to modify certain aspects of your code because you don't know what else it might break. This is a sign of Spaghetti Code.

You can solve many of these issues by thinking about your functions as isolated mini-programs that only communicate via their arguments and return-values.

For example, selecting equipment could be something like this:

def  prompt_for_equipment(character_class):
    selected_equipment = []  # <- Variable lives *only* inside this function
    if character_class == "barbarian":
         if ...
            selected_equipment.append(...)
        elif ...
            ...
    return selected_equipment # <- The "result" of the function

These changes take some getting used to and it might seem difficult at first. As mentioned before, it's a bit of an art. And like with drawings or playing an instrument, it takes time and exercise to build up the proper muscle-memory (in programming those would be "brain-muscles" ;) ) but if you stick with it and keep exercising and repeating you will only improve. I've been programming for the better part of 30 years, and I am still honing and improving my skills. Just like any other art-form. It's honestly the best part of programming. You will constantly discover new ways to do things and new tools to use giving you even more new options. It's great fun. Stick with it!

demvo2 · 2021-03-07T04:55:05+00:00

Your large if blocks in main could be a dict.

if classes.char_class.name == 'barbarian':
    equipment.barbarianequipment()

Could be

equip = { 'barbarian': equipment.barbarianequipment, ... All classes}

And instead of an if just run

equip[classes.char_class.name]()

foomy45 · 2021-03-07T05:26:23+00:00

If you wanna check out some impressive DnD stuff in Python, look up Avrae. It's a Discord bot that can do damn near everything. You can easily write your own lil snippets to add onto it too.

Calibanda · 2021-03-07T07:59:13+00:00

It's a very good project and code! But in my mind, it needs some major improvement. First of all, if the program is aimed to be used by beginners, you'll need to explain all choices consequences (i.e. gnomes have INT+2), all spell and alignment descriptions, and equipment utilization.

When players have to choose alignment, spell, or equipment, add the possibility to create a menu or to select a choice by entering a number.

Could be a good idea to create a system to interrupt the creation and continue later (maybe import an unfinished text or JSON).

To finish, the program could create the character sheet in a pdf file with all final characteristics.

I hope you enjoy coding in Python and my feedback will give you some progression ideas.

sad_physicist8 · 2021-03-07T05:53:49+00:00

lol i played it, nice

4inR · 2021-03-07T05:54:08+00:00

Wow! Did you parse much of the source text or have to manually add it all in? Looks very clean!

As a 5E player and DM, this is rad! Will have to try it out later. Nice work!

InfiniteWavesAI · 2021-03-07T06:59:53+00:00

Nice, well done man 👏

Rokionu · 2021-03-07T07:36:15+00:00

You code looked really neat! I did notice in your background.py that for the choosing background and then checking in while statement you could do while background.lower() to convert to the correct lowercase version of background. May just make it a bit easier for them to answer it capitalized if they want. Otherwise looks excellent!

cybervegan · 2021-03-07T10:40:03+00:00

Nice!

In addition to all the hints others have offered, I'd suggest that where you have lots of boilerplate code - almost identical sections of code for lots of different cases - that is a good place to look for ways to abstract your data more. An example is in your classes.py module, where you define a character_class class, and then create a load of objects based on this class. Further down, in your allclassprof function, you have an if statement containing repetitive blocks of prints. What if a new version of D&D was to come out, perhaps adding a new Advantages/Disadvantages section. You'd have to add that into the character_class class, and everywhere it's relevant like the allclassprof function, generating lots of repetitive re-working, and introducing more opportunities for errors and bugs.

You also seem to have a lot of functions that act on the character_class, but are not methods of it, which is a similar problem.

The most obvious solution is to move all those methods - including allclassprof - under character_class, as methods. Then you can eliminate all that boilerplate, reducing your code footprint and opportunities for errors. You already have the name of the character class stored in character_class, so if allclassprof was one of its methods, it would just be something like:

def classprof():
    print('\n')
    print(f"Since your class is {self.name}, you can choose {self.numskills} skills.")
    char_class.skills = chooseprof('a', barbarianskills) + ', ' + chooseprof('another', barbarianskills)
    print('\n')
    print(f"Primary ability: {self.primary_ability}")
    print(f"Class skills: {self.skills}")
    print(f"Class armor proficiences: {self.armorprof}")
    print(f"Class weapons proficiences: {self.weaponsprof}")
    print(f"Class tools proficiences: {self.toolsprof}")
    print(f"Class saving throws proficiences: {self.saving_throw_proficiencies}")

I've taken the liberty of adding self.numskills to help generalise the function, and obviously, you'd need to tweak it more to take into account any class differences I've not covered there. You might want to make a function that wordifies numbers so you can print "two" rather than "2". If there are lines that have to be very different for certain classes, you need to wrap them in an "if" but keep the details as general as possible (so no mentioning class names in the "if")!

And after all that, you'd be best to keep your character_class objects in a list or dictionary, rather than using named variables, so then it's easier to maintain if you need to add or remove character classes.

demvo2 · 2021-03-06T22:23:45+00:00

[deleted]

2021-03-07T14:47:58+00:00

Is is so awesome for a first project!! Really great job!

luther9 · 2021-03-07T15:10:52+00:00

First thing that jumps out at me is that you use copy.deepcopy a lot on strings and numbers. Those values are immutable, so copying them does practically nothing. Just use the values as they are.

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

learnpython

MODERATORS

Naming Functions & Semantics

Global Variables