game design – Music, scene, or character first

Here’s my personal description, skip if you want:

I’m a high school student and I have three years of JavaScript experience. I made my way and created several project (most left unfinished) that includes database, server, and client. These days, however, Toby Fox got my attention. I finished the game as well as went through lots and lots of community stuff. I got inspired and now I want to give game development a try (I understand game design is different from coding, and I just want to give it a shot). From my past experience on JavaScript, I know there’s no “right way” in terms of styling and designing but more of a personal preferences and that might make this question meaningless, but still I need an answer from experienced. If there’s anything wrong with my question, please tell me as I’m new and I wouldn’t want to make any more mistakes.

Question:

I know there’s different aspects of a game: scene, character, story, mechanic, and music (maybe there’s more). I never design my own game before, and I would like to know when brainstorming, which aspect of a game is the best to get started on?

movement – What are some good examples of the practical usages of cross product in game development?

I know how to calculate cross product, and know that the cross product of 2 vectors is a third vector that is perpendicular to a plane created by the first 2 vectors.

However, I have not seen any good explanations about the practical usages of cross product in game development.

Would anyone please tell me some practical examples of the usages of cross product in game development ? (If you can share some links to websites that show me some good examples, that will be great too).


I am sorry if this question is vague, and some people may not like it or may even suggest that it should be closed. But, I have tried to google and can’t find any good, practical, and meaningful explanation yet.

What are the ages of role-playing game history?

The first age of RPG is arguably 1971 – 1977

In the period before the Lake Geneva Group was introduced to the RPG ideas that eventually became D&D, Dave Arneson and his associates in the Twin Cities area had been playing in Blackmoor, more or less playing and playtesting in the wild (if we view it with hindsight). They were beginning to get a grip on what they had discovered/created1. Arneson has stated that it started in 1971. (In the opening to the film The Secrets of Blackmoor)

The period 1972 to 1974 saw a synergy between the Twin Cities group, the Lake Geneva group, and a few others all of which led to D&D getting published in early 1974. (The court decision that Arneson provided the spark, although the hard work of getting published was surely led by Gygax and the Lake Geneva crew, is born out by Kuntz’ testimony in his recently published essays on Dave Arneson’s genius in game design and concepts).

From that point until just after GenCon IX, August 1976, the momentum was moving in a particular direction, however a pivotal event that foreshadowed a sea change, and coincided with the departure from TSR of Dave Arneson, Rob Kuntz, Dave Meggary, and a number of other early pioneers was a meeting in TSR after that convention. (Seeking date, will consult other sources).

Kuntz, as an eyewitness and insider, asserts that before that meeting, LGTSA and MMSA were in harmony. (Page 21, Kuntz, see source below).

Once the decision to produce AD&D was made and followed up on, the lead model in the hobby/industry/RPG-verse significantly changed, though (as Shannon Appelcline points out in Designers and Dragons) a dozen game publishers were active in the last half of the 1970’s. This burst of activity and success for the hobby, and the companies involved in it, both spread the hobby and accelerated its movement in varying directions.

With the above in mind, the first age of RPG’s lasted from 1970 to 1977. (If that’s imprecise, it’s at least very close).

  • You can argue that this period needs to be broken into two bits: the era of discovery and at table development from about 1971-1974, predating the publishing of D&D’s first printing, where Roleplaying was certainly happening but RPG’s weren’t formally published, and the initial burst of success from January 1974 through the first three years of discovery and spread of this new and unusual game form. In a few months (spring 2019) another film and some more material drawn from Twin Cities area veterans of Arneson’s first role playing, and other experiences in that same time frame, may shed more light on how to better classify “ages” and “periods” … but it’s hard to be objective given that there may still be a few axes to grind before it’s all over. (The Secrets of Blackmoor is the result of this group’s efforts).

The AD&D Monster Manual was published in 1977 which made a major player in this new game form take a particular direction. That games from that ear are still alive and well — Ken St Andre’s Tunnels and Trolls among them — shows that some divergence was already taking place by that point in time. Kuntz cites a TSR “sweet spot” of the years 1974-1977 in numerous points in the cited work so it makes sense to end the first age, or era, around 1977.

A key transition point not at TSR, in 1977, is the publication of quality RPG material by Chaosium: All the Worlds’ Monsters. With the publication of Traveller in 1977, and Runequest in 1978, the next age of RPGs was well underway.

1977 was the year that Chaosium began publishing RPGs. It was an era when everyone was publishing supplements for the original Dungeons & Dragons game. Even though Stafford had decided to avoid this route for Glorantha, he was still happy to publish Steve Perrin & Jeff Pimper’s All the Worlds’ Monsters, a D&D-based monster manual.

Though AD&D got their own Monster Manual out later the same year, the Worlds’ Monsters supplements put Chaosium on the map as a publisher of RPGs. It was a fledgling industry that then consisted of just TSR, Flying Buffalo, GDW, Judges Guild, Fantasy Games Unlimited, Metagaming Concepts, and a few smaller companies–Chaosium may well be one of only two survivors from this dawn of roleplaying. (From Shanon Appelcline, blog post, Copyright © 2006 Shannon Appelcline, published by RPGnet under license)


1 While Diplomacy had an influence on a lot of proto RPG development, given its popularity among the early practitioners of the RPG scene, I can’t point to Diplomacy as having initiated RPGs since it remains a board game. (Great training for a chaotic RPG setting).

The Braunstein role playing Wesley is credited with introducing as an ancestor to the hobby comes from a form of war gaming (for the military) survives to this day, at places like JRTCC in Fort Polk Louisiana. That form of non-attrition based, non-linear outcomes that are ruled on and judged by a war game staff still goes on (albeit aided a lot by computers and other machines). I participated in four major war games/exercises (1990’s) where the “white cells” behaved as game masters – these multi-million dollar war games/exercises/CPXs require professional military officers and troops to confront a lot of decisions that don’t have hard and fast “right” answers. The JRTCC exercises are particularly good at the “it’s not quite war and you can’t solve this through firepower” (sort of like “you can’t murderhobo your way through this adventure”) style of exercise/war game. That kind of role play, where the GM/White Cell/Judge makes a ruling so that the exercise/play can continue is strikingly close, though at a much larger scale, to RPGs.


Source:
Dave Arneson’s True Genius, Robert J. Kuntz, Three Line Studios, 2017, pages 20-25; points summarized for brevity due to the authors inflated prose style.

Closing note: Kuntz contests the Braunstein/Chainmail genesis of Arneson’s game design conceptual approach, but at the moment I am having trouble unpacking his arguments, and need to cross reference with other sources to see what matches and what doesn’t. I sense a little score settling as an undercurrent.
Follow Up Note: the boggswood blog has a complementary view on the proto D&D period that looks to agree with a lot of Kuntz’s points in the book.

unity – How to create a aimLine in a pool game on unity2d?

I want to design a Aim Line for my player in unity2d. The game is split screen so what I basically want is that whenever its my player turn I want my player which is a ball to cast a raycast like you see in pool/snooker/billiard games. Reference.

This image is what I want. I have done some research and this image is also from other forum which uses Gl lines that seems a little complicated for me So what I have done is this.

   public LineRenderer lr;
public Transform rayStart;
void FixedUpdate()
{
    // Cast a ray straight down.
    RaycastHit2D hit = Physics2D.Raycast(rayStart.position, Vector2.up);

    // If it hits something...
    if (hit)
    {
        Debug.Log(hit.transform.name);
        lr.SetPosition(0, rayStart.position);
        lr.SetPosition(1, hit.point);
   
    }
}

What is the problem of using a self signed-certificate for a game?

You don’t seem to understand the issue with self-signed certificates, so allow me to explain.

Generally, when people say “Don’t use self-signed certificates!”, they mean in the context of a web-server, in which you expect the general public to connect via a web browser. In such a situation, if a self-signed certificate is used, this will lead to an error message:

Self-Signed Certificate Warning

Users will naturally want to ignore the warning and proceed – after all, that’s the only way for them to use your website. So if an attacker intercepts the connection and presents his own self-signed certificate, the user would not be able to see that. After all, the error message is seen as a natural part of the process.

Self-Signed Certificates in other settings

Companies usually have a self-signed certificate as a root-certificate for internal services. This certificate is distributed internally (usually via Active Directory) and thus trusted by all clients.

This is a normal setup and works as intended. If an attacker would attempt to intercept the connection, an error would occur, as his certificate would not be trusted.

Self-Signed Certificates for your game

I assume that you have a server, which manages the game state, and a game client (likely a native client). In this situation, there is nothing wrong with using a self-signed certificate. Simply distribute the certificate with the client and keep the private key on the server.

Can the attacker just steal the private key?

Only if your server has a vulnerability, which would allow the attacker to do so. But that risk would also exist with a certificate signed by an external certificate authority.

legal – Looking to build a game that uses names of Premier League teams – what are the steps required to stay compliant

If you want to use someone’s intellectual property, you need to contact them regarding licensing.

The description of your game essentially sounds like gambling. As such you would also need to check to see if you are compliant with any laws you might be subject to as well as any terms of service with respect to whatever platform you plan to release on.

Does anyone know of a simple one page warfare system I could drop into a D&D game for a large battle?

I’m running a large battle.

We’re using D&D 5E.

Does anyone know of a simple one page warfare system I could drop in to make the battle a little more hands on?

Simple battleship game in Groovy

I am trying to learn Groovy and I did an attempt on implementing a simple Battleship game. Any feedback is welcome. I will start with the modal classes I have.

Modal classes

Coordinate.groovy

package biz.tugay.groovyship.modal

import groovy.transform.Memoized

/**
 * A Coordinate represents a certain point.
 *
 * <pre>
 * 0,0  5,0
 * .....
 * .
 * .
 * .
 * .
 * .
 * 0,5
 * </pre>
 */
class Coordinate
{
  final int column

  final int row

  private Coordinate(int column, int row) {
    this.column = column
    this.row = row
  }

  @Memoized
  static Coordinate of(int column, int row) {
    return new Coordinate(column, row)
  }
}

Ship.groovy

package biz.tugay.groovyship.modal

/**
 * A Ship object is represented as a Map of Coordinate:Boolean where the Boolean value represents whether
 * the ship coordinate has been hit by a missile or not.
 * An example might be: (
 *   (0,0):false,
 *   (1,0):false,
 *   (2,0):true
 * ).
 * That would be a ship floating horizontally on the first row of a board, where its last piece has been damaged.
 */
class Ship
{
  def coordinateIsHitByMissileMap = (:) as Map<Coordinate, Boolean>

  Ship(Coordinate... coordinates) {
    coordinates.each { this.coordinateIsHitByMissileMap.put(it, false) }
  }
}

Board.groovy

package biz.tugay.groovyship.modal

import biz.tugay.groovyship.commons.GroovyShipConstants

class Board
{
  @SuppressWarnings('GrFinalVariableAccess')
  final int boardSize

  Board(int boardSize) {
    if (boardSize < GroovyShipConstants.MINIMUM_BOARD_SIZE) {
      throw new IllegalArgumentException("Board size must at least be: $GroovyShipConstants.MINIMUM_BOARD_SIZE")
    }
    this.boardSize = boardSize
  }

  def ships = () as Set<Ship>

  def missileAttempts = () as Set<Coordinate>
}

The modal classes do not have any business logic – that is on purpose. I want to be able to serialize / deserialize them as I proceed so that I can save the state of the game into a file and then load it back. Although adding methods would still be ok, I find it simpler the classes to be only data, hence my approach.

I also have a commons class I can put here, this class I am planning to extend as well in future.

GroovyShipConstant.groovy

package biz.tugay.groovyship.commons

class GroovyShipConstants
{
  public static final int MINIMUM_SHIP_LENGTH = 1

  public static final int MAXIMUM_SHIP_LENGTH = 4

  public static final int MINIMUM_BOARD_SIZE = 4
}

Service Classes

ShipService.groovy

package biz.tugay.groovyship.service

import biz.tugay.groovyship.modal.Coordinate
import biz.tugay.groovyship.modal.Ship

import static java.lang.Math.min
import static java.util.concurrent.ThreadLocalRandom.current

import static biz.tugay.groovyship.commons.GroovyShipConstants.*

class ShipService
{
  /**
   * Creates a {@link biz.tugay.groovyship.modal.Ship} object depending on the board it will be placed in.
   *
   * The passed in {@code boardSize} ensures the ship randomly generated
   * will fit in a board with a size of {@code boardSize}.
   *
   * @param boardSize The size of the board this ship should successfully can be placed in.
   * @return The randomly generated ship.
   */
  Ship newRandomShip(int boardSize) {
    int shipSize = current().nextInt(MINIMUM_SHIP_LENGTH, 1 + min(boardSize, MAXIMUM_SHIP_LENGTH))
    boolean isHorizontal = current().nextBoolean()

    int shipCoordinateColumn
    int shipCoordinateRow

    // Ensure the ship does not exceed the borders of the board
    if (isHorizontal) {
      shipCoordinateColumn = current().nextInt(boardSize - shipSize + 1)
      shipCoordinateRow = current().nextInt(boardSize)
    }
    else {
      shipCoordinateColumn = current().nextInt(boardSize)
      shipCoordinateRow = current().nextInt(boardSize - shipSize + 1)
    }

    // Generate the coordinates of the ship
    Coordinate() coordinates = new Coordinate(shipSize)
    (0..<shipSize).each {
      coordinates(it) = isHorizontal ?
          Coordinate.of(shipCoordinateColumn + it, shipCoordinateRow) :
          Coordinate.of(shipCoordinateColumn, shipCoordinateRow + it)
    }

    new Ship(coordinates)
  }

  /**
   * As per the rule of the game, boundaries of a ship is the location of the ship itself
   * and the immediate surroundings of it. A ship with a size of 1 on coordinate 1,1 would
   * have boundaries: 0,0 - 0,1 - 0,2 - 1,0 - 1,1 - 1,2 - 2,0 - 2,1 - 2,2
   * @param ship The ship the boundaries will be checked.
   * @param coordinates The coordinates to check if any of them is in the boundaries of the ship.
   * @return Whether any of the coordinates provded is in the boundaries of the ship.
   */
  boolean isBoundariesOfShipInCoordinates(Ship ship, Collection<Coordinate> coordinates) {
    boolean occupiesCoordinate = false

    ship.coordinateIsHitByMissileMap.keySet().each { shipCoordinate ->
      (-1..1).each { colIndex ->
        (-1..1).each { rowIndex ->
          if (coordinates.contains(Coordinate.of(shipCoordinate.column + colIndex, shipCoordinate.row + rowIndex))) {
            occupiesCoordinate = true
          }
        }
      }
    }

    return occupiesCoordinate
  }

  /**
   * @param ship The ship to check.
   * @param coordinate The coordinate to check.
   * @return Whether a ship immediately occupies the coordinate.
   */
  boolean hasPartOnCoordinate(Ship ship, Coordinate coordinate) {
    ship.coordinateIsHitByMissileMap.keySet().contains(coordinate)
  }

  /**
   * Updates the state of the ship if the missileCoordinate hits this ship.
   * If this ship does not have any parts in the incoming missileCoordinate, this method
   * returns false without modifying the state of the {@code ship}.
   *
   * @param missileCoordinate The coordinates of the incoming missile.
   * @return Whether the missile hit the ship or not.
   */
  boolean attemptMissileHit(Ship ship, Coordinate missileCoordinate) {
    Coordinate coordinate = ship.coordinateIsHitByMissileMap.keySet().find({ it == missileCoordinate })
    if (coordinate) {
      ship.coordinateIsHitByMissileMap.replace(coordinate, true)
    }
    coordinate
  }

  /**
   * @return Whether this ship is sank or not.
   */
  boolean isSank(Ship ship) {
    ship.coordinateIsHitByMissileMap.values().every { it }
  }
}

BoardService.groovy

package biz.tugay.groovyship.service

import biz.tugay.groovyship.modal.Board
import biz.tugay.groovyship.modal.Ship
import biz.tugay.groovyship.modal.Coordinate

class BoardService
{

  ShipService shipService = new ShipService()

  /**
   * Attempts to add the {@code ship} to the board. As per the rules of the game, a ship cannot overlay with
   * any other existing ship on the board. Ships also cannot be adjacent to each other.
   *
   * @param board The board the ship will be added to, potentially having ships already added.
   * @param ship The new ship that is being attempted to be added.
   * @return Whether ship was added to the board or not.
   */
  boolean addShip(Board board, Ship ship) {
    def shipCoordinates = ship.coordinateIsHitByMissileMap.keySet()

    if (board.ships.any { shipService.isBoundariesOfShipInCoordinates(it, shipCoordinates) }) {
      return false
    }

    board.ships.add(ship)
  }

  /**
   * Sends a missile to to the board. Returns whether it hit a ship or not.
   *
   * @param board The board the missile be sent to
   * @param column The column of the missile
   * @param row The row of the missle
   * @return Whether a ship was hit or not
   */
  boolean missileCoordinate(Board board, int column, int row) {
    def missileCoordinate = Coordinate.of(column, row)
    board.missileAttempts << missileCoordinate

    boolean anyHit = false
    board.ships.each { { anyHit = anyHit || shipService.attemptMissileHit(it, missileCoordinate) } }

    anyHit
  }

  /**
   * @param board The board to be checked if all ships on the board sank
   * @return Whether all ships on the board sank
   */
  boolean allShipsSank(Board board) {
    board.ships.every { it.coordinateIsHitByMissileMap.values().every { it } }
  }
}

GameService.groovy

package biz.tugay.groovyship.service

import biz.tugay.groovyship.modal.Board

import biz.tugay.groovyship.modal.Ship

/**
 * Responsible for creating a new board with the desired size
 * and desired number of ships.
 *
 * This is the only service that should be consumed for creating
 * and interacting with the game as it exposes the required methods
 * such as sendMissile and allShipsSank.
 */
class GameService
{
  ShipService shipService = new ShipService()

  BoardService boardService = new BoardService()

  Board createNewGame(int boardSize, int numberOfShips) {
    Board board = null

    int numberOfAttempts = 0
    while (!board && ++numberOfAttempts < 100) {
      board = boardWithRandomShips(boardSize, numberOfShips)
    }

    return board
  }

  boolean sendMissile(Board board, int column, int row) {
    boardService.missileCoordinate(board, column, row)
  }

  boolean allShipsSank(Board board) {
    boardService.allShipsSank(board)
  }

  private Board boardWithRandomShips(int boardSize, int numberOfShips) {
    int numberOfAttempts = 0

    Board board = new Board(boardSize)
    int numberOfShipsPlaced = 0
    while (numberOfShipsPlaced < numberOfShips) {
      numberOfAttempts++
      Ship ship = shipService.newRandomShip(boardSize)
      if (boardService.addShip(board, ship)) {
        numberOfShipsPlaced++
      }
      // We are unable to find a way to place $numberOfShips of ships in this board the way we placed
      // the existing ships so far. Return null - caller may do another attempt if it wants to.
      // The way we place the first few ships will determine whether a solution can be found or not.
      if (numberOfAttempts > 100) {
        return null
      }
    }
    board
  }
}

Client/Controller

And finally I can share the command line client I have:

CliGameController.groovy

package biz.tugay.groovyship.cli

import biz.tugay.groovyship.modal.Board
import biz.tugay.groovyship.service.GameService

import static java.lang.Integer.parseInt

class CliGameController
{

  static GameService gameService = new GameService()

  static void main(String() args) {
    Scanner scanner = new Scanner(System.in)
    println "Type ng to create a new game at any time or exit to stop playing."
    println "Send missile at coordinates in the format: columnIndex,rowIndex."
    println "Top left corner is coordinates 0,0"
    println "Type ng to start a new game now."

    Board board

    BoardCommandLinePrinter boardCommandLinePrinter = new BoardCommandLinePrinter()

    while (true) {
      if (board) {
        boardCommandLinePrinter.print(board)
        if (gameService.allShipsSank(board)) {
          println "Congratulations, you win."
          board = null
        }
      }

      if (!board) {
        println "Enter one of: ng | exit"
      } else {
        println "Enter coordinates: 'column,row' to send a missile, 'ng' for a new game, 'exit' to exit."
      }

      String userInput = scanner.nextLine()
      if ("exit" == userInput) {
        System.exit(1)
      }
      else if ("ng" == userInput) {
        board = newGameQuestions(scanner)
        if (!board) {
          println "We could not generate a random board with the provided number of ships in the provided board."
          println "Enter a bigger board and less number of ships."
        }
      }
      else {
        if (gameService.sendMissile(board, parseInt(userInput(0)), parseInt(userInput(-1)))) {
          println "Hit."
        } else {
          println "Missed."
        }
      }
    }
  }

  static Board newGameQuestions(Scanner scanner) {
    println "Board size?"
    int boardSize = parseInt(scanner.nextLine())
    println "How many ships?"
    int numberOfShips = parseInt(scanner.nextLine())
    gameService.createNewGame(boardSize, numberOfShips)
  }
}

BoardCommandLinePrinter.groovy

package biz.tugay.groovyship.cli


import biz.tugay.groovyship.modal.Board
import biz.tugay.groovyship.modal.Coordinate
import biz.tugay.groovyship.modal.Ship
import biz.tugay.groovyship.service.ShipService

class BoardCommandLinePrinter
{
  ShipService shipService = new ShipService()

  void print(Board board) {
    def noAttempt = ' '
    def missedAttempt = '-'
    def successfulAttempt = '□'
    def sankShip = '◼'

    print '   '
    for (column in 0..<board.boardSize) {
      print column + '  '
    }
    println ''
    for (row in 0..<board.boardSize) {
      print row + '  '
      for (column in 0..<board.boardSize) {
        Coordinate coordinate = Coordinate.of(column, row)
        Ship shipOnCoordinate = board.ships.find { shipService.hasPartOnCoordinate(it, coordinate) }
        if (!board.missileAttempts.contains(coordinate)) {
          print noAttempt + '  '
        }
        else if (!shipOnCoordinate) {
          print missedAttempt + '  '
        }
        else if (shipService.isSank(shipOnCoordinate)) {
          print sankShip + '  '
        }
        else {
          print successfulAttempt + '  '
        }
      }
      println ''
    }
  }
}

I also have extended test coverage, but I will skip the tests I have.

Any feedback on what can be improved or fixed is welcome.

Portion of a sample run:

Enter coordinates: 'column,row' to send a missile, 'ng' for a new game, 'exit' to exit.
21
Hit.
   0  1  2  3  
0  -  -        
1     □  □     
2     -        
3              
Enter coordinates: 'column,row' to send a missile, 'ng' for a new game, 'exit' to exit.
31
Hit.
   0  1  2  3  
0  -  -        
1     □  □  □  
2     -        
3              
Enter coordinates: 'column,row' to send a missile, 'ng' for a new game, 'exit' to exit.
01
Hit.
   0  1  2  3  
0  -  -        
1  ◼  ◼  ◼  ◼  
2     -        
3              
Congratulations, you win.
Enter one of: ng | exit

Thai Language 1 Keyword Online Game Casino Poker Sbobet Ufabet Football Sports Betting Gambling Site for $999

Thai Language 1 Keyword Online Game Casino Poker Sbobet Ufabet Football Sports Betting Gambling Site

Always Welcome Sir.

I’m Always Happy With Your Business.

I Am SEO Member: Top Rated Level X Elite Seller.


You Have Come To Right Place About Online Sports Betting Gambling SEO Service

Biggest Offer: All Types Mixed SEO High Quality Google First Page Do-follow Back-links PBNs

About Online Casino Sports Betting Gambling Featured!

Guaranteed Google First Page Rank.

Guaranteed Indexed Google As Fast As Possible.

Google 1st Page Lots Of Benefits For Your Business.

Many People To Finding Google Search Betting Sites.

We Accept Your 1 URL 1 Keyword Per Order.

If You Want To Rank More Keywords Then Pay Extra Qty.

I’ve Ranked Many More User Gambling Sites Keywords.
(—————————————————————–)

I Suggest All OF The SEO Buyer: Don’t Try To Buy Spam And Fake Services,

And Don’t Waste Money Buying Bad Quality Service. I’m Top Rated Level X

Elite Seller On SEOClerks. We Are Providing SEO High Quality

Google.co.th Front Page Offer Package Service.

I Have Ranked Many More Gambling Sites With Keywords. Just Sample For You Below.

URL: https://www.ufabet123.com/

Keyword: “ufabet”

Before Rank: 5th Page No.50 Position.

After Rank: First Page No.9 Position.

Location: Thailand Google.co.th/

Language: “Thai”

(—————————————————————)If You Have More Question Kindly Inbox Me.Have A Better Day.Thank you so much.

Top LX3 SLR SINCE 2012

.(tagsToTranslate)Gambling(t)Service

How should a Game object be used correctly?

Is it better to show game objects in a scene by using them in a script, or is it better to create them in a scane and use them in a script? (for Unity)

Will there be performance differences between these two when using multiple Game Object ?