That 9b modlel for coding is INSANE good. How is that even possible?
#4
by
mirek190
- opened
Not only impressive but also really follow instructions ! Easily beats GPT 3.5 and in coding is actually GPT-4 level ... insane
Look on the code and questions , no mistakes and perfectly following instructions! :
llama-cli.exe --model models/new3/codegeex4-all-9b-Q8_0.gguf --color --threads 30 --keep -1 --n-predict -1 --repeat-penalty 1.1 --ctx-size 0 --interactive -ngl 99 --simple-io --in-prefix " <|user|>\n" --in-suffix " <|assistant|>\n" -p "[gMASK] <sop> <|system|>\nYou are a helpful, smart, kind, and efficient AI assistant. You always fulfil the user's requests to the best of your ability." -e --multiline-input --no-display-prompt --conversation --no-mmap
Log start
main: build = 3356 (e500d613)
main: built with MSVC 19.29.30154.0 for x64
main: seed = 1720551041
llama_model_loader: loaded meta data with 27 key-value pairs and 283 tensors from models/new3/codegeex4-all-9b-Q8_0.gguf (version GGUF V3 (latest))
llama_model_loader: Dumping metadata keys/values. Note: KV overrides do not apply in this output.
llama_model_loader: - kv 0: general.architecture str = chatglm
llama_model_loader: - kv 1: general.name str = codegeex4-all-9b
llama_model_loader: - kv 2: chatglm.context_length u32 = 131072
llama_model_loader: - kv 3: chatglm.embedding_length u32 = 4096
llama_model_loader: - kv 4: chatglm.feed_forward_length u32 = 13696
llama_model_loader: - kv 5: chatglm.block_count u32 = 40
llama_model_loader: - kv 6: chatglm.attention.head_count u32 = 32
llama_model_loader: - kv 7: chatglm.attention.head_count_kv u32 = 2
llama_model_loader: - kv 8: chatglm.attention.layer_norm_rms_epsilon f32 = 0.000010
llama_model_loader: - kv 9: general.file_type u32 = 7
llama_model_loader: - kv 10: chatglm.rope.dimension_count u32 = 64
llama_model_loader: - kv 11: tokenizer.ggml.add_bos_token bool = false
llama_model_loader: - kv 12: chatglm.rope.freq_base f32 = 5000000.000000
llama_model_loader: - kv 13: tokenizer.ggml.model str = gpt2
llama_model_loader: - kv 14: tokenizer.ggml.pre str = chatglm-bpe
llama_model_loader: - kv 15: tokenizer.ggml.tokens arr[str,151552] = ["!", "\"", "#", "$", "%", "&", "'", ...
llama_model_loader: - kv 16: tokenizer.ggml.token_type arr[i32,151552] = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ...
llama_model_loader: - kv 17: tokenizer.ggml.merges arr[str,151073] = ["Ġ Ġ", "ĠĠ ĠĠ", "i n", "Ġ t",...
llama_model_loader: - kv 18: tokenizer.ggml.padding_token_id u32 = 151329
llama_model_loader: - kv 19: tokenizer.ggml.eos_token_id u32 = 151329
llama_model_loader: - kv 20: tokenizer.ggml.eot_token_id u32 = 151336
llama_model_loader: - kv 21: tokenizer.ggml.unknown_token_id u32 = 151329
llama_model_loader: - kv 22: general.quantization_version u32 = 2
llama_model_loader: - kv 23: quantize.imatrix.file str = /models/codegeex4-all-9b-GGUF/codegee...
llama_model_loader: - kv 24: quantize.imatrix.dataset str = /training_data/calibration_datav3.txt
llama_model_loader: - kv 25: quantize.imatrix.entries_count i32 = 160
llama_model_loader: - kv 26: quantize.imatrix.chunks_count i32 = 125
llama_model_loader: - type f32: 121 tensors
llama_model_loader: - type q8_0: 162 tensors
llm_load_vocab: special tokens cache size = 223
llm_load_vocab: token to piece cache size = 0.9732 MB
llm_load_print_meta: format = GGUF V3 (latest)
llm_load_print_meta: arch = chatglm
llm_load_print_meta: vocab type = BPE
llm_load_print_meta: n_vocab = 151552
llm_load_print_meta: n_merges = 151073
llm_load_print_meta: vocab_only = 0
llm_load_print_meta: n_ctx_train = 131072
llm_load_print_meta: n_embd = 4096
llm_load_print_meta: n_layer = 40
llm_load_print_meta: n_head = 32
llm_load_print_meta: n_head_kv = 2
llm_load_print_meta: n_rot = 64
llm_load_print_meta: n_swa = 0
llm_load_print_meta: n_embd_head_k = 128
llm_load_print_meta: n_embd_head_v = 128
llm_load_print_meta: n_gqa = 16
llm_load_print_meta: n_embd_k_gqa = 256
llm_load_print_meta: n_embd_v_gqa = 256
llm_load_print_meta: f_norm_eps = 0.0e+00
llm_load_print_meta: f_norm_rms_eps = 1.0e-05
llm_load_print_meta: f_clamp_kqv = 0.0e+00
llm_load_print_meta: f_max_alibi_bias = 0.0e+00
llm_load_print_meta: f_logit_scale = 0.0e+00
llm_load_print_meta: n_ff = 13696
llm_load_print_meta: n_expert = 0
llm_load_print_meta: n_expert_used = 0
llm_load_print_meta: causal attn = 1
llm_load_print_meta: pooling type = 0
llm_load_print_meta: rope type = 0
llm_load_print_meta: rope scaling = linear
llm_load_print_meta: freq_base_train = 5000000.0
llm_load_print_meta: freq_scale_train = 1
llm_load_print_meta: n_ctx_orig_yarn = 131072
llm_load_print_meta: rope_finetuned = unknown
llm_load_print_meta: ssm_d_conv = 0
llm_load_print_meta: ssm_d_inner = 0
llm_load_print_meta: ssm_d_state = 0
llm_load_print_meta: ssm_dt_rank = 0
llm_load_print_meta: model type = 9B
llm_load_print_meta: model ftype = Q8_0
llm_load_print_meta: model params = 9.40 B
llm_load_print_meta: model size = 9.30 GiB (8.50 BPW)
llm_load_print_meta: general.name = codegeex4-all-9b
llm_load_print_meta: EOS token = 151329 '<|endoftext|>'
llm_load_print_meta: UNK token = 151329 '<|endoftext|>'
llm_load_print_meta: PAD token = 151329 '<|endoftext|>'
llm_load_print_meta: LF token = 128 'Ä'
llm_load_print_meta: EOT token = 151336 '<|user|>'
llm_load_print_meta: max token length = 1024
ggml_cuda_init: GGML_CUDA_FORCE_MMQ: no
ggml_cuda_init: GGML_CUDA_FORCE_CUBLAS: no
ggml_cuda_init: found 1 CUDA devices:
Device 0: NVIDIA GeForce RTX 3090, compute capability 8.6, VMM: yes
llm_load_tensors: ggml ctx size = 0.28 MiB
llm_load_tensors: offloading 40 repeating layers to GPU
llm_load_tensors: offloading non-repeating layers to GPU
llm_load_tensors: offloaded 41/41 layers to GPU
llm_load_tensors: CUDA_Host buffer size = 629.00 MiB
llm_load_tensors: CUDA0 buffer size = 8897.23 MiB
.................................................................................
llama_new_context_with_model: n_ctx = 131072
llama_new_context_with_model: n_batch = 2048
llama_new_context_with_model: n_ubatch = 512
llama_new_context_with_model: flash_attn = 0
llama_new_context_with_model: freq_base = 5000000.0
llama_new_context_with_model: freq_scale = 1
llama_kv_cache_init: CUDA0 KV buffer size = 5120.00 MiB
llama_new_context_with_model: KV self size = 5120.00 MiB, K (f16): 2560.00 MiB, V (f16): 2560.00 MiB
llama_new_context_with_model: CUDA_Host output buffer size = 0.58 MiB
llama_new_context_with_model: CUDA0 compute buffer size = 8481.00 MiB
llama_new_context_with_model: CUDA_Host compute buffer size = 264.01 MiB
llama_new_context_with_model: graph nodes = 1606
llama_new_context_with_model: graph splits = 2
main: in-suffix/prefix is specified, chat template will be disabled
system_info: n_threads = 30 / 32 | AVX = 1 | AVX_VNNI = 0 | AVX2 = 1 | AVX512 = 0 | AVX512_VBMI = 0 | AVX512_VNNI = 0 | AVX512_BF16 = 0 | FMA = 1 | NEON = 0 | SVE = 0 | ARM_FMA = 0 | F16C = 1 | FP16_VA = 0 | WASM_SIMD = 0 | BLAS = 1 | SSE3 = 1 | SSSE3 = 1 | VSX = 0 | MATMUL_INT8 = 0 | LLAMAFILE = 0 |
main: interactive mode on.
Input prefix: ' <|user|>
'
Input suffix: ' <|assistant|>
'
sampling:
repeat_last_n = 64, repeat_penalty = 1.100, frequency_penalty = 0.000, presence_penalty = 0.000
top_k = 40, tfs_z = 1.000, top_p = 0.950, min_p = 0.050, typical_p = 1.000, temp = 0.800
mirostat = 0, mirostat_lr = 0.100, mirostat_ent = 5.000
sampling order:
CFG -> Penalties -> top_k -> tfs_z -> typical_p -> top_p -> min_p -> temperature
generate: n_ctx = 131072, n_batch = 2048, n_predict = -1, n_keep = 34
== Running in interactive mode. ==
- Press Ctrl+C to interject at any time.
- To return control to the AI, end your input with '\'.
- To return control without starting a new line, end your input with '/'.
> write a snake game in python/
Certainly, here's a simple version of the classic Snake game written in Python using the `pygame` library. This code will create a window where you can play the game.
First, you'll need to install `pygame` if you haven't already:
```bash
pip install pygame
```
Now, here's the basic Snake game:
```python
import pygame
import time
import random
pygame.init()
# Screen size
width = 800
height = 600
game_display = pygame.display.set_mode((width, height))
pygame.display.set_caption('Snake Game')
snake_block = 10
snake_speed = 15
black = (0, 0, 0)
white = (255, 255, 255)
red = (213, 50, 80)
green = (0, 255, 0)
blue = (50, 153, 213)
clock = pygame.time.Clock()
font_style = pygame.font.SysFont(None, 35)
def our_snake(snake_block, snake_list):
for x in snake_list:
pygame.draw.rect(game_display, black, [x[0], x[1], snake_block, snake_block])
def message(msg, color):
mesg = font_style.render(msg, True, color)
game_display.blit(mesg, [width / 6, height / 3])
def gameLoop():
game_over = False
game_close = False
x1 = width / 2
y1 = height / 2
x1_change = 0
y1_change = 0
snake_List = []
Length_of_snake = 1
foodx = round(random.randrange(0, width - snake_block) / 10.0) * 10.0
foody = round(random.randrange(0, height - snake_block) / 10.0) * 10.0
while not game_over:
while game_close == True:
game_display.fill(white)
message("You Lost! Press Q-Quit or C-Play Again", red)
pygame.display.update()
for event in pygame.event.get():
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_q:
game_over = True
game_close = False
if event.key == pygame.K_c:
gameLoop()
for event in pygame.event.get():
if event.type == pygame.QUIT:
game_over = True
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_LEFT:
x1_change = -snake_block
y1_change = 0
elif event.key == pygame.K_RIGHT:
x1_change = snake_block
y1_change = 0
elif event.key == pygame.K_UP:
y1_change = -snake_block
x1_change = 0
elif event.key == pygame.K_DOWN:
y1_change = snake_block
x1_change = 0
if x1 >= width or x1 < 0 or y1 >= height or y1 < 0:
game_close = True
x1 += x1_change
y1 += y1_change
game_display.fill(blue)
pygame.draw.rect(game_display, green, [foodx, foody, snake_block, snake_block])
snake_Head = []
snake_Head.append(x1)
snake_Head.append(y1)
snake_List.append(snake_Head)
if len(snake_List) > Length_of_snake:
del snake_List[0]
for x in snake_List[:-1]:
if x == snake_Head:
game_close = True
our_snake(snake_block, snake_List)
pygame.display.update()
if x1 == foodx and y1 == foody:
foodx = round(random.randrange(0, width - snake_block) / 10.0) * 10.0
foody = round(random.randrange(0, height - snake_block) / 10.0) * 10.0
Length_of_snake += 1
clock.tick(snake_speed)
pygame.quit()
quit()
gameLoop()
```
To run the game, simply copy and paste this code into a Python script file (e.g., `snake_game.py`) and execute it with your Python interpreter. The snake will move around the screen as you use the arrow keys to control it, eating food that appears at random positions on the screen. If the snake runs into itself or the edges of the window, the game is over.
Remember that this is a very basic version of Snake. You can extend it by adding features such as scoring, levels, different types of food with varying effects, and more.
> Can you add a score counter to the game?/
Certainly! Here's how you can modify the code above to include a score counter. This version of Snake will display your score at the top-left corner of the window.
```python
import pygame
import time
import random
pygame.init()
# Screen size
width = 800
height = 600
game_display = pygame.display.set_mode((width, height))
pygame.display.set_caption('Snake Game')
snake_block = 10
snake_speed = 15
black = (0, 0, 0)
white = (255, 255, 255)
red = (213, 50, 80)
green = (0, 255, 0)
blue = (50, 153, 213)
clock = pygame.time.Clock()
font_style = pygame.font.SysFont(None, 35)
score_font = pygame.font.SysFont(None, 45)
def our_snake(snake_block, snake_list):
for x in snake_list:
pygame.draw.rect(game_display, black, [x[0], x[1], snake_block, snake_block])
def message(msg, color):
mesg = font_style.render(msg, True, color)
game_display.blit(mesg, [width / 6, height / 3])
def Your_score(score):
value = score_font.render("Your Score: " + str(score), True, black)
game_display.blit(value, [0, 0])
def gameLoop():
game_over = False
game_close = False
x1 = width / 2
y1 = height / 2
x1_change = 0
y1_change = 0
snake_List = []
Length_of_snake = 1
foodx = round(random.randrange(0, width - snake_block) / 10.0) * 10.0
foody = round(random.randrange(0, height - snake_block) / 10.0) * 10.0
score = 0
while not game_over:
while game_close == True:
game_display.fill(white)
message("You Lost! Press Q-Quit or C-Play Again", red)
Your_score(score)
pygame.display.update()
for event in pygame.event.get():
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_q:
game_over = True
game_close = False
if event.key == pygame.K_c:
gameLoop()
for event in pygame.event.get():
if event.type == pygame.QUIT:
game_over = True
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_LEFT:
x1_change = -snake_block
y1_change = 0
elif event.key == pygame.K_RIGHT:
x1_change = snake_block
y1_change = 0
elif event.key == pygame.K_UP:
y1_change = -snake_block
x1_change = 0
elif event.key == pygame.K_DOWN:
y1_change = snake_block
x1_change = 0
if x1 >= width or x1 < 0 or y1 >= height or y1 < 0:
game_close = True
x1 += x1_change
y1 += y1_change
game_display.fill(blue)
pygame.draw.rect(game_display, green, [foodx, foody, snake_block, snake_block])
snake_Head = []
snake_Head.append(x1)
snake_Head.append(y1)
snake_List.append(snake_Head)
if len(snake_List) > Length_of_snake:
del snake_List[0]
for x in snake_List[:-1]:
if x == snake_Head:
game_close = True
our_snake(snake_block, snake_List)
Your_score(score)
pygame.display.update()
if x1 == foodx and y1 == foody:
foodx = round(random.randrange(0, width - snake_block) / 10.0) * 10.0
foody = round(random.randrange(0, height - snake_block) / 10.0) * 10.0
Length_of_snake += 1
score += 1
clock.tick(snake_speed)
pygame.quit()
quit()
gameLoop()
```
This version of the game will now display your score in the top-left corner at all times, and increase it each time you eat a piece of food. The game loop has been updated to call the `Your_score` function to draw the score on the screen after every frame update.
> can you chage a color of background to red and "game over" bacground to yellow? /
/
Certainly! Here's the updated code with the background color changed to red:
```python
import pygame
import time
import random
pygame.init()
# Screen size
width = 800
height = 600
game_display = pygame.display.set_mode((width, height))
pygame.display.set_caption('Snake Game')
snake_block = 10
snake_speed = 15
black = (0, 0, 0)
white = (255, 255, 255)
red = (213, 50, 80)
green = (0, 255, 0)
blue = (50, 153, 213)
clock = pygame.time.Clock()
font_style = pygame.font.SysFont(None, 35)
score_font = pygame.font.SysFont(None, 45)
def our_snake(snake_block, snake_list):
for x in snake_list:
pygame.draw.rect(game_display, black, [x[0], x[1], snake_block, snake_block])
def message(msg, color):
mesg = font_style.render(msg, True, color)
game_display.blit(mesg, [width / 6, height / 3])
def Your_score(score):
value = score_font.render("Your Score: " + str(score), True, black)
game_display.blit(value, [0, 0])
def gameLoop():
game_over = False
game_close = False
x1 = width / 2
y1 = height / 2
x1_change = 0
y1_change = 0
snake_List = []
Length_of_snake = 1
foodx = round(random.randrange(0, width - snake_block) / 10.0) * 10.0
foody = round(random.randrange(0, height - snake_block) / 10.0) * 10.0
score = 0
while not game_over:
while game_close == True:
# Change the background color to yellow on game over
game_display.fill((255, 255, 102))
message("You Lost! Press Q-Quit or C-Play Again", red)
Your_score(score)
pygame.display.update()
for event in pygame.event.get():
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_q:
game_over = True
game_close = False
if event.key == pygame.K_c:
gameLoop()
for event in pygame.event.get():
if event.type == pygame.QUIT:
game_over = True
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_LEFT:
x1_change = -snake_block
y1_change = 0
elif event.key == pygame.K_RIGHT:
x1_change = snake_block
y1_change = 0
elif event.key == pygame.K_UP:
y1_change = -snake_block
x1_change = 0
elif event.key == pygame.K_DOWN:
y1_change = snake_block
x1_change = 0
if x1 >= width or x1 < 0 or y1 >= height or y1 < 0:
game_close = True
x1 += x1_change
y1 += y1_change
# Change the background color to red
game_display.fill(red)
pygame.draw.rect(game_display, green, [foodx, foody, snake_block, snake_block])
snake_Head = []
snake_Head.append(x1)
snake_Head.append(y1)
snake_List.append(snake_Head)
if len(snake_List) > Length_of_snake:
del snake_List[0]
for x in snake_List[:-1]:
if x == snake_Head:
game_close = True
our_snake(snake_block, snake_List)
Your_score(score)
pygame.display.update()
if x1 == foodx and y1 == foody:
foodx = round(random.randrange(0, width - snake_block) / 10.0) * 10.0
foody = round(random.randrange(0, height - snake_block) / 10.0) * 10.0
Length_of_snake += 1
score += 1
clock.tick(snake_speed)
pygame.quit()
quit()
gameLoop()
```
This code will change the background color to red during gameplay and yellow when the game is over.
> Is possible to change a background game to a loop color transisioning from red - green - blue ? /
Certainly, here's how you can modify the code above to change the background color in a loop between red, green, and blue. This creates a smooth transition effect:
```python
import pygame
import time
import random
pygame.init()
# Screen size
width = 800
height = 600
game_display = pygame.display.set_mode((width, height))
pygame.display.set_caption('Snake Game')
snake_block = 10
snake_speed = 15
black = (0, 0, 0)
white = (255, 255, 255)
red = (213, 50, 80)
green = (0, 255, 0)
blue = (50, 153, 213)
clock = pygame.time.Clock()
font_style = pygame.font.SysFont(None, 35)
score_font = pygame.font.SysFont(None, 45)
def our_snake(snake_block, snake_list):
for x in snake_list:
pygame.draw.rect(game_display, black, [x[0], x[1], snake_block, snake_block])
def message(msg, color):
mesg = font_style.render(msg, True, color)
game_display.blit(mesg, [width / 6, height / 3])
def Your_score(score):
value = score_font.render("Your Score: " + str(score), True, black)
game_display.blit(value, [0, 0])
def gameLoop():
game_over = False
game_close = False
x1 = width / 2
y1 = height / 2
x1_change = 0
y1_change = 0
snake_List = []
Length_of_snake = 1
foodx = round(random.randrange(0, width - snake_block) / 10.0) * 10.0
foody = round(random.randrange(0, height - snake_block) / 10.0) * 10.0
score = 0
colors = [(213, 50, 80), (0, 255, 0), (50, 153, 213)] # Red, Green, Blue
color_index = 0
while not game_over:
while game_close == True:
game_display.fill((255, 255, 102)) # Yellow background on game over
message("You Lost! Press Q-Quit or C-Play Again", red)
Your_score(score)
pygame.display.update()
for event in pygame.event.get():
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_q:
game_over = True
game_close = False
if event.key == pygame.K_c:
gameLoop()
for event in pygame.event.get():
if event.type == pygame.QUIT:
game_over = True
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_LEFT:
x1_change = -snake_block
y1_change = 0
elif event.key == pygame.K_RIGHT:
x1_change = snake_block
y1_change = 0
elif event.key == pygame.K_UP:
y1_change = -snake_block
x1_change = 0
elif event.key == pygame.K_DOWN:
y1_change = snake_block
x1_change = 0
if x1 >= width or x1 < 0 or y1 >= height or y1 < 0:
game_close = True
x1 += x1_change
y1 += y1_change
# Change the background color in a loop
color_index = (color_index + 1) % len(colors)
game_display.fill(colors[color_index])
pygame.draw.rect(game_display, green, [foodx, foody, snake_block, snake_block])
snake_Head = []
snake_Head.append(x1)
snake_Head.append(y1)
snake_List.append(snake_Head)
if len(snake_List) > Length_of_snake:
del snake_List[0]
for x in snake_List[:-1]:
if x == snake_Head:
game_close = True
our_snake(snake_block, snake_List)
Your_score(score)
pygame.display.update()
if x1 == foodx and y1 == foody:
foodx = round(random.randrange(0, width - snake_block) / 10.0) * 10.0
foody = round(random.randrange(0, height - snake_block) / 10.0) * 10.0
Length_of_snake += 1
score += 1
clock.tick(snake_speed)
pygame.quit()
quit()
gameLoop()
```
This code will change the background color in a loop from red to green to blue, and then back to red again. This creates a smooth transition effect as the game progresses.
> color can changing slower? /
Certainly, if you want to slow down the transition between colors, you can adjust the speed of the color index update. For example, by increasing the increment value in the modulo operation `(color_index + 1) % len(colors)`.
Here's an example with a slower transition:
```python
import pygame
import time
import random
pygame.init()
# Screen size
width = 800
height = 600
game_display = pygame.display.set_mode((width, height))
pygame.display.set_caption('Snake Game')
snake_block = 10
snake_speed = 15
black = (0, 0, 0)
white = (255, 255, 255)
red = (213, 50, 80)
green = (0, 255, 0)
blue = (50, 153, 213)
clock = pygame.time.Clock()
font_style = pygame.font.SysFont(None, 35)
score_font = pygame.font.SysFont(None, 45)
def our_snake(snake_block, snake_list):
for x in snake_list:
pygame.draw.rect(game_display, black, [x[0], x[1], snake_block, snake_block])
def message(msg, color):
mesg = font_style.render(msg, True, color)
game_display.blit(mesg, [width / 6, height / 3])
def Your_score(score):
value = score_font.render("Your Score: " + str(score), True, black)
game_display.blit(value, [0, 0])
def gameLoop():
game_over = False
game_close = False
x1 = width / 2
y1 = height / 2
x1_change = 0
y1_change = 0
snake_List = []
Length_of_snake = 1
foodx = round(random.randrange(0, width - snake_block) / 10.0) * 10.0
foody = round(random.randrange(0, height - snake_block) / 10.0) * 10.0
score = 0
colors = [(213, 50, 80), (0, 255, 0), (50, 153, 213)] # Red, Green, Blue
color_index = 0
while not game_over:
while game_close == True:
game_display.fill((255, 255, 102)) # Yellow background on game over
message("You Lost! Press Q-Quit or C-Play Again", red)
Your_score(score)
pygame.display.update()
for event in pygame.event.get():
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_q:
game_over = True
game_close = False
if event.key == pygame.K_c:
gameLoop()
for event in pygame.event.get():
if event.type == pygame.QUIT:
game_over = True
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_LEFT:
x1_change = -snake_block
y1_change = 0
elif event.key == pygame.K_RIGHT:
x1_change = snake_block
y1_change = 0
elif event.key == pygame.K_UP:
y1_change = -snake_block
x1_change = 0
elif event.key == pygame.K_DOWN:
y1_change = snake_block
x1_change = 0
if x1 >= width or x1 < 0 or y1 >= height or y1 < 0:
game_close = True
x1 += x1_change
y1 += y1_change
# Change the background color in a loop, but slower
color_index = (color_index + 2) % len(colors)
game_display.fill(colors[color_index])
pygame.draw.rect(game_display, green, [foodx, foody, snake_block, snake_block])
snake_Head = []
snake_Head.append(x1)
snake_Head.append(y1)
snake_List.append(snake_Head)
if len(snake_List) > Length_of_snake:
del snake_List[0]
for x in snake_List[:-1]:
if x == snake_Head:
game_close = True
our_snake(snake_block, snake_List)
Your_score(score)
pygame.display.update()
if x1 == foodx and y1 == foody:
foodx = round(random.randrange(0, width - snake_block) / 10.0) * 10.0
foody = round(random.randrange(0, height - snake_block) / 10.0) * 10.0
Length_of_snake += 1
score += 1
clock.tick(snake_speed)
pygame.quit()
quit()
gameLoop()
```
In this version of the code, the color index updates every other frame (`color_index = (color_index + 2) % len(colors)`), which slows down the transition between colors. You can adjust the increment value to speed up or slow down the transition as needed.
> can colors changing gradually? /
Certainly, you can change the color of the background gradually by using linear interpolation between two colors. Here's how you can modify the code to achieve this:
```python
import pygame
import time
import random
pygame.init()
# Screen size
width = 800
height = 600
game_display = pygame.display.set_mode((width, height))
pygame.display.set_caption('Snake Game')
snake_block = 10
snake_speed = 15
black = (0, 0, 0)
white = (255, 255, 255)
red = (213, 50, 80)
green = (0, 255, 0)
blue = (50, 153, 213)
clock = pygame.time.Clock()
font_style = pygame.font.SysFont(None, 35)
score_font = pygame.font.SysFont(None, 45)
def our_snake(snake_block, snake_list):
for x in snake_list:
pygame.draw.rect(game_display, black, [x[0], x[1], snake_block, snake_block])
def message(msg, color):
mesg = font_style.render(msg, True, color)
game_display.blit(mesg, [width / 6, height / 3])
def Your_score(score):
value = score_font.render("Your Score: " + str(score), True, black)
game_display.blit(value, [0, 0])
def color_transition(prev_color, next_color, fraction):
r1, g1, b1 = prev_color
r2, g2, b2 = next_color
return (int(r1 + fraction * (r2 - r1)), int(g1 + fraction * (g2 - g1)), int(b1 + fraction * (b2 - b1)))
def gameLoop():
game_over = False
game_close = False
x1 = width / 2
y1 = height / 2
x1_change = 0
y1_change = 0
snake_List = []
Length_of_snake = 1
foodx = round(random.randrange(0, width - snake_block) / 10.0) * 10.0
foody = round(random.randrange(0, height - snake_block) / 10.0) * 10.0
score = 0
colors = [(213, 50, 80), (0, 255, 0), (50, 153, 213)] # Red, Green, Blue
current_color_index = 0
next_color_index = 1
transition_fraction = 0.0
transition_speed = 0.01
while not game_over:
while game_close == True:
game_display.fill((255, 255, 102)) # Yellow background on game over
message("You Lost! Press Q-Quit or C-Play Again", red)
Your_score(score)
pygame.display.update()
for event in pygame.event.get():
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_q:
game_over = True
game_close = False
if event.key == pygame.K_c:
gameLoop()
for event in pygame.event.get():
if event.type == pygame.QUIT:
game_over = True
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_LEFT:
x1_change = -snake_block
y1_change = 0
elif event.key == pygame.K_RIGHT:
x1_change = snake_block
y1_change = 0
elif event.key == pygame.K_UP:
y1_change = -snake_block
x1_change = 0
elif event.key == pygame.K_DOWN:
y1_change = snake_block
x1_change = 0
if x1 >= width or x1 < 0 or y1 >= height or y1 < 0:
game_close = True
x1 += x1_change
y1 += y1_change
# Change the background color with a smooth transition
if transition_fraction > 1.0:
current_color_index = next_color_index
next_color_index = (next_color_index + 1) % len(colors)
transition_fraction = 0.0
prev_color = colors[current_color_index]
next_color = colors[next_color_index]
background_color = color_transition(prev_color, next_color, transition_fraction)
game_display.fill(background_color)
transition_fraction += transition_speed
pygame.draw.rect(game_display, green, [foodx, foody, snake_block, snake_block])
snake_Head = []
snake_Head.append(x1)
snake_Head.append(y1)
snake_List.append(snake_Head)
if len(snake_List) > Length_of_snake:
del snake_List[0]
for x in snake_List[:-1]:
if x == snake_Head:
game_close = True
our_snake(snake_block, snake_List)
Your_score(score)
pygame.display.update()
if x1 == foodx and y1 == foody:
foodx = round(random.randrange(0, width - snake_block) / 10.0) * 10.0
foody = round(random.randrange(0, height - snake_block) / 10.0) * 10.0
Length_of_snake += 1
score += 1
clock.tick(snake_speed)
pygame.quit()
quit()
gameLoop()
```
In this version of the code, we use a color transition function `color_transition` to interpolate between two colors based on a fraction value (`transition_fraction`). The background color is updated every frame, and when the fraction exceeds 1.0, it resets to start the next color transition.
> Can you reposiosion a score counter to the center on top ? /
Certainly, you can reposition the score counter to the center of the top of the screen. Here's how you can modify the code:
```python
import pygame
import time
import random
pygame.init()
# Screen size
width = 800
height = 600
game_display = pygame.display.set_mode((width, height))
pygame.display.set_caption('Snake Game')
snake_block = 10
snake_speed = 15
black = (0, 0, 0)
white = (255, 255, 255)
red = (213, 50, 80)
green = (0, 255, 0)
blue = (50, 153, 213)
clock = pygame.time.Clock()
font_style = pygame.font.SysFont(None, 35)
score_font = pygame.font.SysFont(None, 45)
def our_snake(snake_block, snake_list):
for x in snake_list:
pygame.draw.rect(game_display, black, [x[0], x[1], snake_block, snake_block])
def message(msg, color):
mesg = font_style.render(msg, True, color)
game_display.blit(mesg, [width / 6, height / 3])
def Your_score(score):
value = score_font.render("Your Score: " + str(score), True, black)
# Center the score on top of the screen
game_display.blit(value, [(width - value.get_width()) // 2, 10])
def color_transition(prev_color, next_color, fraction):
r1, g1, b1 = prev_color
r2, g2, b2 = next_color
return (int(r1 + fraction * (r2 - r1)), int(g1 + fraction * (g2 - g1)), int(b1 + fraction * (b2 - b1)))
def gameLoop():
game_over = False
game_close = False
x1 = width / 2
y1 = height / 2
x1_change = 0
y1_change = 0
snake_List = []
Length_of_snake = 1
foodx = round(random.randrange(0, width - snake_block) / 10.0) * 10.0
foody = round(random.randrange(0, height - snake_block) / 10.0) * 10.0
score = 0
colors = [(213, 50, 80), (0, 255, 0), (50, 153, 213)] # Red, Green, Blue
current_color_index = 0
next_color_index = 1
transition_fraction = 0.0
transition_speed = 0.01
while not game_over:
while game_close == True:
game_display.fill((255, 255, 102)) # Yellow background on game over
message("You Lost! Press Q-Quit or C-Play Again", red)
Your_score(score)
pygame.display.update()
for event in pygame.event.get():
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_q:
game_over = True
game_close = False
if event.key == pygame.K_c:
gameLoop()
for event in pygame.event.get():
if event.type == pygame.QUIT:
game_over = True
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_LEFT:
x1_change = -snake_block
y1_change = 0
elif event.key == pygame.K_RIGHT:
x1_change = snake_block
y1_change = 0
elif event.key == pygame.K_UP:
y1_change = -snake_block
x1_change = 0
elif event.key == pygame.K_DOWN:
y1_change = snake_block
x1_change = 0
if x1 >= width or x1 < 0 or y1 >= height or y1 < 0:
game_close = True
x1 += x1_change
y1 += y1_change
# Change the background color with a smooth transition
if transition_fraction > 1.0:
current_color_index = next_color_index
next_color_index = (next_color_index + 1) % len(colors)
transition_fraction = 0.0
prev_color = colors[current_color_index]
next_color = colors[next_color_index]
background_color = color_transition(prev_color, next_color, transition_fraction)
game_display.fill(background_color)
transition_fraction += transition_speed
pygame.draw.rect(game_display, green, [foodx, foody, snake_block, snake_block])
snake_Head = []
snake_Head.append(x1)
snake_Head.append(y1)
snake_List.append(snake_Head)
if len(snake_List) > Length_of_snake:
del snake_List[0]
for x in snake_List[:-1]:
if x == snake_Head:
game_close = True
our_snake(snake_block, snake_List)
Your_score(score)
pygame.display.update()
if x1 == foodx and y1 == foody:
foodx = round(random.randrange(0, width - snake_block) / 10.0) * 10.0
foody = round(random.randrange(0, height - snake_block) / 10.0) * 10.0
Length_of_snake += 1
score += 1
clock.tick(snake_speed)
pygame.quit()
quit()
gameLoop()
```
In this version of the code, we use `value.get_width()` to get the width of the rendered text and calculate its center position on the screen. We then blit (draw) the score at that position.