bastd.ui.partyqueue

  1# Released under the MIT License. See LICENSE for details.
  2#
  3"""UI related to waiting in line for a party."""
  4
  5from __future__ import annotations
  6
  7import random
  8import time
  9from typing import TYPE_CHECKING
 10
 11import _ba
 12import ba
 13
 14if TYPE_CHECKING:
 15    from typing import Any, Sequence
 16
 17
 18class PartyQueueWindow(ba.Window):
 19    """Window showing players waiting to join a server."""
 20
 21    # ewww this needs quite a bit of de-linting if/when i revisit it..
 22    # pylint: disable=invalid-name
 23    # pylint: disable=consider-using-dict-comprehension
 24    class Dude:
 25        """Represents a single dude waiting in a server line."""
 26
 27        def __init__(self, parent: PartyQueueWindow, distance: float,
 28                     initial_offset: float, is_player: bool, account_id: str,
 29                     name: str):
 30            self.claimed = False
 31            self._line_left = parent.get_line_left()
 32            self._line_width = parent.get_line_width()
 33            self._line_bottom = parent.get_line_bottom()
 34            self._target_distance = distance
 35            self._distance = distance + initial_offset
 36            self._boost_brightness = 0.0
 37            self._debug = False
 38            self._sc = sc = 1.1 if is_player else 0.6 + random.random() * 0.2
 39            self._y_offs = -30.0 if is_player else -47.0 * sc
 40            self._last_boost_time = 0.0
 41            self._color = (0.2, 1.0,
 42                           0.2) if is_player else (0.5 + 0.3 * random.random(),
 43                                                   0.4 + 0.2 * random.random(),
 44                                                   0.5 + 0.3 * random.random())
 45            self._eye_color = (0.7 * 1.0 + 0.3 * self._color[0],
 46                               0.7 * 1.0 + 0.3 * self._color[1],
 47                               0.7 * 1.0 + 0.3 * self._color[2])
 48            self._body_image = ba.buttonwidget(
 49                parent=parent.get_root_widget(),
 50                selectable=True,
 51                label='',
 52                size=(sc * 60, sc * 80),
 53                color=self._color,
 54                texture=parent.lineup_tex,
 55                model_transparent=parent.lineup_1_transparent_model)
 56            ba.buttonwidget(edit=self._body_image,
 57                            on_activate_call=ba.WeakCall(
 58                                parent.on_account_press, account_id,
 59                                self._body_image))
 60            ba.widget(edit=self._body_image, autoselect=True)
 61            self._eyes_image = ba.imagewidget(
 62                parent=parent.get_root_widget(),
 63                size=(sc * 36, sc * 18),
 64                texture=parent.lineup_tex,
 65                color=self._eye_color,
 66                model_transparent=parent.eyes_model)
 67            self._name_text = ba.textwidget(parent=parent.get_root_widget(),
 68                                            size=(0, 0),
 69                                            shadow=0,
 70                                            flatness=1.0,
 71                                            text=name,
 72                                            maxwidth=100,
 73                                            h_align='center',
 74                                            v_align='center',
 75                                            scale=0.75,
 76                                            color=(1, 1, 1, 0.6))
 77            self._update_image()
 78
 79            # DEBUG: vis target pos..
 80            self._body_image_target: ba.Widget | None
 81            self._eyes_image_target: ba.Widget | None
 82            if self._debug:
 83                self._body_image_target = ba.imagewidget(
 84                    parent=parent.get_root_widget(),
 85                    size=(sc * 60, sc * 80),
 86                    color=self._color,
 87                    texture=parent.lineup_tex,
 88                    model_transparent=parent.lineup_1_transparent_model)
 89                self._eyes_image_target = ba.imagewidget(
 90                    parent=parent.get_root_widget(),
 91                    size=(sc * 36, sc * 18),
 92                    texture=parent.lineup_tex,
 93                    color=self._eye_color,
 94                    model_transparent=parent.eyes_model)
 95                # (updates our image positions)
 96                self.set_target_distance(self._target_distance)
 97            else:
 98                self._body_image_target = self._eyes_image_target = None
 99
100        def __del__(self) -> None:
101
102            # ew.  our destructor here may get called as part of an internal
103            # widget tear-down.
104            # running further widget calls here can quietly break stuff, so we
105            # need to push a deferred call to kill these as necessary instead.
106            # (should bulletproof internal widget code to give a clean error
107            # in this case)
108            def kill_widgets(widgets: Sequence[ba.Widget | None]) -> None:
109                for widget in widgets:
110                    if widget:
111                        widget.delete()
112
113            ba.pushcall(
114                ba.Call(kill_widgets, [
115                    self._body_image, self._eyes_image,
116                    self._body_image_target, self._eyes_image_target,
117                    self._name_text
118                ]))
119
120        def set_target_distance(self, dist: float) -> None:
121            """Set distance for a dude."""
122            self._target_distance = dist
123            if self._debug:
124                sc = self._sc
125                position = (self._line_left + self._line_width *
126                            (1.0 - self._target_distance),
127                            self._line_bottom - 30)
128                ba.imagewidget(edit=self._body_image_target,
129                               position=(position[0] - sc * 30,
130                                         position[1] - sc * 25 - 70))
131                ba.imagewidget(edit=self._eyes_image_target,
132                               position=(position[0] - sc * 18,
133                                         position[1] + sc * 31 - 70))
134
135        def step(self, smoothing: float) -> None:
136            """Step this dude."""
137            self._distance = (smoothing * self._distance +
138                              (1.0 - smoothing) * self._target_distance)
139            self._update_image()
140            self._boost_brightness *= 0.9
141
142        def _update_image(self) -> None:
143            sc = self._sc
144            position = (self._line_left + self._line_width *
145                        (1.0 - self._distance), self._line_bottom + 40)
146            brightness = 1.0 + self._boost_brightness
147            ba.buttonwidget(edit=self._body_image,
148                            position=(position[0] - sc * 30,
149                                      position[1] - sc * 25 + self._y_offs),
150                            color=(self._color[0] * brightness,
151                                   self._color[1] * brightness,
152                                   self._color[2] * brightness))
153            ba.imagewidget(edit=self._eyes_image,
154                           position=(position[0] - sc * 18,
155                                     position[1] + sc * 31 + self._y_offs),
156                           color=(self._eye_color[0] * brightness,
157                                  self._eye_color[1] * brightness,
158                                  self._eye_color[2] * brightness))
159            ba.textwidget(edit=self._name_text,
160                          position=(position[0] - sc * 0,
161                                    position[1] + sc * 40.0))
162
163        def boost(self, amount: float, smoothing: float) -> None:
164            """Boost this dude."""
165            del smoothing  # unused arg
166            self._distance = max(0.0, self._distance - amount)
167            self._update_image()
168            self._last_boost_time = time.time()
169            self._boost_brightness += 0.6
170
171    def __init__(self, queue_id: str, address: str, port: int):
172        ba.app.ui.have_party_queue_window = True
173        self._address = address
174        self._port = port
175        self._queue_id = queue_id
176        self._width = 800
177        self._height = 400
178        self._last_connect_attempt_time: float | None = None
179        self._last_transaction_time: float | None = None
180        self._boost_button: ba.Widget | None = None
181        self._boost_price: ba.Widget | None = None
182        self._boost_label: ba.Widget | None = None
183        self._field_shown = False
184        self._dudes: list[PartyQueueWindow.Dude] = []
185        self._dudes_by_id: dict[int, PartyQueueWindow.Dude] = {}
186        self._line_left = 40.0
187        self._line_width = self._width - 190
188        self._line_bottom = self._height * 0.4
189        self.lineup_tex = ba.gettexture('playerLineup')
190        self._smoothing = 0.0
191        self._initial_offset = 0.0
192        self._boost_tickets = 0
193        self._boost_strength = 0.0
194        self._angry_computer_transparent_model = ba.getmodel(
195            'angryComputerTransparent')
196        self._angry_computer_image: ba.Widget | None = None
197        self.lineup_1_transparent_model = ba.getmodel(
198            'playerLineup1Transparent')
199        self._lineup_2_transparent_model = ba.getmodel(
200            'playerLineup2Transparent')
201        self._lineup_3_transparent_model = ba.getmodel(
202            'playerLineup3Transparent')
203        self._lineup_4_transparent_model = ba.getmodel(
204            'playerLineup4Transparent')
205        self._line_image: ba.Widget | None = None
206        self.eyes_model = ba.getmodel('plasticEyesTransparent')
207        self._white_tex = ba.gettexture('white')
208        uiscale = ba.app.ui.uiscale
209        super().__init__(root_widget=ba.containerwidget(
210            size=(self._width, self._height),
211            color=(0.45, 0.63, 0.15),
212            transition='in_scale',
213            scale=(1.4 if uiscale is ba.UIScale.SMALL else
214                   1.2 if uiscale is ba.UIScale.MEDIUM else 1.0)))
215
216        self._cancel_button = ba.buttonwidget(parent=self._root_widget,
217                                              scale=1.0,
218                                              position=(60, self._height - 80),
219                                              size=(50, 50),
220                                              label='',
221                                              on_activate_call=self.close,
222                                              autoselect=True,
223                                              color=(0.45, 0.63, 0.15),
224                                              icon=ba.gettexture('crossOut'),
225                                              iconscale=1.2)
226        ba.containerwidget(edit=self._root_widget,
227                           cancel_button=self._cancel_button)
228
229        self._title_text = ba.textwidget(
230            parent=self._root_widget,
231            position=(self._width * 0.5, self._height * 0.55),
232            size=(0, 0),
233            color=(1.0, 3.0, 1.0),
234            scale=1.3,
235            h_align='center',
236            v_align='center',
237            text=ba.Lstr(resource='internal.connectingToPartyText'),
238            maxwidth=self._width * 0.65)
239
240        self._tickets_text = ba.textwidget(parent=self._root_widget,
241                                           position=(self._width - 180,
242                                                     self._height - 20),
243                                           size=(0, 0),
244                                           color=(0.2, 1.0, 0.2),
245                                           scale=0.7,
246                                           h_align='center',
247                                           v_align='center',
248                                           text='')
249
250        # update at roughly 30fps
251        self._update_timer = ba.Timer(0.033,
252                                      ba.WeakCall(self.update),
253                                      repeat=True,
254                                      timetype=ba.TimeType.REAL)
255        self.update()
256
257    def __del__(self) -> None:
258        try:
259            ba.app.ui.have_party_queue_window = False
260            _ba.add_transaction({
261                'type': 'PARTY_QUEUE_REMOVE',
262                'q': self._queue_id
263            })
264            _ba.run_transactions()
265        except Exception:
266            ba.print_exception('Error removing self from party queue.')
267
268    def get_line_left(self) -> float:
269        """(internal)"""
270        return self._line_left
271
272    def get_line_width(self) -> float:
273        """(internal)"""
274        return self._line_width
275
276    def get_line_bottom(self) -> float:
277        """(internal)"""
278        return self._line_bottom
279
280    def on_account_press(self, account_id: str | None,
281                         origin_widget: ba.Widget) -> None:
282        """A dude was clicked so we should show his account info."""
283        from bastd.ui.account import viewer
284        if account_id is None:
285            ba.playsound(ba.getsound('error'))
286            return
287        viewer.AccountViewerWindow(
288            account_id=account_id,
289            position=origin_widget.get_screen_space_center())
290
291    def close(self) -> None:
292        """Close the ui."""
293        ba.containerwidget(edit=self._root_widget, transition='out_scale')
294
295    def _update_field(self, response: dict[str, Any]) -> None:
296        if self._angry_computer_image is None:
297            self._angry_computer_image = ba.imagewidget(
298                parent=self._root_widget,
299                position=(self._width - 180, self._height * 0.5 - 65),
300                size=(150, 150),
301                texture=self.lineup_tex,
302                model_transparent=self._angry_computer_transparent_model)
303        if self._line_image is None:
304            self._line_image = ba.imagewidget(
305                parent=self._root_widget,
306                color=(0.0, 0.0, 0.0),
307                opacity=0.2,
308                position=(self._line_left, self._line_bottom - 2.0),
309                size=(self._line_width, 4.0),
310                texture=self._white_tex)
311
312        # now go through the data they sent, creating dudes for us and our
313        # enemies as needed and updating target positions on all of them..
314
315        # mark all as unclaimed so we know which ones to kill off..
316        for dude in self._dudes:
317            dude.claimed = False
318
319        # always have a dude for ourself..
320        if -1 not in self._dudes_by_id:
321            dude = self.Dude(
322                self, response['d'], self._initial_offset, True,
323                _ba.get_v1_account_misc_read_val_2('resolvedAccountID', None),
324                _ba.get_v1_account_display_string())
325            self._dudes_by_id[-1] = dude
326            self._dudes.append(dude)
327        else:
328            self._dudes_by_id[-1].set_target_distance(response['d'])
329        self._dudes_by_id[-1].claimed = True
330
331        # now create/destroy enemies
332        for (enemy_id, enemy_distance, enemy_account_id,
333             enemy_name) in response['e']:
334            if enemy_id not in self._dudes_by_id:
335                dude = self.Dude(self, enemy_distance, self._initial_offset,
336                                 False, enemy_account_id, enemy_name)
337                self._dudes_by_id[enemy_id] = dude
338                self._dudes.append(dude)
339            else:
340                self._dudes_by_id[enemy_id].set_target_distance(enemy_distance)
341            self._dudes_by_id[enemy_id].claimed = True
342
343        # remove unclaimed dudes from both of our lists
344        # noinspection PyUnresolvedReferences
345        self._dudes_by_id = dict([
346            item for item in list(self._dudes_by_id.items()) if item[1].claimed
347        ])
348        self._dudes = [dude for dude in self._dudes if dude.claimed]
349
350    def _hide_field(self) -> None:
351        if self._angry_computer_image:
352            self._angry_computer_image.delete()
353        self._angry_computer_image = None
354        if self._line_image:
355            self._line_image.delete()
356        self._line_image = None
357        self._dudes = []
358        self._dudes_by_id = {}
359
360    def on_update_response(self, response: dict[str, Any] | None) -> None:
361        """We've received a response from an update to the server."""
362        # pylint: disable=too-many-branches
363        if not self._root_widget:
364            return
365
366        # Seeing this in logs; debugging...
367        if not self._title_text:
368            print('PartyQueueWindows update: Have root but no title_text.')
369            return
370
371        if response is not None:
372            should_show_field = (response.get('d') is not None)
373            self._smoothing = response['s']
374            self._initial_offset = response['o']
375
376            # If they gave us a position, show the field.
377            if should_show_field:
378                ba.textwidget(edit=self._title_text,
379                              text=ba.Lstr(resource='waitingInLineText'),
380                              position=(self._width * 0.5,
381                                        self._height * 0.85))
382                self._update_field(response)
383                self._field_shown = True
384            if not should_show_field and self._field_shown:
385                ba.textwidget(
386                    edit=self._title_text,
387                    text=ba.Lstr(resource='internal.connectingToPartyText'),
388                    position=(self._width * 0.5, self._height * 0.55))
389                self._hide_field()
390                self._field_shown = False
391
392            # if they told us there's a boost button, update..
393            if response.get('bt') is not None:
394                self._boost_tickets = response['bt']
395                self._boost_strength = response['ba']
396                if self._boost_button is None:
397                    self._boost_button = ba.buttonwidget(
398                        parent=self._root_widget,
399                        scale=1.0,
400                        position=(self._width * 0.5 - 75, 20),
401                        size=(150, 100),
402                        button_type='square',
403                        label='',
404                        on_activate_call=self.on_boost_press,
405                        enable_sound=False,
406                        color=(0, 1, 0),
407                        autoselect=True)
408                    self._boost_label = ba.textwidget(
409                        parent=self._root_widget,
410                        draw_controller=self._boost_button,
411                        position=(self._width * 0.5, 88),
412                        size=(0, 0),
413                        color=(0.8, 1.0, 0.8),
414                        scale=1.5,
415                        h_align='center',
416                        v_align='center',
417                        text=ba.Lstr(resource='boostText'),
418                        maxwidth=150)
419                    self._boost_price = ba.textwidget(
420                        parent=self._root_widget,
421                        draw_controller=self._boost_button,
422                        position=(self._width * 0.5, 50),
423                        size=(0, 0),
424                        color=(0, 1, 0),
425                        scale=0.9,
426                        h_align='center',
427                        v_align='center',
428                        text=ba.charstr(ba.SpecialChar.TICKET) +
429                        str(self._boost_tickets),
430                        maxwidth=150)
431            else:
432                if self._boost_button is not None:
433                    self._boost_button.delete()
434                    self._boost_button = None
435                if self._boost_price is not None:
436                    self._boost_price.delete()
437                    self._boost_price = None
438                if self._boost_label is not None:
439                    self._boost_label.delete()
440                    self._boost_label = None
441
442            # if they told us to go ahead and try and connect, do so..
443            # (note: servers will disconnect us if we try to connect before
444            # getting this go-ahead, so don't get any bright ideas...)
445            if response.get('c', False):
446                # enforce a delay between connection attempts
447                # (in case they're jamming on the boost button)
448                now = time.time()
449                if (self._last_connect_attempt_time is None
450                        or now - self._last_connect_attempt_time > 10.0):
451                    _ba.connect_to_party(address=self._address,
452                                         port=self._port,
453                                         print_progress=False)
454                    self._last_connect_attempt_time = now
455
456    def on_boost_press(self) -> None:
457        """Boost was pressed."""
458        from bastd.ui import account
459        from bastd.ui import getcurrency
460        if _ba.get_v1_account_state() != 'signed_in':
461            account.show_sign_in_prompt()
462            return
463
464        if _ba.get_v1_account_ticket_count() < self._boost_tickets:
465            ba.playsound(ba.getsound('error'))
466            getcurrency.show_get_tickets_prompt()
467            return
468
469        ba.playsound(ba.getsound('laserReverse'))
470        _ba.add_transaction(
471            {
472                'type': 'PARTY_QUEUE_BOOST',
473                't': self._boost_tickets,
474                'q': self._queue_id
475            },
476            callback=ba.WeakCall(self.on_update_response))
477        # lets not run these immediately (since they may be rapid-fire,
478        # just bucket them until the next tick)
479
480        # the transaction handles the local ticket change, but we apply our
481        # local boost vis manually here..
482        # (our visualization isn't really wired up to be transaction-based)
483        our_dude = self._dudes_by_id.get(-1)
484        if our_dude is not None:
485            our_dude.boost(self._boost_strength, self._smoothing)
486
487    def update(self) -> None:
488        """Update!"""
489        if not self._root_widget:
490            return
491
492        # Update boost-price.
493        if self._boost_price is not None:
494            ba.textwidget(edit=self._boost_price,
495                          text=ba.charstr(ba.SpecialChar.TICKET) +
496                          str(self._boost_tickets))
497
498        # Update boost button color based on if we have enough moola.
499        if self._boost_button is not None:
500            can_boost = (
501                (_ba.get_v1_account_state() == 'signed_in'
502                 and _ba.get_v1_account_ticket_count() >= self._boost_tickets))
503            ba.buttonwidget(edit=self._boost_button,
504                            color=(0, 1, 0) if can_boost else (0.7, 0.7, 0.7))
505
506        # Update ticket-count.
507        if self._tickets_text is not None:
508            if self._boost_button is not None:
509                if _ba.get_v1_account_state() == 'signed_in':
510                    val = ba.charstr(ba.SpecialChar.TICKET) + str(
511                        _ba.get_v1_account_ticket_count())
512                else:
513                    val = ba.charstr(ba.SpecialChar.TICKET) + '???'
514                ba.textwidget(edit=self._tickets_text, text=val)
515            else:
516                ba.textwidget(edit=self._tickets_text, text='')
517
518        current_time = ba.time(ba.TimeType.REAL)
519        if (self._last_transaction_time is None
520                or current_time - self._last_transaction_time >
521                0.001 * _ba.get_v1_account_misc_read_val('pqInt', 5000)):
522            self._last_transaction_time = current_time
523            _ba.add_transaction(
524                {
525                    'type': 'PARTY_QUEUE_QUERY',
526                    'q': self._queue_id
527                },
528                callback=ba.WeakCall(self.on_update_response))
529            _ba.run_transactions()
530
531        # step our dudes
532        for dude in self._dudes:
533            dude.step(self._smoothing)