dave/ic10emu
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

chore(clippy): sweep sweep sweep

Browse Source
This commit is contained in:
Rachel Powers
2024-05-18 04:28:30 -07:00
parent 29ef54ca04
commit b0bdc37a8a
10 changed files with 202 additions and 231 deletions
Download Patch File Download Diff File Expand all files Collapse all files

169
ic10emu/src/interpreter.rs
View File

@@ -190,92 +190,87 @@ pub fn i64_to_f64(i: i64) -> f64 {
#[cfg(test)]
mod tests {
use crate::{errors::VMError, vm::VM};
use super::*;
use color_eyre::eyre::Ok;
static INIT: std::sync::Once = std::sync::Once::new();
fn setup() {
INIT.call_once(|| {
let _ = color_eyre::install();
})
}
#[test]
fn batch_modes() -> color_eyre::Result<()> {
setup();
let mut vm = VM::new();
let ic = vm.add_ic(None).unwrap();
let ic_id = {
let device = vm.devices.get(&ic).unwrap();
let device_ref = device.borrow();
device_ref.ic.unwrap()
};
let ic_chip = vm.circuit_holders.get(&ic_id).unwrap().borrow();
vm.set_code(
ic,
r#"lb r0 HASH("ItemActiveVent") On Sum
lb r1 HASH("ItemActiveVent") On Maximum
lb r2 HASH("ItemActiveVent") On Minimum"#,
)?;
vm.step_ic(ic, false)?;
let r0 = ic_chip.get_register(0, 0).unwrap();
assert_eq!(r0, 0.0);
vm.step_ic(ic, false)?;
let r1 = ic_chip.get_register(0, 1).unwrap();
assert_eq!(r1, f64::NEG_INFINITY);
vm.step_ic(ic, false)?;
let r2 = ic_chip.get_register(0, 2).unwrap();
assert_eq!(r2, f64::INFINITY);
Ok(())
}
#[test]
fn stack() -> color_eyre::Result<()> {
setup();
let mut vm = VM::new();
let ic = vm.add_ic(None).unwrap();
let ic_id = {
let device = vm.devices.get(&ic).unwrap();
let device_ref = device.borrow();
device_ref.ic.unwrap()
};
let ic_chip = vm.circuit_holders.get(&ic_id).unwrap().borrow();
vm.set_code(
ic,
r#"push 100
push 10
pop r0
push 1000
peek r1
poke 1 20
pop r2
"#,
)?;
vm.step_ic(ic, false)?;
let stack0 = ic_chip.peek_addr(0.0)?;
assert_eq!(stack0, 100.0);
vm.step_ic(ic, false)?;
let stack1 = ic_chip.peek_addr(1.0)?;
assert_eq!(stack1, 10.0);
vm.step_ic(ic, false)?;
let r0 = ic_chip.get_register(0, 0).unwrap();
assert_eq!(r0, 10.0);
vm.step_ic(ic, false)?;
let stack1 = ic_chip.peek_addr(1.0)?;
assert_eq!(stack1, 1000.0);
vm.step_ic(ic, false)?;
let r1 = ic_chip.get_register(0, 1).unwrap();
assert_eq!(r1, 1000.0);
vm.step_ic(ic, false)?;
let stack1 = ic_chip.peek_addr(1.0)?;
assert_eq!(stack1, 20.0);
vm.step_ic(ic, false)?;
let r2 = ic_chip.get_register(0, 2).unwrap();
assert_eq!(r2, 20.0);
Ok(())
}
// static INIT: std::sync::Once = std::sync::Once::new();
//
// fn setup() {
// INIT.call_once(|| {
// let _ = color_eyre::install();
// })
// }
//
// #[test]
// fn batch_modes() -> color_eyre::Result<()> {
// setup();
// let mut vm = VM::new();
// let ic = vm.add_ic(None).unwrap();
// let ic_id = {
// let device = vm.devices.get(&ic).unwrap();
// let device_ref = device.borrow();
// device_ref.ic.unwrap()
// };
// let ic_chip = vm.circuit_holders.get(&ic_id).unwrap().borrow();
// vm.set_code(
// ic,
// r#"lb r0 HASH("ItemActiveVent") On Sum
// lb r1 HASH("ItemActiveVent") On Maximum
// lb r2 HASH("ItemActiveVent") On Minimum"#,
// )?;
// vm.step_ic(ic, false)?;
// let r0 = ic_chip.get_register(0, 0).unwrap();
// assert_eq!(r0, 0.0);
// vm.step_ic(ic, false)?;
// let r1 = ic_chip.get_register(0, 1).unwrap();
// assert_eq!(r1, f64::NEG_INFINITY);
// vm.step_ic(ic, false)?;
// let r2 = ic_chip.get_register(0, 2).unwrap();
// assert_eq!(r2, f64::INFINITY);
// Ok(())
// }
//
// #[test]
// fn stack() -> color_eyre::Result<()> {
// setup();
// let mut vm = VM::new();
// let ic = vm.add_ic(None).unwrap();
// let ic_id = {
// let device = vm.devices.get(&ic).unwrap();
// let device_ref = device.borrow();
// device_ref.ic.unwrap()
// };
// let ic_chip = vm.circuit_holders.get(&ic_id).unwrap().borrow();
// vm.set_code(
// ic,
// r#"push 100
// push 10
// pop r0
// push 1000
// peek r1
// poke 1 20
// pop r2
// "#,
// )?;
// vm.step_ic(ic, false)?;
// let stack0 = ic_chip.peek_addr(0.0)?;
// assert_eq!(stack0, 100.0);
// vm.step_ic(ic, false)?;
// let stack1 = ic_chip.peek_addr(1.0)?;
// assert_eq!(stack1, 10.0);
// vm.step_ic(ic, false)?;
// let r0 = ic_chip.get_register(0, 0).unwrap();
// assert_eq!(r0, 10.0);
// vm.step_ic(ic, false)?;
// let stack1 = ic_chip.peek_addr(1.0)?;
// assert_eq!(stack1, 1000.0);
// vm.step_ic(ic, false)?;
// let r1 = ic_chip.get_register(0, 1).unwrap();
// assert_eq!(r1, 1000.0);
// vm.step_ic(ic, false)?;
// let stack1 = ic_chip.peek_addr(1.0)?;
// assert_eq!(stack1, 20.0);
// vm.step_ic(ic, false)?;
// let r2 = ic_chip.get_register(0, 2).unwrap();
// assert_eq!(r2, 20.0);
// Ok(())
// }
}

18
ic10emu/src/network.rs
View File

@@ -258,19 +258,17 @@ impl Logicable for CableNetwork {
}
fn can_logic_read(&self, lt: LogicType) -> bool {
use LogicType::*;
match lt {
Channel0 | Channel1 | Channel2 | Channel3 | Channel4 | Channel5 | Channel6
| Channel7 => true,
_ => false,
}
matches!(
lt,
Channel0 | Channel1 | Channel2 | Channel3 | Channel4 | Channel5 | Channel6 | Channel7
)
}
fn can_logic_write(&self, lt: LogicType) -> bool {
use LogicType::*;
match lt {
Channel0 | Channel1 | Channel2 | Channel3 | Channel4 | Channel5 | Channel6
| Channel7 => true,
_ => false,
}
matches!(
lt,
Channel0 | Channel1 | Channel2 | Channel3 | Channel4 | Channel5 | Channel6 | Channel7
)
}
fn get_logic(&self, lt: LogicType) -> Result<f64, crate::vm::object::errors::LogicError> {
use LogicType::*;

27
ic10emu/src/vm.rs
View File

@@ -43,10 +43,11 @@ pub struct VMTransactionNetwork {
pub power_only: Vec<ObjectID>,
}
#[allow(dead_code)]
#[derive(Debug)]
/// used as a temp structure to add objects in case
/// there are errors on nested templates
pub struct VMTransaction {
struct VMTransaction {
pub objects: BTreeMap<ObjectID, VMObject>,
pub circuit_holders: Vec<ObjectID>,
pub program_holders: Vec<ObjectID>,
@@ -121,13 +122,11 @@ impl VM {
.borrow()
.get(&net_id)
.cloned()
.expect(&format!(
"desync between vm and transaction networks: {net_id}"
));
.unwrap_or_else(|| panic!("desync between vm and transaction networks: {net_id}"));
let mut net_ref = net.borrow_mut();
let net_interface = net_ref
.as_mut_network()
.expect(&format!("non network network: {net_id}"));
.unwrap_or_else(|| panic!("non network network: {net_id}"));
for id in trans_net.devices {
net_interface.add_data(id);
}
@@ -772,7 +771,7 @@ impl VM {
if let Some(device) = obj.borrow().as_device() {
for conn in device.connection_list().iter() {
if let Connection::CableNetwork { net: Some(net), .. } = conn {
if let Some(network) = self.networks.borrow().get(&net) {
if let Some(network) = self.networks.borrow().get(net) {
network
.borrow_mut()
.as_mut_network()
@@ -781,7 +780,7 @@ impl VM {
}
}
}
if let Some(_) = device.as_circuit_holder() {
if device.as_circuit_holder().is_some() {
self.circuit_holders.borrow_mut().retain(|a| *a != id);
}
}
@@ -955,13 +954,13 @@ impl VM {
for (net_id, trans_net) in transaction.networks.into_iter() {
let networks_ref = self.networks.borrow();
let net = networks_ref.get(&net_id).expect(&format!(
"desync between vm and transaction networks: {net_id}"
));
let net = networks_ref
.get(&net_id)
.unwrap_or_else(|| panic!("desync between vm and transaction networks: {net_id}"));
let mut net_ref = net.borrow_mut();
let net_interface = net_ref
.as_mut_network()
.expect(&format!("non network network: {net_id}"));
.unwrap_or_else(|| panic!("non network network: {net_id}"));
for id in trans_net.devices {
net_interface.add_data(id);
}
@@ -1025,7 +1024,7 @@ impl VMTransaction {
}
}
let obj_id = if let Some(obj_id) = template.object_info().map(|info| info.id).flatten() {
let obj_id = if let Some(obj_id) = template.object_info().and_then(|info| info.id) {
self.id_space.use_id(obj_id)?;
obj_id
} else {
@@ -1042,7 +1041,7 @@ impl VMTransaction {
let occupant_id = self.add_device_from_template(occupant_template)?;
storage
.get_slot_mut(slot_index)
.expect(&format!("object storage slots out of sync with template which built it: {slot_index}"))
.unwrap_or_else(|| panic!("object storage slots out of sync with template which built it: {slot_index}"))
.occupant = Some(occupant_id);
}
}
@@ -1068,7 +1067,7 @@ impl VMTransaction {
role: ConnectionRole::None,
} = conn
{
if let Some(net) = self.networks.get_mut(&net_id) {
if let Some(net) = self.networks.get_mut(net_id) {
match typ {
CableConnectionType::Power => net.power_only.push(obj_id),
_ => net.devices.push(obj_id),

42
ic10emu/src/vm/enums/basic_enums.rs
View File

@@ -918,27 +918,27 @@ impl BasicEnum {
pub fn iter() -> impl std::iter::Iterator<Item = Self> {
use strum::IntoEnumIterator;
AirConditioningMode::iter()
.map(|enm| Self::AirCon(enm))
.chain(AirControlMode::iter().map(|enm| Self::AirControl(enm)))
.chain(ColorType::iter().map(|enm| Self::Color(enm)))
.chain(DaylightSensorMode::iter().map(|enm| Self::DaylightSensorMode(enm)))
.chain(ElevatorMode::iter().map(|enm| Self::ElevatorMode(enm)))
.chain(EntityState::iter().map(|enm| Self::EntityState(enm)))
.chain(GasType::iter().map(|enm| Self::GasType(enm)))
.chain(LogicSlotType::iter().map(|enm| Self::LogicSlotType(enm)))
.chain(LogicType::iter().map(|enm| Self::LogicType(enm)))
.chain(PowerMode::iter().map(|enm| Self::PowerMode(enm)))
.chain(PrinterInstruction::iter().map(|enm| Self::PrinterInstruction(enm)))
.chain(ReEntryProfile::iter().map(|enm| Self::ReEntryProfile(enm)))
.chain(RobotMode::iter().map(|enm| Self::RobotMode(enm)))
.chain(RocketMode::iter().map(|enm| Self::RocketMode(enm)))
.chain(Class::iter().map(|enm| Self::SlotClass(enm)))
.chain(SorterInstruction::iter().map(|enm| Self::SorterInstruction(enm)))
.chain(SortingClass::iter().map(|enm| Self::SortingClass(enm)))
.chain(SoundAlert::iter().map(|enm| Self::Sound(enm)))
.chain(LogicTransmitterMode::iter().map(|enm| Self::TransmitterMode(enm)))
.chain(VentDirection::iter().map(|enm| Self::Vent(enm)))
.chain(ConditionOperation::iter().map(|enm| Self::Unnamed(enm)))
.map(Self::AirCon)
.chain(AirControlMode::iter().map(Self::AirControl))
.chain(ColorType::iter().map(Self::Color))
.chain(DaylightSensorMode::iter().map(Self::DaylightSensorMode))
.chain(ElevatorMode::iter().map(Self::ElevatorMode))
.chain(EntityState::iter().map(Self::EntityState))
.chain(GasType::iter().map(Self::GasType))
.chain(LogicSlotType::iter().map(Self::LogicSlotType))
.chain(LogicType::iter().map(Self::LogicType))
.chain(PowerMode::iter().map(Self::PowerMode))
.chain(PrinterInstruction::iter().map(Self::PrinterInstruction))
.chain(ReEntryProfile::iter().map(Self::ReEntryProfile))
.chain(RobotMode::iter().map(Self::RobotMode))
.chain(RocketMode::iter().map(Self::RocketMode))
.chain(Class::iter().map(Self::SlotClass))
.chain(SorterInstruction::iter().map(Self::SorterInstruction))
.chain(SortingClass::iter().map(Self::SortingClass))
.chain(SoundAlert::iter().map(Self::Sound))
.chain(LogicTransmitterMode::iter().map(Self::TransmitterMode))
.chain(VentDirection::iter().map(Self::Vent))
.chain(ConditionOperation::iter().map(Self::Unnamed))
}
}
impl std::str::FromStr for BasicEnum {

12
ic10emu/src/vm/object.rs
View File

@@ -86,14 +86,10 @@ impl Name {
}
}
pub fn from_prefab_hash(hash: i32) -> Option<Self> {
if let Some(prefab) = StationpediaPrefab::from_repr(hash) {
Some(Name {
value: prefab.to_string(),
hash,
})
} else {
None
}
StationpediaPrefab::from_repr(hash).map(|prefab| Name {
value: prefab.to_string(),
hash,
})
}
pub fn set(&mut self, name: &str) {
self.value = name.to_owned();

2
ic10emu/src/vm/object/stationpedia/structs.rs
View File

@@ -1,4 +1,4 @@
mod integrated_circuit;
mod circuit_holder;
mod integrated_circuit;
pub use integrated_circuit::ItemIntegratedCircuit10;

67
ic10emu/src/vm/object/stationpedia/structs/circuit_holder.rs
View File

@@ -138,8 +138,18 @@ impl Logicable for StructureCircuitHousing {
}
fn can_logic_read(&self, lt: LogicType) -> bool {
use LogicType::*;
matches!(lt, Error | LineNumber | NameHash | On | Power | PrefabHash | ReferenceId
| RequiredPower | Setting)
matches!(
lt,
Error
| LineNumber
| NameHash
| On
| Power
| PrefabHash
| ReferenceId
| RequiredPower
| Setting
)
}
fn can_logic_write(&self, lt: LogicType) -> bool {
use LogicType::*;
@@ -152,18 +162,13 @@ impl Logicable for StructureCircuitHousing {
LogicType::ReferenceId => Ok(*self.get_id() as f64),
LogicType::Error => Ok(self.error as f64),
LogicType::LineNumber => {
let result = self
.slot
.occupant
.and_then(|id| {
self.vm
.get_object(id)
.and_then(|obj| {
obj.borrow()
.as_logicable()
.map(|logicable| logicable.get_logic(LogicType::LineNumber))
})
});
let result = self.slot.occupant.and_then(|id| {
self.vm.get_object(id).and_then(|obj| {
obj.borrow()
.as_logicable()
.map(|logicable| logicable.get_logic(LogicType::LineNumber))
})
});
result.unwrap_or(Ok(0.0))
}
LogicType::On => Ok(self.on as i32 as f64),
@@ -203,13 +208,11 @@ impl Logicable for StructureCircuitHousing {
.slot
.occupant
.and_then(|id| {
self.vm
.get_object(id)
.and_then(|obj| {
obj.borrow_mut().as_mut_logicable().map(|logicable| {
logicable.set_logic(LogicType::LineNumber, value, force)
})
self.vm.get_object(id).and_then(|obj| {
obj.borrow_mut().as_mut_logicable().map(|logicable| {
logicable.set_logic(LogicType::LineNumber, value, force)
})
})
})
.unwrap_or(Err(LogicError::CantWrite(lt))),
LogicType::On => {
@@ -326,9 +329,7 @@ impl CircuitHolder for StructureCircuitHousing {
if let Some(connection) = connection {
self.connections.get(connection).and_then(|conn| {
if let Connection::CableNetwork { net: Some(net), .. } = conn {
self.vm
.get_network(*net)
.map(ObjectRef::from_vm_object)
self.vm.get_network(*net).map(ObjectRef::from_vm_object)
} else {
None
}
@@ -341,10 +342,7 @@ impl CircuitHolder for StructureCircuitHousing {
return None;
}
self.pins.get(device as usize).and_then(|pin| {
pin.and_then(|id| {
self.vm
.get_object(id).map(ObjectRef::from_vm_object)
})
pin.and_then(|id| self.vm.get_object(id).map(ObjectRef::from_vm_object))
})
}
}
@@ -359,9 +357,7 @@ impl CircuitHolder for StructureCircuitHousing {
if let Some(connection) = connection {
self.connections.get(connection).and_then(|conn| {
if let Connection::CableNetwork { net: Some(net), .. } = conn {
self.vm
.get_network(*net)
.map(ObjectRefMut::from_vm_object)
self.vm.get_network(*net).map(ObjectRefMut::from_vm_object)
} else {
None
}
@@ -374,10 +370,7 @@ impl CircuitHolder for StructureCircuitHousing {
return None;
}
self.pins.get(device as usize).and_then(|pin| {
pin.and_then(|id| {
self.vm
.get_object(id).map(ObjectRefMut::from_vm_object)
})
pin.and_then(|id| self.vm.get_object(id).map(ObjectRefMut::from_vm_object))
})
}
}
@@ -393,8 +386,7 @@ impl CircuitHolder for StructureCircuitHousing {
if device == self.id {
return Some(ObjectRef::from_ref(self.as_object()));
}
self.vm
.get_object(device).map(ObjectRef::from_vm_object)
self.vm.get_object(device).map(ObjectRef::from_vm_object)
}
fn get_logicable_from_id_mut(
@@ -408,8 +400,7 @@ impl CircuitHolder for StructureCircuitHousing {
if device == self.id {
return Some(ObjectRefMut::from_ref(self.as_mut_object()));
}
self.vm
.get_object(device).map(ObjectRefMut::from_vm_object)
self.vm.get_object(device).map(ObjectRefMut::from_vm_object)
}
fn get_ic(&self) -> Option<VMObject> {

88
ic10emu/src/vm/object/templates.rs
View File

@@ -74,7 +74,7 @@ impl ObjectTemplate {
}
pub fn build(&self, id: ObjectID, vm: &Rc<VM>) -> VMObject {
if let Some(obj) = stationpedia::object_from_prefab_template(&self, id, vm) {
if let Some(obj) = stationpedia::object_from_prefab_template(self, id, vm) {
obj
} else {
self.build_generic(id, vm.clone())
@@ -111,7 +111,7 @@ impl ObjectTemplate {
.filter_map(|info| {
info.occupant
.as_ref()
.map(|obj| obj.object_info().map(|obj_info| obj_info.id).flatten())
.map(|obj| obj.object_info().and_then(|obj_info| obj_info.id))
})
.flatten()
.collect(),
@@ -121,7 +121,7 @@ impl ObjectTemplate {
.filter_map(|info| {
info.occupant
.as_ref()
.map(|obj| obj.object_info().map(|obj_info| obj_info.id).flatten())
.map(|obj| obj.object_info().and_then(|obj_info| obj_info.id))
})
.flatten()
.collect(),
@@ -131,7 +131,7 @@ impl ObjectTemplate {
.filter_map(|info| {
info.occupant
.as_ref()
.map(|obj| obj.object_info().map(|obj_info| obj_info.id).flatten())
.map(|obj| obj.object_info().and_then(|obj_info| obj_info.id))
})
.flatten()
.collect(),
@@ -141,7 +141,7 @@ impl ObjectTemplate {
.filter_map(|info| {
info.occupant
.as_ref()
.map(|obj| obj.object_info().map(|obj_info| obj_info.id).flatten())
.map(|obj| obj.object_info().and_then(|obj_info| obj_info.id))
})
.flatten()
.collect(),
@@ -151,7 +151,7 @@ impl ObjectTemplate {
.filter_map(|info| {
info.occupant
.as_ref()
.map(|obj| obj.object_info().map(|obj_info| obj_info.id).flatten())
.map(|obj| obj.object_info().and_then(|obj_info| obj_info.id))
})
.flatten()
.collect(),
@@ -161,7 +161,7 @@ impl ObjectTemplate {
.filter_map(|info| {
info.occupant
.as_ref()
.map(|obj| obj.object_info().map(|obj_info| obj_info.id).flatten())
.map(|obj| obj.object_info().and_then(|obj_info| obj_info.id))
})
.flatten()
.collect(),
@@ -171,7 +171,7 @@ impl ObjectTemplate {
.filter_map(|info| {
info.occupant
.as_ref()
.map(|obj| obj.object_info().map(|obj_info| obj_info.id).flatten())
.map(|obj| obj.object_info().and_then(|obj_info| obj_info.id))
})
.flatten()
.collect(),
@@ -257,7 +257,7 @@ impl ObjectTemplate {
.copied()
.collect::<Vec<_>>()
})
.unwrap_or_else(|| Vec::new()),
.unwrap_or_else(Vec::new),
writeable_logic: s
.logic
.logic_slot_types
@@ -273,7 +273,7 @@ impl ObjectTemplate {
.copied()
.collect::<Vec<_>>()
})
.unwrap_or_else(|| Vec::new()),
.unwrap_or_else(Vec::new),
occupant: None,
quantity: info.quantity.unwrap_or(0),
})
@@ -292,8 +292,7 @@ impl ObjectTemplate {
.logic
.logic_values
.as_ref()
.map(|values| values.get(key))
.flatten()
.and_then(|values| values.get(key))
.copied()
.unwrap_or(0.0),
},
@@ -332,7 +331,7 @@ impl ObjectTemplate {
.copied()
.collect::<Vec<_>>()
})
.unwrap_or_else(|| Vec::new()),
.unwrap_or_else(Vec::new),
writeable_logic: s
.logic
.logic_slot_types
@@ -348,7 +347,7 @@ impl ObjectTemplate {
.copied()
.collect::<Vec<_>>()
})
.unwrap_or_else(|| Vec::new()),
.unwrap_or_else(Vec::new),
occupant: None,
quantity: info.quantity.unwrap_or(0),
})
@@ -367,8 +366,7 @@ impl ObjectTemplate {
.logic
.logic_values
.as_ref()
.map(|values| values.get(key))
.flatten()
.and_then(|values| values.get(key))
.copied()
.unwrap_or(0.0),
},
@@ -432,7 +430,7 @@ impl ObjectTemplate {
.copied()
.collect::<Vec<_>>()
})
.unwrap_or_else(|| Vec::new()),
.unwrap_or_else(Vec::new),
writeable_logic: s
.logic
.logic_slot_types
@@ -450,7 +448,7 @@ impl ObjectTemplate {
.copied()
.collect::<Vec<_>>()
})
.unwrap_or_else(|| Vec::new()),
.unwrap_or_else(Vec::new),
occupant: None,
quantity: info.quantity.unwrap_or(0),
})
@@ -469,8 +467,7 @@ impl ObjectTemplate {
.logic
.logic_values
.as_ref()
.map(|values| values.get(key))
.flatten()
.and_then(|values| values.get(key))
.copied()
.unwrap_or(0.0),
},
@@ -502,7 +499,7 @@ impl ObjectTemplate {
.memory
.values
.clone()
.unwrap_or_else(|| vec![0.0; s.memory.memory_size as usize]),
.unwrap_or_else(|| vec![0.0; s.memory.memory_size]),
})
}
StructureLogicDeviceMemory(s) => {
@@ -538,7 +535,7 @@ impl ObjectTemplate {
.copied()
.collect::<Vec<_>>()
})
.unwrap_or_else(|| Vec::new()),
.unwrap_or_else(Vec::new),
writeable_logic: s
.logic
.logic_slot_types
@@ -556,7 +553,7 @@ impl ObjectTemplate {
.copied()
.collect::<Vec<_>>()
})
.unwrap_or_else(|| Vec::new()),
.unwrap_or_else(Vec::new),
occupant: None,
quantity: info.quantity.unwrap_or(0),
})
@@ -575,8 +572,7 @@ impl ObjectTemplate {
.logic
.logic_values
.as_ref()
.map(|values| values.get(key))
.flatten()
.and_then(|values| values.get(key))
.copied()
.unwrap_or(0.0),
},
@@ -608,7 +604,7 @@ impl ObjectTemplate {
.memory
.values
.clone()
.unwrap_or_else(|| vec![0.0; s.memory.memory_size as usize]),
.unwrap_or_else(|| vec![0.0; s.memory.memory_size]),
})
}
Item(i) => VMObject::new(GenericItem {
@@ -676,7 +672,7 @@ impl ObjectTemplate {
.copied()
.collect::<Vec<_>>()
})
.unwrap_or_else(|| Vec::new()),
.unwrap_or_else(Vec::new),
writeable_logic: i
.logic
.logic_slot_types
@@ -692,7 +688,7 @@ impl ObjectTemplate {
.copied()
.collect::<Vec<_>>()
})
.unwrap_or_else(|| Vec::new()),
.unwrap_or_else(Vec::new),
occupant: None,
quantity: info.quantity.unwrap_or(0),
})
@@ -711,8 +707,7 @@ impl ObjectTemplate {
.logic
.logic_values
.as_ref()
.map(|values| values.get(key))
.flatten()
.and_then(|values| values.get(key))
.copied()
.unwrap_or(0.0),
},
@@ -756,7 +751,7 @@ impl ObjectTemplate {
.copied()
.collect::<Vec<_>>()
})
.unwrap_or_else(|| Vec::new()),
.unwrap_or_else(Vec::new),
writeable_logic: i
.logic
.logic_slot_types
@@ -774,7 +769,7 @@ impl ObjectTemplate {
.copied()
.collect::<Vec<_>>()
})
.unwrap_or_else(|| Vec::new()),
.unwrap_or_else(Vec::new),
occupant: None,
quantity: info.quantity.unwrap_or(0),
})
@@ -793,8 +788,7 @@ impl ObjectTemplate {
.logic
.logic_values
.as_ref()
.map(|values| values.get(key))
.flatten()
.and_then(|values| values.get(key))
.copied()
.unwrap_or(0.0),
},
@@ -806,7 +800,7 @@ impl ObjectTemplate {
.memory
.values
.clone()
.unwrap_or_else(|| vec![0.0; i.memory.memory_size as usize]),
.unwrap_or_else(|| vec![0.0; i.memory.memory_size]),
})
}
ItemLogicMemory(i) => VMObject::new(GenericItemLogicableMemoryReadWriteable {
@@ -841,7 +835,7 @@ impl ObjectTemplate {
.copied()
.collect::<Vec<_>>()
})
.unwrap_or_else(|| Vec::new()),
.unwrap_or_else(Vec::new),
writeable_logic: i
.logic
.logic_slot_types
@@ -857,7 +851,7 @@ impl ObjectTemplate {
.copied()
.collect::<Vec<_>>()
})
.unwrap_or_else(|| Vec::new()),
.unwrap_or_else(Vec::new),
occupant: None,
quantity: info.quantity.unwrap_or(0),
})
@@ -876,8 +870,7 @@ impl ObjectTemplate {
.logic
.logic_values
.as_ref()
.map(|values| values.get(key))
.flatten()
.and_then(|values| values.get(key))
.copied()
.unwrap_or(0.0),
},
@@ -889,7 +882,7 @@ impl ObjectTemplate {
.memory
.values
.clone()
.unwrap_or_else(|| vec![0.0; i.memory.memory_size as usize]),
.unwrap_or_else(|| vec![0.0; i.memory.memory_size]),
}),
}
}
@@ -1218,13 +1211,11 @@ impl From<&VMObject> for PrefabInfo {
prefab_name: obj_prefab.value.clone(),
prefab_hash: obj_prefab.hash,
name: prefab_lookup
.map(|prefab| prefab.get_str("name"))
.flatten()
.and_then(|prefab| prefab.get_str("name"))
.unwrap_or("")
.to_string(),
desc: prefab_lookup
.map(|prefab| prefab.get_str("desc"))
.flatten()
.and_then(|prefab| prefab.get_str("desc"))
.unwrap_or("")
.to_string(),
}
@@ -1433,9 +1424,7 @@ impl From<DeviceRef<'_>> for DeviceInfo {
.map(|conn| conn.to_info())
.collect(),
device_pins_length: device.device_pins().map(|pins| pins.len()),
device_pins: device
.device_pins()
.map(|pins| pins.iter().copied().collect()),
device_pins: device.device_pins().map(|pins| pins.to_vec()),
has_reagents: device.has_reagents(),
has_lock_state: device.has_lock_state(),
has_mode_state: device.has_mode_state(),
@@ -1497,7 +1486,7 @@ impl From<MemoryReadableRef<'_>> for MemoryInfo {
MemoryAccess::Read
},
memory_size: mem_r.memory_size(),
values: Some(mem_r.get_memory_slice().iter().copied().collect()),
values: Some(mem_r.get_memory_slice().to_vec()),
}
}
}
@@ -1619,6 +1608,7 @@ mod tests {
})
}
#[allow(dead_code)]
#[derive(Debug, Deserialize)]
struct Database {
pub prefabs: BTreeMap<String, ObjectTemplate>,
@@ -1631,7 +1621,7 @@ mod tests {
d = d.parent().unwrap().join("data").join("database.json");
println!("loading database from {}", d.display());
let database: Database = serde_json::from_reader(BufReader::new(File::open(d)?))?;
let _database: Database = serde_json::from_reader(BufReader::new(File::open(d)?))?;
Ok(())
}

4
ic10emu/src/vm/object/traits.rs
View File

@@ -11,7 +11,9 @@ use crate::{
},
instructions::{traits::ICInstructable, Instruction},
object::{
errors::{LogicError, MemoryError}, macros::tag_object_traits, ObjectID, Slot, VMObject
errors::{LogicError, MemoryError},
macros::tag_object_traits,
ObjectID, Slot, VMObject,
},
},
};

4
xtask/src/generate/enums.rs
View File

@@ -140,9 +140,9 @@ fn write_enum_aggragate_mod<T: std::io::Write>(
.to_case(Case::Pascal);
let enum_name = listing.enum_name.to_case(Case::Pascal);
if index == 0 {
format!("{enum_name}::iter().map(|enm| Self::{variant_name}(enm))")
format!("{enum_name}::iter().map(Self::{variant_name})")
} else {
format!(".chain({enum_name}::iter().map(|enm| Self::{variant_name}(enm)))")
format!(".chain({enum_name}::iter().map(Self::{variant_name}))")
}
})
.collect::<Vec<_>>()