1. 23 Dec, 2016 3 commits
    • Terence Martin's avatar
      Check that a play is possible before switching · 41bc2c35
      Terence Martin authored
      We can now check to ensure that if it is to be a player's turn, that
      there is a valid move for that player first. If not, we instead skip
      to the next player's turn.
      
      In the case that neither player has a valid move, we transition to the
      state that handles the final ball drop, although currently that's not
      how this state is handled.
      41bc2c35
    • Terence Martin's avatar
      Enhance state machine · 86cba188
      Terence Martin authored
      In order to handle some upcoming timing changes, make the state
      machine aware of how long it has been in the current state so that we
      can check it, knowing when to transition to another state or perform
      an event at a set interval.
      86cba188
    • Terence Martin's avatar
      Replace ball swapping with direct dropping · 1fffad2a
      Terence Martin authored
      Originally, the MazeContent class would store an array that contained
      the balls left to be played for both the human and computer player
      along with a variable that indicated which of the two were currently
      visible in the maze. We would then save the balls from the maze into
      one array and restore from the other.
      
      This actually causes a problem in that this gets the balls in the
      array out of sync with reality if you don't swap right away.
      
      For example, if the computer pushes a ball, then we check to see if
      the human can play a ball and cannot (all blocked), then we check to
      see if the computer can play to see if they can take another turn,
      since we did not save the ball state and the check happens from the
      array, it thinks it can play the ball it just played.
      
      If that ball is the only ball that can be played, this gets us into
      a situation where there is actually no move to be made.
      
      Now we instead just restore from an array to the maze, and every time
      a ball drops we check to see if it was in one of the arrays and remove
      it from there, thus always keeping everything in sync.
      1fffad2a
  2. 22 Dec, 2016 8 commits
    • Terence Martin's avatar
      Update game thumbnail · bdde1e10
      Terence Martin authored
      bdde1e10
    • Terence Martin's avatar
      Remove some old debug logs · a2de46c6
      Terence Martin authored
      This cleans up the console now that we know that everything works the
      way we want it to.
      a2de46c6
    • Terence Martin's avatar
      Add a "Just in case" check · 22e0f85d
      Terence Martin authored
      Just to ensure that nothing goes away, before we hide a ball while
      swapping we first remove it from the maze. This makes sure that the
      update loop can't hose it out from under us.
      
      I'm pretty sure this can't actually happen but I'm not 100% sure in
      what sequence the code runs if it is responding to input, so bette
      safe than sorry.
      22e0f85d
    • Terence Martin's avatar
      Re-enable the ability of the computer to take turn · 07e0ff3f
      Terence Martin authored
      Now that we have fixed the underlying issue, we can proceed with
      allowing the computer to take a turn again when it becomes its turn,
      since the balls are actually there now.
      
      The rest of the code should work as we want it to from this point, but
      I'll check anyway.
      07e0ff3f
    • Terence Martin's avatar
      Fix a bug; do not reap balls that are hidden · 52d8f9d0
      Terence Martin authored
      Yesterday's woes are caused by the fact that the update loop is
      constantly trying to reap hidden balls by marking them as dead.
      
      This is an issue because a dead ball will not render or update, which
      means that any computer balls that are hidden are almost immediately
      killed, causing them to no longer update even though they're still in
      the maze.
      
      Since we render all balls that are alive, this means that once the
      scene is set up with a set of live balls, it always looks like this
      even when the balls are swapped into the maze, because they won't
      overwrite themselves. Grrr.
      52d8f9d0
    • Terence Martin's avatar
      Include Question mark debugging key · 249f7e6e
      Terence Martin authored
      This adds in the question mark key during debugging mode to dump some
      information to the console of the maze entity currently at this maze
      position.
      249f7e6e
    • Terence Martin's avatar
      Turn off AI pushing of suggested ball · 05ae4a83
      Terence Martin authored
      The question mark key is now a player key, so it only works while it
      is the player's turn. Instead of playing the ball for the human
      player, it merely jumps the player to the suggested ball and turns to
      face the ball in order to set up playing.
      05ae4a83
    • Terence Martin's avatar
      Include some debug keys · b1a8a977
      Terence Martin authored
      For the purposes of debugging the bug from yesterday, introduce a key
      that allows us to switch directly to a set of balls.
      b1a8a977
  3. 21 Dec, 2016 6 commits
    • Terence Martin's avatar
      Include ball swapping at player switch time · d65471c1
      Terence Martin authored
      Now when the game state switches from one player to the other, the
      appropriate ball swap happens.
      
      This is curruently buggy for some reason; although the code is
      extremely straight forward, it somehow fails after the first time,
      which breaks everything and I can't figure out why just yet.
      
      This task will have to carry over into tomorrow.
      d65471c1
    • Terence Martin's avatar
      Update Maze end of game tracking · ecd041c3
      Terence Martin authored
      Now that we have a separate set of balls for the compute and for the
      player, we need better checking to determine if all balls have been
      played or not (since not all are visible).
      
      There is a method we can use for this, which makes the existing code
      much simpler.
      ecd041c3
    • Terence Martin's avatar
      Fix bug in MazeContents · f37c720c
      Terence Martin authored
      In favor of pasing a parameter to the swap function that swaps balls
      between the computer and the player that says if it should save the
      ball state or not, instead allow setting the visible ball state to
      clobber the existing ball row.
      
      This will be futher enhanced in the immediate future, but this causes
      a problem in that we want the player balls to be visible first, but
      because that is the default, the swap function swaps them and displays
      the wrong one.
      f37c720c
    • Terence Martin's avatar
      Fix ball visiblity during generation and swaps · 59c03a4a
      Terence Martin authored
      Now when balls are generated, they are generated hidden. Saving the
      balls to the appropriate array in the MazeContent class hides them and
      restoring them shows them again.
      
      This means that when we swap balls, we automatically hide and show
      everything as needed.
      59c03a4a
    • Terence Martin's avatar
      MazeGenerator now generates dual sets of balls · 05ae7e09
      Terence Martin authored
      When the maze is generated, we now fill out the generated balls into the
      appropriate arrays and then restore the default ones to the top row,
      which gets everything ready to go.
      05ae7e09
    • Terence Martin's avatar
      Enhance MazeContent class · c4a86a1a
      Terence Martin authored
      We now have two separate arrays that store the playable balls for each
      player, and have the ability to swap what set is currently visible in
      the top row of the maze.
      
      We can also query to see if a given player has a move or not, allowing
      us to skip the turn of a player if needed.
      c4a86a1a
  4. 20 Dec, 2016 6 commits
    • Terence Martin's avatar
      Remove superflous state · 983a442f
      Terence Martin authored
      As implemented we don't need a state for the AI to select its move;
      this happens as a part of the state in which it is taking its turn.
      983a442f
    • Terence Martin's avatar
      Use state logic to make a computer take a turn · c5d0a5ad
      Terence Martin authored
      This introduces the logic required to have the computer player take a
      turn. When this happens it will select a move, then walk to that
      location and push the appropriate ball.
      
      This lacks the change to the state where we know that the end of the
      round is at hand, so when this happens the two players just keep
      swapping back and forth doing nothing.
      c5d0a5ad
    • Terence Martin's avatar
      Proper visibility for Player entities · 2f3b5ae5
      Terence Martin authored
      We now track the switching of states so that when it is the player
      turn they are visible and when it is the computer turn they are
      visble, and the alternate entity visiblity is swapped when this
      happens.
      2f3b5ae5
    • Terence Martin's avatar
      Player entity can be visually turned off · 42e3654b
      Terence Martin authored
      This adds to the Player entity a visible property that allows us to
      turn off it's rendering. This will be used by the game scene to only
      display the human or computer player, but not both.
      42e3654b
    • Terence Martin's avatar
      Game scene makes a computer player object too · 50f47de4
      Terence Martin authored
      In order to prepare for the computer to take a turn, we need a Player
      entity that represents it as well.
      
      The Game scene now creates the entity and sets it up; it is currently
      visible at the same time as the player entity. This will be addressed
      shortly.
      50f47de4
    • Terence Martin's avatar
      Respond to ball drop finishing properly (moreso) · 09d29e3e
      Terence Martin authored
      Instead of just always being the turn of the player, we now take turns
      by swapping to an appropriate state depending on what the prior state
      was.
      
      This is only a base implementation; it doesn't know where to go after
      the final ball drop, it doesn't swap balls for the computer or player,
      and so on.
      09d29e3e
  5. 19 Dec, 2016 7 commits
    • Terence Martin's avatar
      Add more state handling · 021c44e1
      Terence Martin authored
      This adds extra events to the Maze entity that tell us if a ball has
      just started being dropped and when it has just finished stopping.
      
      Currently this is handled by disabling player input by switching to an
      appropriate state. Control returns when the ball stops dropping.
      021c44e1
    • Terence Martin's avatar
      Handle maze events in Game scene · a9a1a745
      Terence Martin authored
      This hooks up the Game scene to the events that the Maze object can
      trigger, so that we can react to the maze generation complete by
      making it the players turn, which adds controls back and once again
      puts us back to where we were before.
      a9a1a745
    • Terence Martin's avatar
      Constrain player input to provided state · 9f98a325
      Terence Martin authored
      This shifts the code responsible for allowing the player to take a
      turn (or do something that can happen only on their turn) into its own
      method, which will handle it as before but do nothing if the state
      does not indicate that this is the player's turn.
      
      This proves that the player will not be able to interact with anything
      when it is not their turn.
      9f98a325
    • Terence Martin's avatar
      Implement MazeEventListener · 0c2b9154
      Terence Martin authored
      This adds to the Maze entity the ability to add a listener object that
      will be told when various events happen. Currently this is just that
      the maze generation is now complete.
      0c2b9154
    • Terence Martin's avatar
      Add state machine to Game scene · f9f42d11
      Terence Martin authored
      This adds in the actual property that includes the state machine in
      the game state. We set up a state and priorState property right on the
      Scene class instance itself so that we can get at the value easier.
      
      This checks at the time that the scene is activated to see if it is
      currently no state (startup) and if so, changes the state to the level
      generation state, which will then kick off the level generation.
      
      This is basically a roundabout way to do what we were already doing.
      f9f42d11
    • Terence Martin's avatar
      Stop Maze entity from generating a Maze on init · 77d174b3
      Terence Martin authored
      This should actually be done as part of the state machine, since we
      need to do it at controlled times. This also sets up for the idea of
      generating the world in steps instead of all at once, in case we get
      that far along in the development.
      77d174b3
    • Terence Martin's avatar
      Include new StateMachine class · 9d91e183
      Terence Martin authored
      This is a first pass and is subject to changes, so we'll see what
      happens.
      
      This is set up so that the machine maintains both a current and a
      previous state (i.e. it has a state stack size of 1), allowing us to
      not only track our current state but also make rudimentary decisions
      about where to go next.
      
      There is a change listener interface that allows the machine to
      directly notify interested parties when the state changes so that they
      can take the appropriate action.
      
      This code currently has a proviso (in comments only) that warns again
      changing the state of the machine while inside the change handler, but
      I think as long as there is only ever a single listener this is safe.
      In the case of a multiple listener, notifications to objects that get
      notifed after the current cycle might be undefined.
      9d91e183
  6. 18 Dec, 2016 6 commits
    • Terence Martin's avatar
      Streamline player movement · 9b473e5a
      Terence Martin authored
      In preparation for the future moving of the computer player on the
      maze, make a simple method that will turn and move a player entity in
      an appropriate direction.
      9b473e5a
    • Terence Martin's avatar
      Simplify Ball and Brick · eadf37a0
      Terence Martin authored
      The ball and brick were still using comparisons against the currently
      running animation in order to determine if they were hidden or not,
      when they could much easier just use the flag.
      eadf37a0
    • Terence Martin's avatar
      Enhance AI · e57b472b
      Terence Martin authored
      This is a feature of the AI that I wanted to implement originally but
      which I did not get around to in the press for getting the basic
      concept up and running.
      
      Essentially, when the AI is calculating the move that it wants to
      make, it  should pretend that the gray bricks are not actually there
      (even if they are) under the theory that when the round ends, such
      balls will drop  and would theoretically score more.
      
      To this end, the collision API for detecting if an entity blocks a
      ball now gets the isSimulation parameter so that this can happen.
      e57b472b
    • Terence Martin's avatar
      Fix AI bug · 1749dc5a
      Terence Martin authored
      During simulation of a drop, a vanished gray brick would count as a
      bonus brick and add points to the ball, even though in practice this
      is not a situation in which points are scored.
      
      As a result of this the AI would prioritize moves through vanished
      gray bricks over regular drops for no discernible reason.
      1749dc5a
    • Terence Martin's avatar
      Enhance Player entity movement API · 6e654caa
      Terence Martin authored
      This is how this should have been implemented originally, but I just
      threw a quick couple of functions together for expediency to try and
      get the change finished before the end of that devember day.
      
      This merges the methods for moving left and right to simple
      translation and updates the documentation comment on this and the
      jumpTo method to not suck.
      6e654caa
    • Terence Martin's avatar
      Add computer animations to Player entity · 97e5cc01
      Terence Martin authored
      This is a simple operation but allows us to support the computer
      player as well. This adds in the animations that are needed in order
      to display as the computer and a parameter in the contructor to
      specify which type of player to be.
      
      The code to select the appropriate animation was already set up to
      work as desired so no changes were needed.
      97e5cc01
  7. 17 Dec, 2016 4 commits
    • Terence Martin's avatar
      Implement simple AI tests · 29cbb3c8
      Terence Martin authored
      This just has the AI run to select a ball, then jump the player there
      and push it so we can see what happens.
      
      This updates the player to have a new test method for jumping to a
      specific location in the maze instead of just going left and right.
      29cbb3c8
    • Terence Martin's avatar
      Implement simple AI · 769484a9
      Terence Martin authored
      This just finds all pushable balls and then simulates them moving
      through the maze to see which one is best. This uses a simple metric
      of just which ball would score the most points at this exact second.
      769484a9
    • Terence Martin's avatar
      Get Maze ready for AI · ec9dcc28
      Terence Martin authored
      This creates some accessor methods for entering and exiting the
      simulation for all entities that require it, and exposes the method
      that calculates the next ball position so that outside code can see
      it.
      ec9dcc28
    • Terence Martin's avatar
      Implement simulation save/restore for Brick · d398dc3f
      Terence Martin authored
      For a bonus brick, we handle touches different. If we are not
      simulating, we do what we always did (only nicer; forgot to refactor
      some code).
      
      If we ARE simulating, we update the score in the ball that touched us
      to indicate that we actually were collected by this ball and then set
      a flag saying it happened so we won't do it again.
      d398dc3f