awkwardly, the case in a networked game where a player runs out of
tiles in his turn but the server hasn't responded yet to kill the
game. It remains the player's turn and he can make lots of 0-point
moves while waiting. (Making it the next player's turn would be the
right thing to do if that player were always on a different device.)
player. Works for gtk client. Compiles for Android but there's no UI
yet to specify more than one dict. Management of dupicate dicts
without duplicating memory -- refcounting -- will be up to the
platforms.
show them and another group depending on whether trading at the time.
To make that work, replace the individual calls made to dis/enable
toolbar buttons with a single jin call that takes a struct full of
booleans and make that struct available in BoardActivity where menus
are hidden/shown. Remove the individual calls from the jin interface.
swapping to view of the current player's board if the current player
is remote -- because then won't be able to swap back to own view until
it's your turn. Fixes annoyance in multi-device game on Android.
than as part of an exchange) and to remove feature where tapping empty
cell moves selected tile there. This is to address user confusion on
Android, and I'll ask for testing before putting this in the main
branch. This leaves only place-arrow-then-tap as an alternative to
drag-and-drop, and may annoy people. Worth trying: disable only the
automatic selection of another tile after the selected one is dropped.
implemented (when not smart) as trying to match the human's score to a
per-robot value between 1 and 100 that gives the percentage of best
moves to store before picking randomly from among them. So a 1 means
save only the best move and always pick it; 100 means save all the
best moves (how many are saved is compile-time configurable) and pick
one of them. Because it's settable per-robot a smarter robot can be
played against a dumber one (though I may choose not to make it
settable per-robot on shipping versions.)
game works to completion with both signing up as guests (no -s) with
one local and one remote player (identical commandlines.) Not yet
tested: if any signs up as a host, reconnecting rather than
connecting, etc. This is just a snapshot.
possible moves in either order both within a cached subset and when
building cached subsets. Still a bit buggy (shows the same move twice
when moving backwards and reaches the top-scoring move) and not well
tested.
cols. When figuring internal dimensions zoom out as needed to meet
maxSize value. This fixes problem where rotating a zoomed portrait
board to landscape leaves cells bigger than they can be made by
zooming, but then the desired zoom has been changed and stored and so
on return to portrait cells are smaller/less zoomed. Need to see if I
can live with that.
scroll-related fields into a struct so vertical and horizontal can be
handled by the same code; add to board_zoom out params indicating
whether further zooming is possible.
Includes ability to scroll horizontally by dragging. Board init API
changes to specify board width and max height instead of cell
dimensions, so now board owns task of picking cell size. If the
number of cells does not evenly divide into a board dimension then the
extra pixels are distributed among some columns/rows in a way that
still allows bitblit-based scroll implementations (though horizontal
scrolling at this point always does an invalAll()). Not yet tested
with overlapping tray. And still need to allow rows to be taller than
cols are wide if platform code has given the space. Stream format
changes with this checkin.
they're 2/3 their height higher. Meant to work better on touchscreens
where finger would otherwise prevent user from seeing where the drop
will land. Still not tested or tuned on device.
areas, pass into draw whether to show it highlighted, and fire a util
method when it's clicked on. Intent is that platforms show the
remaining tiles dialog.
so, and only if it is not move the cursor (or if needed to keep it
visible after scroll.) This makes it easier for users to scroll --
but may not be needed if focussing scrolbar works.
access can then be via a ptr, more effecient and faster. The change
seems to save 1K of generated code. No changes to algorithms, only to
field access.
The goal is to have the tray drawn on top, even if it's otherwise
hidden, when the whole thing's focussed. Fix is to inval and
recalculate rects more often as focus changes or tray is hidden.
board. Enabling key-to-text works, but constants to turn it off
aren't in cegcc. So for b2 add a quick hack where 1 means first tile
in tray, 7 means last (rightmost). Enable and test on gtk.
util_altKeyDown to allow user to choose between scrolling board and
dragging the hint rect when both are possible. add adjustYOffset;
make it and board_setYOffset more tolerant of out-of-bounds inputs and
use that to simplify calling code.
before and after the scroll. Otherwise on platforms where scrolling
is via a bitmove the old position gets scrolled away and never redrawn
leaving ghost tile parts lying around.
