Snake: Difference between revisions

 

=={{header|Ada}}==

-- This code is a basic implementation of snake in Ada using the command prompt

-- feel free to improve it!

Snake.run;

end;

 

{{out}}

=={{header|Amazing Hopper}}==

{{trans|C}}

/* Snake */

/* Implementing this task in Hopper-FLOW-MATIC++ */

#include <flow-term.h>

#include <keys.h>

 

#enum 1,N,E,S,W

#enum 1,SPACE,FOOD,BORDER

BREAK-ON

STACK 16

 

SET( TIME, 100 )

LET( Size := MUL(w,h) )

VOID( big number, numL1, numL2, numL3 )

GOSUB( set score )

 

HIDE-CURSOR

 

}

WEND

SHOW-CURSOR

PRNL

 

RUTINES

 

// initialize the board, plant a very first food item

 

 

GOSUB( plant )

RET

DEF-FUN( you lost )

SET(i,1), SET(k,0), SET(n,1)

FOR( LE?(i, h), ++i)

SET(j,1)

COND( IS-NEG?( k ))

LOCATE(i,j)

CEND

++n

NEXT

NEXT

RET

 

DEF-FUN( show )

SET(i,1)

MSET(j, k)

SET(n,1)

LOCATE(1,1)

FOR( LE?(i, h), ++i)

FOR( LE?(j, w), ++j)

LET( k := [ n ] GET(board) )

COND( IS-NEG?( k ))

ELS-COND( {k} IS-EQ?(BORDER))

ELS-COND( {k}IS-EQ?(FOOD) )

ELS

CEND

++n

NEXT

PRNL

NEXT

RET

 

 

GET( board ) PLUS(1) »» (jAge)

// this is necessary, because Hopper arrays begining in 1

CART( IS-ZERO?(jAge) ) »» (jR)

// ******

{jAge} PUT(board), CLR-RANGE

RET

 

DEF-FUN( step )

LET( len := [nHead] GET(board) )

CASE (N){ nHead -= w, EXIT }

CASE (S){ nHead += w, EXIT }

CASE (W){ --nHead, EXIT }

CASE (E){ ++nHead, EXIT }

CASE (SPACE){

[nHead] { len }, CPUT(board) // keep in mind len is negative

GOSUB( age )

}

CASE (FOOD){

[nHead] { len }, CPUT(board)

ADD(SCORE,TIME), MOVE-TO(SCORE)

 

LET( TIME := 100 )

LET( TLimit := SUB( TLimit,5 ))

LET( counter := 0 )

CEND

++ConsPrey

COLOR-FG(10)

 

EXIT

}

RET

 

 

DEF-FUN( put titles )

COLOR-FG(15)

RET

 

LET( p4 := ADD( posx, 4 ))

PERF-UP(k, lsb, 1)

LET( nB := VAL( MID( 1, k, sb )) )

SET( j, rx )

FOR( LE?(j, ADD( rx, 2 ) ), ++j )

++x

NEXT

rx += 4

NEXT

RET

 

LOCATE ( posx, posy ) FILL-BOX(" ",4,20)

SET(i, 1)

PERF-UP( i, ln, 1)

LET( s := VAL( MID( 1, i, sp )) )

posy += 2

NEXT

RET

 

{"\033[38;5;4m\033[48;5;11m"}

LOC-COL(16)

RET

 

{"\033[38;5;15m\033[48;5;9m"}

LOC-COL(17)

RET

 

 

 

 

=={{header|AutoHotkey}}==

Gui, +AlwaysOnTop

Gui, font, s12, consolas

return [oGrid, row, col]

}

 

=={{header|BASIC}}==

 

==={{header|FreeBASIC}}===

REM Snake

 

End

'--------------------------

 

==={{header|Locomotive Basic}}===

 

 

If you are playing this in [https://benchmarko.github.io/CPCBasic/cpcbasic.html CPCBasic], first click on the CPC screen so it gets keyboard input and then enter "run" (clicking the Run button would deselect the screen again).

20 sx=20:sy=5:dx=1:dy=0:ml=20:dim ox(ml),oy(ml):oi=1:ll=4:skill=6

30 f$=chr$(228):w$=chr$(127):b$=chr$(231)

280 if a$<>" " then 260

290 print f$;

 

==={{header|ZX Spectrum Basic}}===

 

Note that lines <code>10</code> to <code>210</code> and <code>580</code> to <code>890</code>—more than half the program—define graphics characters for the snake's head (facing in different directions) and for its food. If you're happy to make do with characters from the standard character set, you can easily adapt lines <code>220</code> to <code>570</code> to work on their own. The things the snake eats are supposed to be apples, although they don't look too much like them.

20 READ bits

30 POKE USR "L"+i,bits

870 DATA BIN 11111100

880 DATA BIN 01111111

 

=={{header|C}}==

As some implementation below (C++) works on Windows console, let it work on Linux. Other implementations could be added as well, reusing the api.

 

// The problem with implementing this task in C is, the language standard

close_screen();

return 0;

 

=={{header|C++}}==

Simple Windows console implementation.

[[File:SnakeCpp.png|200px|thumb|right]]

#include <windows.h>

#include <ctime>

snake s; s.play(); return 0;

}

=={{header|Delphi}}==

{{libheader| Winapi.Windows}}

{{libheader| Vcl.ExtCtrls}}

{{Trans|JavaScript}}

unit SnakeGame;

 

FrameTimer.Enabled := True;

end;

Form resources:

object SnakeApp: TSnakeApp

OnCreate = FormCreate

end

 

=={{header|Go}}==

FreeBSD, OpenBSD, NetBSD, DragonFly BSD, Linux, MS Windows, and MacOS

(tested on FreeBSD and MS Windows).

 

import (

snakeHead = termbox.Cell{Ch: 'O', Bg: bg, Fg: termbox.ColorYellow | termbox.AttrBold}

food = termbox.Cell{Ch: '@', Bg: bg, Fg: termbox.ColorRed}

 

=={{header|Haskell}}==

import Control.Monad.Random (getRandomRs)

import Graphics.Gloss.Interface.Pure.Game

main = do world <- createWorld

play inW white 7 world renderWorld handleEvents updateWorld

 

'''Extra credit'''

It is easy to make snake to seek food automatically. Just change the first line of the <code>updateWorld</code> definition:

 

 

and add local definition:

 

where

optimalDirection = minimumBy (comparing distanceToFood) safeTurns

distanceToFood d = let (a,b) = w^.snake & turns d & moves & (^.body) & head

(x,y) = w^.food & head

 

=={{header|J}}==

Needs j9 qt:

 

 

coinsert 'jgl2'

 

}}

 

open''

snake=: 10 10,10 11,:10 12

 

move=: {{

head=. y+{.snake

if. head e. snake do. head gameover'' return. end.

if. _1 e. head do. (0>.head) gameover'' return. end.

newdot''

else.

end.

draw''

 

gameover=: {{

if. 1<#snake do.

draw''

glbrush glrgb 255 255 0

end.

snake=: ,:_ _

 

=={{header|Java}}==

=={{header|JavaScript}}==

You need the P5 Library to run this code!

const L = 1, R = 2, D = 4, U = 8;

var block = 24, wid = 30, hei = 20, frameR = 7, fruit, snake;

if( !snake.alive ) text( "THE END", 630, 250 );

}

 

=={{header|Julia}}==

 

mutable struct SnakeGame

end

 

 

function play(;n=10,t=0.5)

scene = Scene(resolution = (1000, 1000), raw = true, camera = campixel!)

display(scene)

 

score_text = @lift("Score: $(length($game.snake)-1)")

 

direction = Ref{Any}(nothing)

 

end

end

 

play()

 

=={{header|Kotlin}}==

{{trans|C++}}

{{works with|Windows 10}}

 

import kotlinx.cinterop.*

srand(time(null).toInt())

Snake().play()

 

{{output}}

[[File:snake-lua.png]]

{{works with|LÖVE}}

UpdateTime=0.200

Timer = 0

Head.nextDirection = iDirection

end

 

=={{header|Nim}}==

{{libheader|nim-ncurses}}

As in the C version, the code is provided for Linux. We use the tiny API defined in the C version, only adjusted to work with Nim and the library “nim-ncurses”.

import ncurses

 

 

sleep(1000)

 

=={{header|OCaml}}==

{{libheader|OCamlSDL2}}

 

open Sdl

 

main_loop state

in

 

=={{header|Perl}}==

[[File:Snake_game_perl.png|200px|thumb|right]]

use Time::HiRes qw(sleep);

use Term::ANSIColor qw(colored);

elsif ($key eq "\e[C" and $dir ne LEFT ) { $dir = RIGHT }

elsif ($key eq "\e[D" and $dir ne RIGHT) { $dir = LEFT }

 

=={{header|Phix}}==

{{trans|C++}}

enum NORTH, EAST, SOUTH, WEST

 

end while

end procedure

 

=={{header|Python}}==

Using Pygame. Works with Python >= 3.7.

 

import itertools

score = game.main()

print(score)

 

=={{header|Raku}}==

This is a variation of a demo script included in the examples folder for the Raku [https://modules.raku.org/search/?q=SDL2%3A%3ARaw SDL2::Raw library bindings].

 

use Cairo;

 

}

 

 

=={{header|Rust}}==

[dependencies]

*/

 

#![windows_subsystem = "windows"]

 

use std::{cell::RefCell, rc::Rc};

 

const SNAKE_W: i32 = 20; // px

 

struct Context {

}

 

pub fn main() {

let mut colors = [(0x00, 0xF0, 0xA0); 6]; // color tail, turn, body

colors[bg] = (0x00, 0x50, 0x90);

let wnd = gui::WindowMain::new(gui::WindowMainOpts {

title: "Snake - Start: Space, then press W-A-S-D".to_string(),

class_bg_brush: brushes[bg],

..Default::default()

});

 

let context = Rc::clone(&context);

}

}

});

 

let context = Rc::clone(&context);

let mut ctx = context.borrow_mut();

}

});

 

}

Ok(())

});

 

 

=={{header|Sidef}}==

const readkey = frequire('Term::ReadKey')

const ansi = frequire('Term::ANSIColor')

var h = `tput lines`.to_i

 

 

=={{header|Wren}}==

{{libheader|Wren-dynamic}}

An embedded program so we can ask the C host to call ncurses and another library function for us.

 

import "random" for Random

}

C.usleep(999 * 1000)

<br>

Now embed this script in the following C program, compile and run it.

 

#include <stdio.h>

WrenVM* vm = wrenNewVM(&config);

const char* module = "main";

char *script = readFile(fileName);

WrenInterpretResult result = wrenInterpret(vm, module, script);

free(script);

return 0;

 

=={{header|XPL0}}==

speed is currently set at nine steps per second.

 

StartLength = 10, \starting length of snake including head

Morsels = 10; \number of food items constantly offered

Sound(0, 36, 1); \pause 2 seconds to see result

OpenI(1); \flush any pending keystrokes