yyc12345/BallanceTasToolbox
1
0
Fork 0
Code Activity

feat: remove fps support from rust to python

Browse Source
This commit is contained in:
yyc12345
2026-01-19 09:34:16 +08:00
parent 06482e2218
commit 85fc2ad3ce
9 changed files with 3 additions and 280 deletions
Download Patch File Download Diff File Expand all files Collapse all files

0
BallanceTasSonnet/BallanceTasSonnet/__init__.py → BallanceTasSonnet/DEVNOTES.md
View File

0
BallanceTasSonnet/python/blctas/__init__.py Normal file
View File

0
BallanceTasSonnet/python/blctas/ballance.py Normal file
View File

0
BallanceTasSonnet/python/blctas/datupd.py Normal file
View File

0
BallanceTasSonnet/python/blctas/fps.py Normal file
View File

0
BallanceTasSonnet/python/blctas/tasfile.py Normal file
View File

0
BallanceTasSonnet/python/blctas/tassupt.py Normal file
View File

250
BallanceTasSonnet/src/lib.rs
View File

@@ -54,80 +54,6 @@ mod tasfile {
}
}
// #[pyclass]
// #[derive(Clone)]
// pub struct PyTasFrame {
// inner: TasFrame,
// }
// // Constructor for PyTasFrame
// impl PyTasFrame {
// fn new_from_inner(inner: TasFrame) -> Self {
// PyTasFrame { inner }
// }
// }
// #[pymethods]
// impl PyTasFrame {
// #[new]
// fn new(delta_time: f32, key_flags: u32) -> PyTasFrame {
// PyTasFrame::new_from_inner(TasFrame::new(delta_time, key_flags))
// }
// #[staticmethod]
// fn with_fps(fps: f32) -> PyResult<PyTasFrame> {
// match TasFrame::with_fps(fps) {
// Ok(frame) => Ok(PyTasFrame::new_from_inner(frame)),
// Err(e) => Err(PyErr::new::<pyo3::exceptions::PyValueError, _>(
// e.to_string(),
// )),
// }
// }
// #[getter]
// fn get_delta_time(&self) -> f32 {
// self.inner.get_delta_time()
// }
// fn get_fps(&self) -> PyResult<f32> {
// match self.inner.get_fps() {
// Ok(fps) => Ok(fps),
// Err(e) => Err(PyErr::new::<pyo3::exceptions::PyValueError, _>(
// e.to_string(),
// )),
// }
// }
// fn set_delta_time(&mut self, delta_time: f32) {
// self.inner.set_delta_time(delta_time);
// }
// fn set_fps(&mut self, fps: f32) -> PyResult<()> {
// match self.inner.set_fps(fps) {
// Ok(()) => Ok(()),
// Err(e) => Err(PyErr::new::<pyo3::exceptions::PyValueError, _>(
// e.to_string(),
// )),
// }
// }
// fn is_key_pressed(&self, key: PyTasKey) -> bool {
// self.inner.is_key_pressed(key.into())
// }
// fn set_key_pressed(&mut self, key: PyTasKey, pressed: bool) {
// self.inner.set_key_pressed(key.into(), pressed);
// }
// fn flip_key_pressed(&mut self, key: PyTasKey) {
// self.inner.flip_key_pressed(key.into());
// }
// fn clear_key_pressed(&mut self) {
// self.inner.clear_key_pressed();
// }
// }
#[pyclass]
#[derive(Debug)]
struct TasFile {
@@ -158,18 +84,10 @@ mod tasfile {
Ok(self.inner.visit(index)?.get_delta_time())
}
fn get_fps(&self, index: usize) -> PyResult<f32> {
Ok(self.inner.visit(index)?.get_fps()?)
}
fn set_delta_time(&mut self, index: usize, delta_time: f32) -> PyResult<()> {
Ok(self.inner.visit_mut(index)?.set_delta_time(delta_time))
}
fn set_fps(&mut self, index: usize, fps: f32) -> PyResult<()> {
Ok(self.inner.visit_mut(index)?.set_fps(fps)?)
}
fn is_key_pressed(&self, index: usize, key: TasKey) -> PyResult<bool> {
Ok(self.inner.visit(index)?.is_key_pressed(key.into()))
}
@@ -197,13 +115,6 @@ mod tasfile {
Ok(())
}
fn batchly_set_fps(&mut self, index_from: usize, index_to: usize, fps: f32) -> PyResult<()> {
for frame in self.inner.batchly_visit_mut(index_from, index_to)? {
frame.set_fps(fps)?;
}
Ok(())
}
fn batchly_set_key_pressed(&mut self, index_from: usize, index_to: usize, key: TasKey, pressed: bool) -> PyResult<()> {
for frame in self.inner.batchly_visit_mut(index_from, index_to)? {
frame.set_key_pressed(key.into(), pressed);
@@ -229,26 +140,16 @@ mod tasfile {
// region: Modify
fn append_with_delta_time(&mut self, count: usize, delta_time: f32) -> PyResult<()> {
fn append(&mut self, count: usize, delta_time: f32) -> PyResult<()> {
let frames = vec![RsTasFrame::with_delta_time(delta_time); count];
Ok(self.inner.append(&frames))
}
fn append_with_fps(&mut self, count: usize, fps: f32) -> PyResult<()> {
let frames = vec![RsTasFrame::with_fps(fps)?; count];
Ok(self.inner.append(&frames))
}
fn insert_with_delta_time(&mut self, index: usize, count: usize, delta_time: f32) -> PyResult<()> {
fn insert(&mut self, index: usize, count: usize, delta_time: f32) -> PyResult<()> {
let frames = vec![RsTasFrame::with_delta_time(delta_time); count];
Ok(self.inner.insert(index, &frames)?)
}
fn insert_with_fps(&mut self, index: usize, count: usize, fps: f32) -> PyResult<()> {
let frames = vec![RsTasFrame::with_fps(fps)?; count];
Ok(self.inner.insert(index, &frames)?)
}
fn remove(&mut self, index_from: usize, index_to: usize) -> PyResult<()> {
Ok(self.inner.remove(index_from, index_to)?)
}
@@ -257,15 +158,10 @@ mod tasfile {
}
#[pyfunction]
fn create_with_delta_time(count: usize, delta_time: f32) -> PyResult<TasFile> {
fn create(count: usize, delta_time: f32) -> PyResult<TasFile> {
Ok(TasFile { inner: RsTasFile::new(vec![RsTasFrame::with_delta_time(delta_time); count]) })
}
#[pyfunction]
fn create_with_fps(count: usize, fps: f32) -> PyResult<TasFile> {
Ok(TasFile { inner: RsTasFile::new(vec![RsTasFrame::with_fps(fps)?; count]) })
}
#[pyfunction]
fn load(filename: &str) -> PyResult<TasFile> {
Ok(TasFile { inner: RsTasFile::load(filename)? })
@@ -276,144 +172,4 @@ mod tasfile {
Ok(file.inner.save(filename)?)
}
// #[pyclass]
// pub struct PyTasFile {
// inner: InternalTasFile,
// }
// // Constructor for PyTasFile
// impl PyTasFile {
// fn new_from_inner(inner: InternalTasFile) -> Self {
// PyTasFile { inner }
// }
// }
// #[pymethods]
// impl PyTasFile {
// #[new]
// fn new(frames: Option<Vec<PyTasFrame>>) -> PyTasFile {
// let frames = frames.unwrap_or_else(|| vec![]);
// let inner_frames = frames.into_iter().map(|f| f.inner).collect();
// PyTasFile::new_from_inner(InternalTasFile::new(inner_frames))
// }
// #[staticmethod]
// fn from_brandnew(count: usize, frame: PyTasFrame) -> PyTasFile {
// PyTasFile::new_from_inner(InternalTasFile::from_brandnew(count, frame.inner))
// }
// #[staticmethod]
// fn from_brandnew_with_fps(count: usize, fps: f32) -> PyResult<PyTasFile> {
// match InternalTasFile::from_brandnew_with_fps(count, fps) {
// Ok(file) => Ok(PyTasFile::new_from_inner(file)),
// Err(e) => Err(PyErr::new::<pyo3::exceptions::PyValueError, _>(
// e.to_string(),
// )),
// }
// }
// #[staticmethod]
// fn load(filename: &str) -> PyResult<PyTasFile> {
// match InternalTasFile::load(filename) {
// Ok(file) => Ok(PyTasFile::new_from_inner(file)),
// Err(e) => Err(PyErr::new::<pyo3::exceptions::PyIOError, _>(e.to_string())),
// }
// }
// fn save(&self, filename: &str) -> PyResult<()> {
// match self.inner.save(filename) {
// Ok(()) => Ok(()),
// Err(e) => Err(PyErr::new::<pyo3::exceptions::PyIOError, _>(e.to_string())),
// }
// }
// fn clear(&mut self) {
// self.inner.clear();
// }
// #[getter]
// fn get_count(&self) -> usize {
// self.inner.get_count()
// }
// fn is_empty(&self) -> bool {
// self.inner.is_empty()
// }
// fn visit(&self, index: usize) -> PyResult<PyTasFrame> {
// match self.inner.visit(index) {
// Ok(frame) => Ok(PyTasFrame::new_from_inner(*frame)),
// Err(e) => Err(PyErr::new::<pyo3::exceptions::PyIndexError, _>(
// e.to_string(),
// )),
// }
// }
// fn visit_mut(&mut self, index: usize) -> PyResult<PyTasFrame> {
// match self.inner.visit_mut(index) {
// Ok(frame) => Ok(PyTasFrame::new_from_inner((*frame).clone())),
// Err(e) => Err(PyErr::new::<pyo3::exceptions::PyIndexError, _>(
// e.to_string(),
// )),
// }
// }
// fn batchly_visit(&self, index_from: usize, index_to: usize) -> PyResult<Vec<PyTasFrame>> {
// match self.inner.batchly_visit(index_from, index_to) {
// Ok(frames) => {
// let py_frames: Vec<PyTasFrame> = frames
// .iter()
// .map(|f| PyTasFrame::new_from_inner(*f))
// .collect();
// Ok(py_frames)
// }
// Err(e) => Err(PyErr::new::<pyo3::exceptions::PyIndexError, _>(
// e.to_string(),
// )),
// }
// }
// fn batchly_visit_mut(
// &mut self,
// index_from: usize,
// index_to: usize,
// ) -> PyResult<Vec<PyTasFrame>> {
// match self.inner.batchly_visit_mut(index_from, index_to) {
// Ok(frames) => {
// let py_frames: Vec<PyTasFrame> = frames
// .iter()
// .map(|f| PyTasFrame::new_from_inner((*f).clone()))
// .collect();
// Ok(py_frames)
// }
// Err(e) => Err(PyErr::new::<pyo3::exceptions::PyIndexError, _>(
// e.to_string(),
// )),
// }
// }
// fn append(&mut self, frames: Vec<PyTasFrame>) {
// let inner_frames: Vec<TasFrame> = frames.into_iter().map(|f| f.inner).collect();
// self.inner.append(&inner_frames);
// }
// fn insert(&mut self, index: usize, frames: Vec<PyTasFrame>) -> PyResult<()> {
// let inner_frames: Vec<TasFrame> = frames.into_iter().map(|f| f.inner).collect();
// match self.inner.insert(index, &inner_frames) {
// Ok(()) => Ok(()),
// Err(e) => Err(PyErr::new::<pyo3::exceptions::PyIndexError, _>(
// e.to_string(),
// )),
// }
// }
// fn remove(&mut self, index_from: usize, index_to: usize) -> PyResult<()> {
// match self.inner.remove(index_from, index_to) {
// Ok(()) => Ok(()),
// Err(e) => Err(PyErr::new::<pyo3::exceptions::PyIndexError, _>(
// e.to_string(),
// )),
// }
// }
// }
}

33
BallanceTasSonnet/src/wrapped/tasfile.rs
View File

@@ -8,11 +8,6 @@ use thiserror::Error as TeError;
#[derive(Debug, TeError)]
pub enum Error {
#[error("delta time should not be zero or negative value")]
BadDeltaTime,
#[error("fps should should not be zero or negative value")]
BadFps,
#[error("given index is out of range")]
IndexOutOfRange,
#[error("arithmetic overflow")]
@@ -61,44 +56,16 @@ impl TasFrame {
pub fn with_delta_time(delta_time: f32) -> Self {
Self::new(delta_time, 0u32)
}
pub fn with_fps(fps: f32) -> Result<Self> {
Ok(Self::with_delta_time(Self::to_delta_time(fps)?))
}
}
impl TasFrame {
fn to_fps(delta_time: f32) -> Result<f32> {
if delta_time <= 0f32 {
Err(Error::BadDeltaTime)
} else {
Ok(1f32 / delta_time)
}
}
fn to_delta_time(fps: f32) -> Result<f32> {
if fps <= 0f32 {
Err(Error::BadFps)
} else {
Ok(1f32 / fps)
}
}
pub fn get_delta_time(&self) -> f32 {
self.delta_time
}
pub fn get_fps(&self) -> Result<f32> {
Self::to_fps(self.get_delta_time())
}
pub fn set_delta_time(&mut self, delta_time: f32) -> () {
self.delta_time = delta_time
}
pub fn set_fps(&mut self, fps: f32) -> Result<()> {
Ok(self.set_delta_time(Self::to_delta_time(fps)?))
}
}
impl TasFrame {