<![CDATA[Electrolysis_Virtual_Lab]]>
false
true
true
false
false
]]>
true
true
true
false
;
20
1
true
undefined
Var Table 1
true
false
VARIABLE_EDITOR
Var Table 2
true
false
VARIABLE_EDITOR
Var Table 3
true
false
VARIABLE_EDITOR
Var Table 6
true
false
VARIABLE_EDITOR
font
true
false
VARIABLE_EDITOR
xapi
true
false
VARIABLE_EDITOR
lookang
true
false
CODE_EDITOR
solutionTypes
true
false
= left && pointX <= right && pointY >= top && pointY <= bottom;
}
]]>
CODE_EDITOR
generateIons
true
false
{
for (let i = 0; i < ionType.amount; i++) {
ions.push({
position: getRandomPosition(),
type: ionType.formula,
stuck: false,
});
}
});
return ions;
}
]]>
CODE_EDITOR
updatePositions
true
false
minDistanceSquared) {
let distance = Math.sqrt(distanceSquared);
let invDistance = 1 / distance;
// Normalize the vector and compute movement
let vx = dx * invDistance;
let vy = dy * invDistance;
let moveDistance = Math.min(stepSize, distance);
// Update position
pos[0] += vx * moveDistance;
pos[1] += vy * moveDistance;
// Check if the ion has reached close enough to the target position
if (distanceSquared <= reachThresholdSquared) {
pos[0] = targetPos[0];
pos[1] = targetPos[1];
positiveIonsStuckStatus[i] = true;
}
} else {
// Ion has reached its target position
pos[0] = targetPos[0];
pos[1] = targetPos[1];
positiveIonsStuckStatus[i] = true;
}
}
}
// Update positions for negative ions
for (let i = 0; i < posOfNegativeIons.length; i++) {
if (!negativeIonsStuckStatus[i] && negativeIonsVisibility[i]) {
allStuck = false; // At least one element is still moving
// Get current and target positions
let pos = posOfNegativeIons[i];
let targetPos = negativeIonsTargetPositions[i];
// Compute vector towards the target position
let dx = targetPos[0] - pos[0];
let dy = targetPos[1] - pos[1];
let distanceSquared = dx * dx + dy * dy;
if (distanceSquared > minDistanceSquared) {
let distance = Math.sqrt(distanceSquared);
let invDistance = 1 / distance;
// Normalize the vector and compute movement
let vx = dx * invDistance;
let vy = dy * invDistance;
let moveDistance = Math.min(stepSize, distance);
// Update position
pos[0] += vx * moveDistance;
pos[1] += vy * moveDistance;
// Check if the ion has reached close enough to the target position
if (distanceSquared <= reachThresholdSquared) {
pos[0] = targetPos[0];
pos[1] = targetPos[1];
negativeIonsStuckStatus[i] = true;
}
} else {
// Ion has reached its target position
pos[0] = targetPos[0];
pos[1] = targetPos[1];
negativeIonsStuckStatus[i] = true;
}
}
}
// After updating positions, check for reactions
checkForReactions();
// Update positions for anode products
for (let i = 0; i < posOfAnodeProducts.length; i++) {
if (anodeProductsVisibility[i] && !anodeProductsReachedTarget[i]) {
allStuck = false; // At least one product is still moving
let pos = posOfAnodeProducts[i];
let dx = anodeProductTarget[0] - pos[0];
let dy = anodeProductTarget[1] - pos[1];
let distanceSquared = dx * dx + dy * dy;
if (distanceSquared > minDistanceSquared) {
let distance = Math.sqrt(distanceSquared);
let invDistance = 1 / distance;
let vx = dx * invDistance;
let vy = dy * invDistance;
let moveDistance = Math.min(stepSize, distance);
pos[0] += vx * moveDistance;
pos[1] += vy * moveDistance;
if (distance <= moveDistance) {
pos[0] = anodeProductTarget[0];
pos[1] = anodeProductTarget[1];
anodeProductsReachedTarget[i] = true;
anodeProductsVisibility[i] = false; // Product disappears
anodeTestTubeLevel += 0.025;
}
} else {
pos[0] = anodeProductTarget[0];
pos[1] = anodeProductTarget[1];
anodeProductsReachedTarget[i] = true;
anodeProductsVisibility[i] = false; // Product disappears
anodeTestTubeLevel += 0.025;
}
}
}
// Update positions for cathode products
for (let i = 0; i < posOfCathodeProducts.length; i++) {
if (cathodeProductsVisibility[i] && !cathodeProductsReachedTarget[i]) {
allStuck = false; // At least one product is still moving
let pos = posOfCathodeProducts[i];
let dx = cathodeProductTarget[0] - pos[0];
let dy = cathodeProductTarget[1] - pos[1];
let distanceSquared = dx * dx + dy * dy;
if (distanceSquared > minDistanceSquared) {
let distance = Math.sqrt(distanceSquared);
let invDistance = 1 / distance;
let vx = dx * invDistance;
let vy = dy * invDistance;
let moveDistance = Math.min(stepSize, distance);
pos[0] += vx * moveDistance;
pos[1] += vy * moveDistance;
if (distance <= moveDistance) {
pos[0] = cathodeProductTarget[0];
pos[1] = cathodeProductTarget[1];
cathodeProductsReachedTarget[i] = true;
cathodeProductsVisibility[i] = false; // Product disappears
cathodeTestTubeLevel += 0.025;
}
} else {
pos[0] = cathodeProductTarget[0];
pos[1] = cathodeProductTarget[1];
cathodeProductsReachedTarget[i] = true;
cathodeProductsVisibility[i] = false; // Product disappears
cathodeTestTubeLevel += 0.025;
}
}
}
// Update positions for anode electrons
for (let i = 0; i < anodeElectronPositions.length; i++) {
if (anodeElectronVisibility[i] && !anodeElectronReachedTarget[i]) {
allStuck = false; // At least one element is still moving
let pos = anodeElectronPositions[i];
let dx = anodeElectronEndPos[0] - pos[0];
let dy = anodeElectronEndPos[1] - pos[1];
let distanceSquared = dx * dx + dy * dy;
if (distanceSquared > minDistanceSquared) {
let distance = Math.sqrt(distanceSquared);
let invDistance = 1 / distance;
let vx = dx * invDistance;
let vy = dy * invDistance;
let moveDistance = Math.min(stepSize, distance);
pos[0] += vx * moveDistance;
pos[1] += vy * moveDistance;
if (distance <= moveDistance) {
pos[0] = anodeElectronEndPos[0];
pos[1] = anodeElectronEndPos[1];
anodeElectronReachedTarget[i] = true;
anodeElectronVisibility[i] = false; // Electron disappears
}
} else {
pos[0] = anodeElectronEndPos[0];
pos[1] = anodeElectronEndPos[1];
anodeElectronReachedTarget[i] = true;
anodeElectronVisibility[i] = false; // Electron disappears
}
}
}
// Update positions for cathode electrons
for (let i = 0; i < cathodeElectronPositions.length; i++) {
if (cathodeElectronVisibility[i] && !cathodeElectronReachedTarget[i]) {
allStuck = false; // At least one element is still moving
let pos = cathodeElectronPositions[i];
let dx = cathodeElectronEndPos[0] - pos[0];
let dy = cathodeElectronEndPos[1] - pos[1];
let distanceSquared = dx * dx + dy * dy;
if (distanceSquared > minDistanceSquared) {
let distance = Math.sqrt(distanceSquared);
let invDistance = 1 / distance;
let vx = dx * invDistance;
let vy = dy * invDistance;
let moveDistance = Math.min(stepSize, distance);
pos[0] += vx * moveDistance;
pos[1] += vy * moveDistance;
if (distance <= moveDistance) {
pos[0] = cathodeElectronEndPos[0];
pos[1] = cathodeElectronEndPos[1];
cathodeElectronReachedTarget[i] = true;
cathodeElectronVisibility[i] = false; // Electron disappears
}
} else {
pos[0] = cathodeElectronEndPos[0];
pos[1] = cathodeElectronEndPos[1];
cathodeElectronReachedTarget[i] = true;
cathodeElectronVisibility[i] = false; // Electron disappears
}
}
}
// Check if any ions or products are still moving
if (
positiveIonsVisibility.some((v, i) => !positiveIonsStuckStatus[i] && v) ||
negativeIonsVisibility.some((v, i) => !negativeIonsStuckStatus[i] && v) ||
anodeProductsVisibility.some((v, i) => !anodeProductsReachedTarget[i] && v) ||
cathodeProductsVisibility.some((v, i) => !cathodeProductsReachedTarget[i] && v) ||
anodeElectronVisibility.some((v, i) => !anodeElectronReachedTarget[i] && v) ||
cathodeElectronVisibility.some((v, i) => !cathodeElectronReachedTarget[i] && v)
) {
allStuck = false;
}
if (allStuck) {
resetIons();
}
}
]]>
CODE_EDITOR
checkForReactions
true
false
{
const { reactants, product, location, electronsTransferred } = reaction;
let ionLabels, ionPositions, ionStuckStatus, ionVisibility;
let productsPositions, productsLabels, productsVisibility, productsReachedTarget;
let electronPositions, electronVisibility, electronReachedTarget;
let electronStartPos;
if (location === "anode") {
ionLabels = negativeIonLabels;
ionPositions = posOfNegativeIons;
ionStuckStatus = negativeIonsStuckStatus;
ionVisibility = negativeIonsVisibility;
productsPositions = posOfAnodeProducts;
productsLabels = anodeProductsLabels;
productsVisibility = anodeProductsVisibility;
productsReachedTarget = anodeProductsReachedTarget;
electronPositions = anodeElectronPositions;
electronVisibility = anodeElectronVisibility;
electronReachedTarget = anodeElectronReachedTarget;
electronStartPos = anodeElectronStartPos;
} else if (location === "cathode") {
ionLabels = positiveIonLabels;
ionPositions = posOfPositiveIons;
ionStuckStatus = positiveIonsStuckStatus;
ionVisibility = positiveIonsVisibility;
productsPositions = posOfCathodeProducts;
productsLabels = cathodeProductsLabels;
productsVisibility = cathodeProductsVisibility;
productsReachedTarget = cathodeProductsReachedTarget;
electronPositions = cathodeElectronPositions;
electronVisibility = cathodeElectronVisibility;
electronReachedTarget = cathodeElectronReachedTarget;
electronStartPos = cathodeElectronStartPos;
} else {
return; // Invalid location
}
// Build a map of available ions by label
const availableIonsMap = new Map();
for (let i = 0; i < ionLabels.length; i++) {
if (ionStuckStatus[i] && ionVisibility[i]) {
const label = ionLabels[i];
if (!availableIonsMap.has(label)) {
availableIonsMap.set(label, []);
}
availableIonsMap.get(label).push(i);
}
}
// Check if enough ions are available for the reaction
const requiredIons = {};
for (const label of reactants) {
requiredIons[label] = (requiredIons[label] || 0) + 1;
}
let canReact = true;
for (const label in requiredIons) {
if (!availableIonsMap.has(label) || availableIonsMap.get(label).length < requiredIons[label]) {
canReact = false;
break;
}
}
// Perform the reaction if possible
while (canReact) {
// Remove the ions used in the reaction
const combinationIndices = [];
for (const label of reactants) {
const index = availableIonsMap.get(label).pop();
combinationIndices.push(index);
ionVisibility[index] = false;
}
// Calculate average position for the product
let avgX = 0;
let avgY = 0;
for (const index of combinationIndices) {
avgX += ionPositions[index][0];
avgY += ionPositions[index][1];
}
avgX /= combinationIndices.length;
avgY /= combinationIndices.length;
// Add the new product
productsPositions.push([avgX, avgY]);
productsLabels.push(product);
productsVisibility.push(true);
productsReachedTarget.push(false);
// Create electron animations
for (let i = 0; i < electronsTransferred; i++) {
const yOffset = i * (2 * moleculeRad);
const position = [electronStartPos[0], electronStartPos[1] - yOffset];
electronPositions.push(position);
electronVisibility.push(true);
electronReachedTarget.push(false);
}
// Check if more reactions can occur
canReact = true;
for (const label in requiredIons) {
if (availableIonsMap.get(label).length < requiredIons[label]) {
canReact = false;
break;
}
}
}
});
}
]]>
CODE_EDITOR
assignTargetPositions
true
false
total + ion.amount, 0);
numOfPositiveIons = positiveIonTypes.reduce((total, ion) => total + ion.amount, 0);
// Generate positions and labels for positive ions
posOfPositiveIons = [];
positiveIonLabels = [];
positiveIonsVisibility = [];
positiveIonsStuckStatus = [];
positiveIonTypes.forEach((ionType) => {
for (let i = 0; i < ionType.amount; i++) {
posOfPositiveIons.push(getRandomPosition());
positiveIonLabels.push(ionType.formula);
positiveIonsVisibility.push(true); // Initially, all ions are visible
positiveIonsStuckStatus.push(false); // Initially, not stuck
}
});
// Generate positions and labels for negative ions
posOfNegativeIons = [];
negativeIonLabels = [];
negativeIonsVisibility = [];
negativeIonsStuckStatus = [];
negativeIonTypes.forEach((ionType) => {
for (let i = 0; i < ionType.amount; i++) {
posOfNegativeIons.push(getRandomPosition());
negativeIonLabels.push(ionType.formula);
negativeIonsVisibility.push(true); // Initially, all ions are visible
negativeIonsStuckStatus.push(false); // Initially, not stuck
}
});
// Assign target positions during initialization
positiveIonsTargetPositions = assignTargetPositions(posOfPositiveIons, cathodePos);
negativeIonsTargetPositions = assignTargetPositions(posOfNegativeIons, anodePos);
// Arrays to keep track of whether an ion is stuck
positiveIonsStuckStatus = new Array(posOfPositiveIons.length).fill(false);
negativeIonsStuckStatus = new Array(posOfNegativeIons.length).fill(false);
// Clear products arrays
posOfAnodeProducts = [];
anodeProductsLabels = [];
anodeProductsVisibility = [];
anodeProductsReachedTarget = [];
posOfCathodeProducts = [];
cathodeProductsLabels = [];
cathodeProductsVisibility = [];
cathodeProductsReachedTarget = [];
// Clear electron elements
anodeElectronPositions = [];
anodeElectronVisibility = [];
anodeElectronReachedTarget = [];
cathodeElectronPositions = [];
cathodeElectronVisibility = [];
cathodeElectronReachedTarget = [];
}
]]>
CODE_EDITOR
initSolution
true
false