Groundhog learns Python - Road to a Basketball Text Sim

[GoldenCrest Games]

Originally Posted by Groundhog

Most interesting thing has probably been how much I've adopted Python at work off the back of trying to make this thing - some of which has made my team's lives a lot easier (or at least, a lot less monotonous).

I've found the same thing. Since I started writing sports sims, I've been transferring the new programming skills to my job, writing various data crunching tools. (which has ended up helping career growth)

Funny how that works out!

[nilodor]

Silly noob question:

I'm trying to generate random numbers so I've done

from _random import Random

A = []
for i in range(0,8):
    A.append(4+Random().random())

But when I print A, I get the same random number the entire time. I'm kind of confused as to why as I thought if I don't specify a seed I should get a different random number based upon the system clock. Or is it just happening too fast, so the clock is the same?

[nilodor]

Originally Posted by nilodor

Silly noob question:

I'm trying to generate random numbers so I've done

from _random import Random

A = []
for i in range(0,8):
    A.append(4+Random().random())

But when I print A, I get the same random number the entire time. I'm kind of confused as to why as I thought if I don't specify a seed I should get a different random number based upon the system clock. Or is it just happening too fast, so the clock is the same?

Apparently _random is different than random, which has fixed my issue!

[Groundhog]

It is - I actually have no idea what _random is, I know there's a few libraries with the underscores.

Another quick tip - you don't need the (0,8) with range, you can just:

for i in range(8):
   A.append(4 + random.random())

[SirBlurton]

You could also use a list comprehension to skip the step of appending to the created list and just create the list.

A=[(4+random.random()) for i in range(8)]

List comprehensions were one of the best things I've learned about. I had one block of about 12 overly complicated lines in an early project get replaced by one list comprehension....and that simplification flowed through everything else.

[Groundhog]

Yes, list comprehensions are the bomb once you get a handle on them. I remember reading through one of my first Python books and my eyes just glazed over when covering that topic (similar to what used to happen to me back in school in maths, actually... I wonder if I have dyscalculia...). It was only when I saw a real simple example in someone else's code that was clearly commented that it clicked with me.

[Groundhog]

It’s been months, so here’s a quick update:

Life and holidays got in the way for the most part since my last updates, but over the past three weeks I’ve picked this up again and got quite a bit done. One of the big changes I’ve made is just to focus entirely on the code component, and so I’ve sliced the GUI (PySide) right out at the moment. The main advantage to putting the UI aside is that it was really slowing me down, and my plan is to try and get the core functionality coded before looking at a UI again. If I’m happy with what I’ve coded I may just pay someone else to do it.

I think PySide is great, but I don’t know that I would ever be able to package it in a way that I’d like, and I also think that if I ever wanted to make money from this at some point, it makes sense to focus on the online/browser based component. This is contrary to how I myself like to play, but hey, I have massive CD and DVD collections too. I'm no design expert or anything, but I liked the overall style I came up with with my PySide GUI, and I'd probably want something very similar no matter which way I go. The code as I've been writing it will make it pretty easy to slot any UI framework over the top, so I can worry about this decision later, once I have a functioning simulator!

[Groundhog]

Testing out the 'universe generator' code I setup ages ago to make sure it all still works after cutting my code to pieces. Right now it uses the fictional default league info I've saved into a csv and generates fictional teams for all leagues based on that info, selecting random cities (weighted towards the most populous cities) and nicknames (if enabled). There is a ton of loading of csv files and calculations to make this info, which is what impresses me about Python - it's done in less than a second (excluding players - they take about 1.5 seconds at the moment).

I want to quickly be able to spin up entire random universes with teams/coaches/players/arenas etc. quickly to help with testing down the road.

For fun, here's the most recent USA 'NBA':

San Jose Seagulls (SAJ): City: San Jose, CA, Popularity: 3, Arena: 1078, FG_Colour: #AF906A BG_Colour: #990000
Nashville Tigers (NAS): City: Nashville, TN, Popularity: 4, Arena: 1079, FG_Colour: #FFC700 BG_Colour: #00386B
Albuquerque Bruins (ALB): City: Albuquerque, NM, Popularity: 1, Arena: 1080, FG_Colour: #243760 BG_Colour: #F07422
Minneapolis Jaguars (MIN): City: Minneapolis, MN, Popularity: 2, Arena: 1081, FG_Colour: #00457C BG_Colour: #FF2222
Mesa Vikings (MES): City: Mesa, AZ, Popularity: 3, Arena: 1082, FG_Colour: #FFFFFF BG_Colour: #005D28
San Antonio Leopards (SAN): City: San Antonio, TX, Popularity: 5, Arena: 1083, FG_Colour: #003399 BG_Colour: #FF9900
San Diego Bucks (SAD): City: San Diego, CA, Popularity: 2, Arena: 1084, FG_Colour: #F8B800 BG_Colour: #000000
Philadelphia Thunderbirds (PHI): City: Philadelphia, PA, Popularity: 4, Arena: 1085, FG_Colour: #B31F29 BG_Colour: #11351A
Washington Stallions (WAS): City: Washington, DC, Popularity: 2, Arena: 1086, FG_Colour: #C41E3A BG_Colour: #321414
Virginia Beach Hornets (VIR): City: Virginia Beach, VA, Popularity: 3, Arena: 1087, FG_Colour: #BDB76B BG_Colour: #000000
Colorado Springs Ospreys (COS): City: Colorado Springs, CO, Popularity: 3, Arena: 1088, FG_Colour: #000000 BG_Colour: #FFC94B
Santa Ana Hawks (SAN): City: Santa Ana, CA, Popularity: 2, Arena: 1089, FG_Colour: #FFFFFF BG_Colour: #D2DDFC
Honolulu Salukis (HON): City: Honolulu, HI, Popularity: 3, Arena: 1090, FG_Colour: #FFFFFF BG_Colour: #990000
Arlington Eagles (ARL): City: Arlington, TX, Popularity: 3, Arena: 1091, FG_Colour: #000000 BG_Colour: #DC143C
Austin Barons (AUS): City: Austin, TX, Popularity: 3, Arena: 1092, FG_Colour: #374EA1 BG_Colour: #FFF200
Raleigh Miners (RAL): City: Raleigh, NC, Popularity: 4, Arena: 1093, FG_Colour: #000066 BG_Colour: #FFFFFF
Chicago Pirates (CHI): City: Chicago, IL, Popularity: 2, Arena: 1094, FG_Colour: #000000 BG_Colour: #CC0000
Denver Bees (DEN): City: Denver, CO, Popularity: 4, Arena: 1095, FG_Colour: #50C878 BG_Colour: #0047AB
Phoenix Nighthawks (PHX): City: Phoenix, AZ, Popularity: 3, Arena: 1096, FG_Colour: #FFFFFF BG_Colour: #0000FF
Tucson Flames (TUC): City: Tucson, AZ, Popularity: 2, Arena: 1097, FG_Colour: #000000 BG_Colour: #E00122
Saint Paul Centaurs (SAP): City: Saint Paul, MN, Popularity: 3, Arena: 1098, FG_Colour: #EF6E22 BG_Colour: #216EB7
Dallas Comets (DAL): City: Dallas, TX, Popularity: 1, Arena: 1099, FG_Colour: #FFFFFF BG_Colour: #000070
Riverside Kings (RIV): City: Riverside, CA, Popularity: 5, Arena: 1100, FG_Colour: #FFFFFF BG_Colour: #5858FA
Los Angeles Hawks (LAS): City: Los Angeles, CA, Popularity: 3, Arena: 1101, FG_Colour: #FFFDD0 BG_Colour: #960018
St. Petersburg Riverhawks (STP): City: St. Petersburg, FL, Popularity: 5, Arena: 1102, FG_Colour: #C5B358 BG_Colour: #8B0000
Houston Defenders (HOU): City: Houston, TX, Popularity: 1, Arena: 1103, FG_Colour: #613005 BG_Colour: #FF7300
Louisville Yellow Jackets (LOI): City: Louisville, KY, Popularity: 4, Arena: 1104, FG_Colour: #FF9900 BG_Colour: #000000
Milwaukee Wolves (MIL): City: Milwaukee, WI, Popularity: 3, Arena: 1105, FG_Colour: #CAB388 BG_Colour: #00285C
New York Cavaliers (NYK): City: New York, NY, Popularity: 4, Arena: 1106, FG_Colour: #990000 BG_Colour: #000066
Jersey City Falcons (JER): City: Jersey City, NJ, Popularity: 3, Arena: 1107, FG_Colour: #FFD700 BG_Colour: #000000

Usually it's very Texas heavy as I used a list of the 80ish most populated cities in the USA.

And the same for Spain:

Alicante (ALI): City: Alicante, Popularity: 1, Arena: 941, FG_Colour: #FF652B BG_Colour: #4C230E
Pamplona (PAM): City: Pamplona, Popularity: 4, Arena: 942, FG_Colour: #FFFFFF BG_Colour: #006000
Valencia (VAL): City: Valencia, Popularity: 1, Arena: 943, FG_Colour: #C41E3A BG_Colour: #321414
Vitoria-Gasteiz (VIT): City: Vitoria-Gasteiz, Popularity: 2, Arena: 944, FG_Colour: #FFFFFF BG_Colour: #00386D
Madrid (MAD): City: Madrid, Popularity: 4, Arena: 945, FG_Colour: #ED1C24 BG_Colour: #F5EE30
Valladolid (VAL): City: Valladolid, Popularity: 3, Arena: 946, FG_Colour: #CFB53B BG_Colour: #006633
A Coruña (ACO): City: A Coruña, Popularity: 4, Arena: 947, FG_Colour: #FFFFFF BG_Colour: #461D7C
Getafe (GET): City: Getafe, Popularity: 4, Arena: 948, FG_Colour: #FFAC2C BG_Colour: #240A67
Bilbao (BIL): City: Bilbao, Popularity: 3, Arena: 949, FG_Colour: #662D91 BG_Colour: #F7BE19
Oviedo (OVI): City: Oviedo, Popularity: 2, Arena: 950, FG_Colour: #EFEFEF BG_Colour: #002F30
Córdoba (COR): City: Córdoba, Popularity: 5, Arena: 951, FG_Colour: #FFFFFF BG_Colour: #00A000
Sabadell (SAB): City: Sabadell, Popularity: 2, Arena: 952, FG_Colour: #FFC61E BG_Colour: #000C03
Málaga (MAL): City: Málaga, Popularity: 3, Arena: 953, FG_Colour: #FAE051 BG_Colour: #002469
Castellón de la Plana (CAS): City: Castellón de la Plana, Popularity: 3, Arena: 954, FG_Colour: #0021A5 BG_Colour: #FF4A00
Santander (SAN): City: Santander, Popularity: 3, Arena: 955, FG_Colour: #000000 BG_Colour: #F47B20
Badajoz (BAZ): City: Badajoz, Popularity: 3, Arena: 956, FG_Colour: #818285 BG_Colour: #105D95
Lleida (LLE): City: Lleida, Popularity: 2, Arena: 957, FG_Colour: #FF652B BG_Colour: #002E4D
Vigo (VIG): City: Vigo, Popularity: 5, Arena: 958, FG_Colour: #FFCC33 BG_Colour: #000000

[SirBlurton]

Very cool! It's interesting to watch your decision making process as you work through the project! Probably a wise move to put GUI aside, from screenshots it looks like you've done enough to know you can do that if that's the direction you want to go!

If there are ever any tasks you think you could use a hand with let me know...I'm still very much a beginner but I've been working away at building little bits and pieces like name generators and cartoon face generators. Just starting to learn about databases and flask right now.

I know that would likely be too complicated to manage and it's also "your baby" - but just wanted to put it out there if there's ever a piece you could use help on.

Continuing to watch for your updates!

[Groundhog]

Yeah, and as a plus I've learnt a good deal about PySide/PyQt/Qt, and have developed UIs for a bunch of other small projects at home and in the office, and created my first "proper" python module to manage stylesheets for widgets, the creatively named qt_widgetstyler, so it has not been time wasted!

While I do think of this as "my baby" to some extent, I'm more than open to help. By no means feel obligated to tackle this, but one thing I was playing with months and months ago and couldn't get it to work quite right is a round-robin schedule creator. When I get a chance I'll post what I put together, and if you can get the dang thing to work, fantastic! It's harder than it sounds, because it needs to take into account a few factors, such as valid days of the week to schedule games, etc.

[SirBlurton]

I have played with scheduling a bit and I definitely wouldn't go in thinking it's easy! But that would be cool to take a look at it...like you said, if I can't do it, it'll be something you can look at again in the future but I'd be interested in taking a crack at it!

[CraigSca]

I don't want to steal sirBlurton's thunder, but I wouldn't mind lending a hand with things, either. I've been programming my own college football sim but it's coming in drips and drabs and wouldn't mind increasing my skill set.

[Groundhog]

Hey, the more the merrier as far as I'm concerned

Here's a snippet of what I put together actually nearly 12 months ago, checking the time stamp of the file. I've made a few small changes just now, but I haven't tested anything yet, so there may be typos/errors if you try run the below currently (just working out of notepad at the moment...)

The part that was frustrating me was the 'get_valid_game_days' method. There's nothing in the code below for this, but I spent an hour or so playing around on the python command line trying to solve this - basically, need to take a date range, and calculate all the valid game days within this range, grouped by week. The timedate library has some cool functionality that should make this possible, but I'll be darned if I could crack it - this was that "math-level" stuff I mentioned above that I struggle with.

For example, if Friday and Saturday were the only valid days, and the date range was for 4 weeks starting this week, the output of this method should be:

[[16/12/2016, 17/12/2016], [23/12/2016, 24/12/2016], [30/12/2016, 31/12/2016], [6/1/2017, 7/1/2017]]

As a rule I generally work with all dates as ordinal numbers - datetime objects have a .toordinal() method. I just trust it more, especially when writing to databases.

class ScheduleGen:


    def __init__(self, current_year=2016, season_start_month=9, season_start_day=30, season_end_month=3, season_end_day=28):
        self.current_year = current_year
        self.season_start_month = season_start_month
   

    def create_round_robin_schedule(self, team_ids=None, play_each_team=3, valid_days={'monday': False, 'tuesday': False,                                                                                         'wednesday': False, 'thursday': False, 
                                                                                        'friday': True, 'saturday': True, 
                                                                                        'sunday': True}):

        matchups = self.generate_round_robin_matchups(teams=team_ids, play_each_team=play_each_team)
        valid_game_days = self.get_valid_game_days(valid_game_days=valid_days)
    

    def get_valid_game_days(self, valid_game_days):
        '''
        Parameters:

        :valid_game_days: (dict) A dictionary of each day of the week and a True/False value.

        Returns:

        A list of all possible game days, in ordinal format.
        '''
        # This is where I had trouble. What is needed here is to use the current_year/season_start_month/season_start_day, 
        # the current_year+1/season_end_month/season_end_date, and the valid_game_days dictionary to compile a list of
        # all available dates, grouped in weeks (to ensure teams don't always play multiple games in the same week), 
        # with the dates stored as ordinals (whole numbers - a feature of the timedate module), similar to this:
        # valid_dates = [[734228, 734229],[734235, 734236],[734241. 734242]] etc.
        pass

    @staticmethod
    def generate_round_robin_matchups(teams=None, play_each_team=1):
        '''
        Note: Bulk of this code taken from: https://gist.github.com/Makistos/7192777

        Parameters:

        :teams: (list) league team IDs.
        :play_each_team: (int) how many times all teams play each other.

        Returns:

        A list of all valid matchups.
        '''
        matchups = []

        if len(teams) % 2 == 1:
            #teams = teams + ['BYE']
            teams.append(False)

        for i in range((len(teams) - 1) * play_each_team):

            mid = round(len(teams) / 2)
            l1 = teams[:mid]
            l2 = teams[mid:]
            l2.reverse()	
            
            # Switch sides after each round
            if(i % 2 == 1):
                matchups = matchups + [ zip(l1, l2) ]
            else:
                matchups = matchups + [ zip(l2, l1) ]

            teams.insert(1, teams.pop())

        return matchups

[Groundhog]

dola

The above was written in Python 2 as well, where as I've moved to 3 now. I think the only impact this has on the above is that the 'generate_round_robin_matchups' method will returns a generator object rather than a list of lists, but this is minor.

edit: fixed some typos in the above.

[CraigSca]

Is the valid_game_day list only for a single week or for all weeks? Meaning, do I want to state that Mondays and Tuesdays are invalid game dates for ALL weeks, or do I just want an potentially long list showing which days are invalid for the entire year?

[Groundhog]

For all weeks - so a long list of dates, grouped by weeks, between a start date and end date. What I'm trying to achieve here is a list of all valid game days between two dates. The next step would be assigning all the matchups generated by the 'generate_round_robin_matchups' method to these dates.

Most of the "round robin" leagues around the world have set days that they usually play their games - for European leagues it's generally Sat/Sun (which makes the Euroleague/Eurocup scheduling easier), in Australia it's everyday except Tue/Weds - so that's the behaviour I'm looking for here. The leagues all have the 'valid days' attribute that defines which of these days of the week to schedule games on. This class (will eventually) take that info as a dictionary, generate a list of all the matchups, generate a list of valid game dates, and then assign those matchups to those dates.

[CraigSca]

Originally Posted by Groundhog

For all weeks - so a long list of dates, grouped by weeks, between a start date and end date. What I'm trying to achieve here is a list of all valid game days between two dates. The next step would be assigning all the matchups generated by the 'generate_round_robin_matchups' method to these dates.

Most of the "round robin" leagues around the world have set days that they usually play their games - for European leagues it's generally Sat/Sun (which makes the Euroleague/Eurocup scheduling easier), in Australia it's everyday except Tue/Weds - so that's the behaviour I'm looking for here. The leagues all have the 'valid days' attribute that defines which of these days of the week to schedule games on. This class (will eventually) take that info as a dictionary, generate a list of all the matchups, generate a list of valid game dates, and then assign those matchups to those dates.

Stupid question - and now I see why working in teams can sometimes be hard - when you generate the list of invalid game days (the "falses" in the list) can't you just generate the "trues" as a list for the entire year, keep it in memory and just access it when needed?

[Groundhog]

No, not a stupid question at all!

Ignore the invalid dates, because we only need those to determine which days are valid, and they will be skipped over. The False/True flags just tell the method that it needs to compile a list of all True days for each week between a range of dates. So if we feed the class a starting date of June 30 2016 up until January 31 2017, the method would first check which days are valid - let's say Saturday and Sunday - and then split up the the period between those dates into units of weeks, and append all the dates of Saturday and Sundays to a list. When we assign the matchups to days, it would be a random.choice() type of operation to randomly assign the individual matchups to these valid dates.

This could all be stored in memory, but this calculation will need to be run for all 70ish leagues once per offseason, as they all have their own unique True/False flags for valid game days, and obviously the dates will also change from year to year.

The final output of this would be a list of all games in a season, with the date, league id, home team id, and road team id, which would then be written to the database.

An instance of this class would be used inside another method somewhere along the lines of (and this is probably full of syntax errors, but just to give you a quick idea):

def generate_all_schedules(dict_of_all_leagues, dict_of_all_teams, current_year=2016, season_start_month=9, season_start_day=30, season_end_month=3, 
                           season_end_day=28):
    # dict_of_all leagues: A dictionary with league_id as the key, all league attributes as values in another dict.
    # dict_of_all_teams: A dictionary with the league_id as the key, and all team ids in a list as value.

    season_schedule = []

    sg = ScheduleGen(current_year, season_start_month, season_start_day, season_end_month, season_end_day)

    for league in dict_of_all_leagues:
        # Create a 'shortcut' reference directly to the league to be processed
        l = dict_of_all_leagues[league]
        # Create a 'shortcut' reference to list of teams in league
        t = dict_of_all_teams[l['id']]

        league_sched = sg.create_round_robin_schedule(team_ids=dict_of_all_teams[l['id']], play_each_team=l['play_each_team'], valid_game_days=l['valid_game_days'])
        
        season_schedule.append(league_sched)

    return season_schedule

[Groundhog]

dola

Had another thought. Maybe the way to approach it is to just create a dictionary once of every week and day of the week in that date range, and then use that info to build all the schedules.

[CraigSca]

Originally Posted by Groundhog

No, not a stupid question at all!

Ignore the invalid dates, because we only need those to determine which days are valid, and they will be skipped over. The False/True flags just tell the method that it needs to compile a list of all True days for each week between a range of dates. So if we feed the class a starting date of June 30 2016 up until January 31 2017, the method would first check which days are valid - let's say Saturday and Sunday - and then split up the the period between those dates into units of weeks, and append all the dates of Saturday and Sundays to a list. When we assign the matchups to days, it would be a random.choice() type of operation to randomly assign the individual matchups to these valid dates.

This could all be stored in memory, but this calculation will need to be run for all 70ish leagues once per offseason, as they all have their own unique True/False flags for valid game days, and obviously the dates will also change from year to year.

The final output of this would be a list of all games in a season, with the date, league id, home team id, and road team id, which would then be written to the database.

An instance of this class would be used inside another method somewhere along the lines of (and this is probably full of syntax errors, but just to give you a quick idea):

def generate_all_schedules(dict_of_all_leagues, dict_of_all_teams, current_year=2016, season_start_month=9, season_start_day=30, season_end_month=3, 
                           season_end_day=28):
    # dict_of_all leagues: A dictionary with league_id as the key, all league attributes as values in another dict.
    # dict_of_all_teams: A dictionary with the league_id as the key, and all team ids in a list as value.

    season_schedule = []

    sg = ScheduleGen(current_year, season_start_month, season_start_day, season_end_month, season_end_day)

    for league in dict_of_all_leagues:
        # Create a 'shortcut' reference directly to the league to be processed
        l = dict_of_all_leagues[league]
        # Create a 'shortcut' reference to list of teams in league
        t = dict_of_all_teams[l['id']]

        league_sched = sg.create_round_robin_schedule(team_ids=dict_of_all_teams[l['id']], play_each_team=l['play_each_team'], valid_game_days=l['valid_game_days'])
        
        season_schedule.append(league_sched)

    return season_schedule

Yeah - getting back to my question - does that mean the list of true/false flags are ONLY for days of the week, or could you have something like false for all Saturdays and also Christmas day?

[Groundhog]

Originally Posted by CraigSca

Yeah - getting back to my question - does that mean the list of true/false flags are ONLY for days of the week, or could you have something like false for all Saturdays and also Christmas day?

Currently, only for days of the week. I did think about things like holidays, but at the same time its a lot of work tracking down holidays/special days for 68 different nations, to have things like no Christmas day games in Australia, or no Sunday games in Israel, etc.

[Young Drachma]

Spam aside, glad you're still at this.

[GoldenCrest Games]

Nice to see you're still chugging along!

[nilodor]

Originally Posted by Groundhog

Until this point I've imported all of my data - teams, coaches, leagues, nations, etc. - in a database (sqlite) that I manually populated from csvs full of info I've gathered over the last couple of years, so I spent some time the past couple of days putting together the 'new game' process - main menu/league selections, etc.

Here's a couple of screens:

Title Screen
A quick (5 minute) title screen just to give the standard new/continue/load options.


New Game Menu
This one took a lot longer - the fully functional league selection screen. All the data here is taken from csv files that can be easily modified to add/subtract/modify the leagues included - currently 44 fields per league (some repetitive, like 7 fields for each day of the week that games will be scheduled). Leagues where I've manually created teams (also done via csvs) default to 'import' teams, other leagues will be randomly generated. Active leagues will be bolded (not yet done), and I'll ditch the '#' in the Teams column header.

The Olympics/Tournaments options on the left will be changed to a table like the regional leagues, because it gives me more flexibility with how many I can include without running out of room - there's international tournaments in the Americas, Asia and Africa that I don't plan on looking at now but would probably like to look at down the track:



Nav Bar
Lastly, the top-of-screen navigation bar - not completely functional yet, because I don't have all the screens completed. This image is at 100% actual width, to give you an idea of how wide the UI will be:

What did you use to make these screens? They look great, much better than what I'm capable of in PyQt

[Groundhog]

Originally Posted by nilodor

What did you use to make these screens? They look great, much better than what I'm capable of in PyQt

Just a combination of the Designer app to layout all the widgets, and then applying different stylesheets to each widget within Python. Most of the "magic" is just labels with rounded corners and partially transparent background colours (rgba with an alpha channel that acts as the transparency %), so the background image shows through.

[nilodor]

Originally Posted by Groundhog

Just a combination of the Designer app to layout all the widgets, and then applying different stylesheets to each widget within Python. Most of the "magic" is just labels with rounded corners and partially transparent background colours (rgba with an alpha channel that acts as the transparency %), so the background image shows through.

To get the rounded push buttons did you use something like:

self.pushButton.setPalette(palette)
self.pushButton.setStyleSheet("background-color: rgb(170, 255, 255); border-style:solid; border-color:black; border-radius:20px;border-width:2px;")
self.pushButton.setObjectName("pushButton")

I can't seem to get rounded edges this way

[Groundhog]

standard_button = '''QPushButton {{
                                   color: rgb{};
                                   background-color: rgb{};
                                   border-bottom-left-radius: {}px;
                                   border-bottom-right-radius: {}px;
                                   border-top-left-radius: {}px;
                                   border-top-right-radius: {}px;
                                 }}
                     QPushButton:hover {{
                                         background-color: rgb{};
                                       }}
                     QPushButton:checked {{
                                           background-color: rgb{};
                                           color: rgb{};
                                         }}
                     QPushButton:disabled {{
                                            color: rgb{};
                                            background-color: rgb{};
                                            border: none;
                                          }}'''

I can't remember if there's a good reason why I used individual corner radius %s vs just a general border-radius setting. Swap out the {} for values and that's straight out of my code.

I didn't use the setPalette or .setObjectName methods for any of my widgets - again, can't remember if that was for a reason or if I just never saw those methods. I created this library to let me group widgets and make it easier to manage colour schemes on different team pages, etc. It's super amateur and I'm sure Qt has a way of doing the same thing (possibly .setObjetcName), but it was an easier "python" way for me to handle it.

[nilodor]

Originally Posted by Groundhog

standard_button = '''QPushButton {{
                                   color: rgb{};
                                   background-color: rgb{};
                                   border-bottom-left-radius: {}px;
                                   border-bottom-right-radius: {}px;
                                   border-top-left-radius: {}px;
                                   border-top-right-radius: {}px;
                                 }}
                     QPushButton:hover {{
                                         background-color: rgb{};
                                       }}
                     QPushButton:checked {{
                                           background-color: rgb{};
                                           color: rgb{};
                                         }}
                     QPushButton:disabled {{
                                            color: rgb{};
                                            background-color: rgb{};
                                            border: none;
                                          }}'''

I can't remember if there's a good reason why I used individual corner radius %s vs just a general border-radius setting. Swap out the {} for values and that's straight out of my code.

I didn't use the setPalette or .setObjectName methods for any of my widgets - again, can't remember if that was for a reason or if I just never saw those methods. I created this library to let me group widgets and make it easier to manage colour schemes on different team pages, etc. It's super amateur and I'm sure Qt has a way of doing the same thing (possibly .setObjetcName), but it was an easier "python" way for me to handle it.

Weird, doing each corner separately seems to work. I think that you have to use the palette command if you're using PyQt5. Like how the QMainWindow moved from PyGui to QtWidgets.

One thing I'm going to have to work on is the ability to batch import. I've got it set up that I can read in constants from a text file for athlete generation, but I'm not sure how to do it to create a generic style sheet based on the country the player is using.

Maybe I'll actually post in my thread to discuss it better.

[Groundhog]

Happy to show you how I do it, PM me if you want a quick example.

[CrescentMoonie]

Enjoyed reading through this. I'm at the very beginning of my journey learning languages, starting with a couple of web developer courses through Udemy (nearly everything on the site was $10 around July 4). After that I'm looking at Ruby on Rails, I already bought an intro course on it, and maybe Python after that. This dynasty will definitely help in my sections on Python in the two developer courses.

[Groundhog]

Just an update on this, because I get the odd PM here and there, especially from folks who find this thread via google. The two questions I get are:

Did I ever finish this? No. Real life, in particular a promotion at work and having a kid, made this begin to feel like work to be completely honest. I was spending 2-3 hours a night coding in bed, and I was beginning to have dreams involving Python functions, which was a bit strange. I decided to take a break from it and never got the urge to pick it up again. I'm sure I will down the line however, and I've still kept up with Python and use it from time-to-time at work.

Is it possible to program something like this in Python? Absolutely yes, and probably a lot better than how I was doing it. Even the GUI I think looked OK, but as I touched on a few times in this thread I would ignore this component it if I did this again and look at a web GUI (and probably paying someone to build one rather than learning it myself).

[Groundhog]

So, it's been a minute!

About 2 years ago I picked this up again, focusing just on python and the simulation engine. I got it to the point where I could simulate a full 48 minute NBA-style game, or a slower paced FIBA 40 minute game with generated rosters and produce stats that were within the realm of reality. I'd started sketching out some free agency rules and scheduling when the age of AI 'vibecoding' arrived. I'd been using Claude code already to build some simple web apps (listbuilders for some of my favourite tabletop wargames) as well as some dumb browser-based games.

What if I connected Claude up to my basketball text sim though...



Welp. 6 months of pretty consistent dabbling later, I essentially have a working single-player basketball simulator. You can generate an entire world full of fictional players/teams/coaches, select a team in any league (a mix of real & fictional leagues), hire coaches, sign players, set rotations. There's a tiered financial model in place for the international leagues, and an NBA-style model for the US league. Both still need work, particularly the NBA-style model, but they are functional.



Internationally you can manage a team, select a 15-man roster from eligible (and willing) players, then compete to qualify for and then to win gold at FIBA World Cup and Olympics events. As with the league financial models it's a bit bare-bones at the moment and a focus over the next few months, particularly the UI elements.




One recent feature I'm real happy with is that, due to the number of leagues/teams/players, simming a whole season initially took a long time - once I'd implemented all offseason tasks, it was about 4 hours beginning-to-end. I managed to cut that into a third, but I still wasn't happy with the speed so I worked on 3 separate engines that can be selected per league when you generate a new universe.

First is the "standard" engine, where each possession is simulated in detail. My goal with the engine was something both simple but realistic - if FBCB is on one end of the spectrum and JBL on the other, I'm shooting for single player-only FBCB+. There are plays with branching options, but a good amount of "abstraction" - an honest way to put it is that the focus is on having the end-results look realistic while being influenced by a number of different attributes, factors, and random dice rolls - to pick one example, each play doesn't track where each player is on the court at each step, however there is a chance each possession of a negative modifier to a PF or C's defensive rebounding ability if he's guarding a stretch big.

Next there's a "fastsim" engine. This is a simplified version of the standard engine built for speed, and strategy and coach settings matter less. It's much quicker though, and results have been tuned to give essentially like-for-like stats for players and teams between the standard and fastsim engines.

And finally there's the background sim engine which essentially just calculates stats from ratings - very simple, very quick, and again tuned to try and replicate the same individual stats as the standard and fastsim engines. This allows for having every single league in the world simulating games and producing stats - doing a day of games for 90 background leagues takes seconds - rather than only having about 10 leagues active which was the largest manageable amount previously.

There's still a whole let left to do and no end in sight, but thought I'd provide an update here considering this is where it all began!

[dgmulligan]

Whoa! This is looking great!

Any plans to get this up on Steam? I'd be really interested in grabbing a game like this as the only comparable competitor, Pro Basketball Manager, is not quite nailing the realism from simming results that I want to see.

[Groundhog]

Thanks! Eventually I would like to put this up on Steam if I can get it to a state I'm satisfied with. I've also tried Pro Basketball Manager, although quite a few years ago now, and agree. It had promise but doesn't look like it's really changed much at all over the years.

[dgmulligan]

That's great, keep posting as you progress and if it ever makes it to Steam I'll try and buy early access.

We always need more sports games filling different niches.


And if you ever need any help please reach out. I worked on the DB team for Pro Basketball Manager and also have done edits on OOTP and Jump Shot Basketball. Love helping improve sports sims.

[Young Drachma]

Hell yeah way to go getting back to this. It's so much easier to do this stuff now. Yours looks like it's heading in good shape and I trust us text sim dorks better than most to make these games. Keep it up! I think FBCB+ is a good target too. the resilience of that sim was that it was customizeable but didn't try to do more than it did. All most of us need is a sandbox RNG that's better than pen/paper/dice.

[Groundhog]

Originally Posted by Young Drachma

Hell yeah way to go getting back to this. It's so much easier to do this stuff now. Yours looks like it's heading in good shape and I trust us text sim dorks better than most to make these games. Keep it up! I think FBCB+ is a good target too. the resilience of that sim was that it was customizeable but didn't try to do more than it did. All most of us need is a sandbox RNG that's better than pen/paper/dice.

Cheers and agree - the customization and sandboxiness of this was about 90% of the effort even before AI came along. Nearly 100% of the effort at this point is ironing out free agency logic and single player logic for the international leagues, before I dive into the NBA which has not really been a focus as yet outside of the getting the CPU-controlled teams to manage themselves in a realistic-ish way, but is currently a dull human-controlled experience with no trade UI and no enforcement of salary rules. That's the biggest hurdle to tackle before I think about release.

One other thing I worked on last weekend was building a new universe menu - WWBM has a number of cvs files that dictate which leagues are active/background, which leagues have real team/league information available, which are fictional, etc. I would need to manually update these files when testing different configurations - ie. only 1 or 2 active leagues when I want to quick-sim a number of seasons, a handful of low prestige leagues when I want to test low prestige team Free Agency, etc. Claude basically one-shot this based on the structure of the cvs, and all I did was tweak the styling of the page and add filters:



The way I liked to play FBCB was also ultra slow-paced, coaching every single game - making subs, adjusting strategy, setting priority offensive player, etc. Given it takes some time to get through a season, I feel this is probably what WWBM best caters to as well. This required a pretty significant change to the sim engine to allow for stepping through each possession, wait for user input (click 'next possession'), and then proceed to sim the next possession.

I made a start on this a little while ago, creating a "live sim" screen with a scoreboard that updates as the game - I mocked the scoreboard up in Google Draw and made the images for all the numbers/characters using GIMP in about 5 mins as a starting point but I would eventually like to improve both.


Claude also one shot this - not sure why at this point I continue to be surprised by stuff like this. I put fluro green boxes where I wanted to overlay the digital numbers/letters, and Claude absolutely nailed it based on those placeholders - I had to correct the penalty icons, but otherwise it was flawless. The little hamburger icon on the top right of the scoreboard options up coach settings - I've added the options I eventually want in place, but it's just placeholder buttons at this point with no functionality:

[Young Drachma]

yeah this looks solid for sure. Super excited you're doing this.

[Groundhog]

Spent weeks trying to get non-NBA free agency quirks ironed out, and happy with where it's at now although still troubleshooting something I noticed where an extra year is being subtracted from contracts during the offseason which is annoying, and I haven't squished it yet, but I think it's related to the multi-season sim function only.

For fun, let's take a deep-dive look at the 2032 Olympics. There's a qualification tournament the offseason prior, with the host automatically qualifying. A total of 12 teams qualify - 2 from Asia/Oceania, 2 from Africa, 3 from the Americas, and 4 from Europe.

2032 Olympics

Host Country: Czech Republic

Africa Region:

South Sudan (FIBA Rank: #17)
I configured diaspora players for nations such as South Sudan to represent the large population of players that end up based in Australia, Europe, and the USA originating from or as 2nd generation from these nations, but one thing I haven't yet configured is the chance that they'll represent their "original" nation. This makes South Sudan weaker than they would be otherwise, and they are led by a handful of domestic players with no players in their squad of 15 with experience outside of South Sudan. 19-year old PF Michael Makuei was named captain, and at 7'1 he absolutely dominated the (fictional) South Sudanese league, picking up MVP honours for the Aweil Rogues behind 20.0 PPG and 12.9 RPG. It's fair to say that the talent level of the South Sudan league is well below the calibre of players South Sudan will face at this level however, and Makuei and the rest of the fairly young South Sudanese struggle will likely struggle to win a game in the group stages.

Tunisia (FIBA Rank: #20)
The biggest news for Tunisia was their leading scorer from the qualification tournament, 22-year old guard Iyadh Hamdi, not making himself available for the Olympics. Players have a patriotism rating that impacts how likely they are to make themselves available, with the top USA players electing to not participate more frequently than other nations. I will likely adjust to make it more likely players will miss qualification tournaments than Olympics/World Cups. Even with Hamdi winning a game would have been an uphill task. The squad of 15 are all domestic players, with another young big, 23-year old Ridha Marzouki, being named captain. Marzouki is a solid defender and can stretch the floor a little, but won't be enough to make up for the lack of quality in the backcourt for Tunisia.

Americas Region

Brazil (FIBA Rank: #7)
Brazil and Canada have been neck and neck behind the USA in the Americas, with Canada missing out due to a tiebreaker this year. Brazil are led by 23-year old PF Lucas Rocha, who initially went undrafted before earning a minimum contract with Orlando (who seem to love signing internationals!), and is now entering season #4 with OKC. Former 2nd round draft pick Paulo Silva, the highest overall rated Brazilian, did not make himself available, however Brazil have a good mix of veterans and young talent on NBA rosters. They should be in the medal picture, even without Silva.


Puerto Rico (FIBA Rank: #10)
Puerto Rico are in the third-tier of American nations, but are still a chance at making some noise this tournament. José Flores, a 23-year old SG entering his 4th season with the Cleveland Cavs are being selected #21 in the 2028 draft, had taken a back seat to more senior players previously for Puerto Rico, but figures to see a bigger role this year. He is joined by SF Eric Rosario, a 25-year old who just signed with the Utah Jazz this past offseason after dominating the Puerto Rico league, and should give this squad a nice 1-2 punch to make some noise. Whether it's enough to get them out of the pools will depend a lot on matchups, as Puerto Rico do not have the same type of quality inside as they do on the perimeter, and there are a lot of quality bigs in this tournament who might take advantage.


Team USA (FIBA Rank: #2)
Looking for revenge after the last Olympics, Team USA has a solid core of their best players available - outside of at PG, interestingly. This squad includes my favourite guy in this universe - 39-year old, 7'6 Kethan Taylor Jr. At age 38 for Sacramento last year he averaged 16.4-6.9-4.9, and is one of the smartest players in the game on both ends. For whatever reason though, NBA PGs were not interested in Olympics basketball. With 3 PGs on the squad, 2 of them are playing in the top leagues in Europe, and one is 6th man for Indiana. Despite this, talent-wise this is clearly the best team in the tournament, although not by a whole lot - Serbia and Australia are close. A lot of the talent does overlap however, with the frontcourt in particular having a lot of similar players who will take minutes away from each other. I'm predicting Silver or Bronze and hopefully some PGs decide to play next tournament!


Asia Region

Australia (FIBA Rank: #1)
Believe it or not I didn't set out to make Australia over-powered... Most universes I've simulated they've roughly equated to where they are right now in real life, but Australia has had some real lucky rolls in this universe. Leading the way for Australia is undersized pivot Dion Burns. The 6'7 all-rounder spent the last 8 seasons with Orlando Magic before signing with an Australian team this offseason at age 33. In fact all 15 of the Australian squad have spent at least one season in the NBA, with 4 on a current NBA roster and 1 playing in Spain. Australia are the reigning Olympics gold medalists, having beaten Canada in the Gold Medal game in 2028 - a year when Canada knocked Team USA out in the elimination round. They're a medal favourite for sure, and anything less than Bronze would be a disappointment.

China (FIBA Rank: #14)
China have been consistently strong, and along with New Zealand and Australia make up the clear best 3 teams in Asia. They were lucky to not have to face New Zealand in qualification, and both sides finished undefeated with total point differential being the decider. China are led by Xin Lin, a 31-year old SG who averaged 17.1 PPG for the San Antonio Spurs last season, and a mainstay of their international team. He elected not to play at these Olympics however. China will instead be relying heavily on veteran wing Nan Weiwei - Weiwei had a very brief NBA career and is currently playing in Japan after a few seasons in a couple of the top international leagues (France, Turkey), and has always played well for his country, averaging 17PPG in 13 appearances. It's a limited ceiling for this China squad despite some former NBA talent on the squad, but depending on matchups they may sneak out of the pool stage.

Europe Region:

Czech Republic (FIBA Rank: #11)
The host nation may have auto-qualified, but they would have been a fighter's chance without it. Although they have a few guys with previous NBA experience, this is a veteran squad with most of their projected rotation all starting in Spain and other strong leagues like Greece and Lithuania. 35-year old guard Daniel Adamčík is still going strong for his age, and I think this is a squad that might over-achieve if they get the right pool.

France (FIBA Rank: #15)
Safe to say France have underachieved in this universe, despite a wealth of talent. A 4-0 result in the qualification tournament shows what they are capable of however. Veteran pivot Amatégué Akobi had a lengthy career as a role player in the NBA with Orlando before making his way back to France to finish out his career, where he is sort of a poor man's Jokic, averaging 17.3-7.9-4.2 in his most recent season for Boulazac. He is support by a talented young core of players in their early 20s on NBA rosters. The future looks bright for France, and failing to get out of their pool would be a massive underachievement.

Italy (FIBA Rank: #16)
Having Italy sit just one rank behind France shows how brutal being in Europe is, especially with the only way to accrue FIBA points currently being through the qualification tournaments & tournament appearances. Italy have a good mix of veterans with NBA experience, such as captain Charles Baffour who averaged 21 PPG for Toronto last season before signing back in Italy this year at 35 years of age. They also have a talented younger crop of players led by current NBA players PG Pietro Cappelluzzo and forward Dario Amenta. They are not a team anyone would be happy to see in their pool and should advance to the elimination round.

Serbia (FIBA Rank: #3)
Although Jokic doesn't exist in this universe, Serbia still have probably the best overall talent level outside of the USA. 25-year old guard Bojan Marković has been dropping over 20PPG for Phoenix in the NBA and doing much same in 14 appearances for Serbia. 23-year old PG Filip Đorđević is another fun one to watch. After going undrafted and seeing spot minutes for New York, he dominated the Spanish league and earnt himself a nice $12m contract with Toronto this past offseason. I'm expecting a Spain-USA Gold medal showdown.

Turkey (FIBA Rank: #13)
In a similar boat to Italy & France, Turkey have for the most part under-performed despite a talented assortment of players. They are led by veteran forward Emre Çetin who is sort of like a Boris Diaw type, if Boris Diaw was 6'11 and super athletic. He spent his 20s with Orlando, with his best season being in 2026 where he averaged a career-best 10.1 PPG to go with 8.9 RPG and 4.3 APG, and has been playing for Manisa in Turkey the past 4 seasons. Outside of Cetin Turkey has a handful of guys in the NBA, with 24-year old Yusuf Jade working his way back into the NBA this offseason. Originally the #15 pick in the draft, he had a solid if erratic start to his NBA career, traded twice and ending up seeing his production dip in his 4th season. He dominated the Turkish league the last 2 seasons and earnt an $18m/3 deal with Orlando this past offseason. I put Turkey in a similar bucket to Italy & France - they have the talent to make some noise, but it would take some luck for them to medal.

[Groundhog]

Group A
It was fairly smooth sailing for Team USA. Puerto Rico stuck with them for 3 quarters but were let down by a 15-point 3rd. I'd say that was maybe a worrying result for Team USA, but as we'll see other results were more favourable to their chances... China beat down hapless Tunisia, but were just outclassed by both Puerto Rico and Team USA, which was no surprise. 6th man Magnum Dunleavy, the Pacers 6th man PG, has done admirable for Team USA at PG it must be said - not the weakness it perhaps first seemed. Dunleavy had 14 points and 7 assists against Puerto Rico.

Group B
As expected Australia-Brazil was a cracker, with Australia jumping out to an early lead and then holding off the Brazilian comeback. Rocha led the way for Brazil with 26 points and 9 rebounds, but fouled out late which helped seal Brazil's fate, while Burns had 20 points and 9 rebounds for Australia. The host nation were fairly underwhelming, getting annihilated by Australia to open the tournament, doing marginally better vs Brazil, and then curb stomping poor South Sudan, they are a shot to make it though depending on other results. Disappointing showing for the hosts overall though. As expected, South Sudan just not enough talent. Young captain Makuei struggled as expected, managing just 8.3ppg and 1.7rpg across the group stage games.

Group C
Well wasn't this a mess. Hosts aside, all European teams were placed in the same Group, and just beat up on each other... well, Italy aside. Serbia's disappointing 24-point loss to Turkey to open the tournament meant they were starting well behind the 8-ball and could just not catch up, losing the 3-way tie, although they will still advance with a poor matchup likely - Australia or Team USA at a guess. Despite dropping a game to France, I think Turkey overall look like the biggest threat out of this group. Italy were not really competitive and would be disappointed in their tournament.


As a total of 8 teams qualify, the "next best" 2 teams to make the knockout stages are: Hosts Czech Republic and ... Serbia!

[Groundhog]

Quarterfinals

Australia defeat Czech Republic 101-79
The hosts started strong, leading 33-27 after the first quarter, but managed just a total of 28 points in the 2nd half versus 56 for Australia in the same. Adamčík led CR with 24 points on 9-20 shooting but didn't get a lot of help, while a balanced attack for Australia saw 6 players in double-digits, led by Orlando Magic starting SG Paul Matthews with 20 points and 6 rebounds.

Team USA defeat Serbia 122-77
Youch. Serbia were just completely annihilated right out of the gate, down 36-15 at quarter time and it didn't get much better for them. Offensively Serbia got some nice contributions from a few players, but you aren't going to win many games when you let your opponent shoot .623 from the floor. Kethan Taylor Jr top scored for USA with 19 points, while Dunleavy continued to impress with a near triple-double - 8 points, 7 rebounds, and 8 assists. The end of a disappointing tournament for Serbia, and although USA will be feeling confident, they are now matched up against Australia for a chance at either gold or bronze.

Puerto Rico defeat Turkey 100-90
I was really surprised by this result. It was a close game until Puerto Rico pulled away in the 4th Q behind the Pedro Fox show. The 39-year old veteran big dominated Turkey inside - I underestimated how well Fox would play, as despite his age he had not played for his country before this tournament and had just put up monster scoring numbers in Puerto Rico, however I didn't notice that earlier in his career he had a season in Japan and Australia and did similar damage - high 20s in points. He looks like one of the best guys to never get an NBA shot. Pedro averaged 26 ppg in the group stages, and sent Turkey home without a medal with 28 points on 10-17 shooting in this one. Unfortunate result for Turkey.

France defeats Brazil 108-101
This was a really good game, with France jumping out to a 34-18 lead, before Brazil fought back in the 3rd Q, with France just doing enough to keep the game out of reach. French SG Pascal Kameni Fru had his best game of the tournament with 23 points, and the French team shot 12-23 from deep, which effectively countered the incredible 30-30 FT shooting for Brazil. That would have to be a record - Brazil have an unusual amount of insanely good FT shooters in their squad, a statistical anomaly. France continue to overachieve but will have their work cut out of them with a 2nd round matchup against Puerto Rico.


Semi Finals

Australia defeats Team USA 101-93
Heartbreak for Team USA as they find themselves now playing for Bronze Australia maintained a narrow lead for most of the game, but a good 3rd quarter from Team USA meant Australia were clinging on for dear life, needing to hit free throws late to keep it out of reach. Another great showing for Dunleavy even in defeat, managing 16 points, 6 rebounds and 5 assists to lead USA, while Paul Matthews had another strong game with 21 points and 6 rebounds to give Australia a shot at back-to-back gold medals!

Puerto Rico defeat France 110-103
Pedro Fox is a bad, bad man. 33 points on 12-19 shooting. Youch. It took a massive 40 point 3rd quarter, but Puerto Rico held off a determined French side who got contributions across the board with 6 players in double-digits. Puerto Rico with a chance at gold, and the first time they've ever finished top 3 in a tournament.


Bronze Medal Game

Team USA defeat France 98-81
It was a valiant effort for France, who entered halftime with a narrow 42-40 lead. Team USA just had too much depth in the end, thoroughly outplaying France in the 2nd half to take home what would be a disappointing Bronze medal. Defensive specialist wing Hakeem Godbold was the star in this one, with 18 points and 3 steals. Charlotte big Robert Faure led the way for France with 25 points and 12 rebounds. France would be disappointed to lose, but fair to say they overachieved, especially consider how the rest of the European teams fared.


Gold Medal Game

Australia defeat Puerto Rico 85-78
Both team's leaned on their defenses in this one, with Australia managing to do what no one else had done all tournament - contain Fox. Pedro ended up with 19 points on just 7-19 shooting, his only subpar performance in the tournament. Aussie veteran big Shaun Volkman definitely the MVP of the game, dropping 21 points and 11 rebounds while matching up on Fox down the other end of the court. Back to back Gold medals for Australia, and Puerto Rico with Silver and by far the biggest surprise of the tournament. Despite Fox's performance in the final, he is named overall MVP for the tournament, averaging 26.7 PPG on a blistering .561 shooting.

[Young Drachma]

the diaspora nations thing is a big one, FM does the second and third nationalities better than any text sim and it's a nice touch.

How do you feel about the sim engine itself? Optimizing for realism, a bit of randomness? Both? I've opted largely in my game to stay out of the weeds because no one else is going to play them but me, but I feel like I need to look at it and have it feel like the sport.

[Groundhog]

Agree re: FM. That's one aspect of the game I tried to capture (along with the global FA market).


For me re: realism/randomness, a little bit of both. The halfcourt loop is something like:


* Determine how quick the offense wants to play
* Determine if the defense "lets" them (offensive awareness vs defensive awareness, coaches play a roll along with randomness)
* Select a branching finishing play based on random chance/different shooting aggression types, and then the play branches based on a number of factors - drive aggression, play making ability, defense, etc.


Plenty of random rolls along the way and tests for fouls/turnovers, but it's important to me that there's some method to the madness. The background engine is purely results driven - ratings generate stats, and those stats are tuned against the real engine to be comparable, however there is no halfcourt loop, strategy doesn't apply, coaches don't matter, etc.