Snake: Difference between revisions
Content deleted Content added
(63 intermediate revisions by 15 users not shown) | |||
Line 13:
The game ends when the snake attempts to eat himself.
<br><br>
=={{header|Ada}}==
<syntaxhighlight lang="ada">
-- This code is a basic implementation of snake in Ada using the command prompt
-- feel free to improve it!
-- Snake.ads
with Ada.Containers; use Ada.Containers;
with Ada.Containers.Vectors;
package Snake is
-- copy from 2048 game (
-- Keyboard management
type directions is (Up, Down, Right, Left, Quit, Restart, Invalid);
-- Redefining this standard procedure as function to allow Get_Keystroke as an expression function
function Get_Immediate return Character;
Arrow_Prefix : constant Character := Character'Val(224); -- works for windows
function Get_Keystroke return directions;
-- )
-- The container for game data
type gameBoard is array (Natural range <>, Natural range <>) of Character;
-- Initilize the board
procedure init;
-- Run the game
procedure run;
-- Displaying the board
procedure Display_Board;
-- Clear the board from content
procedure ClearBoard;
-- coordinates data structure
type coord is tagged record
X,Y : Integer;
end record;
-- list of coordinate (one coordinate for each body part of the snake)
package snakeBody is new Ada.Containers.Vectors (Natural, coord);
use snakeBody;
-- update snake's part depending on the snakeDirection and checking colicion (with borders and snak's part)
function moveSnake return Boolean;
-- generate food if it was eaten
procedure generateFood;
-- Add snake and food to the board
procedure addDataToBoard;
-- generate random integer between 1 and upperBound to generate random food position
function getRandomInteger(upperBound : Integer) return Integer;
private
width, height : Positive := 10;
board : gameBoard := (0 .. (width+1) => (0 .. (height+1) => ' '));
snake : Vector := (1,1) & (2,1) & (3,1);
snakeDirection : directions := Right;
food : coord := (5,5);
end Snake;
-- Snake.adb
with Ada.Text_IO; use Ada.Text_IO;
with Ada.Numerics.Discrete_Random;
package body Snake is
-----------------------------------------------------------------------------
-- Redefining this standard procedure as function to allow Get_Keystroke as an expression function (copy from 2048 game)
function Get_Immediate return Character is
begin
return Answer : Character do Ada.Text_IO.Get_Immediate(Answer);
end return;
end Get_Immediate;
-----------------------------------------------------------------------------
-- (copy from 2048 game)
function Get_Keystroke return directions is
(case Get_Immediate is
when 'Q' | 'q' => Quit,
when 'R' | 'r' => Restart,
when 'W' | 'w' => Left,
when 'A' | 'a' => Up,
when 'S' | 's' => Down,
when 'D' | 'd' => Right,
-- Windows terminal
when Arrow_Prefix => (case Character'Pos(Get_Immediate) is
when 72 => Up,
when 75 => Left,
when 77 => Right,
when 80 => Down,
when others => Invalid),
-- Unix escape sequences
when ASCII.ESC => (case Get_Immediate is
when '[' => (case Get_Immediate is
when 'A' => Up,
when 'B' => Down,
when 'C' => Right,
when 'D' => Left,
when others => Invalid),
when others => Invalid),
when others => Invalid);
-----------------------------------------------------------------------------
procedure init is
begin
for Row in 0 .. width+1 loop
for Column in 0 .. height+1 loop
if Row = 0 or Row = width+1 then
board(Row,Column) := '#';
-- Insert(board(Row,0), Column, '#');
else
if Column = 0 or Column = height+1 then
board(Row,Column) := '#';
-- Insert(board, board(Row, Column), "#");
else
board(Row,Column) := ' ';
-- Insert(board, board(Row, Column), " ");
end if;
end if;
end loop;
end loop;
end;
-----------------------------------------------------------------------------
procedure run is
task T;
task body T is
begin
loop
snakeDirection := Get_Keystroke;
end loop;
end T;
begin
init;
loop
exit when snakeDirection = Quit;
if moveSnake = False then
Put_Line("GAME OVER!!!");
Put_Line("Your score is:" & Length(snake)'Image);
exit;
end if;
Display_Board;
delay 0.7;
end loop;
end run;
-----------------------------------------------------------------------------
procedure Display_Board is
begin
for Row in 0 .. width+1 loop
for Column in 0 .. height+1 loop
Put(board(Row, Column));
end loop;
New_Line;
end loop;
end Display_Board;
-----------------------------------------------------------------------------
procedure ClearBoard is
begin
for Row in 1 .. width loop
for Column in 1 .. height loop
board(Row, Column) := ' ';
end loop;
end loop;
end ClearBoard;
-----------------------------------------------------------------------------
function moveSnake return Boolean is
colision : Boolean := False;
headCoord : coord := Snake.First_Element;
addSnakePart : Boolean := False;
begin
case snakeDirection is
when Up => headCoord.X := headCoord.X - 1;
when Down => headCoord.X := headCoord.X + 1;
when Right => headCoord.Y := headCoord.Y + 1;
when Left => headCoord.Y := headCoord.Y - 1;
when others => null;
end case;
if headCoord.Y = height+1 then
return False;
end if;
if headCoord.Y = 0 then
return False;
end if;
if headCoord.X = width+1 then
return False;
end if;
if headCoord.X = 0 then
return False;
end if;
for index in snake.Iterate loop
if headCoord = snake(To_Index(index)) then
return False;
end if;
end loop;
snake.Prepend(headCoord);
if headCoord /= food then
snake.Delete_Last;
else
food := (0,0);
generateFood;
end if;
addDataToBoard;
return True;
end moveSnake;
-----------------------------------------------------------------------------
procedure generateFood is
begin
if food.X = 0 or food.Y = 0 then
food := (getRandomInteger(width), getRandomInteger(height));
end if;
end generateFood;
-----------------------------------------------------------------------------
procedure addDataToBoard is
begin
ClearBoard;
board(food.X, food.Y) := '*';
for index in snake.Iterate loop
board(snake(To_Index(index)).X, snake(To_Index(index)).Y) := 'o';
end loop;
end addDataToBoard;
-----------------------------------------------------------------------------
function getRandomInteger(upperBound : Integer) return Integer is
subtype Random_Range is Integer range 1 .. upperBound;
package R is new
Ada.Numerics.Discrete_Random (Random_Range);
use R;
G : Generator;
begin
Reset (G);
return Random (G);
end getRandomInteger;
end Snake;
-- main.adb
with Snake;
procedure Main is
begin
Snake.run;
end;
</syntaxhighlight>
{{out}}
<pre>
############
# #
# #
# ooo #
# o #
# o #
# o #
# o #
# o #
# * #
# #
############
</pre>
=={{header|Amazing Hopper}}==
{{trans|C}}
<syntaxhighlight lang="amazing hopper">
/* Snake */
/* Implementing this task in Hopper-FLOW-MATIC++ */
/* The snake must catch a bite before time runs out, which decreases by
10 points every 800 milliseconds.
The remaining time will be added to your total score. */
#include <flow.h>
#include <flow-term.h>
#include <keys.h>
#define LIMIT_TIME 120
#define INF_TIME 80 //70
#define ONE_SECOND 1000
#define TOTAL_TIME 100
#define DECREMENT_TIME 10
#define COLOR_FOOD 232
#define BACK_FOOD 255
#define TIME_LEVEL 90000 //90000 // un minuto y medio
#define TIME_CHALLENGE 40000 // 40 segundos
#define TIME_LOST 30000
#define COLUMNA_PRINT 55
#define SIZE_INITIAL -7
#enum 1,N,E,S,W
#enum 1,SPACE,FOOD,BORDER
DEF-MAIN
BREAK-ON
STACK 16
MSET(C, quit, nHead, dir, Size, SCORE, counter, T, TPlay,TSound, ConsPrey,Consumed stage )
SET(len,0)
SET( w, 50)
SET( h, 28)
SET( color food, COLOR_FOOD )
SET( back food, BACK_FOOD )
SET( TIME, 100 )
LET( Size := MUL(w,h) )
SET( LEVEL,1 )
SET( REAL LEVEL,1 )
FALSE(swPierde)
TRUE(swExtra1,swExtra2)
TRUE( tiles )
SET( back tiles,1 ), MSET(tile1, tile2)
VOID( head back tiles )
MEM("\033[48;5;28m","\033[48;5;29m","\033[48;5;62m","\033[48;5;63m","\033[48;5;70m","\033[48;5;71m","\033[48;5;4m","\033[48;5;27m" )
MEM("\033[48;5;99m","\033[48;5;97m","\033[48;5;17m","\033[48;5;18m","\033[48;5;62m","\033[48;5;63m")
APND-LST(head back tiles)
[back tiles] GET(head back tiles), MOVE-TO(tile1)
[PLUS-ONE(back tiles)] GET(head back tiles), MOVE-TO(tile2)
VOID( big number, numL1, numL2, numL3 )
VOID( sounds ), SET( sound index, 1 )
MEM("Snake_music.wav","Snake_music_l3.wav","Snake_music_l5.wav","Snake_music_l4.wav","Snake_music_l6.wav")
APND-LST(sounds)
GOSUB( set score )
MSET(tBoard1,tmpLimit,Maze,wM,hM,SizeM)
DIM( Size ) AS-ONES( board ), {board} MOVE-TO(tBoard1)
// load and prepare maze for challenge stage:
SET(i,1)
LET( Maze := REPLICATE("3",50) )
PERF-UP(i,26,1)
LET( Maze := CAT( Maze, CAT( CAT("3", REPLICATE("1",48) ), "3") ) )
NEXT
LET( Maze := CAT( Maze, REPLICATE("3",50) ))
GOSUB( prepare maze )
HIDE-CURSOR
CLR-SCR
SET( TLimit := LIMIT_TIME )
MEM(SIZE_INITIAL),GOSUB( start )
SET( time out, TIME_LEVEL)
SYS( CAT(CAT("aplay fl/",[sound index]CGET(sounds)), "</dev/null >/dev/null 2>&1 &"))
GOSUB( titles )
/* PLAY GAME!! */
SET(lives,3)
WHILE( lives )
GOSUB( show )
GOSUB( put titles )
GOSUB( ready ), SLEEP(1.5)
TIC( T ), TIC( TPlay ), TIC(TSound)
KBD-FREE
WHILE( NOT (quit) )
ON-TIME( TLimit ~= TPlay ){
GOSUB( show )
WHEN( KEY-PRESSED? ){
SCAN-CODE( C )
SELECT( C )
CASE( K_UP ) { dir = N, EXIT }
CASE( K_RIGHT ){ dir = E, EXIT }
CASE( K_DOWN ) { dir = S, EXIT }
CASE( K_LEFT ) { dir = W, EXIT }
CASE( K_ESC ) { quit = 1, EXIT }
CASE( 32 ) { PAUSE, EXIT }
SELEND
}
GOSUB( step )
}
ON-TIME( ONE_SECOND ~= T ) {
TIME-=DECREMENT_TIME, CLAMP(0,TOTAL_TIME,TIME)
{TIME, 12, COLUMNA_PRINT} GOSUB( put time )
}
ON-TIME( time out ~= TSound ){
GOSUB(LEVELCLEAR)
}
WEND
COND( OR(EQ?(LEVEL,3),EQ?(LEVEL,6)) )
GOSUB(you lost),SLEEP(3)
SET(quit,0), [nHead]{len}CPUT(board)
LOCATE(1,1), FILL-BOX(" ",29,54)
GOSUB( another play )
ELS
GOSUB(you lost), SLEEP(3)
--lives
SET(quit,0)
TRUE(swPierde)
{len}GOSUB( start )
COND( IS-NOT-ZERO?(lives) )
SYS("aplay fl/Snake_music_vida_repechaje.wav </dev/null >/dev/null 2>&1 &")
CEND
CEND
WEND
/* GAME OVER */
GOSUB(game over ), SLEEP(7)
SET-VIDEO-TEXT
SHOW-CURSOR
PRNL
END
RUTINES
DEF-FUN( KILLSOUND )
SET( PID,0 )
LET( PID := ONLY-CHR("0123456789 ", EXEC( "pidof aplay" )))
COND( LEN(PID) )
SYS( CAT(CAT("kill ",PID), " </dev/null >/dev/null 2>&1"))
CEND
RET
// initialize the board, plant a very first food item
DEF-FUN( start, initial pos )
COND( NOT-EQ?(LEVEL,3) )
{tBoard1} MOVE-TO(board)
{50,28},MUL(50,28), MOVE-TO( w, h, Size )
[1:w] {BORDER} CPUT(board) // top
[ SUB(MUL(h,w),MINUS-ONE(w)) : end] {BORDER} CPUT(board) // bottom
[1:w:end] {BORDER} CPUT(board) // left
SET(i, 1)
FOR( LE?(i, h), ++i )
[ MUL(i, w )] {BORDER} PUT(board) // right
NEXT
LET( time out:=TIME_LEVEL )
ELS
TRASH(board)
CEND
SELECT(LEVEL)
CASE(2){
SET(i,3)
PERF-UP(i,5,1)
// laterales extremos:
[ADD(MUL(i,w),5):ADD(MUL(i,w),8)] {BORDER} CPUT(board)
[ADD(MUL(i,w),SUB(w,7)):ADD(MUL(i,w),SUB(w,4))] {BORDER} CPUT(board)
// laterales fondo
[ADD(MUL(ADD(i,19),w),5):ADD(MUL(ADD(i,19),w),8)] {BORDER} CPUT(board)
[ADD(MUL(ADD(i,19),w),SUB(w,7)):ADD(MUL(ADD(i,19),w),SUB(w,4))] {BORDER} CPUT(board)
NEXT
EXIT
}
CASE(3){ // challenge stage!
SPLIT(Maze,board, "" ), VAL(board), MOVE-TO(board)
[1:w] {BORDER}CPUT(board)
SET(i,1)
PERF-UP(i,19,1)
GOSUB(plant)
NEXT
LET(time out := TIME_CHALLENGE)
EXIT
}
CASE(4){
SET(i,3)
PERF-UP(i,5,1)
// laterales medios
[ADD(MUL(ADD(i,9),w),5):ADD(MUL(ADD(i,9),w),8)] {BORDER} CPUT(board)
[ADD(MUL(ADD(i,9),w),SUB(w,7)):ADD(MUL(ADD(i,9),w),SUB(w,4))] {BORDER} CPUT(board)
// medio arriba
[ADD(MUL(i,w),17):ADD(MUL(i,w),20)] {BORDER} CPUT(board)
[ADD(MUL(i,w),31):ADD(MUL(i,w),34)] {BORDER} CPUT(board)
// medio abajo
[ADD(MUL(ADD(i,19),w),17):ADD(MUL(ADD(i,19),w),20)] {BORDER} CPUT(board)
[ADD(MUL(ADD(i,19),w),31):ADD(MUL(ADD(i,19),w),34)] {BORDER} CPUT(board)
NEXT
EXIT
}
CASE(5){
SET(i,3)
PERF-UP(i,5,1)
// laterales extremos:
[ADD(MUL(i,w),5):ADD(MUL(i,w),8)] {BORDER} CPUT(board)
[ADD(MUL(i,w),SUB(w,7)):ADD(MUL(i,w),SUB(w,4))] {BORDER} CPUT(board)
// laterales medios
[ADD(MUL(ADD(i,9),w),5):ADD(MUL(ADD(i,9),w),8)] {BORDER} CPUT(board)
[ADD(MUL(ADD(i,9),w),SUB(w,7)):ADD(MUL(ADD(i,9),w),SUB(w,4))] {BORDER} CPUT(board)
// laterales fondo
[ADD(MUL(ADD(i,19),w),5):ADD(MUL(ADD(i,19),w),8)] {BORDER} CPUT(board)
[ADD(MUL(ADD(i,19),w),SUB(w,7)):ADD(MUL(ADD(i,19),w),SUB(w,4))] {BORDER} CPUT(board)
// medio arriba
[ADD(MUL(i,w),17):ADD(MUL(i,w),20)] {BORDER} CPUT(board)
[ADD(MUL(i,w),31):ADD(MUL(i,w),34)] {BORDER} CPUT(board)
// medio abajo
[ADD(MUL(ADD(i,19),w),17):ADD(MUL(ADD(i,19),w),20)] {BORDER} CPUT(board)
[ADD(MUL(ADD(i,19),w),31):ADD(MUL(ADD(i,19),w),34)] {BORDER} CPUT(board)
NEXT
EXIT
}
CASE(6){
SET(i,1)
PERF-UP(i,29,1)
GOSUB(plant)
NEXT
LET(time out := TIME_CHALLENGE)
}
CASE(7){
SET(i,3)
PERF-UP(i,5,1)
// laterales extremos:
[ADD(MUL(i,w),5):ADD(MUL(i,w),8)] {BORDER} CPUT(board)
[ADD(MUL(i,w),SUB(w,7)):ADD(MUL(i,w),SUB(w,4))] {BORDER} CPUT(board)
// laterales medios
[ADD(MUL(ADD(i,9),w),5):ADD(MUL(ADD(i,9),w),8)] {BORDER} CPUT(board)
[ADD(MUL(ADD(i,9),w),SUB(w,7)):ADD(MUL(ADD(i,9),w),SUB(w,4))] {BORDER} CPUT(board)
// laterales fondo
[ADD(MUL(ADD(i,19),w),5):ADD(MUL(ADD(i,19),w),8)] {BORDER} CPUT(board)
[ADD(MUL(ADD(i,19),w),SUB(w,7)):ADD(MUL(ADD(i,19),w),SUB(w,4))] {BORDER} CPUT(board)
// medio arriba
[ADD(MUL(i,w),17):ADD(MUL(i,w),20)] {BORDER} CPUT(board)
[ADD(MUL(i,w),31):ADD(MUL(i,w),34)] {BORDER} CPUT(board)
// medio medio
[ADD(MUL(ADD(i,9),w),17):ADD(MUL(ADD(i,9),w),20)] {BORDER} CPUT(board)
[ADD(MUL(ADD(i,9),w),31):ADD(MUL(ADD(i,9),w),34)] {BORDER} CPUT(board)
// medio abajo
[ADD(MUL(ADD(i,19),w),17):ADD(MUL(ADD(i,19),w),20)] {BORDER} CPUT(board)
[ADD(MUL(ADD(i,19),w),31):ADD(MUL(ADD(i,19),w),34)] {BORDER} CPUT(board)
NEXT
EXIT
}
SELEND
COND( NOT-EQ?(LEVEL,3) )
LET( nHead := MUL( w, SUB( SUB( h, 1 ), MOD(h,2) )) DIV-INTO(2) )
LET( dir := N )
ELS
LET( nHead := ADD( MUL( w, 13 ), 26 ) )
LET( dir := N )
CEND
[ nHead ] {initial pos} CPUT( board )
IF( swPierde, SRAND( ~SECONDS); FALSE(swPierde); {TIME_LOST} »» (time out),\
SRAND( 26785 ) )
GOSUB( plant )
RET
DEF-FUN( you lost )
SET(i,1), SET(k,0), SET(n,1)
FOR( LE?(i, h), ++i)
SET(j,1)
FOR( LE?(j, w), ++j)
LET( k := [ n ] GET(board) )
COND( IS-NEG?( k ))
LOCATE(i,j)
PRN("\033[38;15;3m\033[48;5;9m~\OFF")
CEND
++n
NEXT
NEXT
SYS("aplay fl/Snake_dolor.wav </dev/null >/dev/null 2>&1 &")
RET
DEF-FUN( show )
SET(i,1)
MSET(j, k)
SET(n,1)
LOCATE(1,1)
FOR( LE?(i, h), ++i)
SET(j,1),LOG-INV(tiles)
FOR( LE?(j, w), ++j)
LET( k := [ n ] GET(board) )
COND( IS-NEG?( k ))
COND( NOT-EQ?(n,nHead) )
IF(GT?(k,-3),IF(tiles,{tile1},{tile2});{"\033[38;5;15m+\OFF"},"\033[38;5;6m\033[48;5;11m \OFF")
ELS
COND( EQ?(dir,N))
IF(tiles,"\033[38;5;9m\033[48;5;15mv\OFF","\033[38;5;9m\033[48;5;15m|\OFF")
ELS-COND( EQ?(dir,S))
IF(tiles,"\033[38;5;9m\033[48;5;15m|\OFF","\033[38;5;9m\033[48;5;15m^\OFF")
ELS-COND( EQ?(dir,E))
IF(tiles,"\033[38;5;9m\033[48;5;15m<\OFF","\033[38;5;9m\033[48;5;15m-\OFF")
ELS
IF(tiles,"\033[38;5;9m\033[48;5;15m-\OFF","\033[38;5;9m\033[48;5;15m>\OFF")
CEND
CEND
ELS-COND( {k} IS-EQ?(BORDER))
{"\033[38;5;82m\033[48;5;57m \OFF"}
ELS-COND( {k}IS-EQ?(FOOD) )
COLOR-FG(color food ),IF(tiles,{tile1},{tile2}) //back food)
{"@\OFF"}
ELS
IF(tiles,{tile1},{tile2})
{" \OFF"}
CEND
PRN
LOG-INV(tiles)
++n
NEXT
PRNL
NEXT
color food+=2,
back food-=2, WHEN( EQ?(color food, PLUS-ONE(BACK_FOOD))){
LET( color food:=COLOR_FOOD)
LET( back food:=BACK_FOOD)
}
RET
// negative values denote the snake (a negated time-to-live in given cell)
// reduce a time-to-live, effectively erasing the tail
DEF-FUN( age )
MSET( r, jAge, jR )
CART( IS-NEG?( board ) ) »» (r), SET-RANGE(r)
GET( board ) PLUS(1) »» (jAge)
// this is necessary, because Hopper arrays begining in 1
CART( IS-ZERO?(jAge) ) »» (jR)
COND( IS-ARRAY?(jR) )
SET-RANGE(jR), SET(jAge, 1), SET-RANGE(r)
CEND
// ******
{jAge} PUT(board), CLR-RANGE
RET
DEF-FUN( step )
LET( len := [nHead] GET(board) )
SELECT(dir)
CASE (N){ nHead -= w, EXIT }
CASE (S){ nHead += w, EXIT }
CASE (W){ --nHead, EXIT }
CASE (E){ ++nHead, EXIT }
SELEND
SELECT( [nHead]CGET(board))
CASE (SPACE){
--len, LET( len := IF( EQ?(len,0), 1, len) )
[nHead] { len }, CPUT(board) // keep in mind len is negative
GOSUB( age )
EXIT
}
CASE (FOOD){
COND( NOT(OR(EQ?(LEVEL,3),EQ?(LEVEL,6))))
--len, LET( len := IF( IS-ZERO?(len), 1, len) )
ELS
++len // quita celda del cuerpo: suma vida!
CEND
[nHead] { len }, CPUT(board)
WHEN(AND(NOT-EQ?(LEVEL,3),NOT-EQ?(LEVEL,6))){ GOSUB( plant ) }
ADD(SCORE,TIME), MOVE-TO(SCORE)
{SCORE, 4, COLUMNA_PRINT} GOSUB( put score )
LET( TIME := 100 )
++counter, COND( EQ?( counter, 25 ) )
LET( TLimit := SUB( TLimit,5 ))
CLAMP(INF_TIME, LIMIT_TIME, TLimit)
LET( counter := 0 )
CEND
WHEN( OR(EQ?(LEVEL,3),EQ?(LEVEL,6))){ ++Consumed stage }
++ConsPrey
COLOR-FG(10)
LOCATE(20,COLUMNA_PRINT) PRN("SPEED: ")
LOC-ROW(21), PRN( ROUND(MUL(INV(TLimit),LIMIT_TIME),2), " M/S " )
LOC-ROW(23) PRN("CONSUMED PREY:")
LOC-ROW(24) PRN(ConsPrey,"\OFF")
LET( color food:=COLOR_FOOD)
LET( back food:=BACK_FOOD)
SYS("aplay fl/Snake_mascada.wav </dev/null >/dev/null 2>&1 &")
TIC( T ),{TIME, 12, COLUMNA_PRINT} GOSUB( put time )
EXIT
}
CASE-NEGATIVE {
GOSUB(KILLSOUND)
SYS("aplay fl/Snake_mascada.wav </dev/null >/dev/null 2>&1")
LET( quit := 1 )
EXIT
}
DEFAULT {
GOSUB(KILLSOUND)
SYS("aplay fl/Snake_golpe.wav </dev/null >/dev/null 2>&1")
LET( quit := 1 )
}
SELEND
RET
DEF-FUN( LEVELCLEAR )
GOSUB(KILLSOUND)
GOSUB( level clear )
SYS("aplay fl/Snake_level_clear.wav </dev/null >/dev/null 2>&1")
SLEEP(1)
WHEN( OR( EQ?(LEVEL,3), EQ?(LEVEL,6))){
WHEN( EQ?(Consumed stage,20)){
GOSUB( show )
SYS( "aplay fl/Snake_bono.wav </dev/null >/dev/null 2>&1 &" )
GOSUB(GANA BONO),SLEEP(3)
ADD(SCORE,1000), MOVE-TO(SCORE)
{SCORE, 4, COLUMNA_PRINT} GOSUB( put score )
}
}
GOSUB( another play )
RET
DEF-FUN( another play )
++sound index, WHEN( EQ?(sound index,6)){ LET(sound index := 2) }
back tiles+=2, WHEN( EQ?(back tiles,15)){ LET(back tiles:=1) }
[back tiles] GET(head back tiles), MOVE-TO(tile1)
[PLUS-ONE(back tiles)] GET(head back tiles), MOVE-TO(tile2)
++LEVEL, WHEN( GT?(LEVEL,7)){ LET(LEVEL:=1) }
++ REAL LEVEL
COLOR-FG(15),LOCATE(26,COLUMNA_PRINT) SET-ITALIC, PRN("LEVEL: ",REAL LEVEL,"\OFF")
LET( len := [nHead] GET(board) )
[1:Size] MEM(1) CPUT(board)
CLR-INTERVAL
MEM(len), GOSUB( start )
GOSUB( show )
COND( OR( EQ?(LEVEL,3), EQ?(LEVEL,6)))
GOSUB(challenge stage)
ELS
GOSUB( ready )
CEND
SLEEP(2)
SYS( CAT(CAT("aplay fl/",[sound index]CGET(sounds)), "</dev/null >/dev/null 2>&1 &"))
LET( TIME := TOTAL_TIME )
{TIME, 12, COLUMNA_PRINT} GOSUB( put time )
RET
// put a piece of food at random empty position
DEF-FUN( plant )
SET(r, 0)
LOOP( search position )
LET( r := MOD( CEIL(RAND(MINUS-ONE(Size))), Size ) )
BACK-IF-NOT-EQ( [r] GET(board), SPACE, search position)
[r] {FOOD} CPUT( board )
RET
DEF-FUN( put titles )
LOCATE(2,COLUMNA_PRINT) PRN("\033[38;5;15mSCORE\OFF")
{SCORE, 4, COLUMNA_PRINT} GOSUB( put score )
LOCATE(10,COLUMNA_PRINT) PRN("\033[38;5;11mTIME\OFF")
{TIME, 12, COLUMNA_PRINT} GOSUB( put time )
COLOR-FG(15)
LOCATE(26,COLUMNA_PRINT) SET-ITALIC, PRN("LEVEL: ",REAL LEVEL,"\OFF")
LOCATE(27,COLUMNA_PRINT) SET-INVERSE, PRN("LIVES: ",lives,"\OFF")
RET
DEF-FUN( put time, B, posx, posy )
MSET( i,j,x )
MSET( sb, lsb,nB, p4 )
SET( k,1 )
LOCATE (posx, posy) FILL-BOX(" ",5,20)
LET( sb := STR(B) )
LET( lsb := LEN(sb) )
SET( rx, posy )
LET( p4 := ADD( posx, 4 ))
COLOR-FG(11)
PERF-UP(k, lsb, 1)
LET( nB := VAL( MID( 1, k, sb )) )
SET(x, 1), SET( i, posx )
FOR( LE?(i, p4), ++i )
SET( j, rx )
FOR( LE?(j, ADD( rx, 2 ) ), ++j )
LOCATE(i, j) PRN( STR-TO-UTF8(CHAR( [ PLUS-ONE(nB), x] CGET(big number) MUL-BY(219) )))
++x
NEXT
NEXT
rx += 4
NEXT
PRN("\OFF")
RET
DEF-FUN( put score, SCORE, posx, posy )
MSET( ln,s, sp )
LET( sp := STR( SCORE ))
LET( ln := LEN(sp))
LOCATE ( posx, posy ) FILL-BOX(" ",4,20)
SET(i, 1)
COLOR-FG(15)
PERF-UP( i, ln, 1)
LET( s := VAL( MID( 1, i, sp )) )
[ PLUS-ONE(s) ]
LOCATE( posx, posy ), PRN ( STR-TO-UTF8( GET(numL1) ))
LOC-ROW( PLUS-ONE(posx) ), PRN ( STR-TO-UTF8( GET(numL2) ))
LOC-ROW( PLUS-TWO(posx) ), PRN ( STR-TO-UTF8( GET(numL3) ))
posy += 2
NEXT
PRN("\OFF")
COND( swExtra1 )
COND( GE?(SCORE,5000) )
++lives
FALSE(swExtra1)
SYS( "aplay fl/Snake_bono.wav </dev/null >/dev/null 2>&1 &" )
LOCATE(27,COLUMNA_PRINT) SET-INVERSE, PRN("LIVES: ",lives,"\OFF")
CEND
ELS-COND(swExtra2)
COND( GE?(SCORE,10000) )
++lives
FALSE(swExtra2)
SYS( "aplay fl/Snake_bono.wav </dev/null >/dev/null 2>&1 &" )
LOCATE(27,COLUMNA_PRINT) SET-INVERSE, PRN("LIVES: ",lives,"\OFF")
CEND
CEND
RET
DEF-FUN( set score )
{"┌┐"," ┐","┌┐","┌┐","┐┐","┌┐","┌┐","┌┐","┌┐","┌┐"} APND-LST(numL1)
{"││"," │","┌┘"," ┤","└┤","└┐","├┐"," │","├┤","└┤"} APND-LST(numL2)
{"└┘"," ┴","└┘","└┘"," ┘","└┘","└┘"," ┴","└┘","└┘"} APND-LST(numL3)
{1,1,1,1,0,1,1,0,1,1,0,1,1,1,1} APND-ROW( big number )
{1,1,0,0,1,0,0,1,0,0,1,0,1,1,1} APND-ROW( big number )
{1,1,1,0,0,1,1,1,1,1,0,0,1,1,1} APND-ROW( big number )
{1,1,1,0,0,1,0,1,1,0,0,1,1,1,1} APND-ROW( big number )
{1,0,1,1,0,1,1,1,1,0,0,1,0,0,1} APND-ROW( big number )
{1,1,1,1,0,0,1,1,1,0,0,1,1,1,1} APND-ROW( big number )
{1,0,0,1,0,0,1,1,1,1,0,1,1,1,1} APND-ROW( big number )
{1,1,1,0,0,1,0,0,1,0,0,1,0,0,1} APND-ROW( big number )
{1,1,1,1,0,1,1,1,1,1,0,1,1,1,1} APND-ROW( big number )
{1,1,1,1,0,1,1,1,1,0,0,1,0,0,1} APND-ROW( big number )
RET
DEF-FUN( ready )
{"\033[38;5;4m\033[48;5;11m"}
LOC-COL(16)
LOC-ROW(13); PRN( STR-TO-UTF8(" ▄ ▄▄ ▄ ▄▄ ▄ ▄ "))
LOC-ROW(14); PRN( STR-TO-UTF8(" █▄▀ █▀ █▄█ █ █ ▀▄▀ "))
LOC-ROW(15); PRN( STR-TO-UTF8(" ▀ ▀ ▀▀ ▀ ▀ ▀▄▀ ▀ "))
PRN("\OFF")
RET
DEF-FUN( level clear )
{"\033[38;5;4m\033[48;5;11m"}
LOC-COL(17)
LOC-ROW(12); PRN( STR-TO-UTF8( " ▄ ▄▄ ▄ ▄ ▄▄ ▄ "))
LOC-ROW(13); PRN( STR-TO-UTF8( " █ █▀ █ █ █▀ █ "))
LOC-ROW(14); PRN( STR-TO-UTF8( " ▀ ▀▀ ▀ ▀▀ ▀ "))
LOC-ROW(15); PRN( STR-TO-UTF8( " ▄ ▄ ▄▄ ▄ ▄ "))
LOC-ROW(16); PRN( STR-TO-UTF8( " █ █ █▀ █▄█ █▄▀ "))
LOC-ROW(17); PRN( STR-TO-UTF8( " ▀ ▀ ▀▀ ▀ ▀ ▀ ▀ "))
PRN("\OFF")
RET
DEF-FUN( challenge stage )
{"\033[38;5;4m\033[48;5;11m"}
LOC-COL(9)
LOC-ROW(12); PRN( STR-TO-UTF8( " ▄ ▄ ▄ ▄ ▄ ▄ ▄▄ ▄ ▄▄ ▄▄ "))
LOC-ROW(13); PRN( STR-TO-UTF8( " █ █▄█ █▄█ █ █ █▀ █ █ █ ▄ █▀ "))
LOC-ROW(14); PRN( STR-TO-UTF8( " ▀ ▀ ▀ ▀ ▀ ▀ ▀ ▀▀ ▀ ▀ ▀▀ ▀▀ "))
LOC-ROW(15); PRN( STR-TO-UTF8( " ▄ ▄ ▄ ▄ ▄▄ ▄▄ "))
LOC-ROW(16); PRN( STR-TO-UTF8( " ▀▄ █ █▄█ █ ▄ █▀ "))
LOC-ROW(17); PRN( STR-TO-UTF8( " ▀ ▀ ▀ ▀ ▀▀ ▀▀ "))
PRN("\OFF")
RET
DEF-FUN( GANA BONO )
{"\033[38;5;11m\033[48;5;196m"}
LOC-COL(17)
LOC-ROW(12); PRN( STR-TO-UTF8(" ▄ ▄ ▄ ▄ ▄ ▄ "))
LOC-ROW(13); PRN( STR-TO-UTF8(" █▄▀ █ █ █ █ █ █ ▀▄ "))
LOC-ROW(14); PRN( STR-TO-UTF8(" ▀▄▀ ▀ ▀ ▀ ▀ ▀ "))
LOC-ROW(15); PRN( STR-TO-UTF8(" ▄ ▄ ▄ ▄ "))
LOC-ROW(16); PRN( STR-TO-UTF8(" █ █ █ █ █ █ █ "))
LOC-ROW(17); PRN( STR-TO-UTF8(" █ ▄ ▀▄▀ ▀▄▀ ▀▄▀ "))
PRN("\OFF")
RET
DEF-FUN( game over )
{"\033[38;5;15m\033[48;5;9m"}
LOC-COL(17)
LOC-ROW(12); PRN( STR-TO-UTF8(" ▄▄ ▄ ▄ ▄ ▄▄ "))
LOC-ROW(13); PRN( STR-TO-UTF8(" █ ▄ █▄█ █ █ █ █▀ "))
LOC-ROW(14); PRN( STR-TO-UTF8(" ▀▀ ▀ ▀ ▀ ▀ ▀ ▀▀ "))
LOC-ROW(15); PRN( STR-TO-UTF8(" ▄ ▄ ▄ ▄▄ ▄ "))
LOC-ROW(16); PRN( STR-TO-UTF8(" █ █ █ █ █▀ █▄▀ "))
LOC-ROW(17); PRN( STR-TO-UTF8(" ▀ ▀ ▀▀ ▀ ▀ "))
PRN("\OFF")
RET
DEF-FUN( titles )
#define COLOR_INI 232
#define COLOR_FIN 255
SET(k,1)
PERF-UP(k,2,1)
SET(j,COLOR_INI), SET(jbg,COLOR_FIN)
PERF-UP(j,COLOR_FIN,1)
COLOR(j, jbg--)
LOC-COL(17)
LOC-ROW(12); PRN(STR-TO-UTF8(" "))
LOC-ROW(13); PRN(STR-TO-UTF8(" ▄ ▄ ▄ ▄ ▄ ▄▄ "))
LOC-ROW(14); PRN(STR-TO-UTF8(" ▀▄ █ █ █▄█ █▄ █▀ "))
LOC-ROW(15); PRN(STR-TO-UTF8(" ▀ ▀ ▀ ▀ ▀ ▀ ▀ ▀▀ "))
LOC-ROW(16); PRN(STR-TO-UTF8(" ▄ ▄ ▄▄ ▄▄ ▄▄ "))
LOC-ROW(17); PRN(STR-TO-UTF8(" ▀▄ █▄█ █▀ █▀ █ █ "))
LOC-ROW(18); PRN(STR-TO-UTF8(" ▀ ▀ ▀▀ ▀▀ ▀▄▀ "))
LOC-ROW(19); PRN(STR-TO-UTF8(" "))
MICROSECS(20000)
NEXT
SET(j,COLOR_FIN), SET(jbg,COLOR_INI)
PERF-DOWN(j,COLOR_INI,1)
COLOR(j, jbg++)
LOC-COL(17)
LOC-ROW(12); PRN(STR-TO-UTF8(" "))
LOC-ROW(13); PRN(STR-TO-UTF8(" ▄ ▄ ▄ ▄ ▄ ▄▄ "))
LOC-ROW(14); PRN(STR-TO-UTF8(" ▀▄ █ █ █▄█ █▄ █▀ "))
LOC-ROW(15); PRN(STR-TO-UTF8(" ▀ ▀ ▀ ▀ ▀ ▀ ▀ ▀▀ "))
LOC-ROW(16); PRN(STR-TO-UTF8(" ▄ ▄ ▄▄ ▄▄ ▄▄ "))
LOC-ROW(17); PRN(STR-TO-UTF8(" ▀▄ █▄█ █▀ █▀ █ █ "))
LOC-ROW(18); PRN(STR-TO-UTF8(" ▀ ▀ ▀▀ ▀▀ ▀▄▀ "))
LOC-ROW(19); PRN(STR-TO-UTF8(" "))
MICROSECS(20000)
NEXT
NEXT
PRN("\OFF")
RET
DEF-FUN( prepare maze )
REPL(12,ADD(MUL(w, 3),20),"333333333333",Maze), MOVE-TO(Maze)
REPL(12,ADD(MUL(w, 24),20),"333333333333",Maze), MOVE-TO(Maze)
REPL(12,ADD(MUL(w, 6),7),"333333333333",Maze), MOVE-TO(Maze)
REPL(12,ADD(MUL(w, 6),33),"333333333333",Maze), MOVE-TO(Maze)
REPL(12,ADD(MUL(w, 21),7),"333333333333",Maze), MOVE-TO(Maze)
REPL(12,ADD(MUL(w, 21),33),"333333333333",Maze), MOVE-TO(Maze)
SET(i,7)
PERF-UP(i,10,1)
REPL(1,ADD(MUL(w, i),7),"3",Maze), MOVE-TO(Maze)
REPL(1,ADD(MUL(w, i),44),"3",Maze), MOVE-TO(Maze)
REPL(1,ADD(MUL(w, ADD(i,10)),44),"3",Maze), MOVE-TO(Maze)
REPL(1,ADD(MUL(w, ADD(i,10)),7),"3",Maze), MOVE-TO(Maze)
NEXT
RET
</syntaxhighlight>
{{out}}
[[File:Captura_de_pantalla_de_2022-10-07_14-13-27.png]]
=={{header|AutoHotkey}}==
<
Gui, +AlwaysOnTop
Gui, font, s12, consolas
Line 135 ⟶ 1,151:
return [oGrid, row, col]
}
;-----------------------------------------</
=={{header|BASIC}}==
==={{header|Applesoft BASIC}}===
Rather than using DIM X%(1599),Y%(1599) which takes a long time to initialize, instead to speed this up, the program will POKE and PEEK the snake coordinates in memory. On initialization, LOMEM: 24576 moves variables out of the way.
Continue playing by typing the CONT command from the Applesoft BASIC prompt if you quit or it's game over.
<syntaxhighlight lang="basic">REM === VARIABLES ===
REM
REM D(4) X DELTAS
REM E(4) Y DELTAS
REM K(255) KEYCODE BEHESTS
REM FN X X COORDINATES OF SNAKE FROM MEMORY
REM FN Y Y COORDINATES OF SNAKE FROM MEMORY
REM A <UNUSED>
REM B BEHEST: 0=NOTHING 1=RIGHT 2=LEFT 3=DOWN 4=UP 5=QUIT
REM C SCRN COLOR
REM D X-DELTA
REM E Y-DELTA
REM F FOOD COLOR= 4 DARK GREEN
REM H HIT= 127
REM I KEYBOARD= 49152
REM J CLEAR KEYBOARD= 49168
REM K KEYCODE
REM L LENGTH WIDTH&HEIGHT= 40
REM M MAX= 1599 UPPER BOUND OF SNAKE X AND Y COORDINATES
REM N NEW POSITION OF HEAD OF SNAKE
REM O OLD POSITION OF TAIL OF SNAKE
REM P ADDRESS OF 1600 X COORDINATES OF SNAKE
REM Q QUIT= 5
REM R REMAINING COLOR= 9 ORANGE
REM S SNAKE HEAD COLOR= 13 YELLOW
REM T ONE= 1
REM U X FOOD COORDINATE
REM V Y FOOD COORDINATE
REM W WALL COLOR= 10 GREY
REM X X SNAKE HEAD COORDINATE
REM Y Y SNAKE HEAD COORDINATE
REM Z ADDRESS OF 1600 Y COORDINATES OF SNAKE
REM Q$ QUIT MESSAGE
REM === KEYBOARD ===
REM
REM UPPER LOWER KEY BEHEST
REM 155 ESC QUIT
REM 139 UP UP
REM 193 225 A UP
REM 201 233 I UP
REM 138 DOWN DOWN
REM 218 250 Z DOWN
REM 203 235 K DOWN
REM 136 LEFT LEFT
REM 202 234 J LEFT
REM 149 RIGHT RIGHT
REM 204 236 L RIGHT
0 ON B = Q GOTO 5: IF B THEN D = D(B):E = E(B)
1 X = X + D:Y = Y + E:C = SCRN( X,Y): COLOR= S: PLOT X,Y: COLOR= R: PLOT FN X(N), FN Y(N):N = N - T + (N = 0) * M: POKE P + N,X: POKE Z + N,Y: ON C(C) GOTO 4: IF NOT C THEN COLOR= 0: PLOT FN X(O), FN Y(O):O = O - T + (O = 0) * M
2 IF C THEN U = INT ( RND (T) * L):V = INT ( RND (T) * L): ON SCRN( U,V) > 0 GOTO 2: COLOR= F: PLOT U,V
3 K = PEEK (I):B = PEEK (J * (K > H)):B = K(K): GOTO
4 COLOR= T: PLOT X,Y: READ Q$: DATA5,20,20,1,-1,1,-1,13,9,4,10,1,40,1599,127,49152,49168,4608,6400,5,4,4,4,4,4,3,3,3,3,3,2,2,2,1,1,1,DONE,GAME OVER
5 IF Q = 5 THEN PRINT Q$;: END : HOME :Q = Q * (B = Q):B = 0: ON Q = 5 GOTO : RUN
6 LOMEM: 24576
7 DIM K(255),D(4),E(4),C(15): READ Q,X,Y,D(1),D(2),E(3),E(4),S,R,F,W,T,L,M,H,I,J,P,Z,K(155),K(139),K(193),K(225),K(201),K(233),K(138),K(218),K(250),K(203),K(235),K(136),K(202),K(234),K(149),K(204),K(236),Q$
8 DEF FN X(I) = PEEK (P + I): DEF FN Y(I) = PEEK (Z + I):B = RND (0):C(S) = T:C(R) = T:C(W) = T:B = INT ( RND (T) * 4) + T:D = D(B):E = E(B): POKE P + O,X: POKE Z + O,Y
9 GR : HOME : COLOR= W: VLIN 0,39 AT 0: VLIN 0,39 AT 39: HLIN 1,38 AT 0: HLIN 1,38 AT 39: COLOR= F: PLOT X + D,Y + E: GOTO</syntaxhighlight>
==={{header|Craft Basic}}===
[[File:Craft Basic Snake.png|right]]
<syntaxhighlight lang="basic">rem Snake example game for Craft Basic
rem by Gemino Smothers 2022
rem www.lucidapogee.com
title "Snake!"
define gfxx = 330, gfxy = 296
define upkey = 0, rightkey = 0, downkey = 0, leftkey = 0, esckey = 0
define speed = 0, delay = 0, score = 0, game = 1
define maxsize = 1000, size = 9, direction = int(rnd * 4) + 1
define rx = int(rnd * (gfxx - 24)) + 12
define ry = int(rnd * (gfxy - 40)) + 25
dim sx[maxsize]
dim sy[maxsize]
let sx[0] = gfxx / 2
let sy[0] = gfxy / 2
fill on
bgcolor 128, 64, 0
cls graphics
resize 0, 0, gfxx + 10, gfxy + 56
center
formid 1
staticform 1, 1, 100, 14
fgcolor 255, 255, 0
bgcolor 0, 80, 0
colorform
alert "Snake! by Gemino Smothers 2022"
alert "Get the gray little rodents and avoid hitting yourself or walls."
alert "Use arrow keys to move. Esc to exit."
input "Enter game speed between 0 to 100+", speed
fgcolor 0, 80, 0
rect 0, 0, gfxx, gfxy
do
button upkey, 38
button rightkey, 39
button downkey, 40
button leftkey, 37
button esckey, 27
if upkey = 1 and direction <> 3 then
let direction = 1
endif
if rightkey = 1 and direction <> 4 then
let direction = 2
endif
if downkey = 1 and direction <> 1 then
let direction = 3
endif
if leftkey = 1 and direction <> 2 then
let direction = 4
endif
fgcolor 0, 80, 0
oval sx[size], sy[size], 15, 15
let i = size + 1
do
let i = i - 1
let c = i - 1
if sx[0] = sx[i] and sy[0] = sy[i] = 1 then
let game = 0
endif
let sx[i] = sx[c]
let sy[i] = sy[c]
fgcolor 0, 255, 0
oval sx[i], sy[i], 15, 15
loop i > 1
fgcolor 0, 0, 255
oval sx[0] + 5, sy[0] + 5, 3, 3
oval sx[0] + 9, sy[0] + 5, 3, 3
if direction = 1 then
let sy[0] = sy[0] - 15
endif
if direction = 2 then
let sx[0] = sx[0] + 15
endif
if direction = 3 then
let sy[0] = sy[0] + 15
endif
if direction = 4 then
let sx[0] = sx[0] - 15
endif
if sx[0] <= -10 or sx[0] >= gfxx or sy[0] <= -10 or sy[0] >= gfxy = 1 then
let game = 0
endif
if sx[0] + 15 >= rx and sx[0] <= rx + 15 and sy[0] + 15 >= ry and sy[0] <= ry + 15 = 1 then
playwave "examples\tada.wav"
fgcolor 0, 80, 0
rect 0, 0, gfxx, gfxy
let rx = int(rnd * (gfxx - 24)) + 12
let ry = int(rnd * (gfxy - 40)) + 25
let size = size + 3
let score = score + 1
endif
fgcolor 100,100,100
oval rx, ry, 15, 15
fgcolor 255, 0, 0
oval rx + 5, ry + 5, 3, 3
oval rx + 9, ry + 5, 3, 3
fgcolor 255, 255, 0
formid 1
formtext "Score: ", score
updateform
let delay = clock
do
wait
loop clock < delay + speed
loop esckey <> 1 and game = 1
playwave "examples\boom.wav"
alert "Game over! Score: ", score</syntaxhighlight>
==={{header|FreeBASIC}}===
<
REM Snake
Line 256 ⟶ 1,508:
End
'--------------------------
</syntaxhighlight>
==={{header|Integer BASIC}}===
{{Trans|Applesoft BASIC}}
<syntaxhighlight lang="basic"> 0 IF B=Q THEN GOTO 9: IF B THEN D=D(B): IF B THEN E=E(B):X=X+D:Y=Y+E:A= SCRN(X,Y): COLOR=S: PLOT X,Y: COLOR=R: PLOT X(N),Y(N)
1 N=N-T+(N=1)*M:X(N)=X:Y(N)=Y: IF C(A) THEN GOTO 9: IF A THEN GOTO 2: COLOR=0: PLOT X(O),Y(O):O=O-T+(O=1)*M: GOTO 3
2 U= RND (L):V= RND (L): IF SCRN(U,V)>0 THEN GOTO 2: COLOR=F: PLOT U,V
3 K= PEEK (I):B= PEEK (J*(K>H)):B=K(K): GOTO 0
4 DIM X(1600),Y(1600),K(255),D(4),E(4),C(15): FOR I=0 TO 255:K(I)=0: NEXT I: FOR I=1 TO 4:D(I)=0:E(I)=0: NEXT I
5 FOR I=0 TO 15:C(I)=0: NEXT I:Q=5:X=20:Y=20:E(1)=-1:D(2)=-1:E(3)=1:D(4)=1:S=13:R=9:F=4:W=10:T=1:L=40:M=1600
6 H=127:I=-16384:J=-16368:K(155)=5:K(193)=1:K(225)=1:K(201)=1:K(233)=1:K(136)=2:K(202)=2:K(234)=2:N=1:O=1
7 K(218)=3:K(250)=3:K(203)=3:K(235)=3:K(149)=4:K(204)=4:K(236)=4:C(S)=T:C(R)=T:C(W)=T:B= RND (4)+T:D=D(B)
8 E=E(B):X(O)=X:Y(O)=Y: GR : CALL -936: COLOR=W: VLIN 0,39 AT 0: VLIN 0,39 AT 39: HLIN 1,38 AT 0: HLIN 1,38 AT 39: COLOR=F: PLOT X+D,Y+E: GOTO 0
9 IF Q#5 THEN GOTO 4:Q=Q*(B=Q): COLOR=T: IF Q=0 THEN PLOT X,Y: IF Q=0 THEN PRINT "GAME OVER";: IF Q THEN PRINT "DONE";:K= PEEK (J):B=0: END </syntaxhighlight>
==={{header|Locomotive Basic}}===
[[File:Snake locomotive basic.png|thumb|''Snake'' running in CPCBasic]]
Use the arrow keys to control movement direction. If you find gameplay too easy, lower the skill parameter in line 20 or increase ml (maximum snake length).
If you would like to play this in [https://benchmarko.github.io/CPCBasic/cpcbasic.html CPCBasic], paste the code into the box at the top in CPCBasic, then click on the "Reset" and "Run" buttons below and finally click on the CPC screen so it gets keyboard focus. (This will turn the frame around the screen dark).
<syntaxhighlight lang="locobasic">10 mode 1:randomize time
15 ink 0,0:ink 1,6:ink 2,18:ink 3,11
20 sx=20:sy=5:dx=1:dy=0:ml=20:dim ox(ml),oy(ml):oi=1:ll=4:skill=8
30 f$=chr$(228):w$=chr$(127):b$=chr$(231)
40 pen 3:print string$(40,w$);
50 for i=2 to 20:print w$;space$(38);w$;:next
60 print string$(40,w$);
70 locate
80 gosub 260
140 locate sx,sy:pen 2:print chr$(224);:ox(oi)=sx:oy(oi)=sy
150 oi=oi+1:if oi>ml then oi=1
160 nx=sx+dx:ny=sy+dy
170 locate nx,ny:a$=copychr$(#0)
180 if a$=w$ or a$=b$ then sound 2,62500/20,100:locate 13,6:print "You have died!":end
190 if a$=f$ then sound 2,62500/500,10: sound
200 locate 1,24:print "SCORE:"p
210 for i=1 to skill:frame
211 if inkey(1)>-1 then dx=1:dy=0
212 if inkey(8)>-1 then dx=-1:dy=0
213 if inkey(0)>-1 then dx=0:dy=-1
214 if inkey(2)>-1 then dx=0:dy=1
215 next
220 locate sx,sy:pen 2:print b$;
230 nn=1+((oi+ml-ll) mod ml)
240 if ox(nn)>0 then locate ox(nn),oy(nn):print " ";
250 sx=nx:sy=ny:goto
260 fx=rnd*39+1:fy=rnd*19+1
270 locate fx,fy:a$=copychr$(#0)
280 if a$<>" " then 260
290 pen 1:print f$;
300 return</
==={{header|ZX Spectrum Basic}}===
Line 300 ⟶ 1,565:
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
Line 388 ⟶ 1,653:
870 DATA BIN 11111100
880 DATA BIN 01111111
890 DATA BIN 00110110</
=={{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
Line 534 ⟶ 1,799:
close_screen();
return 0;
}</
=={{header|C++}}==
Simple Windows console implementation.
[[File:SnakeCpp.png|200px|thumb|right]]
<
#include <windows.h>
#include <ctime>
Line 652 ⟶ 1,917:
snake s; s.play(); return 0;
}
</syntaxhighlight>
=={{header|Delphi}}==
{{libheader| Winapi.Windows}}
Line 663 ⟶ 1,929:
{{libheader| Vcl.ExtCtrls}}
{{Trans|JavaScript}}
<syntaxhighlight lang="delphi">
unit SnakeGame;
Line 1,019 ⟶ 2,285:
FrameTimer.Enabled := True;
end;
end.</
Form resources:
<syntaxhighlight lang="delphi">
object SnakeApp: TSnakeApp
OnCreate = FormCreate
end
</syntaxhighlight>
=={{header|EasyLang}}==
[https://easylang.dev/apps/snake.html Run it]
{{Trans|Craft Basic}}
<syntaxhighlight>
subr fruit
rx = (randint 20 - 1) * 5 + 2.5
ry = (randint 20 - 1) * 5 + 2.5
.
subr start
fruit
game = 1
sx[] = [ 52.5 0 0 0 0 ]
sy[] = [ 52.5 0 0 0 0 ]
dir = randint 4
timer 0
.
background 242
move 30 70
clear
color 997
text "SNAKE"
textsize 5
move 6 40
text "Keys or mouse for controlling"
move 6 30
text "Space or click to to start"
#
on key
if game = 0 and keybkey = " "
start
return
.
if dir mod 2 = 1
if keybkey = "ArrowRight"
dir = 2
elif keybkey = "ArrowLeft"
dir = 4
.
else
if keybkey = "ArrowUp"
dir = 1
elif keybkey = "ArrowDown"
dir = 3
.
.
.
on mouse_down
if game = 0
start
return
.
if dir mod 2 = 1
if mouse_x < sx
dir = 4
else
dir = 2
.
else
if mouse_y < sy
dir = 3
else
dir = 1
.
.
.
on timer
clear
color 997
move 2 95
text "Score: " & 10 * len sx[] - 50
color 966
move rx ry
circle 1.5
#
sx = sx[1] ; sy = sy[1]
if dir = 1
sy += 5
elif dir = 2
sx += 5
elif dir = 3
sy -= 5
elif dir = 4
sx -= 5
.
if sx < 0 or sx > 100 or sy < 0 or sy > 100
game = 0
.
color 494
for i = len sx[] downto 2
if sx = sx[i] and sy = sy[i]
game = 0
.
sx[i] = sx[i - 1]
sy[i] = sy[i - 1]
if sx[i] > 0
move sx[i] sy[i]
circle 2.5
.
.
move sx sy
circle 2.5
color 000
if dir = 2 or dir = 4
move sx sy + 1
circle 0.5
move sx sy - 1
circle 0.5
else
move sx + 1 sy
circle 0.5
move sx - 1 sy
circle 0.5
.
if sx = rx and sy = ry
len sx[] len sx[] + 3
len sy[] len sy[] + 3
fruit
.
sx[1] = sx ; sy[1] = sy
if game = 1
timer 0.15
else
color 997
move 10 10
text "Space or click new game"
.
.
</syntaxhighlight>
=={{header|Emacs Lisp}}==
[[File:Snake emacs lisp.png|thumb|''Snake'' in Emacs]]
GNU Emacs has a built-in Snake game in Lisp that is started with
<syntaxhighlight>M-x snake</syntaxhighlight>
and which uses the same tile set as the included [[Tetris]] game.
=={{header|F Sharp}}==
<syntaxhighlight lang="fsharp">
open System
open System.Threading.Tasks
open System.Threading
module SnakeGame =
/// 🚏 Directions on our grid:
type Movement =
| Left of Position
| Right of Position
| Down of Position
| Up of Position
| InvalidMove
/// 🐍 Sort of like a list, but not:
and Snake<'Position> =
| Head of Position * Snake<'Position>
| Belly of Position * Snake<'Position>
| Tail
/// 🕹️ Our basic runtime information:
and Game =
| GameRunning of Movement * Snake<Position> * Grid * Eaten:int * Food
| GameOver of Grid * Eaten:int
/// 🧭 x & y in our plane:
and Position = int * int
/// 🍎 The food our snake will eat:
and Food = Position * string
/// 🌐 A simple two dimensional plane:
and Grid = string[][]
/// Making a list of positions from a Snake 🐍
let snakeUnzip (snake:Snake<Position>) =
let rec unzip snake carry =
match snake with
| Head (p, rest) -> unzip rest <| carry @ [p]
| Belly (p, rest) -> unzip rest <| carry @ [p]
| Tail -> carry
unzip snake []
/// Making a Snake from a list of positions 🐍
let snakeZip (positions:list<Position>) (upto:int) =
let correctLength = (List.take upto positions)
let rec zip (carry:Snake<Position>) (rest:list<Position>) =
match rest with
| head::[] -> zip (Head(head, carry)) []
| back::front -> zip (Belly (back, carry)) front
| [] -> carry
zip Tail (List.rev correctLength)
module Graphics =
let private random = new Random()
let private head = "🤢"
let private belly = "🟢"
let private display = "⬜"
let private errorDisplay = "🟥"
let private food = [|"🐁";"🐀";"🐥";"🪺";"🐸";"🐛";"🪰";"🐞";"🦗"|]
let private randomFood () = food.[random.Next(food.Length - 1)]
let isFood square = Array.contains square food
let isFreeSpace square = square = display || square = errorDisplay
let isOccupied square =
match square with
| square when isFreeSpace square -> false
| square when isFood square -> false
| _ -> true
let makeGrid (dimensionsSquared) : Grid =
let row _ = Array.init dimensionsSquared (fun _ -> display)
Array.init dimensionsSquared row
let clearGrid (grid:Grid) : unit =
Array.iteri (fun i row ->
Array.iteri (fun j _ ->
grid.[i].[j] <- display
) row
) grid
let render (grid:Grid) : unit =
Console.Clear()
Array.iter (fun (row:string array) ->
let prettyprint = String.concat "" row
printfn $"{prettyprint}") grid
printfn "Snake Game in FSharp by @wiredsister"
printfn "Controls: ⬅️ ↕️ ➡️"
printfn "Press Ctrl+C to Quit Game"
Console.Title <- "FSharp Snake 🐍"
let getFreeSpaces (grid:Grid) : list<Position> =
let results : Position list ref = ref []
for i in 0..(grid.Length-1) do
for j in 0..(grid.Length-1) do
if isFreeSpace grid.[i].[j]
then results.Value <- results.Value @ [i,j]
else ()
()
results.Value
let getFood (grid:Grid) : Food =
Console.Beep()
let freeSpaces =
getFreeSpaces grid
|> Array.ofList
let food = randomFood ()
let randomPos = freeSpaces.[random.Next(freeSpaces.Length - 1)]
randomPos, food
let dropFood (grid:Grid) (food:Food) =
let (x, y), animal = food
grid.[x].[y] <- animal
let slither (snake:Snake<Position>) (grid:Grid) : unit =
try
let rec slithering (body:Snake<Position>) =
match body with
| Head(p, s) ->
let row, column = p
grid.[row].[column] <- head
slithering s
| Belly(p, s) ->
let row, column = p
grid.[row].[column] <- belly
slithering s
| Tail -> ()
do slithering snake
with _ -> failwith "ERROR: Could not slither snake!"
let endGame (grid:Grid) : unit =
Console.Clear()
Array.iteri (fun i row ->
Array.iteri (fun j _ ->
grid.[i].[j] <- errorDisplay
) row
) grid
Array.iter (fun (row:string array) ->
let prettyprint = String.concat "" row
printfn $"{prettyprint}") grid
Console.Beep()
module GamePlay =
let moveUp (snake:Snake<Position>) (grid:Grid) (eaten:int) (food:Food) : Game =
match snake with
| Head (p, rest:Snake<Position>) ->
let x, y = p
let shiftUp = ((x-1), y)
try
match shiftUp with
| (row,column) when Graphics.isOccupied grid.[row].[column] ->
GameOver (grid, eaten)
| (row, column) when Graphics.isFood grid.[row].[column] ->
let unzipped = snakeUnzip (Head (shiftUp, (Belly (p, rest))))
let newSnake = snakeZip unzipped (eaten+1)
let nextFood = Graphics.getFood grid
GameRunning (Up shiftUp, newSnake, grid, eaten+1, nextFood)
| pivot ->
let unzipped = snakeUnzip (Head (pivot, (Belly (p, rest))))
let newSnake = snakeZip unzipped eaten
GameRunning (Up pivot, newSnake, grid, eaten, food)
with _ -> GameOver (grid, eaten)
| _ -> failwith "ERROR: No head!"
let moveDown (snake:Snake<Position>) (grid:Grid) (eaten:int) (food:Food) : Game =
match snake with
| Head (p, rest:Snake<Position>) ->
let x, y = p
let shiftDown = ((x+1), y)
try
match shiftDown with
| (row,column) when Graphics.isOccupied grid.[row].[column] ->
GameOver (grid, eaten)
| (row, column) when Graphics.isFood grid.[row].[column] ->
let unzipped = snakeUnzip (Head (shiftDown, (Belly (p, rest))))
let newSnake = snakeZip unzipped (eaten+1)
let nextFood = Graphics.getFood grid
GameRunning (Down shiftDown, newSnake, grid, (eaten+1), nextFood)
| pivot ->
let unzipped = snakeUnzip (Head (pivot, (Belly (p, rest))))
let newSnake = snakeZip unzipped eaten
GameRunning (Down pivot, newSnake, grid, eaten, food)
with _ -> GameOver (grid, eaten)
| _ -> failwith "ERROR: No head!"
let moveLeft (snake:Snake<Position>) (grid:Grid) (eaten:int) (food:Food) : Game =
match snake with
| Head (p, rest:Snake<Position>) ->
let x, y = p
let shiftLeft = (x, (y-1))
try
match shiftLeft with
| (row,column) when Graphics.isOccupied grid.[row].[column] ->
GameOver (grid, eaten)
| (row, column) when Graphics.isFood grid.[row].[column] ->
let unzipped = snakeUnzip (Head (shiftLeft, (Belly (p, rest))))
let newSnake = snakeZip unzipped (eaten+1)
let nextFood = Graphics.getFood grid
GameRunning (Left shiftLeft, newSnake, grid, eaten+1, nextFood)
| pivot ->
let unzipped = snakeUnzip (Head (pivot, (Belly (p, rest))))
let newSnake = snakeZip unzipped eaten
GameRunning (Left pivot, newSnake, grid, eaten, food)
with _ -> GameOver (grid, eaten)
| _ -> failwith "ERROR: No head!"
let moveRight (snake:Snake<Position>) (grid:Grid) (eaten:int) (food:Food) : Game =
match snake with
| Head (p, rest:Snake<Position>) ->
let (x: int), y = p
let shiftRight = (x, (y+1))
try
match shiftRight with
| (row,column) when Graphics.isOccupied grid.[row].[column] ->
GameOver (grid, eaten)
| (row, column) when Graphics.isFood grid.[row].[column] ->
let unzipped = snakeUnzip (Head (shiftRight, (Belly (p, rest))))
let newSnake = snakeZip unzipped (eaten+1)
let nextFood = Graphics.getFood grid
GameRunning (Right shiftRight, newSnake, grid, eaten+1, nextFood)
| pivot ->
let unzipped = snakeUnzip (Head (pivot, (Belly (p, rest))))
let newSnake = snakeZip unzipped eaten
GameRunning (Right pivot, newSnake, grid, eaten, food)
with _ -> GameOver (grid, eaten)
| _ -> failwith "ERROR: No head!"
open SnakeGame
[<EntryPoint>]
let main _ =
/// A gentle slope function for making the snake go faster:
let tick (eaten:int) = 100./log10(float eaten) |> int
let getNextMove prev snake grid eaten food : Task<Game> =
task {
do! Task.Delay(tick(eaten))
if not Console.KeyAvailable
then
match prev with
| Up _ -> return GamePlay.moveUp snake grid eaten food
| Down _ -> return GamePlay.moveDown snake grid eaten food
| Right _ -> return GamePlay.moveRight snake grid eaten food
| Left _ -> return GamePlay.moveLeft snake grid eaten food
| InvalidMove -> return GameOver (grid, eaten)
else
match Console.ReadKey() with
| keystroke when keystroke.Key.Equals(ConsoleKey.UpArrow) ->
return GamePlay.moveUp snake grid eaten food
| keystroke when keystroke.Key.Equals(ConsoleKey.DownArrow) ->
return GamePlay.moveDown snake grid eaten food
| keystroke when keystroke.Key.Equals(ConsoleKey.RightArrow) ->
return GamePlay.moveRight snake grid eaten food
| keystroke when keystroke.Key.Equals(ConsoleKey.LeftArrow) ->
return GamePlay.moveLeft snake grid eaten food
| _ ->
match prev with
| Up _ -> return GamePlay.moveUp snake grid eaten food
| Down _ -> return GamePlay.moveDown snake grid eaten food
| Right _ -> return GamePlay.moveRight snake grid eaten food
| Left _ -> return GamePlay.moveLeft snake grid eaten food
| InvalidMove -> return GameOver (grid, eaten)
}
let gridDimension = 20
let segments = [(0,3); (0,2); (0,1); (0,0)]
let youngSnake : Snake<Position> = snakeZip segments segments.Length
let startingGrid = Graphics.makeGrid gridDimension
let startingFood = Graphics.getFood startingGrid
let start = GamePlay.moveRight youngSnake startingGrid segments.Length startingFood
let rec gameLoop (game:Game) =
match game with
| GameRunning (prev, snake, grid, eaten, food) ->
do Graphics.clearGrid grid
do Graphics.dropFood grid food
do Graphics.slither snake grid
do Graphics.render grid
let eitherPlayerOrCursor = getNextMove prev snake grid eaten food
do eitherPlayerOrCursor.Wait()
gameLoop eitherPlayerOrCursor.Result
| GameOver (grid,eaten) ->
do Graphics.endGame grid
printfn $"Game Over! Snake ate {eaten-segments.Length} critters!"
do Thread.Sleep(1000)
let rec wantToPlayAgain () =
match Console.ReadKey() with
| keystroke when keystroke.Key.Equals(ConsoleKey.Y) -> gameLoop start
| keystroke when keystroke.Key.Equals(ConsoleKey.N) -> ()
| _ -> wantToPlayAgain ()
printfn $"Restart? Type Y to continue..."
wantToPlayAgain()
do gameLoop start
0
</syntaxhighlight>
=={{header|Go}}==
Line 1,033 ⟶ 2,739:
FreeBSD, OpenBSD, NetBSD, DragonFly BSD, Linux, MS Windows, and MacOS
(tested on FreeBSD and MS Windows).
<
import (
Line 1,267 ⟶ 2,973:
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
Line 1,369 ⟶ 3,075:
main = do world <- createWorld
play inW white 7 world renderWorld handleEvents updateWorld
where inW = InWindow "The Snake" (400, 400) (10, 10)</
'''Extra credit'''
Line 1,375 ⟶ 3,081:
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
Line 1,391 ⟶ 3,097:
distanceToFood d = let (a,b) = w^.snake & turns d & moves & (^.body) & head
(x,y) = w^.food & head
in (a-x)^2 + (b-y)^2</
=={{header|J}}==
Needs j9 qt:
Use WASD to move. Use <code>start''</code> to start.
Difficulty may be adjusted by providing a non-default argument to start (time in milliseconds between animation updates). For example, <code>start 200</code> for an easier game.
In this implementation, speed is fixed (and final score is by the update rate). Another approach might be to start slow and gradually speed based on the length of the snake. Those sorts of changes are left as an exercise for the reader.
<syntaxhighlight lang="j">require'ide/qt/gl2'
coinsert 'jgl2'
open=: wd@{{)n
pc s closeok;
cc n isidraw;
set n wh 400 400;
pshow;
}}
start=: {{
speed=: {.y,200
open''
snake=: 10 10,10 11,:10 12
newdot''
draw''
}}
newdot=: {{
dot=: ({~ ?@#) snake -.~ ,/(#: i.)40 40
}}
s_n_char=: {{
select. {.toupper sysdata
case. 'W' do. move 0 _1
case. 'A' do. move _1 0
case. 'S' do. move 0 1
case. 'D' do. move 1 0
end.
}}
move=: {{
s_timer=: move@y
wd 'ptimer ',":speed
head=. y+{.snake
if. head e. snake do. head gameover'' return. end.
if. _1 e. head do. (0>.head) gameover'' return. end.
if. 1 e. 40 <: head do. (39<.head) gameover'' return. end.
if. dot -: head do.
snake=: dot,snake
newdot''
else.
snake=: head,}: snake
end.
draw''
}}
draw=: {{
glclear''
glbrush glrgb 0 0 255
glrect 10*}.snake,"1(1 1)
glbrush glrgb 0 255 0
glrect 10*({.snake),1 1
glbrush glrgb 255 0 0
glrect 10*dot,1 1
glpaint''
EMPTY
}}
gameover=: {{
wd 'ptimer 0'
if. 1<#snake do.
echo 'game over'
echo 'score: ',":(#snake)*1000%speed
draw''
glbrush glrgb 255 255 0
glrect 10*x,1 1
end.
snake=: ,:_ _
}}</syntaxhighlight>
=={{header|Java}}==
Line 1,399 ⟶ 3,186:
=={{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;
Line 1,507 ⟶ 3,294:
if( !snake.alive ) text( "THE END", 630, 250 );
}
</syntaxhighlight>
=={{header|Julia}}==
<syntaxhighlight lang="julia">using GLMakie, GeometryBasics
mutable struct SnakeGame
height::Int
width::Int
snake::Vector{CartesianIndex{2}}
food::CartesianIndex{2}
end
Line 1,556 ⟶ 3,342:
function play(;n=10,t=0.5)
game =
scene = Scene(resolution = (1000, 1000), raw = true, camera = campixel!)
display(scene)
Line 1,577 ⟶ 3,363:
score_text = @lift("Score: $(length($game.snake)-1)")
text!(scene, score_text, color=:gray, position = @lift((widths($area)[1]/2, widths($area)[2])),
direction = Ref{Any}(nothing)
on(events(scene).
if
direction[] = CartesianIndex(-1,0)
direction[] = CartesianIndex(0,1)
direction[] = CartesianIndex(0,-1)
direction[] = CartesianIndex(1,0)
end
end
end
Line 1,611 ⟶ 3,399:
play()
</syntaxhighlight>
=={{header|Kotlin}}==
{{trans|C++}}
{{works with|Windows 10}}
<
import kotlinx.cinterop.*
Line 1,797 ⟶ 3,585:
srand(time(null).toInt())
Snake().play()
}</
{{output}}
Line 1,803 ⟶ 3,591:
Similar to C++ entry
</pre>
=={{header|Lua}}==
[[File:snake-lua.png]]
{{works with|LÖVE}}
<syntaxhighlight lang="lua">UP, RIGHT, DOWN, LEFT = 1, 2, 3, 4
UpdateTime=0.200
Timer = 0
GridSize = 30
GridWidth, GridHeight = 20, 10
local directions = {
[UP] = {x= 0, y=-1},
[RIGHT] = {x= 1, y= 0},
[DOWN] = {x= 0, y= 1},
[LEFT] = {x=-1, y= 0},
}
local function isPositionInBody(x, y)
for i = 1, #Body-3, 2 do -- skip tail, it moves before we get in
if x == Body[i] and y == Body[i+1] then
return true
end
end
return false
end
local function isPositionInApple(x, y)
if x == Apple.x and y == Apple.y then
return true
end
return false
end
local function newApple ()
local ApplePlaced = false
while not ApplePlaced do
local x = GridSize*math.random (GridWidth)
local y = GridSize*math.random (GridHeight)
if not isPositionInBody(x, y) then
Apple = {x=x, y=y}
ApplePlaced = true
end
end
end
local function newGame ()
Score = 0
GameOver = false
local x = GridSize*math.floor(math.random (0.25*GridWidth, 0.75*GridWidth))
print (x)
local y = GridSize*math.floor(math.random (0.25*GridHeight, 0.75*GridHeight))
print (y)
local iDirection = math.random(4)
local d = directions[iDirection]
Head = {
x=x,
y=y,
iDirection = iDirection,
nextDirection = iDirection,
}
Body = {x, y, x-GridSize*d.x, y-GridSize*d.y}
Apples = {}
newApple ()
end
function love.load()
newGame ()
end
local function moveSnake (x, y, iDirection, longer)
table.insert (Body, 1, x)
table.insert (Body, 2, y)
Head.x = x
Head.y = y
Head.iDirection = iDirection
if not longer then
-- remove last pair
table.remove(Body)
table.remove(Body)
end
if x <= 0 or x > GridSize*(GridWidth) or
y <= 0 or y > GridSize*(GridHeight) then
GameOver = true
end
end
function love.update(dt)
Timer = Timer + dt
if Timer < UpdateTime then return end
Timer = Timer - UpdateTime
local iDirection = Head.nextDirection
local d = directions[iDirection]
local x, y = Head.x+GridSize*d.x, Head.y+GridSize*d.y
if isPositionInBody(x, y) then
GameOver = true
elseif isPositionInApple(x, y) then
Score = Score + 1
newApple ()
moveSnake (x, y, iDirection, true)
else
moveSnake (x, y, iDirection, false)
end
end
function drawHead () -- position, length, width and angle
love.graphics.push()
love.graphics.translate(Head.x, Head.y)
love.graphics.rotate((Head.iDirection-2)*math.pi/2)
love.graphics.polygon("fill",
-GridSize/3, -GridSize /3,
-GridSize/3, GridSize /3,
GridSize/3, 0)
love.graphics.pop()
end
function love.draw()
love.graphics.setColor(0,1,0)
love.graphics.print ('Score: '..tostring(Score), 10, 10)
if GameOver then
love.graphics.print ('Game Over: '..tostring(GameOver)..'. Press "Space" to continue', 10, 30)
else
love.graphics.translate(GridSize, GridSize)
love.graphics.setColor(0.6,0.6,0.6)
love.graphics.setLineWidth(0.25)
for x = GridSize, GridSize*GridWidth, GridSize do
love.graphics.line (x, GridSize, x, GridSize*GridHeight)
end
for y = GridSize, GridSize*GridHeight, GridSize do
love.graphics.line (GridSize, y, GridSize*GridWidth, y)
end
love.graphics.setLineWidth((GridSize/4)+0.5)
love.graphics.setColor(1,1,1)
love.graphics.line (Body)
drawHead ()
love.graphics.setColor(1,0,0)
love.graphics.circle ('fill', Apple.x, Apple.y, GridSize/4)
end
end
function love.keypressed(key, scancode, isrepeat)
if false then
elseif key == "space" then
if GameOver then
GameOver = false
newGame ()
end
elseif key == "escape" then
love.event.quit()
else
local iDirection = Head.iDirection
if iDirection == UP or
iDirection == DOWN then
local right = love.keyboard.isScancodeDown ("d")
local left = love.keyboard.isScancodeDown ("a")
if right and not left then
iDirection = RIGHT
elseif left and not right then
iDirection = LEFT
end
else -- right or left
local down = love.keyboard.isScancodeDown ("s")
local up = love.keyboard.isScancodeDown ("w")
if up and not down then
iDirection = UP
elseif down and not up then
iDirection = DOWN
end
end
Head.nextDirection = iDirection
end
end</syntaxhighlight>
=={{header|Nim}}==
Line 1,808 ⟶ 3,768:
{{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
Line 1,917 ⟶ 3,877:
sleep(1000)
closeScreen()</
=={{header|OCaml}}==
Line 1,923 ⟶ 3,883:
{{libheader|OCamlSDL2}}
<
open Sdl
Line 2,076 ⟶ 4,036:
main_loop state
in
main_loop initial_state</
=={{header|Perl}}==
[[File:Snake_game_perl.png|200px|thumb|right]]
<
use Time::HiRes qw(sleep);
use Term::ANSIColor qw(colored);
Line 2,250 ⟶ 4,210:
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
Line 2,334 ⟶ 4,294:
end while
end procedure
play()</
=={{header|Python}}==
Using Pygame. Works with Python >= 3.7.
<
import itertools
Line 2,599 ⟶ 4,559:
score = game.main()
print(score)
</syntaxhighlight>
=={{header|Raku}}==
Line 2,606 ⟶ 4,566:
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].
<syntaxhighlight lang="raku"
use Cairo;
Line 2,780 ⟶ 4,740:
}
SDL_Quit();</
=={{header|Rust}}==
Implemented smooth (per-pixel) animation on Win32 API (tested on Windows 7 and Windows 11)
<syntaxhighlight lang="rust">/* add to file Cargo.toml:
[dependencies]
winsafe = "0.0.8" # IMHO: before the appearance of winsafe="0.1" it is not worth raising the version here
rand = "0.8
derive-new = "0.5"
*/
#![windows_subsystem = "windows"]
use
use rand::{thread_rng, Rng};
use std::{cell::RefCell, rc::Rc};
use winsafe::{co, gui, prelude::*, COLORREF, HBRUSH, HPEN, RECT, SIZE};
const STEP: i32 = 3; // px, motion per frame
const
const SNAKE_W: i32 = 20; // px
const FW: i32 = 20; // the width of the square field in the cells of the game grid
const TW: i32 = (FW + 2) * GCW; // total field width (with overlap for collisions) in STEPs
const
#[rustfmt::skip]
#[derive(new)]
struct Context {
wnd: gui::WindowMain,
#[new(default) ] snake: Vec<i32>, // [
#[new(value = "TW") ] next_incr: i32, // `incr` in the next grid cell
#[new(default) ] gap: i32, // interval in STEPs to the next grid cell; negative - tail clipping mark
}
pub fn main() {
let [bg, tail, turn, body, food, head] = [
let grid: Vec<_> = (1..=FW).flat_map(|y| (1..=FW).map(move |x| (y * TW + x) * GCW)).collect();
let mut colors = [(0x00, 0xF0, 0xA0); 6]; // color tail, turn, body
colors[bg] = (0x00, 0x50, 0x90);
Line 2,855 ⟶ 4,787:
let wnd = gui::WindowMain::new(gui::WindowMainOpts {
title: "Snake - Start: Space, then press W-A-S-D".to_string(),
size:
class_bg_brush: brushes[bg],
..Default::default()
});
// WindowMain is based on Arc, so wnd.clone() is a shallow copy of a reference.
let context = Rc::new(RefCell::new(Context::new(wnd.clone())));
wnd.on().wm_paint({
let context = Rc::clone(&context);
move |
let
let hdc =
hdc.SelectObjectPen(HPEN::CreatePen(co::PS::NULL, 0, COLORREF::new(0, 0, 0))?)?;
for (&id, &brush) in
let [left, top] =
let rect = RECT
hdc.RoundRect(rect, SIZE::new(SNAKE_W / 2, SNAKE_W / 2))?;
}
Ok(ctx.wnd.hwnd().EndPaint(&ps))
}
});
wnd.on().
let context = Rc::clone(&context);
let mut ctx = context.borrow_mut();
(TW, bt @ (b'A' | b'D')) => ctx.
}
});
wnd.on().
let mut ctx = context.
let
if ctx.gap < 0 {
}
ctx.
if ctx.gap == 0 {
ctx.gap = if new_h == ctx.r[food] { GCW } else { -GCW };
let mut snake_cells: Vec<_> = ctx.snake.iter().step_by(GCW as usize).collect();
if new_h == ctx.r[food] {
ctx.wnd.hwnd().SetWindowText(&format!("Snake - Eaten: {}", snake_cells.len()))?;
snake_cells.sort();
ctx.r[food] = *(grid.iter())
.filter(|i| **i != new_h && snake_cells.binary_search(i).is_err())
.nth(thread_rng().gen_range(0..(grid.len() - 1 - snake_cells.len()).max(1)))
.unwrap_or(&0);
} else if grid.binary_search(&new_h).is_err() || snake_cells.contains(&&new_h) {
ctx.wnd.hwnd().KillTimer(1)?; // Stop
let title = ctx.wnd.hwnd().GetWindowText()?;
ctx.wnd.hwnd().SetWindowText(&(title + ". Restart: Space"))?;
*ctx = Context::new(ctx.wnd.clone());
return Ok(());
}
ctx.incr = ctx.next_incr;
}
ctx.snake.push(new_h);
ctx.wnd.hwnd().InvalidateRect(None, new_h == ID0)?; // call .wm_paint(), with erase on Restart
Ok(())
});
}</syntaxhighlight>
{{out}}
[[File:Snake rust.png]]
=={{header|Sidef}}==
<
const readkey = frequire('Term::ReadKey')
const ansi = frequire('Term::ANSIColor')
Line 3,098 ⟶ 5,000:
var h = `tput lines`.to_i
SnakeGame(w || 80, h || 24).play</
=={{header|UNIX Shell}}==
{{works with|Bourne Again SHell}}
{{works with|Z Shell}}
Play ASCII snake in your ANSI terminal.
It theoretically should also work with the Korn Shell, but for some reason the timeout on the key read is not consistent and the snake stops moving except one step after each keypress.
<syntaxhighlight lang="bash">function main {
typeset -i game_over=0
typeset -i height=$(tput lines) width=$(tput cols)
# start out in the middle moving to the right
typeset -i dx dy hx=$(( width/2 )) hy=$(( height/2 ))
typeset -a sx=($hx) sy=($hy)
typeset -a timeout
clear
tput cup "$sy" "$sx" && printf '@'
tput cup $(( height/2+2 )) 0
center $width "Press h, j, k, l to move left, down, up, right"
# place first food
typeset -i fx=hx fy=hy
while (( fx == hx && fy == hy )); do
fx=$(( RANDOM % (width-2)+1 )) fy=$(( RANDOM % (height-2)+1 ))
done
tput cup "$fy" "$fx" && printf '*'
# handle variations between shells
keypress=(-N 1) origin=0
if [[ -n $ZSH_VERSION ]]; then
keypress=(-k)
origin=1
fi
stty -echo
tput civis
typeset key
read "${keypress[@]}" -s key
typeset -i start_time=$(date +%s)
tput cup "$(( height/2+2 ))" 0 && tput el
while (( ! game_over )); do
timeout=(-t $(printf '0.%04d' $(( 2000 / (${#sx[@]}+1) )) ) )
if [[ -z $key ]]; then
read "${timeout[@]}" "${keypress[@]}" -s key
fi
case "$key" in
h) if (( dx != 1 )); then dx=-1; dy=0; fi;;
j) if (( dy != -1 )); then dy=1; dx=0; fi;;
k) if (( dy != 1 )); then dy=-1; dx=0; fi;;
l) if (( dx != -1 )); then dx=1; dy=0; fi;;
q) game_over=1; tput cup 0 0 && print "Final food was at ($fx,$fy)";;
esac
key=
(( hx += dx, hy += dy ))
# if we try to go off screen, game over
if (( hx < 0 || hx >= width || hy < 0 || hy >= height )); then
game_over=1
else
# if we run into ourself, game over
for (( i=0; i<${#sx[@]}; ++i )); do
if (( hx==sx[i+origin] && hy==sy[i+origin] )); then
game_over=1
break
fi
done
fi
if (( game_over )); then
break
fi
# add new spot
sx+=($hx) sy+=($hy)
if (( hx == fx && hy == fy )); then
# if we just ate some food, place some new food out
ok=0
while (( ! ok )); do
# make sure we don't put it under ourselves
ok=1
fx=$(( RANDOM % (width-2)+1 )) fy=$(( RANDOM % (height-2)+1 ))
for (( i=0; i<${#sx[@]}; ++i )); do
if (( fx == sx[i+origin] && fy == sy[i+origin] )); then
ok=0
break
fi
done
done
tput cup "$fy" "$fx" && printf '*'
# and don't remove our tail because we've just grown by 1
else
# if we didn't just eat food, remove our tail from its previous spot
tput cup ${sy[origin]} ${sx[origin]} && printf ' '
sx=( ${sx[@]:1} )
sy=( ${sy[@]:1} )
fi
# draw our new head
tput cup "$hy" "$hx" && printf '@'
done
typeset -i end_time=$(date +%s)
tput cup $(( height / 2 -1 )) 0 && center $width 'GAME OVER'
tput cup $(( height / 2 )) 0 &&
center $width 'Time: %d seconds' $(( end_time - start_time ))
tput cup $(( height / 2 + 1 )) 0 &&
center $width 'Final length: %d' ${#sx[@]}
echo
stty echo
tput cnorm
}
function center {
typeset -i width=$1 i
shift
typeset message=$(printf "$@")
tput cuf $(( (width-${#message}) / 2 ))
printf '%s' "$message"
}
main "$@"</syntaxhighlight>
=={{header|Wren}}==
Line 3,105 ⟶ 5,127:
{{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
Line 3,240 ⟶ 5,262:
}
C.usleep(999 * 1000)
Ncurses.endwin()</
<br>
Now embed this script in the following C program, compile and run it.
<
#include <stdio.h>
Line 3,389 ⟶ 5,411:
WrenVM* vm = wrenNewVM(&config);
const char* module = "main";
const char* fileName = "
char *script = readFile(fileName);
WrenInterpretResult result = wrenInterpret(vm, module, script);
Line 3,405 ⟶ 5,427:
free(script);
return 0;
}</
=={{header|XPL0}}==
Line 3,419 ⟶ 5,441:
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
Line 3,527 ⟶ 5,549:
Sound(0, 36, 1); \pause 2 seconds to see result
OpenI(1); \flush any pending keystrokes
]</
|