import { logging } from "near-sdk-as" import { users, User, notes, Note } from "./models";

export function registerUser (accountId : string, name: string, phone: string, email: string, password: string): void

movementGame

A game that has to do with smooth movement of the user. se sdl2::pixels::Color; use sdl2::event::Event; use sdl2::keyboard::Keycode; use sdl2::render::{WindowCanvas, Texture}; use sdl2::rect::{Point, Rect}; // "self" imports the "image" module itself as well as everything else we listed use sdl2::image::{self, LoadTexture, InitFlag}; use std::time::Duration;

const PLAYER_MOVEMENT_SPEED: i32 = 20;

#[derive(Debug, Clone, Copy, PartialEq, Eq)] enum Direction { Up, Down, Left, Right, }

#[derive(Debug)] struct Player { position: Point, sprite: Rect, speed: i32, direction: Direction, }

fn render( canvas: &mut WindowCanvas, color: Color, texture: &Texture, player: &Player, ) -> Result<(), String> { canvas.set_draw_color(color); canvas.clear();

let (width, height) = canvas.output_size()?;

// Treat the center of the screen as the (0, 0) coordinate
let screen_position = player.position + Point::new(width as i32 / 2, height as i32 / 2);
let screen_rect = Rect::from_center(screen_position, player.sprite.width(), player.sprite.height());
canvas.copy(texture, player.sprite, screen_rect)?;

canvas.present();

Ok(())

}

// Update player a fixed amount based on their speed. // WARNING: Calling this function too often or at a variable speed will cause the player's speed // to be unpredictable! fn update_player(player: &mut Player) { use self::Direction::*; match player.direction { Left => { player.position = player.position.offset(-player.speed, 0); }, Right => { player.position = player.position.offset(player.speed, 0); }, Up => { player.position = player.position.offset(0, -player.speed); }, Down => { player.position = player.position.offset(0, player.speed); }, } }

fn main() -> Result<(), String> { let sdl_context = sdl2::init()?; let video_subsystem = sdl_context.video()?; // Leading "_" tells Rust that this is an unused variable that we don't care about. It has to // stay unused because if we don't have any variable at all then Rust will treat it as a // temporary value and drop it right away! let _image_context = image::init(InitFlag::PNG | InitFlag::JPG)?;

let window = video_subsystem.window("game tutorial", 800, 600)
    .position_centered()
    .build()
    .expect("could not initialize video subsystem");

let mut canvas = window.into_canvas().build()
    .expect("could not make a canvas");

let texture_creator = canvas.texture_creator();
let texture = texture_creator.load_texture("assets/bardo.png")?;

let mut player = Player {
    position: Point::new(0, 0),
    sprite: Rect::new(0, 0, 26, 36),
    speed: 0,
    direction: Direction::Right,
};

let mut event_pump = sdl_context.event_pump()?;
let mut i = 0;
'running: loop {
    // Handle events
    for event in event_pump.poll_iter() {
        match event {
            Event::Quit {..} |
            Event::KeyDown { keycode: Some(Keycode::Escape), .. } => {
                break 'running;
            },
            Event::KeyDown { keycode: Some(Keycode::Left), repeat: false, .. } => {
                player.speed = PLAYER_MOVEMENT_SPEED;
                player.direction = Direction::Left;
            },
            Event::KeyDown { keycode: Some(Keycode::Right), repeat: false, .. } => {
                player.speed = PLAYER_MOVEMENT_SPEED;
                player.direction = Direction::Right;
            },
            Event::KeyDown { keycode: Some(Keycode::Up), repeat: false, .. } => {
                player.speed = PLAYER_MOVEMENT_SPEED;
                player.direction = Direction::Up;
            },
            Event::KeyDown { keycode: Some(Keycode::Down), repeat: false, .. } => {
                player.speed = PLAYER_MOVEMENT_SPEED;
                player.direction = Direction::Down;
            },
            Event::KeyUp { keycode: Some(Keycode::Left), repeat: false, .. } |
            Event::KeyUp { keycode: Some(Keycode::Right), repeat: false, .. } |
            Event::KeyUp { keycode: Some(Keycode::Up), repeat: false, .. } |
            Event::KeyUp { keycode: Some(Keycode::Down), repeat: false, .. } => {
                player.speed = 0;
            },
            _ => {}
        }
    }

    // Update
    i = (i + 1) % 255;
    update_player(&mut player);

    // Render
    render(&mut canvas, Color::RGB(i, 64, 255 - i), &texture, &player)?;

    // Time management!
    ::std::thread::sleep(Duration::new(0, 1_000_000_000u32 / 20));
}

Ok(())

}