applysci/aim

All-Ireland Mahjong mobile app

aim's Issues

for users, it's not clear in the score page that "penalties" only means out-of-game penalties.

We can put in-game and out-of-game penalties onto the player profile page, which will help mitigate this.

scorescreen looks bad in light mode with selected player

ask permission for full intent, and fail gracefully if refused

server-side: have a straightforward way to change the number of tables

two parts:

1. change it before the tournament starts - fairly easy - just use one of the standard templates. May need to check assigned seating numbers are contiguous 1-N.

2. change it after at least one round has been played - much more difficult. For this, we need to track substitutes, and need to reassign seating to minimise collisions. There's a crude starting point in https://github.com/ApplySci/aim/blob/main/server/run/reassign.py

"past" tab for tournaments?

Back button doesn't feel predictable

I rarely want to go to the all tournaments page, but it might still be good to have a dedicated button for it, rather than the back button sometimes going there, and not always when expected.

Also, not sure about losing the bottom tabs when going into player profile or hanchan results page.

don't move seating for a hanchan to the past tab, until the done flag for it is set, or it's more than 15 minutes past the scheduled start of hanchan time

Some users expect dragging down to force a refresh

Obviously we don't do that. Should we catch it anyway and tell them it auto refreshed?

when an alarm sounds, stop all previous alarms first. And check whether the alarm was more than 5 minutes ago: if so, kill the alarm, don't sound it

API suggestions

so this is what i'm thinking, its written in typescript but i can convert it to something else if you're not familiar with it.

type PlayerId = number

// same as current
interface Player {
  id: PlayerId
  name: string
}

// players store
// same as current
type PlayersCollection = Player[]

type TournamentId = string

// same as current
interface Tournament {
  id: TournamentId
  name: string
  address: string
  country: string
  startDate: string
  endDate: string
  status: string
  rules: string
}

// tournaments store
// same as current
type TournamentsCollection = Tournament[]

type RoundId = string
type TableId = string

// schedule store
// combined Schedule + seating
interface ScheduleCollection {
  timezone: string
  rounds: {
    id: RoundId
    name: string
    start: string
    tables: {
      id: TableId
      name: string
      players: [
        PlayerId,
        PlayerId,
        PlayerId,
        PlayerId,
      ]
    }[]
  }[]
}

class PlayerRoundScore {
  score: number
  penalties: number
  uma: number
  position: number
  rank: number
  tied: boolean

  get finalScore(): number {
    return this.score - this.penalties + this.uma
  }
}

class PlayerScore {
  id: PlayerId
   // is it too much info to get this per round?
  rounds: PlayerRoundScore[]

  get score(): number {
    return this.rounds.reduce((value, round) => value + round.score, 0)
  }
  get penalties(): number {
    return this.rounds.reduce((value, round) => value + round.penalties, 0)
  }
  get finalScore(): number {
    return this.rounds.reduce((value, round) => value + round.finalScore, 0)
  }
  rank(roundIndex: number): number | undefined {
    return this.rounds[roundIndex]?.rank
  }
  tied(roundIndex: number): boolean {
    return this.rounds[roundIndex]?.tied ?? false
  }
}

// scores store
type ScoresCollection = PlayerScore[]

// calculate roundsDone like this:
let scoresCollection: PlayerScore[] = []
const roundsDone = () => scoresCollection.reduce<number | null>(
  (value, playerScore) => value != null
    ? Math.min(value, playerScore.rounds.length)
    : playerScore.rounds.length,
  null,
) ?? 0

As json doesn't support non-string keys, my preference is to return lists with the id instead. This means the client doesn't need to do any unnecessary conversion and ids are always consistently typed.

Looking at the docs for firestore, it looks like they support nested json. Is there any reason you're converting to a json string? I've not used firestore so maybe there is some limitation i'm unaware of.

Associate the followed player by the tournament id, in the store?

It's not really anticipated that people will follow more than 1 tournament at once, so this is low priority for now.

BUG: players > search > type some letters to shortlist the names > tap the x to clear the search box > list remains filtered

reproduced on ipad and android

consider switching from alarm back to flutter_local_notifications

This is the problem with the alarm package (from https://pub.dev/packages/alarm ):

The alarms sound & vibrate even if the user has silenced them on their phone. This is very much unwanted behaviour.

IIRC, this is much better behaved: https://pub.dev/documentation/flutter_local_notifications/

player profile stats screen errors if there are no scores yet - Bad state: No elements

favouriting before seats are assigned gets messed up when seats get assigned, as IDs change

We need a way to have a unique player ID that remains unperturbed by seating ID. We can use the registration ID for this, we just need to work out how.

handling substitute players

it's taken quite some special handling to be able to deal with substitutes. I don't like it, and we should definitely look at this again.

It messes up the whole existing paradigm.

there's now a dummy table created, server-side, called "missing", to handle players that don't appear at any table.

See [server/run/run.py#L358]