alex/agb
1
0
Fork 0
mirror of https://github.com/italicsjenga/agb.git synced 2025-02-02 12:36:35 +11:00
Code Issues Projects Releases Packages Wiki Activity

Fix spellings (#351)

Browse source 
Fixes a bunch of spellings found by the cspell vscode extension.

- [x] Changelog updated / no changelog update needed
This commit is contained in:
Gwilym Kuiper 2022-11-17 21:48:01 +00:00 • committed by GitHub
commit bdf994cab7
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
32 changed files with 257 additions and 146 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

108
.vscode/settings.json vendored Normal file
View file

@ -0,0 +1,108 @@
{
"cSpell.words": [
"aeabi",
"agb",
"agbabi",
"asefile",
"aseprite",
"Atmel",
"behaviour",
"bindgen",
"binutils",
"bitarray",
"Bitfield",
"bitflags",
"bitmask",
"boing",
"boops",
"chipsets",
"chrono",
"clonable",
"collidable",
"Colour",
"Colours",
"constness",
"COOLDOWN",
"cooldowns",
"cstring",
"Customise",
"Datelike",
"dealloc",
"EABI",
"EEPROM",
"ewram",
"fixnum",
"fixnums",
"fontdue",
"fract",
"FRAM",
"framebuffer",
"framebuffers",
"gameboy",
"Gamepak",
"gbafix",
"hadamard",
"Hasher",
"HBLANK",
"healthbar",
"hflip",
"hurtbox",
"initialisation",
"initialise",
"Initialises",
"iwram",
"justfile",
"Knockback",
"lateout",
"Macronix",
"mgba",
"normalise",
"normalised",
"Normalises",
"nostack",
"objcopy",
"Optimisation",
"optimise",
"optimised",
"Optimiser",
"optimises",
"pacman",
"Paks",
"paletted",
"prioritised",
"replacen",
"repr",
"Respawn",
"rustc",
"rustdoc",
"rustup",
"Sanyo",
"screenblock",
"screenblocks",
"signum",
"SRAM",
"struct",
"subcrates",
"subpat",
"synchronisation",
"syscall",
"syscalls",
"THUMBV",
"tilemap",
"tileset",
"tilesets",
"tonc",
"trunc",
"Uninit",
"uninitialised",
"vblank",
"VCOUNT",
"vdraw",
"vflip",
"vram",
"Woah",
"WRAM",
"xmin",
"ymin"
]
}

10
agb-fixnum/src/lib.rs
View file

@ -424,7 +424,7 @@ impl<I: FixedWidthUnsignedInteger, const N: usize> Num<I, N> {
impl<const N: usize> Num<i32, N> {
#[must_use]
/// Returns the square root of a number, it is calcuated a digit at a time.
/// Returns the square root of a number, it is calculated a digit at a time.
/// ```
/// # use agb_fixnum::*;
/// let n: Num<i32, 8> = num!(16.);
@ -530,7 +530,7 @@ impl<I: FixedWidthUnsignedInteger, const N: usize> Display for Num<I, N> {
let mut fractional = self.0 & mask;
// Negative fix nums are awkward to print if they have non zero fractional part.
// Negative fixnums are awkward to print if they have non zero fractional part.
// This is because you can think of them as `number + non negative fraction`.
//
// But if you think of a negative number, you'd like it to be `negative number - non negative fraction`
@ -569,7 +569,7 @@ impl<I: FixedWidthUnsignedInteger, const N: usize> Debug for Num<I, N> {
}
}
/// A vector of two points: (x, y) represened by integers or fixed point numbers
/// A vector of two points: (x, y) represented by integers or fixed point numbers
#[derive(Clone, Copy, PartialEq, Eq, Debug, Default)]
pub struct Vector2D<T: Number> {
/// The x coordinate
@ -675,7 +675,7 @@ impl<I: FixedWidthUnsignedInteger, const N: usize> Vector2D<Num<I, N>> {
}
#[must_use]
/// Floors the x and y coordnate, see [Num::floor]
/// Floors the x and y coordinate, see [Num::floor]
/// ```
/// # use agb_fixnum::*;
/// let v1: Vector2D<Num<i32, 8>> = Vector2D::new(num!(1.56), num!(-2.2));
@ -984,7 +984,7 @@ impl<T: Number> Vector2D<T> {
Vector2D { x, y }
}
/// Returns the tuple of the coorinates
/// Returns the tuple of the coordinates
/// ```
/// # use agb_fixnum::*;
/// let v = Vector2D::new(1, 2);

4
agb-image-converter/src/config.rs
View file

@ -28,7 +28,7 @@ pub(crate) trait Config {
pub(crate) trait Image {
fn filename(&self) -> String;
fn tilesize(&self) -> TileSize;
fn tile_size(&self) -> TileSize;
fn colours(&self) -> Colours;
}
@ -84,7 +84,7 @@ impl Image for ImageV1 {
self.filename.clone()
}
fn tilesize(&self) -> TileSize {
fn tile_size(&self) -> TileSize {
self.tile_size.into()
}

8
agb-image-converter/src/lib.rs
View file

@ -84,7 +84,7 @@ pub fn include_gfx(input: TokenStream) -> TokenStream {
match settings.colours() {
Colours::Colours16 => {
let tile_size = settings.tilesize().to_size();
let tile_size = settings.tile_size().to_size();
if image.width % tile_size != 0 || image.height % tile_size != 0 {
panic!("Image size not a multiple of tile size");
}
@ -96,7 +96,7 @@ pub fn include_gfx(input: TokenStream) -> TokenStream {
config.transparent_colour(),
);
let num_tiles = image.width * image.height / settings.tilesize().to_size().pow(2);
let num_tiles = image.width * image.height / settings.tile_size().to_size().pow(2);
assignment_offsets.insert(name, assignment_offset);
assignment_offset += num_tiles;
}
@ -183,7 +183,7 @@ pub fn include_aseprite_inner(input: TokenStream) -> TokenStream {
let height = frame.height();
assert!(
valid_sprite_size(width, height),
"File {} contains sprites with unrepresentable size {}x{}",
"File {} contains sprites with size {}x{} which cannot be represented on the GameBoy Advance",
filename.display(),
width,
height
@ -290,7 +290,7 @@ fn convert_image(
optimisation_results,
&image,
&image_filename.to_string_lossy(),
settings.tilesize(),
settings.tile_size(),
crate_prefix.to_owned(),
assignment_offset,
)

12
agb/examples/wave.rs
View file

@ -32,10 +32,10 @@ fn main(mut gba: agb::Gba) -> ! {
let back = Mutex::new(RefCell::new(BackCosines { cosines, row: 0 }));
let _a = agb::interrupt::add_interrupt_handler(Interrupt::HBlank, |key: CriticalSection| {
let mut backc = back.borrow(key).borrow_mut();
let deflection = backc.cosines[backc.row % 32];
let mut back = back.borrow(key).borrow_mut();
let deflection = back.cosines[back.row % 32];
unsafe { ((0x0400_0010) as *mut u16).write_volatile(deflection) }
backc.row += 1;
back.row += 1;
});
let vblank = agb::interrupt::VBlank::get();
@ -43,10 +43,10 @@ fn main(mut gba: agb::Gba) -> ! {
loop {
vblank.wait_for_vblank();
free(|key| {
let mut backc = back.borrow(key).borrow_mut();
backc.row = 0;
let mut back = back.borrow(key).borrow_mut();
back.row = 0;
time += 1;
for (r, a) in backc.cosines.iter_mut().enumerate() {
for (r, a) in back.cosines.iter_mut().enumerate() {
let n: FixedNum<8> = (FixedNum::new(r as i32) / 32 + FixedNum::new(time) / 128)
.cos()
* (256 * 4 - 1)

40
agb/src/agb_alloc/block_allocator.rs
View file

@ -67,9 +67,9 @@ impl BlockAllocator {
let mut count = 0;
let mut list_ptr = &mut state.first_free_block;
while let Some(mut curr) = list_ptr {
while let Some(mut current) = list_ptr {
count += 1;
list_ptr = &mut curr.as_mut().next;
list_ptr = &mut current.as_mut().next;
}
count
@ -89,18 +89,18 @@ impl BlockAllocator {
let mut list_ptr = &mut state.first_free_block;
while let Some(mut curr) = list_ptr {
if let Some(next_elem) = curr.as_mut().next {
while let Some(mut current) = list_ptr {
if let Some(next_elem) = current.as_mut().next {
let difference = next_elem
.as_ptr()
.cast::<u8>()
.offset_from(curr.as_ptr().cast::<u8>());
.offset_from(current.as_ptr().cast::<u8>());
let usize_difference: usize = difference
.try_into()
.expect("distances in alloc'd blocks must be positive");
if usize_difference == curr.as_mut().size {
let current = curr.as_mut();
if usize_difference == current.as_mut().size {
let current = current.as_mut();
let next = next_elem.as_ref();
current.size += next.size;
@ -108,7 +108,7 @@ impl BlockAllocator {
continue;
}
}
list_ptr = &mut curr.as_mut().next;
list_ptr = &mut current.as_mut().next;
}
});
}
@ -128,18 +128,18 @@ impl BlockAllocator {
// This iterates the free list until it either finds a block that
// is the exact size requested or a block that can be split into
// one with the desired size and another block header.
while let Some(mut curr) = current_block {
let curr_block = curr.as_mut();
if curr_block.size == full_layout.size() {
*list_ptr = curr_block.next;
return Some(curr.cast());
} else if curr_block.size >= block_after_layout.size() {
while let Some(mut current) = current_block {
let block_to_examine = current.as_mut();
if block_to_examine.size == full_layout.size() {
*list_ptr = block_to_examine.next;
return Some(current.cast());
} else if block_to_examine.size >= block_after_layout.size() {
// can split block
let split_block = Block {
size: curr_block.size - block_after_layout_offset,
next: curr_block.next,
size: block_to_examine.size - block_after_layout_offset,
next: block_to_examine.next,
};
let split_ptr = curr
let split_ptr = current
.as_ptr()
.cast::<u8>()
.add(block_after_layout_offset)
@ -147,10 +147,10 @@ impl BlockAllocator {
*split_ptr = split_block;
*list_ptr = NonNull::new(split_ptr).map(SendNonNull);
return Some(curr.cast());
return Some(current.cast());
}
current_block = curr_block.next;
list_ptr = &mut curr_block.next;
current_block = block_to_examine.next;
list_ptr = &mut block_to_examine.next;
}
self.new_block(layout, key)

26
agb/src/display/affine.rs
View file

@ -1,50 +1,50 @@
#![deny(missing_docs)]
//! # Affine matricies for the Game Boy Advance
//! # Affine matrices for the Game Boy Advance
//!
//! An affine matrix represents an affine transformation, an affine
//! transformation being one which preserves parallel lines (note that this
//! therefore cannot represent perspective seen in games like Super Mario Kart).
//! Affine matricies are used in two places on the GBA, for affine backgrounds
//! Affine matrices are used in two places on the GBA, for affine backgrounds
//! and for affine objects.
//!
//! # Linear Algebra
//! As a matrix, they can be manipulated using linear algebra. The short version
//! of this section is to beware that the matrix is the inverse of the normal
//! transformation matricies.
//! transformation matrices.
//!
//! One quick thing to point out at the start as it will become very relevant is
//! that matrix-matrix multiplication is not commutative, meaning swapping the
//! order changes the result, or **A** × **B** ≢ **B** × **A**. However,
//! matricies are, at least in the case they are used here, associative, meaning
//! matrices are, at least in the case they are used here, associative, meaning
//! (**AB**)**C** = **A**(**BC**).
//!
//! ## Normal (wrong on GBA!) transformation matricies
//! ## Normal (wrong on GBA!) transformation matrices
//!
//! As a start, normal transformation matricies will transform a shape from it's
//! As a start, normal transformation matrices will transform a shape from it's
//! original position to it's new position. Generally when people talk about
//! transformation matricies they are talking about them in this sense.
//! transformation matrices they are talking about them in this sense.
//!
//! > If **A** and **B** are transformation matricies, then matrix **C** = **A**
//! > If **A** and **B** are transformation matrices, then matrix **C** = **A**
//! > × **B** represents the transformation **A** performed on **B**, or
//! > alternatively **C** is transformation **B** followed by transformation
//! > **A**.
//!
//! This is not what they represent on the GBA! If you are looking up more
//! information about tranformation matricies bear this in mind.
//! information about transformation matrices bear this in mind.
//!
//! ## Correct (on GBA) transformation matricies
//! ## Correct (on GBA) transformation matrices
//!
//! On the GBA, the affine matrix works the other way around. The GBA wants to
//! know for each pixel what colour it should render, to do this it applies the
//! affine transformation matrix to the pixel it is rendering to lookup correct
//! pixel in the texture.
//!
//! This describes the inverse of the previously given transformation matricies.
//! This describes the inverse of the previously given transformation matrices.
//!
//! Above I described the matrix **C** = **A** × **B**, but what the GBA wants
//! is the inverse of **C**, or **C**<sup>-1</sup> = (**AB**)<sup>-1</sup> =
//! **B**<sup>-1</sup> × **A**<sup>-1</sup>. This means that if we have the
//! matricies **I** and **J** in the form the GBA expects then
//! matrices **I** and **J** in the form the GBA expects then
//!
//! > Transformation **K** = **I** × **J** is the transformation **I** followed
//! > by the transformation **J**.
@ -278,7 +278,7 @@ impl AffineMatrixBackground {
#[must_use]
/// Creates a transformation matrix using GBA specific syscalls.
/// This can be done using the standard transformation matricies like
/// This can be done using the standard transformation matrices like
///
/// ```rust,no_run
/// # #![no_std]

8
agb/src/display/bitmap4.rs
View file

@ -58,10 +58,10 @@ impl Bitmap4 {
/// index whose colour is specified in the background palette. Panics if (x,
/// y) is out of the bounds of the screen.
pub fn draw_point(&mut self, x: i32, y: i32, colour: u8) {
let disp = DISPLAY_CONTROL.get();
let display = DISPLAY_CONTROL.get();
// get other page
let page = if disp & GraphicsSettings::PAGE_SELECT.bits() != 0 {
let page = if display & GraphicsSettings::PAGE_SELECT.bits() != 0 {
Page::Front
} else {
Page::Back
@ -78,8 +78,8 @@ impl Bitmap4 {
/// Flips page, changing the Gameboy advance to draw the contents of the
/// other page
pub fn flip_page(&mut self) {
let disp = DISPLAY_CONTROL.get();
let swapped = disp ^ GraphicsSettings::PAGE_SELECT.bits();
let display = DISPLAY_CONTROL.get();
let swapped = display ^ GraphicsSettings::PAGE_SELECT.bits();
DISPLAY_CONTROL.set(swapped);
}
}

8
agb/src/display/blend.rs
View file

@ -3,7 +3,7 @@
//! For now a description of how blending can be used is found on [the tonc page
//! for graphic
//! effects](https://www.coranac.com/tonc/text/gfx.htm#ssec-bld-gba). See the
//! [Blend] struct for all the functions to manage blend effects. You accquire
//! [Blend] struct for all the functions to manage blend effects. You acquire
//! the Blend struct through the [Display][super::Display] struct.
//! ```no_run
//! # #![no_main]
@ -28,12 +28,12 @@ pub enum Layer {
Bottom = 1,
}
/// The different blend modes avaliable on the GBA
/// The different blend modes available on the GBA
#[derive(Clone, Copy, Debug)]
pub enum BlendMode {
// No blending
Off = 0,
// Aditive blending, use the [Blend::set_blend_weight] function to use this
// Additive blending, use the [Blend::set_blend_weight] function to use this
Normal = 0b01,
// Brighten, use the [Blend::set_fade] to use this
FadeToWhite = 0b10,
@ -129,7 +129,7 @@ impl Blend {
self
}
/// Reset targers, blend weights, and fades
/// Reset targets, blend weights, and fades
pub fn reset(&mut self) -> &mut Self {
self.reset_targets().reset_fades().reset_weights()
}

20
agb/src/display/object.rs
View file

@ -26,7 +26,7 @@ use attributes::*;
/// Include this type if you call `get_object_controller` in impl block. This
/// helps you use the right lifetimes and doesn't impl Sync (using from two
/// "threads" without syncronisation is not safe), but sending to another
/// "threads" without synchronisation is not safe), but sending to another
/// "thread" is safe.
#[derive(Clone, Copy)]
struct ObjectControllerReference<'a> {
@ -314,7 +314,7 @@ impl TagMap {
/// Gets a tag associated with the name. A tag in aseprite refers to a
/// sequence of sprites with some metadata for how to animate it. You should
/// call this in a constant context so it is evalulated at compile time. It
/// call this in a constant context so it is evaluated at compile time. It
/// is inefficient to call this elsewhere.
/// ```rust,no_run
/// # #![no_std]
@ -348,7 +348,7 @@ impl TagMap {
enum Direction {
Forward,
Backward,
Pingpong,
PingPong,
}
impl Direction {
@ -356,7 +356,7 @@ impl Direction {
match a {
0 => Direction::Forward,
1 => Direction::Backward,
2 => Direction::Pingpong,
2 => Direction::PingPong,
_ => panic!("Invalid direction, this is a bug in image converter or agb"),
}
}
@ -376,7 +376,7 @@ impl Tag {
unsafe { slice::from_raw_parts(self.sprites, self.len) }
}
/// A single sprite refered to by index in the animation sequence.
/// A single sprite referred to by index in the animation sequence.
#[must_use]
pub const fn sprite(&self, idx: usize) -> &'static Sprite {
if idx >= self.len {
@ -400,7 +400,7 @@ impl Tag {
match self.direction {
Direction::Forward => self.sprite(idx % self.len),
Direction::Backward => self.sprite(len_sub_1 - (idx % self.len)),
Direction::Pingpong => self.sprite(
Direction::PingPong => self.sprite(
(((idx + len_sub_1) % (len_sub_1 * 2)) as isize - len_sub_1 as isize)
.unsigned_abs(),
),
@ -667,7 +667,7 @@ struct ObjectInner {
}
struct ObjectControllerStatic {
_free_affine_matricies: Vec<u8>,
_free_affine_matrices: Vec<u8>,
free_object: Vec<u8>,
shadow_oam: Vec<Option<ObjectInner>>,
z_order: Vec<u8>,
@ -680,7 +680,7 @@ impl ObjectControllerStatic {
shadow_oam: (0..128).map(|_| None).collect(),
z_order: (0..128).collect(),
free_object: (0..128).collect(),
_free_affine_matricies: (0..32).collect(),
_free_affine_matrices: (0..32).collect(),
sprite_controller: SpriteControllerInner::new(),
}
}
@ -1033,7 +1033,7 @@ impl<'a> Object<'a> {
self
}
/// Sets the z priority of the sprite. Higher priority will be dislayed
/// Sets the z priority of the sprite. Higher priority will be displayed
/// above background layers with lower priorities. No change will be seen
/// until [ObjectController::commit] is called.
pub fn set_priority(&mut self, priority: Priority) -> &mut Self {
@ -1067,7 +1067,7 @@ impl<'a> Object<'a> {
}
/// Sets the z position of the sprite, this controls which sprites are above
/// eachother. No change will be seen until [ObjectController::commit] is
/// each other. No change will be seen until [ObjectController::commit] is
/// called.
pub fn set_z(&mut self, z: i32) -> &mut Self {
{

8
agb/src/display/window.rs
View file

@ -128,8 +128,8 @@ impl Window {
/// Sets whether the blend is enabled inside of this window, must call
/// [Windows::commit] for this change to be seen.
#[inline(always)]
pub fn set_blend_enable(&mut self, blnd: bool) -> &mut Self {
self.set_bit(5, blnd);
pub fn set_blend_enable(&mut self, blend: bool) -> &mut Self {
self.set_bit(5, blend);
self
}
@ -204,8 +204,8 @@ impl MovableWindow {
/// Sets whether the blend is enabled inside of this window, must call
/// [Windows::commit] for this change to be seen.
#[inline(always)]
pub fn set_blend_enable(&mut self, blnd: bool) -> &mut Self {
self.inner.set_blend_enable(blnd);
pub fn set_blend_enable(&mut self, blend: bool) -> &mut Self {
self.inner.set_blend_enable(blend);
self
}
/// Sets whether the given background will be rendered inside this window,

4
agb/src/hash_map.rs
View file

@ -27,7 +27,7 @@ type HashType = u32;
// The key concept is to keep the distance from the initial bucket chosen for a given
// key to a minimum. We shall call this distance the "distance to the initial bucket"
// or DIB for short. With each key - value pair, we store its DIB. When inserting
// a value into the hashtable, we check to see if there is an element in the initial
// a value into the hash table, we check to see if there is an element in the initial
// bucket. If there is, we move onto the next value. Then, we check to see if there
// is already a value there and if there is, we check its DIB. If our DIB is greater
// than or equal to the DIB of the value that is already there, we swap the working
@ -942,7 +942,7 @@ impl<K, V> Node<K, V> {
let old_value = mem::replace(&mut self.value, MaybeUninit::new(value));
unsafe { old_value.assume_init() }
} else {
panic!("Cannot replace an unininitalised node");
panic!("Cannot replace an uninitialised node");
}
}

2
agb/src/input.rs
View file

@ -66,7 +66,7 @@ bitflags! {
const BUTTON_INPUT: *mut u16 = (0x04000130) as *mut u16;
// const BUTTON_INTURRUPT: *mut u16 = (0x04000132) as *mut u16;
// const BUTTON_INTERRUPT: *mut u16 = (0x04000132) as *mut u16;
/// Helper to make it easy to get the current state of the GBA's buttons.
///

2
agb/src/interrupt.rs
View file

@ -312,7 +312,7 @@ where
pub struct VBlank {}
impl VBlank {
/// Handles setting up everything reqired to be able to use the wait for
/// Handles setting up everything required to be able to use the wait for
/// interrupt syscall.
#[must_use]
pub fn get() -> Self {

6
agb/src/lib.rs
View file

@ -437,11 +437,11 @@ mod test {
let address = iwram_ptr as usize;
assert!(
(0x0300_0000..0x0300_8000).contains(&address),
"iwram is located beween 0x0300_0000 and 0x0300_8000, but was actually found to be at {:#010X}",
"iwram is located between 0x0300_0000 and 0x0300_8000, but was actually found to be at {:#010X}",
address
);
let c = iwram_ptr.read_volatile();
assert_eq!(c, 9, "exctected content to be 9");
assert_eq!(c, 9, "expected content to be 9");
iwram_ptr.write_volatile(u32::MAX);
let c = iwram_ptr.read_volatile();
assert_eq!(c, u32::MAX, "expected content to be {}", u32::MAX);
@ -460,7 +460,7 @@ mod test {
address
);
let c = iwram_ptr.read_volatile();
assert_eq!(c, 9, "exctected content to be 9");
assert_eq!(c, 9, "expected content to be 9");
iwram_ptr.write_volatile(u32::MAX);
let c = iwram_ptr.read_volatile();
assert_eq!(c, u32::MAX, "expected content to be {}", u32::MAX);

6
agb/src/save/asm_routines.s
View file

@ -36,14 +36,14 @@ agb_thumb_end agb_rs__WramVerifyBuf
@
@ void WramXferBuf(const char* source, char* dest, int count);
@ void WramTransferBuf(const char* source, char* dest, int count);
@
@ A routine that copies one buffer into another.
@
agb_thumb_func agb_rs__WramXferBuf
agb_thumb_func agb_rs__WramTransferBuf
0: sub r2, #1
ldrb r3, [r0,r2]
strb r3, [r1,r2]
bne 0b
bx lr
agb_thumb_end agb_rs__WramXferBuf
agb_thumb_end agb_rs__WramTransferBuf

6
agb/src/save/asm_utils.rs
View file

@ -3,7 +3,7 @@
//! performed via code in WRAM and cannot be accessed by DMA.
extern "C" {
fn agb_rs__WramXferBuf(src: *const u8, dst: *mut u8, count: usize);
fn agb_rs__WramTransferBuf(src: *const u8, dst: *mut u8, count: usize);
fn agb_rs__WramReadByte(src: *const u8) -> u8;
fn agb_rs__WramVerifyBuf(buf1: *const u8, buf2: *const u8, count: usize) -> bool;
}
@ -18,7 +18,7 @@ extern "C" {
#[inline(always)]
pub unsafe fn read_raw_buf(dst: &mut [u8], src: usize) {
if !dst.is_empty() {
agb_rs__WramXferBuf(src as _, dst.as_mut_ptr(), dst.len());
agb_rs__WramTransferBuf(src as _, dst.as_mut_ptr(), dst.len());
}
}
@ -31,7 +31,7 @@ pub unsafe fn read_raw_buf(dst: &mut [u8], src: usize) {
#[inline(always)]
pub unsafe fn write_raw_buf(dst: usize, src: &[u8]) {
if !src.is_empty() {
agb_rs__WramXferBuf(src.as_ptr(), dst as _, src.len());
agb_rs__WramTransferBuf(src.as_ptr(), dst as _, src.len());
}
}

8
agb/src/save/eeprom.rs
View file

@ -61,14 +61,14 @@ impl BufferData {
/// Reads a number from the input buffer.
fn read_num(&mut self, off: usize, count: usize) -> u32 {
let mut accum = 0;
let mut accumulator = 0;
unsafe {
for i in 0..count {
accum <<= 1;
accum |= self.data.bits[off + i] as u32;
accumulator <<= 1;
accumulator |= self.data.bits[off + i] as u32;
}
}
accum
accumulator
}
/// Receives a number of words into the input buffer.

8
agb/src/save/mod.rs
View file

@ -44,8 +44,8 @@
//! [`SaveManager::access_with_timer`] methods to create a new [`SaveData`]
//! object. Its methods are used to read or write save media.
//!
//! Reading data from the savegame is simple. Use [`read`] to copy data from an
//! offset in the savegame into a buffer in memory.
//! Reading data from the save media is simple. Use [`read`] to copy data from an
//! offset in the save media into a buffer in memory.
//!
//! Writing to save media requires you to prepare the area for writing by
//! calling the [`prepare_write`] method to return a [`SavePreparedBlock`],
@ -185,7 +185,7 @@ fn set_save_implementation(access_impl: &'static dyn RawSaveAccess) {
let mut access = CURRENT_SAVE_ACCESS.lock();
assert!(
access.is_none(),
"Cannot initialize the savegame engine more than once."
"Cannot initialize the save media engine more than once."
);
*access = Some(access_impl);
}
@ -202,7 +202,7 @@ pub struct SaveData {
timeout: utils::Timeout,
}
impl SaveData {
/// Creates a new save accessor around the current save implementaiton.
/// Creates a new save accessor around the current save implementation.
fn new(timer: Option<Timer>) -> Result<SaveData, Error> {
match get_save_implementation() {
Some(access) => Ok(SaveData {

8
agb/src/sound/mixer/hw.rs
View file

@ -22,8 +22,8 @@ const DMA2_SOURCE_ADDR: MemoryMapped<u32> = unsafe { MemoryMapped::new(dma_sourc
const DMA2_DEST_ADDR: MemoryMapped<u32> = unsafe { MemoryMapped::new(dma_dest_addr(2)) };
const DMA2_CONTROL: MemoryMapped<u16> = unsafe { MemoryMapped::new(dma_control_addr(2)) };
const FIFOA_DEST_ADDR: u32 = 0x0400_00a0;
const FIFOB_DEST_ADDR: u32 = 0x0400_00a4;
const FIFO_A_DEST_ADDR: u32 = 0x0400_00a0;
const FIFO_B_DEST_ADDR: u32 = 0x0400_00a4;
const SOUND_CONTROL: MemoryMapped<u16> = unsafe { MemoryMapped::new(0x0400_0082) };
const SOUND_CONTROL_X: MemoryMapped<u16> = unsafe { MemoryMapped::new(0x0400_0084) };
@ -56,14 +56,14 @@ pub(super) fn enable_dma_for_sound(sound_memory: &[i8], lr: LeftOrRight) {
fn enable_dma1_for_sound(sound_memory: &[i8]) {
DMA1_CONTROL.set(0);
DMA1_SOURCE_ADDR.set(sound_memory.as_ptr() as u32);
DMA1_DEST_ADDR.set(FIFOA_DEST_ADDR);
DMA1_DEST_ADDR.set(FIFO_A_DEST_ADDR);
DMA1_CONTROL.set(DMA_CONTROL_SETTING_FOR_SOUND);
}
fn enable_dma2_for_sound(sound_memory: &[i8]) {
DMA2_CONTROL.set(0);
DMA2_SOURCE_ADDR.set(sound_memory.as_ptr() as u32);
DMA2_DEST_ADDR.set(FIFOB_DEST_ADDR);
DMA2_DEST_ADDR.set(FIFO_B_DEST_ADDR);
DMA2_CONTROL.set(DMA_CONTROL_SETTING_FOR_SOUND);
}

2
agb/src/sound/mixer/mod.rs
View file

@ -306,7 +306,7 @@ impl SoundChannel {
/// Creates a new high priority [`SoundChannel`].
///
/// A high priority sound channel will override low priority ones if
/// the mixer runs out of channels. They will also never be overriden
/// the mixer runs out of channels. They will also never be overridden
/// by other high priority channels.
///
/// High priority channels are intended for background music and for

2
agb/src/sound/mod.rs
View file

@ -6,7 +6,7 @@
//! which allows for Game Boy and Game Boy Color style sound effects, or the mixer
//! which allows for more advanced sounds.
//!
//! The [`dmg`](crate::sound::dmg) module is very rudimentry and doesn't support most of the possible
//! The [`dmg`](crate::sound::dmg) module is very rudimentary and doesn't support most of the possible
//! sounds possible. However, it may be expanded in the future.
//!
//! The [`mixer`](crate::sound::mixer) module is high performance, and allows for playing wav files at

2
agb/src/sync/locks.rs
View file

@ -26,7 +26,7 @@ impl RawMutex {
/// Locks the mutex and returns whether a lock was successfully acquired.
fn raw_lock(&self) -> bool {
if self.0.replace(true) {
// value was already true, opps.
// value was already true, oops.
false
} else {
// prevent any weird reordering, and continue

2
book/src/setup/setup.md
View file

@ -3,4 +3,4 @@
Environment setup will depend on the platform you are using.
agb's requirements are [rust nightly](https://www.rust-lang.org/) edition and the gnu binutils for `arm-none-eabi`.
See the subpages here for platform specific setup guides.
See the sub-pages here for platform specific setup guides.

4
examples/hyperspace-roll/src/customise.rs
View file

@ -280,12 +280,12 @@ pub(crate) fn customise_screen(
}
}
CustomiseState::Upgrade => {
let old_updade = cursor.upgrade;
let old_upgrade = cursor.upgrade;
cursor.upgrade = (cursor.upgrade as isize + ud as isize)
.rem_euclid(upgrades.len() as isize) as usize;
if (upgrades[cursor.upgrade] as u32) < 17 {
if cursor.upgrade != old_updade {
if cursor.upgrade != old_upgrade {
load_description(
upgrades[cursor.upgrade] as usize,
descriptions_map,

8
examples/hyperspace-roll/src/graphics.rs
View file

@ -37,8 +37,8 @@ impl FaceSprites {
const S_MALFUNCTION: &Sprite = SPRITES.tags().get("malfunction").sprite(0);
const S_HEAL: &Sprite = SPRITES.tags().get("player_heal").sprite(0);
const S_BYPASS: &Sprite = SPRITES.tags().get("shield bypass").sprite(0);
const S_DOUBLESHOT: &Sprite = SPRITES.tags().get("double shoot").sprite(0);
const S_TRIPLESHOT: &Sprite = SPRITES.tags().get("triple shoot").sprite(0);
const S_DOUBLE_SHOT: &Sprite = SPRITES.tags().get("double shoot").sprite(0);
const S_TRIPLE_SHOT: &Sprite = SPRITES.tags().get("triple shoot").sprite(0);
const S_BLANK: &Sprite = SPRITES.tags().get("blank").sprite(0);
const S_DISRUPT: &Sprite = SPRITES.tags().get("disruption").sprite(0);
const S_MALFUNCTION_SHOOT: &Sprite = SPRITES.tags().get("malfunction shot").sprite(0);
@ -57,8 +57,8 @@ impl FaceSprites {
S_MALFUNCTION,
S_HEAL,
S_BYPASS,
S_DOUBLESHOT,
S_TRIPLESHOT,
S_DOUBLE_SHOT,
S_TRIPLE_SHOT,
S_BLANK,
S_DISRUPT,
S_MALFUNCTION_SHOOT,

17
examples/hyperspace-roll/src/save.rs
View file

@ -1,8 +1,8 @@
use agb::Gba;
use agb::save::Error;
use agb::sync::Static;
use agb::Gba;
static HIGHSCORE: Static<u32> = Static::new(0);
static HIGH_SCORE: Static<u32> = Static::new(0);
pub fn init_save(gba: &mut Gba) -> Result<(), Error> {
gba.save.init_sram();
@ -22,9 +22,9 @@ pub fn init_save(gba: &mut Gba) -> Result<(), Error> {
let high_score = u32::from_le_bytes(buffer);
if high_score > 100 {
HIGHSCORE.write(0)
HIGH_SCORE.write(0)
} else {
HIGHSCORE.write(high_score)
HIGH_SCORE.write(high_score)
}
}
@ -32,11 +32,14 @@ pub fn init_save(gba: &mut Gba) -> Result<(), Error> {
}
pub fn load_high_score() -> u32 {
HIGHSCORE.read()
HIGH_SCORE.read()
}
pub fn save_high_score(gba: &mut Gba, score: u32) -> Result<(), Error> {
gba.save.access()?.prepare_write(1..5)?.write(1, &score.to_le_bytes())?;
HIGHSCORE.write(score);
gba.save
.access()?
.prepare_write(1..5)?
.write(1, &score.to_le_bytes())?;
HIGH_SCORE.write(score);
Ok(())
}

4
examples/the-purple-night/build.rs
View file

@ -77,8 +77,8 @@ fn extract_tiles(layer: &'_ tiled::LayerData) -> impl Iterator<Item = u16> + '_
.map(get_map_id)
}
fn get_map_id(tileid: u32) -> u16 {
match tileid {
fn get_map_id(tile_id: u32) -> u16 {
match tile_id {
0 => 0,
i => i as u16 - 1,
}

50
examples/the-purple-night/src/main.rs
View file

@ -33,17 +33,17 @@ use sfx::Sfx;
const GRAPHICS: &Graphics = agb::include_aseprite!("gfx/objects.aseprite", "gfx/boss.aseprite");
const TAG_MAP: &TagMap = GRAPHICS.tags();
const LONGSWORD_IDLE: &Tag = TAG_MAP.get("Idle - longsword");
const LONGSWORD_WALK: &Tag = TAG_MAP.get("Walk - longsword");
const LONGSWORD_JUMP: &Tag = TAG_MAP.get("Jump - longsword");
const LONGSWORD_ATTACK: &Tag = TAG_MAP.get("Attack - longsword");
const LONGSWORD_JUMP_ATTACK: &Tag = TAG_MAP.get("Jump attack - longsword");
const LONG_SWORD_IDLE: &Tag = TAG_MAP.get("Idle - longsword");
const LONG_SWORD_WALK: &Tag = TAG_MAP.get("Walk - longsword");
const LONG_SWORD_JUMP: &Tag = TAG_MAP.get("Jump - longsword");
const LONG_SWORD_ATTACK: &Tag = TAG_MAP.get("Attack - longsword");
const LONG_SWORD_JUMP_ATTACK: &Tag = TAG_MAP.get("Jump attack - longsword");
const SHORTSWORD_IDLE: &Tag = TAG_MAP.get("Idle - shortsword");
const SHORTSWORD_WALK: &Tag = TAG_MAP.get("Walk - shortsword");
const SHORTSWORD_JUMP: &Tag = TAG_MAP.get("jump - shortsword");
const SHORTSWORD_ATTACK: &Tag = TAG_MAP.get("attack - shortsword");
const SHORTSWORD_JUMP_ATTACK: &Tag = TAG_MAP.get("jump attack - shortsword");
const SHORT_SWORD_IDLE: &Tag = TAG_MAP.get("Idle - shortsword");
const SHORT_SWORD_WALK: &Tag = TAG_MAP.get("Walk - shortsword");
const SHORT_SWORD_JUMP: &Tag = TAG_MAP.get("jump - shortsword");
const SHORT_SWORD_ATTACK: &Tag = TAG_MAP.get("attack - shortsword");
const SHORT_SWORD_JUMP_ATTACK: &Tag = TAG_MAP.get("jump attack - shortsword");
const KNIFE_IDLE: &Tag = TAG_MAP.get("idle - knife");
const KNIFE_WALK: &Tag = TAG_MAP.get("walk - knife");
@ -166,7 +166,7 @@ struct Entity<'a> {
impl<'a> Entity<'a> {
fn new(object_controller: &'a ObjectController, collision_mask: Rect<u16>) -> Self {
let s = object_controller.sprite(LONGSWORD_IDLE.sprite(0));
let s = object_controller.sprite(LONG_SWORD_IDLE.sprite(0));
let mut sprite = object_controller.object(s);
sprite.set_priority(Priority::P1);
Entity {
@ -353,16 +353,16 @@ impl SwordState {
fn idle_animation(self, counter: u16) -> &'static Sprite {
let counter = counter as usize;
match self {
SwordState::LongSword => LONGSWORD_IDLE.animation_sprite(counter / 8),
SwordState::ShortSword => SHORTSWORD_IDLE.animation_sprite(counter / 8),
SwordState::LongSword => LONG_SWORD_IDLE.animation_sprite(counter / 8),
SwordState::ShortSword => SHORT_SWORD_IDLE.animation_sprite(counter / 8),
SwordState::Dagger => KNIFE_IDLE.animation_sprite(counter / 8),
SwordState::Swordless => SWORDLESS_IDLE.animation_sprite(counter / 8),
}
}
fn jump_tag(self) -> &'static Tag {
match self {
SwordState::LongSword => LONGSWORD_JUMP,
SwordState::ShortSword => SHORTSWORD_JUMP,
SwordState::LongSword => LONG_SWORD_JUMP,
SwordState::ShortSword => SHORT_SWORD_JUMP,
SwordState::Dagger => KNIFE_JUMP,
SwordState::Swordless => SWORDLESS_JUMP,
}
@ -370,8 +370,8 @@ impl SwordState {
fn walk_animation(self, counter: u16) -> &'static Sprite {
let counter = counter as usize;
match self {
SwordState::LongSword => LONGSWORD_WALK.animation_sprite(counter / 4),
SwordState::ShortSword => SHORTSWORD_WALK.animation_sprite(counter / 4),
SwordState::LongSword => LONG_SWORD_WALK.animation_sprite(counter / 4),
SwordState::ShortSword => SHORT_SWORD_WALK.animation_sprite(counter / 4),
SwordState::Dagger => KNIFE_WALK.animation_sprite(counter / 4),
SwordState::Swordless => SWORDLESS_WALK.animation_sprite(counter / 4),
}
@ -402,8 +402,8 @@ impl SwordState {
}
fn jump_attack_tag(self) -> &'static Tag {
match self {
SwordState::LongSword => LONGSWORD_JUMP_ATTACK,
SwordState::ShortSword => SHORTSWORD_JUMP_ATTACK,
SwordState::LongSword => LONG_SWORD_JUMP_ATTACK,
SwordState::ShortSword => SHORT_SWORD_JUMP_ATTACK,
SwordState::Dagger => KNIFE_JUMP_ATTACK,
SwordState::Swordless => SWORDLESS_JUMP_ATTACK,
}
@ -425,8 +425,8 @@ impl SwordState {
}
fn attack_tag(self) -> &'static Tag {
match self {
SwordState::LongSword => LONGSWORD_ATTACK,
SwordState::ShortSword => SHORTSWORD_ATTACK,
SwordState::LongSword => LONG_SWORD_ATTACK,
SwordState::ShortSword => SHORT_SWORD_ATTACK,
SwordState::Dagger => KNIFE_ATTACK,
SwordState::Swordless => SWORDLESS_ATTACK,
}
@ -539,7 +539,7 @@ impl<'a> Player<'a> {
object_controller,
Rect::new((0_u16, 0_u16).into(), (4_u16, 12_u16).into()),
);
let s = object_controller.sprite(LONGSWORD_IDLE.sprite(0));
let s = object_controller.sprite(LONG_SWORD_IDLE.sprite(0));
entity.sprite.set_sprite(s);
entity.sprite.show();
entity.position = (144, 0).into();
@ -739,7 +739,7 @@ impl<'a> Player<'a> {
instruction
}
// retuns true if the player is alive and false otherwise
// returns true if the player is alive and false otherwise
fn damage(&mut self) -> (bool, bool) {
if self.damage_cooldown != 0 {
return (true, false);
@ -1284,9 +1284,9 @@ impl EmuData {
let gravity = gravity / 16;
entity.velocity.y += gravity;
let distance_travelled = entity.update_position(level);
let distance_traveled = entity.update_position(level);
if distance_travelled.x == 0.into() {
if distance_traveled.x == 0.into() {
sfx.emu_crash();
self.state = EmuState::Knockback;
entity.velocity = (-direction / 2, Number::new(-1)).into();

2
mgba-test-runner/build.rs
View file

@ -26,7 +26,7 @@ fn main() {
.compile("test-runner");
println!("cargo:rustc-link-search={}", out_path.to_str().unwrap());
println!("cargo:rustc-link-lib=static={}", "mgba-cycle");
println!("cargo:rustc-link-lib=static=mgba-cycle");
println!("cargo:rustc-link-lib=elf");
let bindings = bindgen::Builder::default()

6
mgba-test-runner/src/main.rs
View file

@ -14,7 +14,7 @@ use std::path::Path;
enum Status {
Running,
Failed,
Sucess,
Success,
}
enum Timing {
@ -84,7 +84,7 @@ fn test_file(file_to_run: &str) -> Status {
}
if out == "Tests finished successfully" {
finished = Status::Sucess;
finished = Status::Success;
}
}
});
@ -111,7 +111,7 @@ fn main() -> Result<(), Error> {
match output {
Status::Failed => Err(anyhow!("Tests failed!")),
Status::Sucess => Ok(()),
Status::Success => Ok(()),
_ => {
unreachable!("very bad thing happened");
}

2
tools/src/release.rs
View file

@ -129,7 +129,7 @@ fn update_to_version(
toml_edit::Item::None => continue,
_ => {
return Err(Error::InvalidToml(format!(
"{:?} while seaching dependencies in {}",
"{:?} while searching dependencies in {}",
this_dep,
cargo_toml_file.to_string_lossy()
)))