me/ayin
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

handle warnings

Browse source
This commit is contained in:
me 2025-12-26 08:59:13 +02:00
parent 3613c7cc8f
commit 7258fe035a
11 changed files with 64 additions and 55 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/game.rs
View file

@ -20,7 +20,7 @@ fn window_conf() -> Conf {
async fn main() { async fn main() {
info!("Hello, 👁️‍🗨️!"); info!("Hello, 👁️‍🗨️!");
if screen_width() < SCREEN_WIDTH { if screen_width() < SCREEN_WIDTH {
request_new_screen_size(SCREEN_WIDTH as f32, SCREEN_HEIGHT as f32); request_new_screen_size(SCREEN_WIDTH, SCREEN_HEIGHT);
} }
rand::srand(macroquad::miniquad::date::now() as _); rand::srand(macroquad::miniquad::date::now() as _);

19
src/interpret/interpret.rs
View file

@ -151,7 +151,7 @@ fn eval_expr(expr_env: &Env, state: &mut State, expr: &ast::Expr) -> Result<ast:
Ok(result) Ok(result)
} }
ast::Expr::Access { expr, field } => match eval_expr(expr_env, state, expr)? { ast::Expr::Access { expr, field } => match eval_expr(expr_env, state, expr)? {
ast::Value::Record(record) => Ok(state.variables.get(record.get(&field)?).clone()), ast::Value::Record(record) => Ok(state.variables.get(record.get(field)?).clone()),
ast::Value::Vector(vec) => match field { ast::Value::Vector(vec) => match field {
_ if field.0.chars().all(char::is_numeric) => { _ if field.0.chars().all(char::is_numeric) => {
let index = field.0.parse::<usize>().unwrap(); let index = field.0.parse::<usize>().unwrap();
@ -172,7 +172,7 @@ fn eval_expr(expr_env: &Env, state: &mut State, expr: &ast::Expr) -> Result<ast:
let value = match expr_env.get(var) { let value = match expr_env.get(var) {
Ok(value) => Ok(value.clone()), Ok(value) => Ok(value.clone()),
Err(err) => { Err(err) => {
if state.primitive_funcs.get(&var).is_some() { if state.primitive_funcs.get(var).is_some() {
Ok(ast::Value::PrimitiveFunc(var.clone())) Ok(ast::Value::PrimitiveFunc(var.clone()))
} else { } else {
Err(err) Err(err)
@ -192,7 +192,7 @@ fn eval_expr(expr_env: &Env, state: &mut State, expr: &ast::Expr) -> Result<ast:
} }
for (arg, e) in func.args.into_iter().zip(args.iter()) { for (arg, e) in func.args.into_iter().zip(args.iter()) {
let evalled = eval_expr(&expr_env, state, e)?; let evalled = eval_expr(expr_env, state, e)?;
closure_env.insert(arg.name, evalled); closure_env.insert(arg.name, evalled);
} }
match eval_expr(&closure_env, state, &func.body)? { match eval_expr(&closure_env, state, &func.body)? {
@ -205,7 +205,7 @@ fn eval_expr(expr_env: &Env, state: &mut State, expr: &ast::Expr) -> Result<ast:
ast::Value::PrimitiveFunc(func) => { ast::Value::PrimitiveFunc(func) => {
let mut argsvec = vec![]; let mut argsvec = vec![];
for arg in args.iter() { for arg in args.iter() {
let evalled = eval_expr(&expr_env, state, arg)?; let evalled = eval_expr(expr_env, state, arg)?;
let e = value_to_stadnalone_expr(state, evalled)?; let e = value_to_stadnalone_expr(state, evalled)?;
argsvec.push(e); argsvec.push(e);
} }
@ -223,7 +223,7 @@ fn eval_expr(expr_env: &Env, state: &mut State, expr: &ast::Expr) -> Result<ast:
Backtrace::capture(), Backtrace::capture(),
)), )),
}, },
ast::Expr::Not(e) => match eval_expr(&expr_env, state, e)? { ast::Expr::Not(e) => match eval_expr(expr_env, state, e)? {
ast::Value::Boolean(b) => Ok(ast::Value::Boolean(!b)), ast::Value::Boolean(b) => Ok(ast::Value::Boolean(!b)),
v => Err(Error::NotABoolean(v, Backtrace::capture())), v => Err(Error::NotABoolean(v, Backtrace::capture())),
}, },
@ -353,9 +353,13 @@ fn eval_expr(expr_env: &Env, state: &mut State, expr: &ast::Expr) -> Result<ast:
let cop = match cop { let cop = match cop {
ast::Cmp::Eq => |a, b| a == b, ast::Cmp::Eq => |a, b| a == b,
ast::Cmp::NotEq => |a, b| a != b, ast::Cmp::NotEq => |a, b| a != b,
#[allow(clippy::bool_comparison)]
ast::Cmp::Gt => |a, b| a > b, ast::Cmp::Gt => |a, b| a > b,
#[allow(clippy::bool_comparison)]
ast::Cmp::Gte => |a, b| a >= b, ast::Cmp::Gte => |a, b| a >= b,
#[allow(clippy::bool_comparison)]
ast::Cmp::Lt => |a, b| a < b, ast::Cmp::Lt => |a, b| a < b,
#[allow(clippy::bool_comparison)]
ast::Cmp::Lte => |a, b| a <= b, ast::Cmp::Lte => |a, b| a <= b,
}; };
Ok(ast::Value::Boolean(cop(a, b))) Ok(ast::Value::Boolean(cop(a, b)))
@ -417,7 +421,7 @@ fn eval_expr_shallow(
) -> Result<ast::Value, Error> { ) -> Result<ast::Value, Error> {
match expr { match expr {
ast::Expr::Var(var) => { ast::Expr::Var(var) => {
let result = expr_env.get(&var)?; let result = expr_env.get(var)?;
match result { match result {
ast::Value::Ref(_) => Ok(result.clone()), ast::Value::Ref(_) => Ok(result.clone()),
v => Err(Error::NotAReference( v => Err(Error::NotAReference(
@ -428,7 +432,7 @@ fn eval_expr_shallow(
} }
} }
ast::Expr::Access { expr, field } => match eval_expr(expr_env, state, expr)? { ast::Expr::Access { expr, field } => match eval_expr(expr_env, state, expr)? {
ast::Value::Record(record) => Ok(ast::Value::Ref(record.get(&field)?.clone())), ast::Value::Record(record) => Ok(ast::Value::Ref(record.get(field)?.clone())),
ast::Value::Vector(vec) => match field { ast::Value::Vector(vec) => match field {
_ if field.0.chars().all(char::is_numeric) => { _ if field.0.chars().all(char::is_numeric) => {
let index = field.0.parse::<usize>().unwrap(); let index = field.0.parse::<usize>().unwrap();
@ -455,6 +459,7 @@ fn defs_to_env(
let mut env = Env::new(env_name.clone()); let mut env = Env::new(env_name.clone());
for def in defs { for def in defs {
#[allow(clippy::match_single_binding)]
let (mutable, name, closure) = match def { let (mutable, name, closure) = match def {
ast::Definition { ast::Definition {
mutable, mutable,

5
src/interpret/mod.rs
View file

@ -1,7 +1,8 @@
//! Interpreter for Ayin. //! Interpreter for Ayin.
pub mod interpret; #[allow(clippy::module_inception)]
pub mod types; mod interpret;
mod types;
pub use interpret::*; pub use interpret::*;
pub use types::*; pub use types::*;

1
src/interpret/types.rs
View file

@ -144,6 +144,7 @@ pub struct Variables {
} }
impl Variables { impl Variables {
#[allow(clippy::new_without_default)]
pub fn new() -> Self { pub fn new() -> Self {
Variables { Variables {
vars: HashMap::new(), vars: HashMap::new(),

1
src/parser/mod.rs
View file

@ -1,3 +1,4 @@
#[allow(clippy::module_inception)]
pub mod parser; pub mod parser;
pub mod scanner; pub mod scanner;
pub mod types; pub mod types;

39
src/parser/parser.rs
View file

@ -23,7 +23,7 @@ fn parse_includes(tokens: &mut Tokens) -> ParseResult<Vec<ast::File>> {
} }
fn parse_include(tokens: &mut Tokens) -> ParseResult<ast::File> { fn parse_include(tokens: &mut Tokens) -> ParseResult<ast::File> {
if let Some(_) = tokens.next_if(&Token::Include) { if tokens.next_if(&Token::Include).is_some() {
if let Some(LocatedToken { if let Some(LocatedToken {
token: Token::String(string), token: Token::String(string),
.. ..
@ -93,11 +93,8 @@ fn parse_dot(tokens: &mut Tokens, expr: ast::Expr) -> Result<ast::Expr, Error> {
} }
fn parse_definition(tokens: &mut Tokens) -> ParseResult<ast::Definition> { fn parse_definition(tokens: &mut Tokens) -> ParseResult<ast::Definition> {
if let Some(_) = tokens.next_if(&Token::Let) { if tokens.next_if(&Token::Let).is_some() {
let mutable = match tokens.next_if(&Token::Mut) { let mutable = tokens.next_if(&Token::Mut).is_some();
Some(_) => true,
_ => false,
};
if let Some(name) = parse_identifier_name(tokens)? { if let Some(name) = parse_identifier_name(tokens)? {
if let Some(expr) = parse_set(tokens)? { if let Some(expr) = parse_set(tokens)? {
Ok(Some(ast::Definition { Ok(Some(ast::Definition {
@ -182,7 +179,7 @@ fn parse_expr2(tokens: &mut Tokens) -> ParseResult<ast::Expr> {
fn parse_simple_expr(tokens: &mut Tokens) -> ParseResult<ast::Expr> { fn parse_simple_expr(tokens: &mut Tokens) -> ParseResult<ast::Expr> {
tokens.one_of(vec![ tokens.one_of(vec![
|t| { |t| {
if let Some(_) = t.next_if(&Token::Not) { if t.next_if(&Token::Not).is_some() {
Ok(parse_expr(t)?.map(|expr| ast::Expr::Not(Box::new(expr)))) Ok(parse_expr(t)?.map(|expr| ast::Expr::Not(Box::new(expr))))
} else { } else {
Ok(None) Ok(None)
@ -197,13 +194,13 @@ fn parse_simple_expr(tokens: &mut Tokens) -> ParseResult<ast::Expr> {
parse_vector, parse_vector,
|t| t.between(&Token::OpenParen, &Token::CloseParen, parse_expr), |t| t.between(&Token::OpenParen, &Token::CloseParen, parse_expr),
|t| { |t| {
if let Some(_) = t.next_if(&Token::If) { if t.next_if(&Token::If).is_some() {
if let Some(condition) = parse_expr(t)? { if let Some(condition) = parse_expr(t)? {
if let Some(then) = t if let Some(then) = t
.between(&Token::OpenCurly, &Token::CloseCurly, parse_block)? .between(&Token::OpenCurly, &Token::CloseCurly, parse_block)?
.map(ast::Expr::Block) .map(ast::Expr::Block)
{ {
if let Some(r#else) = if let Some(_) = t.next_if(&Token::Else) { if let Some(r#else) = if t.next_if(&Token::Else).is_some() {
Ok( Ok(
t.between(&Token::OpenCurly, &Token::CloseCurly, parse_block)? t.between(&Token::OpenCurly, &Token::CloseCurly, parse_block)?
.map(ast::Expr::Block), .map(ast::Expr::Block),
@ -239,7 +236,7 @@ fn parse_simple_expr(tokens: &mut Tokens) -> ParseResult<ast::Expr> {
} }
fn parse_fn(tokens: &mut Tokens) -> ParseResult<ast::Expr> { fn parse_fn(tokens: &mut Tokens) -> ParseResult<ast::Expr> {
if let Some(_) = tokens.next_if(&Token::Fn) { if tokens.next_if(&Token::Fn).is_some() {
if let Some(args) = parse_args(tokens)? { if let Some(args) = parse_args(tokens)? {
if let Some(body) = if let Some(body) =
tokens.between(&Token::OpenCurly, &Token::CloseCurly, parse_block)? tokens.between(&Token::OpenCurly, &Token::CloseCurly, parse_block)?
@ -268,7 +265,7 @@ fn parse_fn(tokens: &mut Tokens) -> ParseResult<ast::Expr> {
fn parse_block(tokens: &mut Tokens) -> ParseResult<Vec<ast::Statement>> { fn parse_block(tokens: &mut Tokens) -> ParseResult<Vec<ast::Statement>> {
if let Some(mut stmts) = tokens.many_sep_by_maybe(&Token::Semicolon, parse_statement)? { if let Some(mut stmts) = tokens.many_sep_by_maybe(&Token::Semicolon, parse_statement)? {
//println!("{stmts:#?} {} {:#?}", stmts.len(), tokens.peek()); //println!("{stmts:#?} {} {:#?}", stmts.len(), tokens.peek());
if stmts.len() > 0 && tokens.next_if(&Token::Semicolon).is_some() { if !stmts.is_empty() && tokens.next_if(&Token::Semicolon).is_some() {
stmts.push(ast::Statement::Expr(ast::UNIT)); stmts.push(ast::Statement::Expr(ast::UNIT));
//println!("stmts: {stmts:#?}"); //println!("stmts: {stmts:#?}");
Ok(Some(stmts)) Ok(Some(stmts))
@ -286,7 +283,7 @@ fn parse_statement(tokens: &mut Tokens) -> ParseResult<ast::Statement> {
|tokens| Ok(parse_expr(tokens)?.map(ast::Statement::Expr)), |tokens| Ok(parse_expr(tokens)?.map(ast::Statement::Expr)),
|tokens| Ok(parse_definition(tokens)?.map(ast::Statement::Let)), |tokens| Ok(parse_definition(tokens)?.map(ast::Statement::Let)),
|tokens| { |tokens| {
if let Some(_) = tokens.next_if(&Token::Return) { if tokens.next_if(&Token::Return).is_some() {
let expr = parse_expr(tokens)?; let expr = parse_expr(tokens)?;
Ok(Some(ast::Statement::Return(expr))) Ok(Some(ast::Statement::Return(expr)))
} else { } else {
@ -294,14 +291,14 @@ fn parse_statement(tokens: &mut Tokens) -> ParseResult<ast::Statement> {
} }
}, },
|tokens| { |tokens| {
if let Some(_) = tokens.next_if(&Token::Break) { if tokens.next_if(&Token::Break).is_some() {
Ok(Some(ast::Statement::Break)) Ok(Some(ast::Statement::Break))
} else { } else {
Ok(None) Ok(None)
} }
}, },
|t| { |t| {
if let Some(_) = t.next_if(&Token::Loop) { if t.next_if(&Token::Loop).is_some() {
if let Some(block) = t if let Some(block) = t
.between(&Token::OpenCurly, &Token::CloseCurly, parse_block)? .between(&Token::OpenCurly, &Token::CloseCurly, parse_block)?
.map(ast::Expr::Block) .map(ast::Expr::Block)
@ -348,7 +345,7 @@ fn parse_vector(tokens: &mut Tokens) -> ParseResult<ast::Expr> {
fn parse_record_field_expr(tokens: &mut Tokens) -> ParseResult<(ast::Label, ast::Expr)> { fn parse_record_field_expr(tokens: &mut Tokens) -> ParseResult<(ast::Label, ast::Expr)> {
if let Some(label) = parse_label(tokens)? { if let Some(label) = parse_label(tokens)? {
if let Some(_) = tokens.next_if(&Token::Colon) { if tokens.next_if(&Token::Colon).is_some() {
if let Some(expr) = parse_expr(tokens)? { if let Some(expr) = parse_expr(tokens)? {
Ok(Some((label, expr))) Ok(Some((label, expr)))
} else { } else {
@ -388,7 +385,7 @@ fn parse_number(tokens: &mut Tokens) -> ParseResult<ast::Expr> {
.. ..
}) = t.next_if(&Token::Int(0)) }) = t.next_if(&Token::Int(0))
{ {
Ok(Some(ast::Expr::Value(ast::Value::Int(number.into())))) Ok(Some(ast::Expr::Value(ast::Value::Int(number))))
} else { } else {
Ok(None) Ok(None)
} }
@ -399,7 +396,7 @@ fn parse_number(tokens: &mut Tokens) -> ParseResult<ast::Expr> {
.. ..
}) = t.next_if(&Token::Float(0.0)) }) = t.next_if(&Token::Float(0.0))
{ {
Ok(Some(ast::Expr::Value(ast::Value::Float(number.into())))) Ok(Some(ast::Expr::Value(ast::Value::Float(number))))
} else { } else {
Ok(None) Ok(None)
} }
@ -408,7 +405,7 @@ fn parse_number(tokens: &mut Tokens) -> ParseResult<ast::Expr> {
} }
fn parse_identifier(tokens: &mut Tokens) -> ParseResult<ast::Expr> { fn parse_identifier(tokens: &mut Tokens) -> ParseResult<ast::Expr> {
Ok(parse_identifier_name(tokens)?.map(|name| ast::Expr::Var(name))) Ok(parse_identifier_name(tokens)?.map(ast::Expr::Var))
} }
fn parse_identifier_arg(tokens: &mut Tokens) -> ParseResult<ast::Arg> { fn parse_identifier_arg(tokens: &mut Tokens) -> ParseResult<ast::Arg> {
@ -416,7 +413,7 @@ fn parse_identifier_arg(tokens: &mut Tokens) -> ParseResult<ast::Arg> {
} }
fn parse_identifier_name(tokens: &mut Tokens) -> ParseResult<ast::Name> { fn parse_identifier_name(tokens: &mut Tokens) -> ParseResult<ast::Name> {
Ok(parse_identifier_string(tokens)?.map(|string| ast::Name(string))) Ok(parse_identifier_string(tokens)?.map(ast::Name))
} }
fn parse_label(tokens: &mut Tokens) -> ParseResult<ast::Label> { fn parse_label(tokens: &mut Tokens) -> ParseResult<ast::Label> {
@ -447,7 +444,7 @@ fn parse_bool(tokens: &mut Tokens) -> ParseResult<ast::Expr> {
tokens.one_of(vec![ tokens.one_of(vec![
|t| { |t| {
Ok({ Ok({
if let Some(_) = t.next_if(&Token::True) { if t.next_if(&Token::True).is_some() {
Some(ast::Expr::Value(ast::Value::Boolean(true))) Some(ast::Expr::Value(ast::Value::Boolean(true)))
} else { } else {
None None
@ -456,7 +453,7 @@ fn parse_bool(tokens: &mut Tokens) -> ParseResult<ast::Expr> {
}, },
|t| { |t| {
Ok({ Ok({
if let Some(_) = t.next_if(&Token::False) { if t.next_if(&Token::False).is_some() {
Some(ast::Expr::Value(ast::Value::Boolean(false))) Some(ast::Expr::Value(ast::Value::Boolean(false)))
} else { } else {
None None

8
src/parser/scanner.rs
View file

@ -112,7 +112,7 @@ pub fn scan(source: String) -> Tokens {
token: Token::Op(Op::Mod), token: Token::Op(Op::Mod),
}), }),
'-' => { '-' => {
let c = c.clone(); let c = *c;
let is_number = scanner.peek().map(|ch| ch.is_numeric()) == Some(true); let is_number = scanner.peek().map(|ch| ch.is_numeric()) == Some(true);
if is_number { if is_number {
tokens.push(lex_number(&mut scanner, start, &c)); tokens.push(lex_number(&mut scanner, start, &c));
@ -240,9 +240,7 @@ pub fn scan(source: String) -> Tokens {
tokens.push(LocatedToken { tokens.push(LocatedToken {
start, start,
end: scanner.cursor(), end: scanner.cursor(),
token: match str.as_str() { token: Token::Label(str),
_ => Token::Label(str),
},
}); });
} }
// comments // comments
@ -274,7 +272,7 @@ pub fn scan(source: String) -> Tokens {
_ if c.is_whitespace() => {} _ if c.is_whitespace() => {}
// numbers // numbers
_ if c.is_numeric() => { _ if c.is_numeric() => {
let c = c.clone(); let c = *c;
tokens.push(lex_number(&mut scanner, start, &c)); tokens.push(lex_number(&mut scanner, start, &c));
} }
// identifiers and keywords // identifiers and keywords

16
src/parser/types.rs
View file

@ -82,14 +82,12 @@ impl Tokens {
pub fn peek(&mut self) -> Option<&LocatedToken> { pub fn peek(&mut self) -> Option<&LocatedToken> {
self.0.last() self.0.last()
} }
#[allow(clippy::should_implement_trait)]
pub fn next(&mut self) -> Option<LocatedToken> { pub fn next(&mut self) -> Option<LocatedToken> {
let t = self.0.pop(); self.0.pop()
// println!("'{:?}'", t);
t
} }
pub fn next_if(&mut self, token: &Token) -> Option<LocatedToken> { pub fn next_if(&mut self, token: &Token) -> Option<LocatedToken> {
let t = self.0.pop_if(|t| match (t.token.clone(), token) { self.0.pop_if(|t| match (t.token.clone(), token) {
(a, b) if a == *b => true, (a, b) if a == *b => true,
(Token::Identifier(_), Token::Identifier(_)) => true, (Token::Identifier(_), Token::Identifier(_)) => true,
(Token::Int(_), Token::Int(_)) => true, (Token::Int(_), Token::Int(_)) => true,
@ -98,9 +96,7 @@ impl Tokens {
(Token::Label(_), Token::Label(_)) => true, (Token::Label(_), Token::Label(_)) => true,
(Token::Op(_), Token::Op(_)) => true, (Token::Op(_), Token::Op(_)) => true,
_ => false, _ => false,
}); })
// println!("'{:?}'", t);
t
} }
pub fn between<T>(&mut self, start: &Token, end: &Token, parser: Parser<T>) -> ParseResult<T> { pub fn between<T>(&mut self, start: &Token, end: &Token, parser: Parser<T>) -> ParseResult<T> {
if let Some(_start) = self.next_if(start) { if let Some(_start) = self.next_if(start) {
@ -162,7 +158,7 @@ impl Tokens {
if let Some(first) = parser(self)? { if let Some(first) = parser(self)? {
let mut results = vec![first]; let mut results = vec![first];
loop { loop {
self.next_if(&separator); self.next_if(separator);
if let Some(result) = parser(self)? { if let Some(result) = parser(self)? {
results.push(result); results.push(result);
} else { } else {
@ -177,7 +173,7 @@ impl Tokens {
pub fn many_sep_by<T>(&mut self, separator: &Token, parser: Parser<T>) -> ParseResult<Vec<T>> { pub fn many_sep_by<T>(&mut self, separator: &Token, parser: Parser<T>) -> ParseResult<Vec<T>> {
if let Some(first) = parser(self)? { if let Some(first) = parser(self)? {
let mut results = vec![first]; let mut results = vec![first];
while let Some(_) = self.next_if(&separator) { while self.next_if(separator).is_some() {
if let Some(result) = parser(self)? { if let Some(result) = parser(self)? {
results.push(result); results.push(result);
} else { } else {

5
src/runtime/mod.rs
View file

@ -1,7 +1,8 @@
pub mod primitive_functions; pub mod primitive_functions;
pub mod runtime; #[allow(clippy::module_inception)]
mod runtime;
pub use runtime::*; pub use runtime::*;
pub mod types; mod types;
pub use types::*; pub use types::*;

15
src/runtime/primitive_functions.rs
View file

@ -16,6 +16,7 @@ pub fn primitive_funcs() -> PrimitiveFuncs {
} }
fn clear(args: Vec<ast::Expr>) -> ast::Value { fn clear(args: Vec<ast::Expr>) -> ast::Value {
#[allow(clippy::get_first)]
let r = to_u8(args.get(0)); let r = to_u8(args.get(0));
let g = to_u8(args.get(1)); let g = to_u8(args.get(1));
let b = to_u8(args.get(2)); let b = to_u8(args.get(2));
@ -29,7 +30,7 @@ fn random_u8(_args: Vec<ast::Expr>) -> ast::Value {
} }
fn frame_time(_args: Vec<ast::Expr>) -> ast::Value { fn frame_time(_args: Vec<ast::Expr>) -> ast::Value {
ast::Value::Float(get_frame_time() as f32) ast::Value::Float(get_frame_time())
} }
struct Rectangle { struct Rectangle {
@ -40,6 +41,7 @@ struct Rectangle {
} }
fn draw_rectangle(args: Vec<ast::Expr>) -> ast::Value { fn draw_rectangle(args: Vec<ast::Expr>) -> ast::Value {
#[allow(clippy::get_first)]
let rectangle = match args.get(0) { let rectangle = match args.get(0) {
Some(ast::Expr::Record(record)) => { Some(ast::Expr::Record(record)) => {
let x = to_f32(record.get(&"x".into())); let x = to_f32(record.get(&"x".into()));
@ -60,16 +62,17 @@ fn draw_rectangle(args: Vec<ast::Expr>) -> ast::Value {
_ => todo!(), _ => todo!(),
}; };
mq::draw_rectangle( mq::draw_rectangle(
rectangle.x * SCALE as f32, rectangle.x * SCALE,
rectangle.y * SCALE as f32, rectangle.y * SCALE,
rectangle.w * SCALE as f32, rectangle.w * SCALE,
rectangle.h * SCALE as f32, rectangle.h * SCALE,
color, color,
); );
ast::UNIT_VALUE ast::UNIT_VALUE
} }
fn draw_text(args: Vec<ast::Expr>) -> ast::Value { fn draw_text(args: Vec<ast::Expr>) -> ast::Value {
#[allow(clippy::get_first)]
let text = to_string(args.get(0)); let text = to_string(args.get(0));
let x = to_f32(args.get(1)); let x = to_f32(args.get(1));
let y = to_f32(args.get(2)); let y = to_f32(args.get(2));
@ -100,7 +103,7 @@ fn to_u8(value: Option<&ast::Expr>) -> u8 {
fn to_f32(value: Option<&ast::Expr>) -> f32 { fn to_f32(value: Option<&ast::Expr>) -> f32 {
match value { match value {
Some(ast::Expr::Value(ast::Value::Int(i))) => *i as f32, Some(ast::Expr::Value(ast::Value::Int(i))) => *i as f32,
Some(ast::Expr::Value(ast::Value::Float(f))) => *f as f32, Some(ast::Expr::Value(ast::Value::Float(f))) => *f,
_ => 0.0, _ => 0.0,
} }
} }

8
src/runtime/types.rs
View file

@ -4,7 +4,7 @@ use macroquad::prelude::*;
pub struct State { pub struct State {
pub assets: Assets, pub assets: Assets,
pub state: interpret::types::State, pub state: interpret::State,
pub game_state: ast::Value, pub game_state: ast::Value,
pub gamepads: gamepads::Gamepads, pub gamepads: gamepads::Gamepads,
} }
@ -50,6 +50,12 @@ impl Input {
} }
} }
impl Default for Input {
fn default() -> Self {
Self::new()
}
}
pub struct Gamepad { pub struct Gamepad {
pub buttons: Buttons, pub buttons: Buttons,
pub dpad: DPad, pub dpad: DPad,