defactosoftware/bearnecessities

Multiplayer bear game with Phoenix Live View

BearNecessities.Umbrella

Front	Side	Back

Death

Install

• Run mix deps.get in the main dir
• Run mix ecto.create in the main dir
• Run yarn in apps/bear_necessities_web/assets

Running

Start with mix phx.server, go to https://localhost:4000/ and wait for the assets to compile

bearnecessities's Issues

Determine texture variants on the server

At the moment the grass texture variant is based on a random number. The problem with this approach is that the texture changes while walking.

https://github.com/fatboypunk/BearNecessities/blob/6eef3deb0b4549098ce88ea7b414385602946e13/apps/bear_necessities_web/lib/bear_necessities_web/views/playfield.ex#L7

So we somehow want to determine and store the texture state on the server, for example as %Grass{texture: 2} and %Tree{texture: 4}.

This also means that tiles can have multiple layers, for example:

[
  %Grass{texture: 2},
  %Tree{texture: 4}
]

Thoughts on this?

---

Would something like this make sense?

%Game{
  field: [
    # row 1 (11 tiles)
    [
      %Tile{layers: [%Grass{texture: 2}]},
      %Tile{layers: [
        %Grass{texture: 2},
        %Bear{}
      ]},
      %Tile{id: 3, layers: [%Grass{texture: 4}]},
      # ...
    ],
    # row 2 (11 tiles)
    [
      %Tile{layers: [%Grass{texture: 3}]},
      %Tile{layers: [%Grass{texture: 2}]},
      %Tile{layers: [
        %Grass{texture: 1}
        %Tree{texture: 3}
      ]},
      # ...
    ]
    # 9 more rows ...
  ]
}

Use Matrix for Tile Map?

related #28

Matrices are used in most tile-based games afaik. For Elixir there is the Matrix modules which might be helpful. Not sure if this is something for us.

Some resources on this

• Tilemaps tuturial
• Tilemaps tuturial: Square tilemaps implementation (Static maps)
  source / demo
• http://technologies4.me//articles/viewport-culling-tile-map-a3/viewport-culling-methods-p1/
• https://gamedevelopment.tutsplus.com/tutorials/an-introduction-to-creating-a-tile-map-engine--gamedev-10900

Basic example from the demo above

const map = {
  cols: 8,
  rows: 8,
  tsize: 64,
  tiles: [
    1, 3, 3, 3, 1, 1, 3, 1,
    1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 2, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 2, 1, 1, 1, 1,
    1, 1, 1, 1, 2, 1, 1, 1,
    1, 1, 1, 1, 2, 1, 1, 1,
    1, 1, 1, 0, 0, 1, 1, 1
  ],
  getTile: (col, row) => {
    return this.tiles[row * map.cols + col]
  }
};

translated to:

Dying animation

Put the URL of the app on the GH repo

https://unbearable.nl

Bears are not removed from state when their sockets are closed

Possibility to monitor the bears and let the monitor send a message to clear the bear from state if the bear process is killed.

Add names to bears on the field

Controls for mobile devices (no keyboard)

We need mobile support!

Options

1. On-screen keyboard controls

   

2. Fake button overlays

   

Regenerate trees with honey

Fit everything on screen to prevent scrollbars

Scrollbars interfere with game controls

Clawing animation shortens after multiple space bar key presses

When clawing multiple times in under 1000ms, the animation will not finish anymore. Something with the decreasing timer in Player.handle_info/2 for :update_claw

Make Player display names unique

Add bees

Hide them in trees, or let them follow bears that are closest maybe?

Add a bear trap

This should slow the movement of the bear and remove some honey?

Order contending players by score high to low

Claw animation

Need one

Add a guide to the lobby

use arrow keys to move
use space bar to get honey from trees and other bears

Show list of bears connected to the lobby

So you can see all the connected players

No sound on safari?

Seems like I don't hear sound on safari.
Version 12.0.3 (14606.4.5)

Upate the view to show where other bears are

After the client connects, mount/2 will be invoked inside a spawned
LiveView process. At this point, you can use connected?/1 to
conditionally perform stateful work, such as subscribing to pubsub topics,
sending messages, etc. For example, you can periodically update a LiveView
with a timer:
defmodule DemoWeb.ThermostatLive do
use Phoenix.LiveView
...
def mount(%{id: id, current_user_id: user_id}, socket) do
if connected?(socket), do: :timer.send_interval(30000, self(), :update)
case Thermostat.get_user_reading(user_id, id) do
{:ok, temperature} ->
{:ok, assign(socket, temperature: temperature, id: id)}
{:error, reason} ->
{:error, reason}
end
end
def handle_info(:update, socket) do
{:ok, temperature} = Thermostat.get_reading(socket.assigns.id)
{:noreply, assign(socket, :temperature, temperature)}
end
end
We used connected?(socket) on mount to send our view a message every 30s if
the socket is in a connected state. We receive :update in a
handle_info just like a GenServer, and update our socket assigns. Whenever
a socket's assigns change, render/1 is automatically invoked, and the
updates are sent to the client.

I think we could use this to update the view every few milliseconds/seconds(?) to return the state of where other bees/bears are