<![CDATA[Electrolysis_Virtual_Lab_xAPI_v2]]>
false
true
true
false
false
]]>
true
true
true
false
./logoElectolysis.png
20
1
false
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
Var Table 8
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) {
if ((distance - anodeTestTubeLevel) <= moveDistance) {
pos[0] = anodeProductTarget[0];
pos[1] = anodeProductTarget[1];
// pos[1] = anodeProductTarget[1] - anodeTestTubeLevel ;
anodeProductsReachedTarget[i] = true;
anodeProductsVisibility[i] = false; // Product disappears
anodeTestTubeLevel += 0.05;
}
}
else {
pos[0] = anodeProductTarget[0];
pos[1] = anodeProductTarget[1] - anodeTestTubeLevel ;
anodeProductsReachedTarget[i] = true;
anodeProductsVisibility[i] = false; // Product disappears
anodeTestTubeLevel += 0.05;
}
}
}
// 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) {
if ((distance - cathodeTestTubeLevel) <= moveDistance) { // make the bubbles disappear at the airlevel instead of the top of the testtube
pos[0] = cathodeProductTarget[0];
pos[1] = cathodeProductTarget[1];
cathodeProductsReachedTarget[i] = true;
cathodeProductsVisibility[i] = false; // Product disappears
cathodeTestTubeLevel += 0.05;
}
} else {
pos[0] = cathodeProductTarget[0];
pos[1] = cathodeProductTarget[1];
cathodeProductsReachedTarget[i] = true;
cathodeProductsVisibility[i] = false; // Product disappears
cathodeTestTubeLevel += 0.05;
}
}
}
// 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) ||
positiveIonsVisibility.some((v, i) => (positiveIonBlinkingFrames[i] > 0 && positiveIonBlinkingFrames[i] < 22) && v) ||
negativeIonsVisibility.some((v, i) => (negativeIonBlinkingFrames[i] > 0 && negativeIonBlinkingFrames[i] < 22) && 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, ionColors;
let productsPositions, productsLabels, productsVisibility, productsReachedTarget, productColors;
let electronPositions, electronVisibility, electronReachedTarget, electronColors;
let electronStartPos;
let ionBlinkingFrames;
if (location === "anode") {
ionLabels = negativeIonLabels;
ionPositions = posOfNegativeIons;
ionStuckStatus = negativeIonsStuckStatus;
ionVisibility = negativeIonsVisibility;
ionBlinkingFrames = negativeIonBlinkingFrames;
productsPositions = posOfAnodeProducts;
productsLabels = anodeProductsLabels;
productsVisibility = anodeProductsVisibility;
productsReachedTarget = anodeProductsReachedTarget;
productColors = anodeProductsColors;
electronPositions = anodeElectronPositions;
electronVisibility = anodeElectronVisibility;
electronReachedTarget = anodeElectronReachedTarget;
electronStartPos = anodeElectronStartPos;
} else if (location === "cathode") {
ionLabels = positiveIonLabels;
ionPositions = posOfPositiveIons;
ionStuckStatus = positiveIonsStuckStatus;
ionVisibility = positiveIonsVisibility;
ionBlinkingFrames = positiveIonBlinkingFrames;
productsPositions = posOfCathodeProducts;
productsLabels = cathodeProductsLabels;
productsVisibility = cathodeProductsVisibility;
productsReachedTarget = cathodeProductsReachedTarget;
productColors = cathodeProductsColors;
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] || (ionBlinkingFrames[i] !== 0 && ionBlinkingFrames[i] !== 22))) {
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) {
console.log(ionBlinkingFrames);
// Remove the ions used in the reaction
const combinationIndices = [];
let allCanCreateProduct = true; // Flag to check if all ions can create a product
// First, collect all indices and check if all can create a product
for (const label of reactants) {
const index = availableIonsMap.get(label).pop();
combinationIndices.push(index);
// If any ion does not have blinkingFrames[index] > 0, set flag to false
if (ionBlinkingFrames[index] > 0) {
allCanCreateProduct = false;
}
}
// Now, handle each ion's visibility and blinking frames
for (const index of combinationIndices) {
if (allCanCreateProduct) {
// All ions are ready to create a product
ionVisibility[index] = false;
// Optionally, reset blinking frames if needed
ionBlinkingFrames[index] = 0;
} else {
// Handle blinking frames and visibility as before
if (ionBlinkingFrames[index] % 7 === 0) {
ionVisibility[index] = false;
} else {
ionVisibility[index] = true;
}
ionBlinkingFrames[index]--;
}
}
if (allCanCreateProduct) {
// 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);
productColors.push(colorMapping[product] || defaultIonColor);
// 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 = [];
positiveIonColors = [];
positiveIonBlinkingFrames = [];
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
positiveIonColors.push(colorMapping[ionType.formula] || defaultIonColor); // Default color if not mapped
positiveIonBlinkingFrames.push(22);
}
});
// Generate positions and labels for negative ions
posOfNegativeIons = [];
negativeIonLabels = [];
negativeIonsVisibility = [];
negativeIonsStuckStatus = [];
negativeIonColors = [];
negativeIonBlinkingFrames = [];
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
negativeIonColors.push(colorMapping[ionType.formula] || defaultIonColor); // Default color if not mapped
negativeIonBlinkingFrames.push(22);
}
});
// 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);
// Hide non-discharged ions if the option is disabled
if (!showNonDischargedIons) {
// Determine which ions are involved in reactions
const dischargedPositiveIons = new Set();
const dischargedNegativeIons = new Set();
reactions.forEach(reaction => {
if (reaction.location === "cathode") {
reaction.reactants.forEach(ion => dischargedPositiveIons.add(ion));
} else if (reaction.location === "anode") {
reaction.reactants.forEach(ion => dischargedNegativeIons.add(ion));
}
});
// Hide positive ions not involved in cathode reactions
for (let i = 0; i < positiveIonLabels.length; i++) {
if (!dischargedPositiveIons.has(positiveIonLabels[i])) {
positiveIonsVisibility[i] = false;
}
}
// Hide negative ions not involved in anode reactions
for (let i = 0; i < negativeIonLabels.length; i++) {
if (!dischargedNegativeIons.has(negativeIonLabels[i])) {
negativeIonsVisibility[i] = false;
}
}
}
// Clear products arrays
posOfAnodeProducts = [];
anodeProductsLabels = [];
anodeProductsVisibility = [];
anodeProductsReachedTarget = [];
anodeProductsColors = [];
posOfCathodeProducts = [];
cathodeProductsLabels = [];
cathodeProductsVisibility = [];
cathodeProductsReachedTarget = [];
cathodeProductsColors = [];
// Clear electron elements
anodeElectronPositions = [];
anodeElectronVisibility = [];
anodeElectronReachedTarget = [];
cathodeElectronPositions = [];
cathodeElectronVisibility = [];
cathodeElectronReachedTarget = [];
}
]]>
CODE_EDITOR
initSolution
true
false
{
if (reaction.location === "anode") {
currentAnodeProductColor = colorMapping[reaction.product];
} else if (reaction.location === "cathode") {
currentCathodeProductColor = colorMapping[reaction.product];
}
});
anodeFormula = solutionTypes[solutionType].anodeFormula;
cathodeFormula = solutionTypes[solutionType].cathodeFormula;
overallFormula = solutionTypes[solutionType].overallFormula;
resetIons();
anodeTestTubeLevel = 0;
cathodeTestTubeLevel = 0;
}
]]>
CODE_EDITOR
toggleNonDischargedVisibility
true
false