Gameheads is a tech youth program whose goal is to prepare low income youth and youth of color (ages 11-25) for a career in the tech and video game industry

Gameheads

gameheads

Crypto & Web 3.0 enthusiasts say NFTs are the future of gaming, but game players are singing a different tune. The last four years in the gaming world have been rife with disruptive developments. As a serial entrepreneur, Gary Vee predicted in 2010, NFTs are now an existential reality and the trendiest buzzword in the ever-growing world of digital escapism. Simply put NFTs, or non-fungible tokens, are unique, non-interchangeable units of data stored on a blockchain. In crypto o NFT games these can be in-game upgrades or collectibles that can be exchanged on the blockchain and verified for ownership authenticity. Think of them like Pokémon cards in the 90s that are rare and command thousands of dollars today. Microtransactions, n-game purchases of virtual items, the current free-to-play gaming business model, is designed to put money back into the hands of the developers and have been around since forever (in gaming years). The emergence of blockchain tech and the proliferation of NFTs has pushed game publishers profiteering to a whole new Web3 frontier. Traditional game publishers don't want to be left out of the NFT gold rush! Blockchain-based games like Axie Infinity, Gods Unchained, and Splinterlands have popularized NFTs so much so that traditional publishers such as Ubisoft, SEGA, and Square Enix want to get in on an industry that brought in [$4.8 billion in gaming-related revenue](https://Gamers say NFTs are sucking away the gaming essence)  in Q3 2021. Gamers worldwide are polarized over who stands to gain in this NFT-mania. Gamers say NFTs are sucking away the gaming essence , positing that game collectibles such as clothing and weapons for characters elicit a negative reaction from players who feel they are a money-making ploy, which dulls gamers' experience, and erodes their trust. To them, "non-fungible tokens" is a sophisticated phrase that solves no real-world problems for which rich snobs are willing to invest to fleece ordinary folks. Antagonists are vitriolic on Reddit and Discord “There is also a case for the environmental impact of crypto mining, the incessant scams, and the frustration of seeing one more warped JPEG monkey again.” Gamers Everywhere Many games that deploy NFTs are built around an economy where a player can trade digital items that can be used in other blockchain games. Consequently, the player is stimulated to make money instead of having a good time. Making bank comes first; gameplay and immersiveness are secondary. Publishers say gamers "just don't get it." In their defense, publishers claim that NFT creation is not inspired by profit-making; instead, it's the next wave of value creation in gaming. Renowned game developers are experimenting with play-to-earn and NFT features in 2022, following in Ubisoft's footsteps despite the outrage that met the release of Ubisoft Quartz and its NFT rollout, Digits. Responding to the backlash, Ubisoft Executive Nicholas Pouard says embracing NFTs is a "matter of personal choice" for gamers who "at no point" are coerced to use them. Future outlook of NFTs, Gaming and Web3 Companies carrying on with NFT programs despite backlash from their community risk getting their games abandoned altogether. "There are a lot of bad actors in the crypto and blockchain space,” say many gamers and critics. "Players are wary of getting entangled with environmental violators and money launderers." Outside the gaming realm, many crypto and NFT enthusiasts believe that the billion-dollar gaming market could be a major catalyst for the adoption of Web 3.0 - the next big internet iteration after Web 2.0 (Social Media) that will be decentralized and powered by the blockchain. A slew of gamers call Discord home, and breaking their resistance to in-game artwork is a huge step towards Web 3's emergence. Just as Henry Ford and Rockefeller blocked the growth of the first electric car with cheaper cars and gasoline in the early 1900s - only for Tesla Motors to lead the 21st-century green energy car race - there will always be initial resistance to innovation. Eventually, hardline stances will wane, and these anti-NFT arguments may become relics that the next generation of gamers would chuckle at. We are all creatures of comparison, communication, conceitedness, and community. All innovations and styles are valuable insofar as the next guy acknowledges them. To the developers, one thing is clear: if your audience is NFT averse, offer it as an unheralded option without aggressive marketing, or remove it entirely. Hold Q and A sessions to address their fears. Interact more (NFT giveaway, anyone?). If your fanbase is NFT-friendly, and you want to stand out from the crowd, give them an enthralling game experience. "To attract gamers, blockchain games have to provide compelling experiences around true ownership of assets and all the rest. So when suggesting that the problem with blockchain games is blockchain, it's not a call to see it removed from the equation. Simply that it should never overshadow the actual game." Jack Martin, Cointelegraph Obtrusive or not, time will tell if cosmetic NFTs will attain widespread acceptance in the gaming community. For relatively unknown studios like GSC Game World, who have already removed their NFTs for S.T.A.L.K.E.R 2 following fan outcry, they'll need more work on their gameplay and character mix before annoying their fans with NFTs. OG game-heads, on their part, should remind aggrieved new schoolers that there was a time when a paid horse armor was ostentatious. Audrey Nesbitt

Gamers Say NFTs Are Sucking Away the Gaming Essence

transformer-based language model definitely lives up to the hype. Following the natural evolution of , this generative language model drew a lot of attention by and appearing in the online text adventure game . OpenAI’s GPT-2 Artificial Intelligence (AI) engaging in interviews AI Dungeon GPT-2, built on transformer decoder blocks, essentially leverages its to train and formulate word sequences based on what it has already learned. Its ability to adapt and generate human-like text interactions with minimal prompts quickly is exceptional. natural language prediction algorithm So it’s no surprise that it’s been deployed across applications like chatbots (of course), translation platforms, (which shows its impressive cognitive abilities), , , and more. TL;DR generators music generators poetry generators Although more complex Natural Language Processing (NLP) models like and were released recently, GPT-2 continues to reign supreme. One of the primary reasons for this is its ability to run efficiently on everyday hardware. For example, the sheer number of trainable parameters, 1.5 billion to be exact, only demands 6.5 GB storage. GPT-3 Google T5 So at , we decided to put it to the test and see what else we could train it to do. Someone suggested playing a game of chess, and we ran with it. Intersog Machine Learning (ML) researcher already trained . The model is clear evidence of its ability to recognize known patterns within the game. Shawn Presser GPT-2 to play chess using Portable Game Notation (PGN) files We decided to take it a step further by training the GPT-2 model on the current board state rather than PGN sequences. This approach ensures that it can play the game based on the present without going through gaming history to predict the next best move. The code you’ll see in the steps below is inspired by and trained on . Professor Blank’s Programming a Chess Player Presser’s Cryochess – GPT-2 1.5B chess engine Step 1. Set up Your Dependencies To play chess with smart algorithms, you need a powerful ML-ready machine with a robust Graphics Processing Unit (GPU). Install , , and . It’s best to engage in this activity in a with a installed. CUDA 10.1 PyTorch TensorFlow 2 virtual environment JupyterLab extension Install python-chess [4] and aitextgen [5] modules: In [ ]: !pip install python-chess !pip install aitextgen !pip install tqdm Download PGN files to the PGN folder. You also have the option of converting databases (*.sg4) to PGN format. For this exercise, we engaged in training by leveraging 100,000 games in PGN archives. SCID Some valuable PGN resources include the following: PGN ChessBook PGN Mentor The Week in Chess import os if not os.path.exists("pgn"): os.mkdir("pgn") 2. Generate Training Data As reflected in the example below, our model uses the current board state along with the training file for the next move on each line. It follows the following format: [Result] FEN-position-and-side-only - next_move [1-0] r1bq3k/ppp2rpp/5b2/3n4/3P4/P4p2/BP1B1PPP/R2QR1K1 w - a2d5 [1-0] 2bQ4/p4kb1/6n1/q1p1p3/1rn1P3/N3BP2/1PP5/2KR2R1 w - a3c4 [0-1] 1r3rk1/p4nbp/1qppb1p1/4p3/PP2P3/4NN1P/2QB1PP1/2R1R1K1 b - f8c8 We decided to use only chess matches that were won and skipped draws. The code to generate this function is as follows: import os from tqdm.auto import tqdm import glob import chess.pgn MAX_IMPORT = 100000 def importPgn(filename, s, max_import): counter = 0 total = 0 with open(filename) as f: for line in f: if "[Result" in line: total += 1 if total > max_import: total = max_import pbar = tqdm(total=total, desc="read " + filename, unit=" games", mininterval=1) pgn = open(filename) while counter < max_import: game = chess.pgn.read_game(pgn) if not game: break board = game.board() moves = game.mainline_moves() count = sum(1 for _ in moves) # skip unfinished games if count <= 5: continue result = game.headers["Result"] # import only resultative games if result != "1-0" and result != "0-1": continue for move in moves: if board.turn == chess.WHITE and result == "1-0": line = ( "[1-0] " + " ".join(board.fen().split(" ", 2)[:2]) + " - " + move.uci() ).strip() s.add(line) elif board.turn == chess.BLACK and result == "0-1": line = ( "[0-1] " + " ".join(board.fen().split(" ", 2)[:2]) + " - " + move.uci() ).strip() s.add(line) board.push(move) counter += 1 pbar.update(1) pbar.close() return counter def convert(): games = 0 moves = 0 max_import = MAX_IMPORT s = set() # load previous state if os.path.exists("fen.txt"): with open("fen.txt") as f: for line in tqdm(f, desc="read fen.txt", unit=" moves", mininterval=1): if line: s.add(line) max_import -= 1 if max_import <= 0: break for file in glob.glob("pgn/*.pgn"): count = importPgn(file, s, max_import) games += count max_import -= count if max_import <= 0: break with open("fen.txt", "w") as f: for line in tqdm(s, desc="write fen.txt", unit=" moves", mininterval=1): f.write(line + "\n") moves += 1 print("imported " + str(games) + " games, " + str(moves) + " moves") convert() It took us about 15 minutes to import 100,000 games. If you want to use more games for training, you’ll also need more RAM. Step 4: Training the GPT-2 Model As described in the , we trained a small GPT-2 model from scratch using only the model memory. We chose a small model as we could quickly train it on basic/average hardware (rather than larger models). aitextgen documentation Larger models come with their own sets of demands and benefits, but it’s far too complex for a simple demonstration. The training function can run many times, repeat it, and archive acceptable loss as a model checkpoint. As model checkpoints are periodically saved, the training function can be run multiple times, repeat the training, and achieve acceptable losses. In this scenario, to save time, we stopped at a loss value close to 0.8. Even at this level, the GPT-2 model could predict moves with an acceptable level of accuracy. To better fit with your GPU and negate out of memory scenarios, tune-up batch_size, and num_workers. from aitextgen import aitextgen from aitextgen.utils import build_gpt2_config from aitextgen.TokenDataset import TokenDataset from aitextgen.tokenizers import train_tokenizer import os file_name = "fen.txt" model_dir = "trained_model" config_file = os.path.join(model_dir, "config.json") pytorch_model_file = os.path.join(model_dir, "pytorch_model.bin") vocab_file = os.path.join(model_dir, "aitextgen-vocab.json") merges_file = os.path.join(model_dir, "aitextgen-merges.txt") dataset_cache_file = os.path.join(model_dir, "dataset_cache.tar.gz") max_length = 100 vocab_size = 10000 def train(): if not os.path.exists(model_dir): os.mkdir(model_dir) # train tokenizer if necessary if not os.path.exists(vocab_file): print("training tokenizer, please wait...") train_tokenizer(file_name, save_path=model_dir, vocab_size=vocab_size) if os.path.exists(dataset_cache_file): # use cache data = TokenDataset(dataset_cache_file,vocab_file=vocab_file,merges_file=merges_file,block_size=max_length,from_cache=True,) else: # or create token cache if necessary data = TokenDataset(file_name,vocab_file=vocab_file,merges_file=merges_file,block_size=max_length,line_by_line=True,save_cache=True,cache_destination=dataset_cache_file) if not os.path.exists(pytorch_model_file): config = build_gpt2_config(vocab_size=vocab_size,max_length=max_length,dropout=0.0,n_embd=512,n_head=16,n_layer=16,) ai = aitextgen(config=config, vocab_file=vocab_file, merges_file=merges_file, to_gpu=True) else: ai = aitextgen(model=pytorch_model_file, config=config_file, vocab_file=vocab_file, merges_file=merges_file, to_gpu=True) ai.train(data, num_steps=150000, generate_every=1000, save_every=1000, learning_rate=1e-4, batch_size=16, num_workers=4,) train() This process takes about eight hours. However, if you want to use a well-trained model, it’s best to give it a few days. Step 5: Assessment 5.1. Introduce a Random Player (random_player) In this scenario, a random player is a simple (or novice) player who’s pretty poor at the game of chess. The function basically makes an arbitrary choice based on a list of valid moves. import random def random_player(board): move = random.choice(list(board.legal_moves)) return move.uci(), False, False 5.2. Introduce a GPT-2 Player (gpt2_player) This player uses AI-powered GPT-2 to predict the next move. The model prompt is constructed from the expected result from the current board state and side (and since we want to win, white = 1-0 and black = 0-1). From here, once prompted the model supplements the next generated move. The GPT-2 player is trained on a small ML dataset and can never evolve into a chess master. The predicted moves are based on unknown board states and not ones presented during the training phase. Whenever the model generates an invalid movement, it’s fixed by using a random valid move. import os from aitextgen import aitextgen from aitextgen.utils import build_gpt2_config import chess from tqdm.auto import tqdm model_dir = "trained_model" vocab_file = "aitextgen-vocab.json" merges_file = "aitextgen-merges.txt" max_length = 100 model_dir = "trained_model" config_file = os.path.join(model_dir, "config.json") pytorch_model_file = os.path.join(model_dir, "pytorch_model.bin") vocab_file = os.path.join(model_dir, "aitextgen-vocab.json") merges_file = os.path.join(model_dir, "aitextgen-merges.txt") dataset_cache_file = os.path.join(model_dir, "dataset_cache.tar.gz") max_length = 100 ai = aitextgen( model=pytorch_model_file, config=config_file, vocab_file=vocab_file, merges_file=merges_file, from_cache=True, to_gpu=True, # to_fp16=True ) # a set to find known states db = set() with open("fen.txt") as f: for line in tqdm(f, desc="read fen.txt", unit=" moves"): if line: db.add(" ".join(line.split(" ", 3)[:3])) def gpt2_player(board): if board.turn == chess.WHITE: prompt = "[1-0] " + " ".join(board.fen().split(" ", 2)[:2]) else: prompt = "[0-1] " + " ".join(board.fen().split(" ", 2)[:2]) isKnown = prompt in db prediction = ai.generate_one(prompt=prompt,max_length=max_length,temperature=0.9,top_k=0,) isPredicted = False try: uci = prediction.split(' - ')[1].strip() move = chess.Move.from_uci(uci) isPredicted = True except Exception as e: # print(str(e)) move = None if not move or move not in board.legal_moves: # give up and do random move move = random.choice(list(board.legal_moves)) isPredicted = False return move.uci(), isPredicted, isKnown Step 6: Play a Game of Chess Now comes the fun part! This function demands two players to play chess against each other: import time from IPython.display import display, HTML, clear_output import chess def who(player): return "White" if player == chess.WHITE else "Black" def display_board(board, use_svg): if use_svg: return board._repr_svg_() else: return "<pre>" + str(board) + "</pre>" def play_game(player1, player2, visual="svg", pause=0.1): """ playerN1, player2: functions that takes board, return uci move visual: "simple" | "svg" | None """ use_svg = (visual == "svg") board = chess.Board() known1 = 0 predicted1 = 0 total1 = 0 known2 = 0 predicted2 = 0 total2 = 0 if visual is not None: display(display_board(board, visual == 'svg')) try: while not board.is_game_over(claim_draw=True): if board.turn == chess.WHITE: uci, isPredicted, isKnown = player1(board) total1 += 1 if isKnown: known1 += 1 if isPredicted: predicted1 += 1 else: uci, isPredicted, isKnown = player2(board) total2 += 1 if isKnown: known2 += 1 if isPredicted: predicted2 += 1 name = who(board.turn) board.push_uci(uci) board_stop = display_board(board, use_svg) html = "<b>Move %s %s, Play '%s':</b><br/>%s<br/>Known/Predicted/Total moves: %s/%s/%s %s%% - %s/%s/%s %s%%" % ( len(board.move_stack), name, uci, board_stop, known1, predicted1, total1, round(predicted1 / (total1 or 1) * 100), known2, predicted2, total2, round(predicted2 / (total2 or 1) * 100)) if visual is not None: if visual == "svg": clear_output(wait=True) display(HTML(html)) if visual == "svg": time.sleep(pause) except KeyboardInterrupt: msg = "Game interrupted!" return (None, msg, board) result = "1/2-1/2" if board.is_checkmate(): msg = "checkmate: " + who(not board.turn) + " wins!" result = "1-0" if who(not board.turn) == "White" else "0-1" elif board.is_stalemate(): msg = "draw: stalemate" elif board.is_fivefold_repetition(): msg = "draw: 5-fold repetition" elif board.is_insufficient_material(): msg = "draw: insufficient material" elif board.can_claim_draw(): msg = "draw: claim" if visual is not None: print(msg) return (result, msg, board) Let’s play the gpt2_player vs. random_player: play_game(gpt2_player, random_player) pass Move 61 White, Play 'd2d7': Known/Predicted/Total moves: 2/29/31 94% - 0/0/30 0% checkmate: White wins! When you're working with a small dataset, these chess matches often end up in a stalemate. While we aren't a hundred percent certain, it could also result from not analyzing the next move and choosing the best one. Now let's play 100 games where the gpt2_player plays white: from tqdm.auto import tqdm plays = 100 white_wins = 0 black_wins = 0 pbar1 = None pbar2 = None for i in tqdm(range(plays), desc="Plays"): if not pbar1: pbar1 = tqdm(total=plays, desc="White wins") if not pbar2: pbar2 = tqdm(total=plays, desc="Black wins") result, _, _ = play_game(gpt2_player, random_player, visual=None) if result is None: break elif result == "1-0": white_wins += 1 pbar1.update(1) elif result == "0-1": black_wins += 1 pbar2.update(1) pbar1.close() pbar2.close() print("Final score: %s-%s" % (white_wins, black_wins)) Final score: 52-0 Most often, the GPT-2 controlled player wins the game or draws. In this scenario, the GPT-2 controlled white player won more than half the games. We also noticed that the current board state was almost always new to the model. The model was also able to engage in more valid moves than fails. So we can conclude that the GPT-2 model was able to learn some basic patterns from the training data to predict the next move successfully. Let’s play the gpt2_player vs. Human Player: The following function effectively handles human input into the game: def human_player(board): uci = get_move("%s's move [q to quit]> " % who(board.turn)) legal_uci_moves = [move.uci() for move in board.legal_moves] while uci not in legal_uci_moves: print("Legal moves: " + (",".join(sorted(legal_uci_moves)))) uci = get_move("%s's move[q to quit]> " % who(board.turn)) return uci, True, False def get_move(prompt): uci = input(prompt) if uci and uci[0] == "q": raise KeyboardInterrupt() try: chess.Move.from_uci(uci) except: uci = None return uci Do you want to play against gpt2_player? If you do, note that you must enter your move in the user-computer interface representing each piece and place. This means that typing something like "a2a4"moves the piece located at a2 to a4. play_game(human_player, gpt2_player) pass Move 10 Black, Play 'b7b6': Known/Predicted/Total moves: 0/5/5 100% - 2/5/5 100% Conclusion In this experiment, we deployed GPT-2 to learn and play a game of chess. Although it was nowhere near our grandmasters (at least not yet), it showed that it was capable of understanding the game's basics. With more training data and larger model size, the model can theoretically take it to the next level and possibly beat human players. An interesting observation was that the model itself behaved quite erratically when playing the random player who made arbitrary moves. However, when we added a human player, the model made more calculated and confident moves. This suggests that a better player creates board states that are similar to the training data. We also noticed that the GPT-2 model engaged in natural text generation and confidently generated different types of textual patterns. It was also able to leverage its training data to successfully handle unknown input, almost like it developed a new internal algorithm. If you like to do your own experiments, this notebook is available . HERE

How to Play Chess Using a GPT-2 Model

Building a Web3 Play-To-Earn Money Dapp with React, Solidity, and CometChat

Why you should use modern AI programming tools I've been using Wordle as an analogy for serious software development. In this article, I will combine the TDD solution that created a good model with an automated code generated using Artificial Intelligence. TL;DR: Use the best available tools wisely Divide and Conquer The Division I have written several articles on software development. I will talk about Worlde to represent serious software. I created a backend Wordle using TDD and PHP in the first one. How to Develop a Wordle Game using TDD in 25 Minutes Next, I watched a video on how to develop a Wordle using Automatic Code Generation fully. Step by Step Wordle Creation With Codex AI Since Wordle is another Kata, I keep practicing it with TDD using Javascript How to Create a Wordle with TDD in Javascript Now we have an amazing Wordle with a great domain model AND an incredible machine-learning user interface for it. Let's combine them. The Conquest We have two repositories: 1 - The one with the Javascript Wordle made with TDD https://replit.com/@mcsee/Wordle-TDD https://github.com/mcsee/wordle/tree/main/How to Create a Wordle with TDD in Javascript 2 - The one with the machine-generated code https://github.com/mcsee/wordle/tree/main/Open AI Codex from DotCSV Playable Version (Live) With Defects https://mcsee.github.io/wordle/DotCSV/index.html?embedable=true Making it work together We need to inject the changes into our main file. Remember the scripted UI version was not modular. We set up our valid game before building our UI const response = await fetch("dictionary.txt");
 const dictionary = await response.text();
 const words = dictionary.split(/\r?\n/).map((string) => new Word(string));

 var randomIndex = Math.floor(Math.random() * words.length);
 var winnerWord = words[randomIndex];

 var game = new Game(words, winnerWord);   

// Before we setup our UI.
// We want to create our valid working Game We create a text field to show status/errors to end users // Step 14 bis
/* add an input text field under the table */

var status = document.createElement('input');
status.setAttribute('type','text');
status.setAttribute('placeholder','');
status.id = 'status';
status.readOnly = true;
document.body.appendChild(status);
status.style.margin = '10px';
status.style.width = '300px'; This is not strictly necessary but it helps keep the UI as simple as possible. // Step 17
/* create variable named 'rowindex' starting at 0 */

var rowIndex = game.wordsAttempted().length; variable is no longer global. We compute it tied to the attempts tried on the game. rowIndex We are reifing the state into our Game object And this is when all magic happens. We replace the algorithmic and error prune letter counts computations with our more robust ones // Step 24
	  
/* when clicking validate button we add an attempt */

document.getElementById('validate').addEventListener('click', function(event) {
  var cells = document.querySelectorAll('td');
  var currentLetters = '';
  for (var i = 0; i < cells.length; i++) {
    if (i >= rowIndex * 5 && i < (rowIndex + 1) * 5) {
        currentLetters += cells[i].innerHTML ;
    }
  }  
  var status = document.getElementById('status');
  status.value = '';
  try { 
    var attempt = new Word(currentLetters);
    game.addAttempt(attempt);  
  }
  catch (error) { 
    status.value = error.message; 
    return;
  }  

  var correctMatches = attempt.matchesPositionWith(winnerWord); 
  var incorrectMatches = attempt.matchesIncorrectPositionWith(winnerWord); 
  
  for (var i = rowIndex * 5; i < (rowIndex + 1) * 5; i++) { 
    if (correctMatches.includes(i-(rowIndex * 5)+1)) { 
        cells[i].style.backgroundColor = '#aedb95'; 
    }
    if (incorrectMatches.includes(i-(rowIndex * 5)+1)) { 
        cells[i].style.backgroundColor = '#edc953'; 
    }
  }
  if (game.hasWon()){
     status.value = 'Congratulations. You won!';
  }
  if (game.hasLost()){
     status.value = 'Sorry. You have lost! Correct word was ' + winnerWord.word();
  }
  document.getElementById('input').value = '';
  rowIndex = game.wordsAttempted().length;
}); We put it as a very long function in the same event for clarification. The model now raises exceptions following the and we can show them to the final user. fail-fast principle This method requires heavy refactorization in a future article. Finally, we reset the game. This was one of the many mistakes corrected from the first version. // Step 27

/* when pressing remove, chose randomly the secret word from the words collection */ 

document.getElementById('remove').addEventListener('click', function(event) {
  var randomIndex = Math.floor(Math.random() * words.length);
  winnerWord = words[randomIndex];
  game = new Game(words, winnerWord);   
}); There are at the start of the script. repeated code You can play with the final version here The source code is here And a working repl.it here The Disclaimer The final code is full of refactoring opportunities and several . code smells It is a proof of concept, not an elegant and final solution. Credits Image credit: A funny Twitter thread asking AIs to draw a Centaur Also Published here

Wordles, Centaur and Code: Building a Game

Creating a Wordle with TDD in Javascript

Today I want to talk about what trends have begun to emerge in the gaming industry as of today. Trend #1: The gaming industry continues to grow, and mobile gaming is its fastest-growing segment After the sharp beginning of the pandemic, the forecast that industry growth would slow down sharply did not come true. There was no global market decline. On the contrary, video games have become a more extensive industry than movies and North American sports combined, . thanks to the pandemic There was some decline in PC and console games, but for the most part, this can be attributed to a lack of parts to produce new hardware. As for mobile games, in 2021, they brought in about $93 billion - more than a third of the total revenue of the gaming market. By 2023, this figure is expected to cross the $100 billion mark with an overall average annual growth rate of more than 18%. This unstoppable growth attracts investors, so there are even more companies and projects, and the competition is growing. At the same time, the process of mergers and acquisitions of studios continues. Key market players continue to buy new studios. This is noticeable both in the PC/console segment (the same Embracer Group) and in the mobile segment (M&A activity and opening offices in other countries by Playrix, MyTona, and others). However, no one knows how long it will last, but until it does, employment in the game industry looks very promising in the coming years. Trend #2: Crossplay and franchises strengthen brands Indeed, developing for multiple platforms with crossplay increases costs, but at the same time, it can open doors to a much larger user base. We all see major PC and console developers trying to enter the mobile market, from Epic Games with Fortnite to Genshin Impact and Pokémon Unite. But a game designed for gamepads and 75-inch monitors won't offer a similar experience when launched on a smartphone. That's why studios are increasingly creating spinoff games, using their leading brand from console or PC versions in variants optimized for mobile devices, such as Mario Cart Tour and Wild Rift. However, not all such games end with success. For example, Ubisoft never brought Tom Clancy's Elite Squad to release, so the most notable appearance on the mobile market were collabs with AFK Arena. Speaking of collaborations in general, their number is also growing in recent years. Persona 5 will appear in the AFK Arena; Neon Genesis Evangelion will appear in Dragon Raja. Naturally, such events attract attention. Sometimes not only from players but also from the outside, and we can expect that their number will only increase. Trend #3: The hardware crisis will continue to dramatically affect the industry The latest graphics cards and next-gen consoles are proving to be an elusive scarce commodity even a year later, and this is one of the main problems delaying a new technological leap in graphics. Even if the developers themselves are already ready to release products at the peak of technical capabilities, the problem is that there is simply no one to play them. in 2022 are very different - it is more likely to say that the problem will be resolved in 2-3 years. In 3 years, we should expect revolutionary changes in the graphics. Forecasts for the video cards market Trend #4: Postponed game releases will finally have final dates The IT sector is the least affected by the pandemic and the mass transition to remote working. It even benefited from it. But if you look at the figures from trend #1, the forced restructuring of work processes has played its not very positive role. Under the pressure of the new pandemic reality, many of the production chains at the major studios making AAA games are collapsing. It takes time to adapt. It's impossible to produce some aspects of game development (such as mockups and sound design) entirely in-house. As a result, in 2022, we will have many new projects postponed for the last two years. It is worth noting that medium and small studios proved to be much more flexible, as they were able to rebuild and restore the efficiency and speed of development much faster. Asian companies did not hesitate to take advantage of this. They released many large and successful projects in 2021 and continued to develop existing ones (Genshin Impact, Garena Free Fire, PUBG New State, Arena of Valor, and others). Trend #5: With the spread of 5G, a whole new speed of mobile gaming awaits Although right now, 5G seems more like a myth than a reality, and the areas covered by it are far from being all over the world, it's more a question of when it will fully come into the lives of mobile device users. This means a significant increase in content download speeds for the mobile gaming market. Players will be able to download heavy clients of modern games much faster and easier - significantly since the built-in memory of smartphones is also growing. Playing synchronous PvP games, where ping values and a stable connection are fundamental, will become more comfortable. This is also a significant incentive to increase the segment of large, heavy mobile games, particularly cross-platform. Also, an increase in mobile internet speeds positively affects cloud gaming services. And due to the above-mentioned hardware shortage, which is not going away anytime soon, cloud gaming will grow even more and seem to be a more tempting alternative for users. Conclusion Of course, this is not all. Among other things, we cannot ignore the increased interest in and . Although many people are skeptical about such phenomena, and it is unclear how long they will last, these technologies and approaches show that studios are actively seeking new ways of development. The potential here can be seen with the naked eye: the market for open economy games is growing at an unprecedented rate, and more and more big players are entering the race. NFT meta-universe You can also read another article on . It is based on real experience. what you can do to make Reddit aware of your game

Top 5 Gaming Industry Trends for 2022

Hey Hackers! I’m Stefano Pavone, and I’m the new retrogaming reporter on HackerNoon. First of all, a huge thank you to the HackerNoon community and staff for nominating me for a 2021 Noonies award! I’ve been nominated in the following category, please do check out these award pages and vote: HackerNoon Contributor of the Year - VIDEO-GAMES: https://noonies.tech/award/2021-hackernoon-contributor-of-the-year-video-games As someone with a foot (or rather, a couple of toes) in the retrogaming industry, I believe that the most exciting technology of the present is emulation because it helps to preserve games that would otherwise be lost forever, and it also introduces these classic (or not-so-classic) titles to a new generation of gamers and technophiles. Learn more about my thoughts and opinions on the games of the past and my journey in the tech industry via the interview below. 1. What do you do and why do you do it? (tell us your story) I like to write articles about games of the past, which laid the foundations for modern gaming. When I was growing up, the gaming industry wasn’t as polished or media-driven as it is today. Gamers had to spend their money carefully, as reviews in magazines were not known for their sincerity. I also felt that there was a sense of disrespect for the reader and gamer, meaning that people were expected to go through unnecessarily grueling games even if they didn’t know what to do (sometimes instructions would be missing or just not included at all) which, at the time, were known for their borderline sadistic difficulty and rage-inducing design. I wanted to bring some of those games into the 21st Century and spare potential players from frustration that permeated so many of these earlier titles. 2. Tell us more about the things you create / write / manage / build! Gaming-wise, my most successful project is a handful of arcade-quality-controllers-on-a-budget which use up to two buttons. You see, back in the day, most games on computers were played with joysticks as opposed to gamepads, and they usually only used one single fire button despite some sticks having multiple physical buttons on their person (a trend popularised by the Atari 2600 console, whose joystick controllers became an unofficial standard for game controllers for these computers). Later computers (from 1985 onwards) supported two separate logical buttons, but very few games utilized these features so as not to alienate the established single-button standard from Atari, which meant there were fewer two-button joysticks around (a controller made for the Sega Master System console could be used on these computers as it shared the exact same pinout configuration save for an additional wire connected to support the second button, making it ideal for games and computers supporting more than one button). Outside of gaming, I like to write stories primarily in the sci-fi genre (nothing published yet, sadly) and am a bit of a cinema snob. circa 3. How did you end up on your current career path? Do you like it? I wouldn’t call it a career. More like a hobby that just happened to give me some much-needed experience and exposure. I like it so far, it’s allowed me to open the doors to this very secluded world of games and technology that most people don’t seem to be aware of, and it gives a real sense of mystery to my work. 4. What tech are you most excited or passionate about right now and why? The very real possibility of augmented reality becoming artificial reality (and eventually, maybe actual reality). It’s been a dream for so many since the genesis of computers and a frequent staple in science fiction stories, so for fantasy to finally meet reality, for art to inspire science, is awe-inspiring in a very strange way. I probably would not use it myself, to be honest, as I have some reservations about the technology, but I’m sure it can be a force for good if treated with care and used responsibly. 5. What tech are you most worried about right now and why? Same thing as last question - the increasingly-blurred dividing line between artificial and actual reality. It reminds me of an episode of the cult sci-fi sitcom , where our heroes stumble upon a videogame entitled , which is able to fulfil their fantasies. Red Dwarf “Better Than Life” I think that story was a cautionary tale in disguise, as one of the main characters has such a low opinion of themselves that their fantasies turn out to be his worst nightmares come to life. I fear that technology will arrive at the point where it can potentially become telepathic, reading and interpreting our subconscious intentions, never mind our private thoughts, so I consider AR to be a very double-edged sword. 6. If we gave you 10 million dollars to invest in something today, what would you invest in and why? I would invest 3/4 of that money in founding my own human rights group to combat humanitarian crises around the world and to hold authority figures and people in power responsible for their mistakes and transgressions - there are some traditions, some conventions of society which cannot be allowed to continue existing because there is a greater awareness of their implications and the fact that more and more people are waking up to the idea of individualism, rejecting the collect call of society and many of the double standards it imposes. The remaining 1/4 of that money would go to my family and be split evenly between my parents, brother, and nephew. 7. What are you currently learning? At the moment, I am trying to learn to speak Spanish. I already have Italian as my first language, and I can speak Japanese (albeit not fluently), in addition to some basic French and German. It is my belief (one of my very few beliefs, as I am known to be more focused on logic and reason) that each of us should learn at least two languages in our lives because not everyone will speak yours, and you might not speak theirs. The more languages you pick up, the easier it is to learn other languages from the same family. 8. What’s the best advice you’ve ever given someone? Quite a few, actually: If you need help, then ask for it If you made a mistake, then own up to it - be responsible for your actions Be careful when wielding power and authority, as a simple penalty can all too often turn into disproportionate retribution - know when to let go of certain issues or situations (I’ve never, ever been a fan of authoritarian, punitive disciplines due to their counterproductive and sadistic nature) Treat others (especially defenseless people like children and disabled people) the way you want to be treated, and try not to make excuses for your bad behavior - complaining when getting caught red-handed isn’t the most honorable action one can perform. It’s OK to lose your temper once in a while; it’s human and normal (but not too often) If you live together, then everyone - including your children - has a say in house rules and events, etc. No half measures, no double standards (personal motto). 9. What’s the best advice you’ve ever received? Know when to stop trusting people who have a reputation for getting in your way and/or abusing your trust. About HackerNoon’s 2021 Noonie Awards The annual Noonie Awards celebrate the best and brightest of the tech industry, bringing together all who are making the Internet and the world of tech what it is today. Please be sure to , nominate, and vote for the people and companies who you think are making the biggest impact on the tech industry today. check out our award categories The 2021 Noonies are sponsored by: , , and . Thank you so much to these sponsors who are helping us celebrate the accomplishments of all our nominees. bybit Dottech Domains Avast

Noonies Interview with Stefano Pavone, the Retrogaming Reporter

I’m Mark Nadal & I want to tell you stories of an awe-inspiring future. I am one of the types that has intense day dreams of vibrantly detailed SciFi universes, full of unique never-imagined before creatures, cities, societies, economies, and ecosystems. My day job, though, is instead stuck writing nuanced code. One day I hope it will power utopian civilizations, but in the meanwhile, getting it to reliably scale for of users to do their cat video thing is, well, the less glorious “one small step” for humankind. tens of millions So here, here I wanted to express some of the endless ideas I have for such a forward facing future and why it matters to me. This is that focuses on various unturned stones of human-computer psychology and interactions. Part 1 #1: UX I originally wanted to be an artist/actor, but the tools I kept using were infuriatingly slow to go from the idea/vision I had in my head to output/reality. I kept thinking “why doesn’t it work this way?”, shocked to find nobody had built what seemed to me stunningly dumbingly obvious. Let’s ignore science-fiction devices for a second, and work with what we’re currently limited to — screens, keyboards, phones, gamepads, VR. These ideally are not the human-machine interfaces we want, but they’re ubiquitous and where we must evolve from if we want accessibility for everyone to be included in this journey. So to start, when you turn on the screen, it should have a way to both and . The lack of built-in creative tooling on most devices is abysmal. So let’s look at the UX of productivity tools. The singular gist is simple: create discover Why doesn’t Photoshop have video game controls? Video games are fundamentally immersive, fun, compelling, and extremely precise yet easy for newcomers to pick up. Why should we even focus on this as the first point? Because if we have really good digital creation tools, it becomes the easiest and most powerful way to bootstrap all sorts of other physical goods and societal/civilization-level structures. You could 3D print products and communicate economic data across countries. The internet and the interface to it has the highest ratio of from-nothing to world-impact possibilities. Throwback 10 years ago, my decade younger high school self tried to build this “video game for Photoshop” type tool. This demo doesn’t give it justice, but the results were very cool, including being able to rebuild any website in minutes — including & we pitched to as teenagers. investors journalists It supported multiplayer experiences across touchscreen mobile — mind you, this was 2011. The hacks I had to go to were insane back then. phones & IE8 Interaction & Information So there are two key design principles to understand, Interaction & Information. Here are the basic ways we can interact with a device: Interaction 1. Stare 2. Scroll 3. Tap 4. Type 5. Talk Scrolling is what the eyes do, they look around to collect more information, because not all of it can fit in the same space you’re staring at. Tapping includes any range of gestures, but poking something is the most basic place to start. Typing refers to external inputs, like a keyboard or gamepad, which translate different types of “tapping” into more complex interactions. Finally, talking includes recorded input, capturing the world around us and trying to shove it into the digital world. If you notice, the degrees of dimensionality and precision increases drastically over each item. For the most part, even paralyzed people can stare and scroll. However, recording audio or video or even 3D body motion performances requires not only a whole lot more data to process, but also talent on the part of the human. This is why some tools can be infuriating, getting the precision of a pixel via a trackpad is not something most people are good at — we’re clumsy. And you shouldn’t have to be rockstar drummer in order to “time” things perfectly. So this is why tools should always reduce interactions down to a single dimension at a time. That way it is easy to move just the X coordinate of something, without wiggling into the Y space. However, each tool should be “composable”, just like a piano keyboard, where as a user gets more proficient with the tool, they can move both X and Y simultaneously by “tapping” down on 2 controls at once. Video games are really good at this type of incremental nudging, letting you unlock more “combos” as you learn the basics. I even tried to turn this whole “staring to tapping” concept into a game itself with a full on kid-friendly Space Opera plot to it: As you see, the game would slowly evolve from a text-based choose-your-own adventure into eventually a full blown 3D FPS MMORPG, where the tooling to create anything from a tweet or blog post to a video game itself was baked into the game and taught as part of the campaign tutorial. However this journey was unfortunately stopped when I that the even-more-basic and boring tools of infrastructure were broken. Simple things, like storing, syncing, and scaling data, was enormously complex. So I turned from building UX tools into building information tools. From design to databases. I couldn’t trust anything anymore. discovered Information Let’s pause and talk about this at a grand scale first. . How we drive on a freeway, exchange money, or how we file books or photo albums on a shelf, or how we organize our closet, are all information management problems. These protocols are “drive on the left side” (unless you’re in England), “arrange things by color”, and even stuff like “Capitalism or Socialism”. Infrastructure is still a type of UX How we do these things, are all infrastructure. Culturally prescribed UX decisions. Yes, we want roads that let you go anywhere if you happen to have a car; “No”, we want free public transit; Yes, we want drinking water delivered in aqueducts and pipes straight to the homes of everyone for free; “No”, we want to have to sell water in bajillions of little plastic bottles. So many of these decisions are engrained into us they’re perceived as the nature and fabric of reality itself. You know, like Socialism and Capitalism, despite being only 170 & 250 years-ish old, and invented by just two guys. Let’s not forget the roaring transition from the Mercantilism of the British East India Trading slavery company, to the skyscrapers & automobiles of America in just a span of a few hundred years: Yes, even how we use and think about money will radically change. Money was a way to past a village. But now that we have the internet, most of what money as a technology was used for is now irrelevant. Instead, we can design a better UX for managing economic information — we can change from “how much you hoard” to “how many people you’ve helped.” The math for this is actually quite simple. scale humanity up the definition of wealth But getting back to our UX point, the design principle of information is to do the same thing we did with interaction, to reduce everything down to one dimension. So now the goal becomes “how do you organize information to fit on a line?” Such that this will work for everything from audio editing, to website layouts, and the beyond. The power of words is that it discretizes language into symbols that can be manipulated on a line, endlessly, until the perfect sequence of unique combinations arise. Sheet music tries to do the same thing for songs, but we don’t see very many music editing apps adopting this technique. But I actually think this is an extraordinarily powerful approach. Windows Movie Maker kinda got this right, although could have been made a million times better. Rather than infinitely scrolling to the right, music and video should wrap like words. This is the same reason we don’t use Egyptian hieroglyphics anymore. Walking down a corridor sucks too much energy compared to scanning your eyes down some papyrus. Sideways scrolling in a tiny timeline viewport is tiring. Let’s take this to an extreme though, the editor should literally be laid out like this article. Where would you place the video preview then? Why not just as a fullscreen transparent overlay. You should be able to edit, cut, and trim the video just like you can with text. For basic commands, such as navigation and deletion, you’d be able to use standard scrolling and caret selection. Ideally, a song gets automatically split into “words” based on silence spaces, or if that cannot be determined, in 1 second chunks. These words can be clicked on and scrubbed through for more precision, and if there is multiple tracks or layers, the active line would expand to accommodate the height of the word. You can even encode website layouts on a line, using the same concepts as a link. A link contains nested data, information, structure — you can always pause a stream and jump into a link, or optionally skip the link and continue on your way. All information, websites, layouts, etc. can be rendered as a series of wrapped and nested lines. The web is the closest to achieving this, but bottlenecked by poor performance and shoddy design structures. Information Design Theory The above approach can be applied to a tremendous number of applications, such that it not only unifies our interactions across informational systems, but also comes to consolidate and replace countless isolated and siloed tools. The reason why we have so many “productivity” tools is because they do not speak a common underlying composable language. Can we reduce design, layout, and creativity tools down to a set of lower level primitives? This is what I call “ ” that has 6 rules for making sure data looks good on larger displays or on handhelds. They’re pretty basic: Information Design Theory 1. Flow & Wrap. 2. Max & Min. 3. Focus & Divide. 4. Leak & Hold. 5. Align & Center. 6. Zoom & Detail. The details that describe a shape’s geometry will often nest these 6 rules in a series of different arrangements or combinations. I have much more detailed thoughts on these subjects, but I’m not going to explore them here — if you’re curious, come and ask me about it there. join our community Unifying II What I’d like you to ponder is a few explorations of how we can integrate interactivity & information. First, Bret Victor’s “Inventing on Principle” did an excellent job in capturing programmer’s imagination, laying out the basic foundations that many tools should include by default. I strive to take this a step further and discuss how we can combine this with Machine Learning tools, natural language programming, and “tactile-spatial” syntaxes that reduce the burden of coding for humans. Here I explore the past, present, and “ ” while showcasing some cool demos of what could be possible. Future of Programming Next up is actually mixing the bits into layout, allowing different Interactions with different Information. Here’s a short example of what it could look like: Finally, we want to take this to the extreme. This should not be just some web page or a network of web apps, it should be the browser itself. Accessibility and security information should always be available wherever you go, and the ability to create and author content should be baked into it, core to the OS. This last touch is to use that to form an overlay network on top of the existing internet, so we get the best of both worlds. The old and the new. #2 : Appliances The real app is hardware & appliances. Things that reduce human labor, sweat, pain. These are the real life savers, not the software aids. They free humanity up to do what we’re good at, creating innovation and art. . It and beyond will address: Appliances, Housing, Transportation, Aerospace, and Molecular Materials. Each subject as a peculiar twist that I haven’t heard others talk about. …but this is a teaser for Part II in this series Generally speaking, I prefer building these things rather than writing or talking about them. Partly because when I go to write about them, it takes years to finish due to my obsession with explaining every detail. Naturally, this pairs better just creating it. However, this article and the next ones are my failed attempts at trying to briefly touch on a variety of deeper ideas. Conclusion I have an energetic brain with an endless number of excruciatingly detailed worlds that I tried to create but quickly became frustrated with the unintuitive interfaces prevalent everywhere that sap an immense amount of time and energy to express the precision an beauty imagined in my head. At first I became trapped in the hope that others smarter than me where on the cusp of releasing tools with the “obvious” features I assumed, only to despair when those projects disappointed, succeeded but were later shut down, or turned into greedy services. You have to be the change in the world you want to see. And so I got building, often failing and disappointing myself and others, but through hard struggle I’m slowly evolving towards a compounding set of tools that accelerate on top of each other. Despite the fact that I’ve had to work backwards all the way down to database infrastructure, and at some point will have to incrementally switch over operating systems and graphics hardware, this process has allowed me to shape technology such that each layer on top of it becomes exponentially more powerful. So while it is a seemingly audacious and ambitious task to tackle a variety of subjects that industries of people have spent their lives dedicated to, this is equally proportional to the awe-inspiring nature of technology itself. It equips, enables, and empowers increasingly smaller teams to achieve magnitudes larger global impact. These tools should be for the children. Not just the certified adult wage maker. They are toys for expression, to shape forward humanity. Not just the means for the penance of our rent and inherited debts. Free as in people free as in product. We have to lay that foundation. and So I invite you to make dance and , and to not stop, until the world becomes the dreams we crave. play games ~ @marknadal

If I Could Create Worlds…

WebXR Device API: Accessing Virtual Reality and Augmented Reality Devices

A parable about missed deadlines and over-engineering Some time ago I attended to a coding interview for the position of Data Scientist at one start-up. I felt myself well-prepared and confident, practicing lots of programming puzzles, coding various Machine Learning techniques from scratch, and having several years of programming experience under the belt. What can go wrong? Unfortunately, I failed at the thing that doesn’t have any relation to the Gradient Descent methods or Time Complexity analysis. No, the failure was related to something very different and much more complicated. It was a Tic-Tac-Toe game! I bet at this moment, some of you just close this story with thoughts: What, a Tic-Tac-Toe game? How can one fail to implement such a simple thing? You should be a total newbie, man, not being able to solve such a trivial exercise! The rest of you, who decided to give me a chance, I invite you to read my story and probably this experience help you to escape similar mistakes in your software development practice and be more careful. Photo by Quino Al on Unsplash How Can Anything Go Wrong Here? Now let me explain the interview task more thoroughly to give you enough context and understanding of the project’s scope. The following list enumerates the minimal requirements. Terminal-based interface. Turn-based gameplay; the one player makes a move after another one. At the very beginning and after each turn, the game shows whose turn it is, and allows to make a choice. When the turn is submitted, the game automatically shows a new board’s state and analyzes if there is a winner. If there is one, the UI shows information about the winner, and the game ends. The game is written in Python ≥ 3.x. Sounds very straightforward, right? The greatest twist here is a . You’re only given a to build the MVP, i.e., working terminal-based game for two players. Also, there is an additional list of priorities that clarify and extend the design requirements. Note that they list in . time limit 1 hour the order of decreasing importance The game meets the minimum requirements stated above. The UI is intuitive and doesn’t require additional instructions. The code is well-structured, compact, and easy to read. Tests are proving the correctness of the developed program and its components. The game can handle incorrect input. The UI is convenient. The code uses modern language features and libraries. Ok, great, the requirements are clear. Everything looks pretty simple and its time to start building the code! It shouldn’t be too tricky… Photo by Ant Rozetsky on Unsplash How I Know How To Prioritize Things As soon as I’d read the document with requirements, my thoughts were: . I wanted to build something fancy and interactive. Up to this moment, I’ve developed many CLI tools, and simple terminal experience wasn’t enough. So I chose the library to make things interactive and convenient. (I know, it could sound strange to talk about “convenience” of a terminal-based interface, but still…) Hey, the basic gameplay of a Tic-Tac-Toe game is very trivial so let’s focus on the UX and handling the input at the beginning, and then build the rest of the game logic curses There is one small question here: Here is a small snippet to explain what I am talking about. The code below shows the simplest program to interactively with a breakpoint. How would you debug a program that controls the terminal? curses curses

def main(term):
    term.clear() i range( ):
        # to debug after curses mangled the terminal
        breakpoint()
        term.addstr(i, , f )
    term.refresh()
    term.getkey() __name__ == :
    curses.wrapper(main) import for in 10 try 0 'String: {i + 1:d}' if '__main__' View codes on Github here Looks nice, right? Until you try to run it. Having an interactive UI wasn’t a strict requirement, as you see from the list shown above. Still, this thing drained my attention and a considerable part of the allocated time. When you run this snippet, it not shows you what you could expect. As you have probably already guessed, the take control over the terminal session, and when a debugger tries to render its interface, things are . curses totally broken Not a something you would like to see when running a debugger I’d spent a whole lot of time trying to set things up and deal with a broken debugger. Sure enough, the precious minutes wasted without bringing any value to the developed program. The most interesting thing here is that having an interactive UI wasn’t a strict requirement, as you see from the list shown above. Still, this thing drained my attention and a considerable part of the allocated time. It Is Easy To Refactor This God-Class Later After I’d gave up my attempts to tame the terminal, I started building the game logic. The main class called (yes, a pretty unusual name for a class that manages the game) was responsible for storing the board state, switching the active player, and managing the whole game process. Game As you already know, I was running out of time, so I’d tried to focus on the building working solution and put off the refactoring for the very end of the process. After some time, the was responsible not only for the gameplay but also rendered the board, including a few hard-coded constants and so on. Without notice, my class became responsible for . Game Game everything Ad-hoc solutions and quick patches had led to the avalanche of bad code without time to fix it Expectation vs Reality from the world of Computer Programming So as you can guess, I didn’t have enough time to factor out this AllmightyGame class into something more manageable and light-weighted. It becomes a great illustration of instead. Ad-hoc solutions and quick patches had led to the avalanche of bad code without time to fix it. It seems that distinguishing the clean code from the ugly one is a more simple thing than spotting how it from one category into another. God-class anti-pattern slowly slides Writing Tests Takes Too Much Time An ugly game logic class, a fragile UI, and the time given to complete the task is almost over. Not bad for such a “simple” thing! How can we safe a bit of time to fix all this mess? Which part of the software development process seems to be the one we can easily drop without much consequences? The answer is unit tests! The code is so compact that you can see every class and function; we can safely jump straight into application logic coding instead of writing these extra functions, right? Wrong. Even with the simplistic and trivial programs, you need You still need to write some to run your program, and you are going to execute it very often during the development process. These entry points are precisely the thing tests give you. somehow verify that your input generates a valid output. entry point The tests not only don’t add too much overhead to your code, but they also bring many benefits to the development process, even for pretty simple, toy programs Moreover, writing tests has a significant effect on your API building process: it forces you to decouple modules and untangle pieces of your system. See the snippet below. You need to verify that game logic works, and the most straightforward way to do so is to pass the game state from outside. Then you only need to call your winner checking function and see if it works as expected. Otherwise, you would need to run the game UI, and type turns manually. Even for small game states, it would steal a few seconds of your time on each run, not talking about testing bigger boards. pytest

@pytest.mark.parametrize( , [ , , ])
def test_game_has_winner(state):
    game = Game(state)
    assert game.has_winner() = state_from_string(state)

    def has_winner(self):
        pass  # check rows, columns, and diagonals

def state_from_string(line): [list(row) row line.split( )] import 'state' 'ooo|x.x|..x' 'xo.|xo.|x..' 'x..|.xo|o.x' : ( , ): . class Game def __init__ self state self state return for in '|' View codes on Github here Therefore, the tests not only don’t add too much overhead to your code, but they also bring many benefits to the development process, even for pretty simple, toy programs. I believe there is an opposite tendency actually: the tests could even and help to make it better. One should think twice before shrinking testing to save time. speed up the development process Lessons Learned Sure enough, this little story was written not to tell you how to deal with terminal rendering troubles or write puzzle games. It is musing about Software Development in general. One could find this “parable” quite shallow with lots of obvious mistakes I’d made. Well, good for you! You are a much better developer than I am. Nevertheless, I decided to share this failure with the rest of us who feel confident and experienced but sometimes forget about such “mundane things” like deadlines, KISS, and MVP. Tight time limits and perceived task’s simplicity could play a bad joke of you, and I am talking not only about test tasks but the daily development process as well. So let’s go through the lessons we can learn from this story. If you don’t have a working product, everything else doesn’t make much sense. I’ve seen similar things in my carrier when a company starts with building fancy customized dashboards, a bunch of cross-platform applications, tries to account all possible edge cases when it would be more beneficial to focus on the minimal logic and not to spread the efforts. Don’t put the horse before the cart. It becomes evident when you’re given just an hour to complete the task. Such a short period highlights things that are true for a broader scope as well. Moreover, long development timespan can easily hide the issue. Being busy doesn’t imply making progress. Tests can’t guarantee the absence of bugs, but they force you to separate the code into smaller fragments, decouple submodules, inverse dependencies, and in general, write a cleaner API. It is a pretty good method to structure the thinking process and better understand the requirements. Try to use test-driven development approach whenever it’s possible. At least, at the very beginning of the development process. Even when the task seems to be super easy, resits the urge to combine its implementation with the learning of a new framework. Go with the technologies you know best. You should keep the convenience of the users in mind but make of it an ultimate goal probably not a good idea. This point has lots in common all the previous ones. Following accidental requests from your customers, you tend to ignore testing, making ad-hoc changes, hacking the codebase, and essentially “overfitting” the quality of your product. Don’t put the user’s convenience before the clean code. Many of these things could seem obvious and many times repeated. (Not talking about plenty of great books). Nevertheless, I believe that every of us has a chance to fall into the same trap, and it is a good idea to remind yourself about these simple observations every once in a while to be in a good fit and make better decisions. Have you ever had similar experience during your developer’s carrier? Or if you’re an employer, which kind of tasks you prefer to give to your candidates? What do you think about such type of “stress-testing”? Would be glad to hear your thoughts!

How To Fail A Coding Interview

This post is a follow up to a about building a multiplayer browser game. In this techsploration, I’m going to quickly brush over how latency can affect your game and how to combat that. I will briefly discuss a couple of game frameworks, including one I built at , and how to incorporate sound into your game. post I made a while ago BrickHack3 Latency and Laaaaaaaaaaaaaaaaaaaaaaag So firstly, what is latency? Well, if you’ve played any online game before, you might have experienced that phenomenon where you click or try to perform an action, and the nothing happens in the game until a bit later. Typically known as “lag”, this is incredibly frustrating to deal with for real time games like multiplayer shooters. Latency occurs simply because of the physical distance between your computer and the server you’re connected to. Remember how in we talked about authoritative server determination? That’s what causes the lag since it takes time for your input to be sent to the server, verified, and sent back. part one has fantastic resources and explanations on why this occurs and how to deal with it, and I will be linking lots of resources from his site. http://gabrielgambetta.com A single client-server interaction (image from ) gabrielgambetta.com To combat lag, I’m going to introduce an idea called client prediction/extrapolation. This concept basically involves playing the animation before an action on the client side BEFORE it has been acknowledged by the server to emulate seamless gameplay. The client is basically predicting the state of the server after the acknowledgement. Especially for player movement, this becomes easy to implement if you have a deterministic model for the world. If your game world is governed by predictable and calculated physics, then the client side can make educated assumptions that its input is valid so that the player move animation can begin before the acknowledgement from the server has been received. Client prediction (image from ) gabrielgambetta.com Aside from these awesome diagrams, Gabriel Gambetta’s site has a lot of cool visualizations of how this works and an explanation of some of the problems with this as well. . Since this post is mostly for introducing the idea in the abstract, I highly recommend that you check out his as well if you’d like to implement this in your own code. Definitely check out his live demo sample code incheon.gg The homepage to incheon.gg In the comments of , recommended the framework to me as a way to abstract away most of the problems that I discussed in the first part of this article. This framework is pretty cool and allows for games with discrete and continuous physics, all while handling most of the client-server synchronization logic. I’ve been checking it out and playing with their sample code and I highly recommend using this framework as a start if you don’t want to implement the network code yourself. It is extremely well documented and easy to read. How to Build a Multiplayer Game (part one) Opherv incheon.gg Granted, it was a little difficult to get started (mostly since I had to learn ES6 style classes) but since its such a dense topic with a lot of great discussion points I’ll make another post soon on how I explored the framework and what I made with it. (But huge shoutout to for linking me to this!) Opherv Writing my own game framework at BrickHack3 If you don’t care too much about network lag and you want to try customizing and writing everything including the physics, sound, and animation, you can also check out the . game code that I use Karl Coehlo (left), me (center), Dan Giaime (right) at BrickHack3 I participated in at the Rochester Institute of Technology this weekend, and since my team submitted a ( ), I actually spent some time writing to build the multiplayer game with. BrickHack3 multiplayer game we won the Best Game Award my own framework I build multiplayer games a lot and over the years I’ve recycled a lot of the code. This framework is simply a culmination of what I’ve learned over the years. Unlike , is much more tailored to the type of open world multiplayer games I like to build and doesn’t have any of the aforementioned networking functionality built in. It’s geared more for people who want to learn about game architecture by writing the code for every part themselves. incheon.gg my framework While it’s still a work in progress, works much closer to the node.js architecture that powers it and allows for more of it to be customized. If you’re a game dev beginner or node.js beginner and you just came from , then I’d probably recommend you take a look at this code and tinker with it to understand what it does. my framework part one . This repository contains a refactored, commented, and cleaned up version of the mockup we built in . In the next section, I’ll explain each part of this framework in detail. I suggest cloning the repository if you’d like to follow along. Here’s a link to the GitHub repository part one git clone https://github.com/omgimanerd/game-framework Files included in the game framework Let’s start with , the bread and butter of any node.js project. The main dependencies I have are , , , , and . The only ones absolutely necessary to this project are socket.io, and hashmap though. morgan is a just a useful logging tool, express is a widely used middleware framework, and pug is a template engine, but if you wanted to, you could very easily swap them out for something you’re more comfortable with. The hashmap package is used to map each client’s socket ID to their Player instance, while socket.io is needed of course to power the real-time communication. package.json express hashmap morgan pug socket.io Next is , which contains two client side dependencies, and . Neither is really necessary, but makes your life easier, and is that powers the sound for the game. I’ll discuss how I use later. bower.json jquery howler.js jquery howler.js a cool library howler.js The “lib” folder contains the server side files that handle and store the state of the game and its entities. and are that encapsulate an entity with basic physics and a circular/spherical hitbox. If you wanted to get ambitious, you could implement more elaborate physics, gravity, hitbox meshes, etc into the class. Entity2D.js Entity3D.js ES5 style classes Entity2D.prototype.update = function(deltaTime) {var currentTime = (new Date()).getTime();if (deltaTime) {this.deltaTime = deltaTime;} else if (this.lastUpdateTime === 0) {this.deltaTime = 0;} else {this.deltaTime = (currentTime - this.lastUpdateTime) / 1000;}for (var i = 0; i < DIMENSIONS; ++i) {this.position[i] += this.velocity[i] * this.deltaTime;this.velocity[i] += this.acceleration[i] * this.deltaTime;this.acceleration[i] = 0;}this.lastUpdateTime = currentTime;}; Note how we implemented the framerate independent updating discussed in here. Updates to the position and velocity are done using a deltaTime so that we get consistent behavior. is just an extension of and simply handles user input on top of the basic physics for the purpose of the mockup demo. part one Player.js Entity2D.js is a bit more interesting. Game.js function Game() {this.clients = new HashMap();this.players = new HashMap();} On top of this basic constructor, we have methods that facilitate the connecting and disconnecting of players. Essentially all this class does is handle the updating and broadcasting of the server state. Game.prototype.update = function() {var players = this.getPlayers();for (var i = 0; i < players.length; ++i) {players[i].update();}}; Game.prototype.sendState = function() {var ids = this.clients.keys();for (var i = 0; i < ids.length; ++i) {this.clients.get(ids[i]).emit('update', {self: this.players.get(ids[i]),players: this.players.values().filter((player) => player.id != ids[i])});}}; Game.prototype.update() simply updates every entity in the game, and Game.prototype.sendState() broadcasts the game state to every client connected to the server. The only interesting thing to note (and this is specific to my implementation) is that we filter out the currently connected player and send them separately. You could implement this your own way however. That’s just the way I chose to do it to since it makes my life easier on the client side. Moving on to the “public” directory, this folder contains all the statically served client-side JavaScript files. Remember how we mentioned that it was a good idea to refactor stuff in ? This is just one way of doing it. Building a set of modules that each specialize in handling a specific part of the functionality is always a good idea and good software design in general. part one , given a HTML5 canvas context object, will handle the drawing of all the game sprites onto it. The client side uses to run a game loop on the client side for sending user input to the game server as well as rendering the received game states. Drawing.js Game.js window.requestAnimationFrame() Game.prototype.animate = function() {this.animationFrameId = window.requestAnimationFrame(Util.bind(this, this.update));}; Game.prototype.update = function() {if (this.selfPlayer) {// Emits an event for the containing the player's input.this.socket.emit('player-action', {keyboardState: {left: Input.LEFT,right: Input.RIGHT,up: Input.UP,down: Input.DOWN}});// Draws the state of the game onto the canvas.this.draw();}this.animate();}; This snippet shows a bit of how that functionality works. Here’s a if you don’t know what it does. In case you were wondering, Util.bind() creates a function that binds the context of the Game object to the update() function so that it can be called by requestAnimationFrame(). It’s a nitty hack that goes into the technicalities of JavaScript, so I won’t really discuss that since you can easily achieve the same thing with an anonymous function. link to the requestAnimationFrame documentation is a file I reuse very commonly in my games (with some variation). It binds the necessary event handlers to track user keyboard/mouse input and stores them for easy access. By abstracting away this functionality and keeping it contained in a single class, I don’t have to worry about fetching user input anywhere else. Input.js Although isn’t used in the mockup demo, I’ll explain it quickly here. This file wraps some of the functionality of the amazing library , which I use to play sounds in my games. Upon initialization, it creates Howl objects for every sound that will be used in the game, which can then be played using Sound.prototype.play(). The way I have it implemented, all your sound files must be stored in a folder called “sound” inside the public directory, but this can easily be changed and tinkered with however you see fit. I highly recommend looking through the . Sound.js Howler.js howler.js documentation Moving on, the “shared” directory only contains one file, . Util.js is another one of those files that I recycle frequently between my projects. It contains a variety of useful utility functions that are used on both the client and server side. The “shared” folder is served statically so that I can include the script from an HTML file and require() it from the server side wherever I need. Feel free to relocate this file if you wish; this is just the organization that I found worked for me. Util.js Another way I use the “shared” folder is to store game constants that need to be accessed by both the server and client. For example, I’ll have a class that looks like this: function Constants() {} Constants.PLAYER_HITBOX = 10; Constants.WORLD_SIZE = 2500; if (typeof(module) === 'object') {module.exports = Constants;} else {window.Util = Util;} This allows the class to be handily loaded into the client or server side. The “views” folder is relatively uninteresting and contains the template for the mockup demo. doctype html htmlheadtitle Game!bodycanvas(id='canvas' width='800px' height='600px')script(src='/socket.io/socket.io.js')script(src='/public/bower/jquery/dist/jquery.min.js')script(src='/shared/Util.js')script(src='/public/js/game/Drawing.js')script(src='/public/js/game/Game.js')script(src='/public/js/game/Input.js')script(src='/public/js/game/Sound.js')script(src='/public/js/client.js') I use the , but you could easily plug in any template of your choice. pug templating engine And finally, we have in the root directory. This file is a pretty standard node.js server using the . There are two important snippets to take note of though. server.js express middleware framework const FPS = 60; io.on('connection', (socket) => {socket.on('player-join', () => {game.addNewPlayer(socket);}); socket.on('player-action', (data) => {game.updatePlayerOnInput(socket.id, data);}); socket.on('disconnect', () => {game.removePlayer(socket.id);})}); setInterval(() => {game.update();game.sendState();}, 1000 / FPS); The socket event handlers were covered in , this is the refactored and cleaned up implementation, where we take advantage of the methods we defined in the from earlier. The setInterval() game loop simply runs the game updating and state broadcasting over and over at approximately 60 FPS. part one Game class Next Steps From here, I highly suggest you take this framework and tinker with it. Make it your own, write your own code, print it out and burn it, I don’t care. Try upgrading the physics or writing your own animation engine. I hope you learn something from messing around it and I hope you make something cool. If you do make something cool, please share it with me! I’d be super interested in checking out anything you make. That’s all I have for now. Thanks for reading! Please hit the ❤ button down below if you enjoyed this article :) Follow me on Twitter: @omgimanerd

Stories, News & Mentions about GAMEHEADS

Gameheads’s Stories on HackerNoon