2. Week 02¶
This week we talked about UDL, Assessment, and Programming. Here is my blog post with notes.
Reflection¶
- When you design a learning activity how do you take into account diversity? Could you describe one learning situation in which you did not take into account diversity in planning? How did you solved the situation?
From a previous course I have taken on UDL I know to always ask what the important goals of a lesson / assessment are as I create it, and allow students to vary everything else. I am not grading students’ grammar in their design journals, or their ability to type or write. Therefore, they can create videos. In the current Project Planning unit I am doing with my Juniors and Seniors, I do not care what project they are planning - the content is in the group creation, so the students have varied projects from a concert, to a fashion show, to a town model. The things they are all doing are making a kanban board and having stand up meetings, building miletstones and running sprints.
In all curricula, I make sure to showcase diverse uses of the thing we’re learning. Programming gets used for art, for saving the world. I show the students diverse (ethnically, racially, gender, ability status as well as in interests) role models.
One class where I tried to consider diversity but did not consider how my own context would interact with the context of my students - I used Ron Eglash’s culturally situated design tools to teach about iteration using cornrow curls. I am white. My students were diverse, but several of them were black, several of them where Hispanic. They looked at this white lady telling them to program cornrow curls and laughed. The thing I learned from this was to allow my students to tell me their own culture, to allow my students to bring their culture to the classroom, and not to assume my students culture and take my view of their culture into the classroom. When I had the students teach dance through flowcharts, this worked much better. I didn’t assume my Puerto Rican students would want to teach me to salsa, even though some did. Invite culture, don’t assume it.
- What aspects would you need to take into consideration if you have kids with a) learning disabilities, b) physical disabilities, c)emotional disabilities when preparing your DF activities
The best thing about UDL is it encourages you to think about all the different ways you can teach something and share knowledge about something up front. I offer students the chance to write their thoughts, or create videos or podcasts (or drawings, as long as the drawings are clear). I try to offer the material by means of lecture, slides, writing, video, and hands-on activities. I give students graphic organizers to fill out. This helps students with learning disabilities, but also students without diagnosed learning disabilities.
To help students with emotional disabilities, again, I use the same tactics I do for everyone - make sure I’ve built a safe space. This means studetns are not allowed to put each other down at all. It means I make it clear that “wrong” answers are ok, that mistakes are great because we can all learn from them. I let all students take breaks, standing, stretching, walking around, if they need to. I have had quick reset meditation moments for all students.
Physical disabilities have always provided a challenge for me, even though I have always thought accommodating them was super important - one of my good friends in High School was blind. The drag-and-drop block-based coding environments are rarely accessible to students with visual or mobility impairments, but they make programming much easier for everyone else. Students enjoy building visually appealing games. The mobility impairments can be helped by different technology. The visual impairments can be helped by programming environments specifically built for screenreaders, like Quorum. Quorum is also even built to be research-supported in helping new programmers. Switching from something like Scratch to something like Quorum changes more of the programming generally, however. I do show all videos with captions (often youtube-generated, alas over the better human generated) for students with hearing impairments, but also for students who have ADHD like me to look up and see what we’re hearing.
- How do you usually assess learning activities which involve digital fabrication? Which is your favourite method? What aspects do you think you can change in your assessment practices?
For most of the projects I have the students work on, I have a rubric, with clear criteria and what makes each level different. The criteria often covers the “hard skills” in a section related to content coverage, that rewards students for trying things above and beyond what we have covered in class, and makes it clear what parts of the class should be in the project. The criteria also covers the “soft skills” - time management, teamwork, creativity. I do have a section on “execution” - while this is a fairly
- What could be the challenges when integrating programming in your classes?
On the one hand, this question doesn’t make sense for the classes I teach, given they are literally about programming. However! Teaching programming for over a decade has given me a strong understanding of what exactly the challenges of programming can be. I’m lucky at this school that the students all have laptops and a very responsive IT person. That said, you still have to get libraries, and permissions. Setting up the environment is often the hardest part of programming, and it’s the first thing you have to do. Mindset is also a huge challenge. Programming requires a lot of persistence, and being ok with things not working. Students have often learned that that’s not ok. Programming teachers have to help students be comfortable taking risks, seeing things not work, and trying more. I often help my students figure things out, but this alone is a problem as it teaches them learned helplessness - they know that when they struggle I will walk them through it and they will not try to struggle. There is a fine balance between making sure students don’t give up, and making sure students know how to persist on their own.
Project¶
I have been programming since High School, and teaching Scratch since 1.0 was in beta, so a traditional “make an easy game” did not seem to be the correct way to fulfill this assignment. This term, however, I am having my students design their own games and program them in Processing. Most of the students chose games I already had a fairly good idea of how I would program. One group chose block-blast, however. I initially assumed this was like breakout, but it’s closer to drag-and-drop tetris.
I sort of had no idea how to begin thinking about this game, so I looked up to see if anyone else had created in in Open Processing. One person had. Looking at that code gave me a way of framing the project, but actively coding it from scratch would be legitimately helpful for helping my students build it, so I created Block Blast in Open Processing for this project so that when it becomes time I can walk the students who are making BLock Blast through it.
As I attempted to code it from scratch, I realized there were a lot of things I just wanted an AI to create for me - like the 2D arrays of blocks, and initializing them. My FLA instructor had also recently suggested that I could lean into what the LLMs could do. The more I thought about it, the more I thought that it was important for students to understand every piece of their project, and be able to see how those pieces could make wholes, but it was not necessarily any more important that they make the 2D arrays of blocks from Scratch than that I did. So, I prompted ChatGPT to build this program for me. I had to clarify that BlockBlast was not Breakout, to start out. Then, the game worked, but it just built a grid and didn’t make the canvas large enough to have extra blocks at the bottom. That was easy enough to do - I kept ChatGPT’s Math and added to the bottom. Of course the blocks themselves were still on the grid, so I moved them to the bottom. First, this required me understanding where the available blocks were being created in the first place. Then, it required me understading the parameters that were used to make those blocks, and which was the y location. This was followed by me needing to know what I needed to do to the y to push it down to the place I wanted in the 2D array. The blocks were still over each other, so I needed to do math to change the xs. This also meant I had to understand what math needed to be done. A lot of these edits required me understanding how to read the code, and what it was doing. A lot of it also required me understanding the Math. I am not sure if “Math” is the subject I am teaching, but I do think that understanding the way Math affects programs is. The program below reflects this process, though there are still some errors - it doesn’t properly check rows and columns for instance.
This experience encouraged me to consider allowing the students to create their games using AI to help, and figuring out how to edit the code they build. On the one hand, I think when students start with going to a LLM to program for them, they don’t learn the concepts, and are less interested in learning the concepts later. One of my students wanted to create something for a game, and I promised “oh, that needs ArrayLists which we will go over next class.” By the time we went over it next class, he had prompted ChatGPT to build it for him, and wasn’t necessarily interested in learning the new idea. On the other hand… now that I’ve taught it to him he was able to better understand what ChatGPT gave him, and could consider editing it while I asked him questions about how. Also, I think the large projects often confuse the students on the concepts, while they are able to read the code no problem. So… I’m going to try letting students create the program the way I did, with prompting ChatGPT, and edit the program I did - by understanding what I wanted to change and finding where in the code I would need to change it and how. I would also encourage students to comment the code for themselves so that I know they understand what it is doing(I can tell when ChatGPT has commented code) and to turn in the conversations they had with ChatGPT.
I think a key here will be teaching people more about how to break down the problem, and solve one piece of it as a time. The skill would be putting those pieces together, which would also show me that they understand the concepts. ChatGPT annoyingly completely rewrites the whole code (even when you tell it not to) rather than giving you one piece at a time, but I think in order to properly comment you are going to have to understand each section ChatGPT added and check as well. ChatGPT also creates error-ridden code by default. It usually doesn’t have any problems fixing those errors when you tell them to ChatGPT, but it will at least proceed to explain to you why that happened (though I don’t expect students to spend much time reading the explanations - certainly I didn’t). Fixing the issue with ChatGPT also requires you to be very clear about what the issue is in the first place (often ChatGPT didn’t seem to fix the issue the first time, and I had to be clearer). I can have the students also create a video or slides or narrative explaining their process, what errors they were running into and what they learned as they solved each problem, which will hopefully encourage them to actively reflect on what ChatGPT is giving them. After exploring this idea some, I did decide that it made worse code initially, and also took way longer than just creating all the code and editing it slightly, but you could more easily poke at the error and make something work better in the end.
If this works well, it’s possible that coding with this new coding partner will be a more useful skill than building it from Scratch would have been in the first place. It is also the case that this is a class of sophomores who mostly don’t want to major in CS in college - so I am teaching them programming so that they can express themselves, and understand code as a thing they can use, so while it’s helpful for them to have a basic idea of what is happening, they don’t actually need to code from scratch often even if they are going to be programmers. Also, the idea of breaking a problem down, and debugging, is more important to me than any particular piece of syntax itself. I wonder if working with ChatGPT is going to be more or less frustrating? I certainly found “ChatGPT makes a whole program and I fix the parts I want” to be a very fast way to create the code, and “Ask ChatGPT for each part and to debug for me” to be generally frustrating, but I have been programming a lot longer than they have.
ChatGPT conversation¶
I accidentally deleted my (not-signed-in) ChatGPT tab where I created a lot of the “iterate with ChatGPT” version of this program. I should make sure to have students document each question they ask so this does not happen to them.
Basically, I started with “Make a 10x10 grid I will put blocks on for a game of Block Blast” which it did just fine then “add to the end a space to keep available blocks” which it did with a variable that worked fine.
Then, I had it build a block it could drag on the grid. It had a super hard time allowing me to drag it into the grid itself, even after several iterations of me telling it the problem. It did eventually figure that out, however, and created an offset for where my mouse was.
I then had it make several blocks. At first, it created a structure without methods; I encouraged it to make the block into an object to make it more readable. ChatGPT did so, and then lectured me on how useful objects with methods were and why (I know, this is why I asked you to do it >< ). Then, I realized all the blocks were on top of each other (which was also the case when I had it build Block Blast from scratch, interestingly), but it was quickly able to create the offset. Then, there were problems where all blocks moved when I was dragging one, which caused ChatGPT to create an “beingDragged” variable and make sure only the first block was set to that.
I then tried to create different sized blocks. This completely threw off literally everything - ChatGPT took it upon itself to also randomize starting location and color and I had blinking blocks at the edge of the screen. I tried to fix this a few different ways, but it was clearly at that point very confused. So, I went back to 3 blocks at the bottom that were all the same 2x2 square - it took some prompting to get it back to that. I could have instead gone up higher in the conversation, but I wanted to make sure ChatGPT and I were on the same page about the most recent code I was looking at and I didn’t feel like reading from the top. I then gave up for a minute on using this differently shaped blocks, to try making it do the next thing I wanted it to do.
I then tried to make it create a new block every time I snapped an old block. That would just make things bounce back to the bottom. Each time I told it what I wanted it to do, it would repeat the same error despite the prose it wrote telling me it understood what I wanted and describing what I wanted correctly. Eventually I asked it “please tell me how this code keeps the previous block snapped?” which is the thing that made it realize it’s error, and then it fixed the issue. This would have been much faster for me to fix for myself (I did, in fact, know the error), but I don’t necessarily expect my students would be able to. Still figuring out how I feel about using this tech for the students’ games.
Having gotten that to work, I tried making ChatGPT make the program delete a row when it was complete. It promised to do this, but kept writing things that did not do it at all. Eventually, I told ChatGPT “I think you’re going about the logic wrong here. I would: \1. figure out where the block was put down \2. Figure out which squares of the grid that would fill \3. Fill those squares with a different color \4. Destroy that block \5. Check if placing this block completed any rows or columns. \6. Replace the block with a new one at the bottom of the screen.” At which point it gave me a program that did close to what I wanted it to do, but appeared to have an x and y mixup. I told it that, and it fixed the x / y mixup for me. I realized it was also filling in the last square after deleting, so I told it to place the block then delete the row, which it did.
This is the point where I realized another thing collaboriting with ChatGPT required was a good understanding of tests. Did it only remove the row in question, and not everything around it? Did it remove 2 rows if both happened at the same time? Did it remove columns in this manner as well? The answer to all of these was yes, but coming up with these tests is a skill that I would like to make sure my students have, and this seems like a good way to supply it.
With that working, I should have gone straight to scoring because that will probably be the next easiest thing to implement, and is important for a game, but I was more interested in seeing if my better understanding of ChatGPT prompting at this point could get it to make the z and T shapes “like you find in tetris.” ChatGPT immediately understood that it would need to implement these blocks as 2D arrays, and explained that to me (so far so good!). It made 3 blocks, one of which was a T, another an L and another a Z. However, they were on top of each other, so I told ChatGPT to make that not happen. It claimed it could, but the code didn’t actually change much. I said “I think you’ll need to space out the bottom row by making the x start at the widest block (which I think is 4x squaresize) and add 10 or something” and this made something that worked approximately. I still have to look more closely at the code to see why when it makes new blocks it sometimes makes those It replaced each block randomly. From there, I just had to give it proper spacing, and it worked.
Each time ChatGPT fixed a problem it was having a hard time fixing, I asked it for the line of code that fixed that problem, and to explain it.
There are still a bunch of issues with this code – I didn’t get to the part where you can’t put blocks on top of each other in the grid, and the blocks still overlap in future rounds, and I don’t have a score yet, but it’s a fairly good start.
Lessons learned:¶
- Giving ChatGPT ordered logic is much better than giving it things you want to happen. Which is great, because it means my students will still need to think abou the logic. This includes, for instance, telling ChatGPT what error you think it made. (I think you mixed up an x and a y worked really well, whereas “squares showed up in the wrong place” didn’t).
- Asking ChatGPT to find specific lines of code that did something will help it realize that it didn’t write that code.
- ChatGPT re-writes the entire code every time, but it will find specific lines for you after. (Not always exactly correct ones)
Code¶
Walking ChatGPT through making the code step-by-step¶
This is the code I got through the process described in “Conversation with ChatGPT”
let gridSize = 10; // 10x10 grid
let squareSize;
let blocks = []; // Array to store multiple blocks
let bottomSpace = 100; // Space at the bottom to hold blocks
let grid = []; // To track which positions on the grid are occupied
function setup() {
createCanvas(400, 500); // Increased height to add space for blocks
squareSize = width / gridSize; // Size of each square based on the canvas width
// Initialize the grid array to track empty and filled cells
for (let i = 0; i < gridSize; i++) {
grid[i] = new Array(gridSize).fill(false); // Initialize all as false (empty)
}
// Calculate the starting X positions for the blocks
let blockWidth = 4 * squareSize + 10; // For largest block (4 squares wide)
// Create 3 random Tetris-like blocks with more space between them at the bottom
blocks.push(new Block(50, gridSize * squareSize + 10, 'T')); // T block
blocks.push(new Block(50 + blockWidth, gridSize * squareSize + 10, 'L')); // L block
blocks.push(new Block(50 + 2 * blockWidth, gridSize * squareSize + 10, 'Z')); // Z block
}
function draw() {
background(255); // Set background to white
// Draw the grid
for (let i = 0; i < gridSize; i++) {
for (let j = 0; j < gridSize; j++) {
let x = i * squareSize;
let y = j * squareSize;
stroke(0);
fill(grid[j][i] ? 'red' : 200); // Fill with red if the square is occupied
rect(x, y, squareSize, squareSize);
}
}
// Draw the bottom space for blocks
fill(180);
noStroke();
rect(0, gridSize * squareSize, width, bottomSpace);
// Loop through the blocks and draw them
for (let block of blocks) {
block.show(); // Use the show method of the Block class to render it
}
}
function mousePressed() {
// Check if the mouse is over any block to allow dragging
for (let block of blocks) {
if (block.isMouseOver(mouseX, mouseY)) {
block.startDragging(mouseX, mouseY); // Start dragging the block
}
}
}
function mouseReleased() {
// Only stop dragging and snap to grid for the block that is being dragged
for (let block of blocks) {
if (block.isDragging) {
block.stopDragging(); // Stop dragging the block
block.snapToGrid(); // Snap the block to the grid
// After snapping, fill the appropriate grid squares
if (block.y < gridSize * squareSize) {
let gridX = floor(block.x / squareSize); // Convert x position to grid column
let gridY = floor(block.y / squareSize); // Convert y position to grid row
// Fill the squares the block occupies
block.fillGrid(gridX, gridY);
// Now check if any row is full and clear it after the block is placed
checkAndClearRows();
// Destroy the block (remove it from the array)
blocks = blocks.filter(b => b !== block);
// Add a new block at the bottom of the screen with a slight offset
blocks.push(new Block(random([50, 150, 250]), gridSize * squareSize + 10, random(['T', 'L', 'Z'])));
}
}
}
}
function mouseDragged() {
// Update the position of any block being dragged
for (let block of blocks) {
if (block.isDragging) {
block.updatePosition(mouseX, mouseY); // Update the block's position while dragging
}
}
}
// Block class to handle each block's behavior
class Block {
constructor(x, y, type) {
this.x = x;
this.y = y;
this.type = type; // Type of the block ('T', 'L', 'Z')
this.isDragging = false; // Flag to check if the block is being dragged
this.offsetX = 0; // Mouse offset for dragging
this.offsetY = 0; // Mouse offset for dragging
// Define the block shapes
this.shapes = {
T: [
[false, true, false],
[true, true, true]
],
L: [
[false, false, true],
[true, true, true]
],
Z: [
[true, true, false],
[false, true, true]
]
};
this.shape = this.shapes[type]; // Select the shape based on the type
this.size = this.shape.length; // Size is the length of the shape (assumed square)
}
// Method to display the block
show() {
fill(255, 0, 0); // Red color for the block
noStroke();
// Loop through the shape and draw each square
for (let row = 0; row < this.shape.length; row++) {
for (let col = 0; col < this.shape[row].length; col++) {
if (this.shape[row][col]) {
rect(this.x + col * squareSize, this.y + row * squareSize, squareSize, squareSize);
}
}
}
}
// Method to check if the mouse is over the block
isMouseOver(mouseX, mouseY) {
return mouseX >= this.x && mouseX <= this.x + this.size * squareSize &&
mouseY >= this.y && mouseY <= this.y + this.size * squareSize;
}
// Method to start dragging the block
startDragging(mouseX, mouseY) {
this.isDragging = true;
this.offsetX = mouseX - this.x;
this.offsetY = mouseY - this.y;
}
// Method to stop dragging the block
stopDragging() {
this.isDragging = false;
}
// Method to update the position of the block while dragging
updatePosition(mouseX, mouseY) {
this.x = mouseX - this.offsetX;
this.y = mouseY - this.offsetY;
// Constrain the block to the canvas
this.x = constrain(this.x, 0, width - this.size * squareSize);
this.y = constrain(this.y, 0, height - this.size * squareSize);
}
// Method to snap the block to the nearest grid cell
snapToGrid() {
let snappedX = floor(this.x / squareSize) * squareSize;
let snappedY = floor(this.y / squareSize) * squareSize;
// Ensure the block stays within the grid area (not outside the canvas)
snappedX = constrain(snappedX, 0, (gridSize - this.size) * squareSize);
snappedY = constrain(snappedY, 0, (gridSize - this.size) * squareSize);
// Set the block's position to the snapped grid position
this.x = snappedX;
this.y = snappedY;
}
// Method to fill the grid with the block's squares
fillGrid(gridX, gridY) {
for (let row = 0; row < this.shape.length; row++) {
for (let col = 0; col < this.shape[row].length; col++) {
if (this.shape[row][col]) {
let xPos = gridX + col;
let yPos = gridY + row;
if (xPos < gridSize && yPos < gridSize) {
grid[yPos][xPos] = true; // Mark the grid cell as occupied
}
}
}
}
}
}
// Function to check if any row is filled and clear it
function checkAndClearRows() {
for (let row = 0; row < gridSize; row++) {
// Check if all columns in this row are filled
let rowFilled = true;
for (let col = 0; col < gridSize; col++) {
if (!grid[row][col]) {
rowFilled = false; // Found an empty cell, so the row is not filled
break;
}
}
if (rowFilled) {
console.log(`Row ${row} is full, clearing squares`);
// Clear the row (remove blocks from the grid)
for (let col = 0; col < gridSize; col++) {
grid[row][col] = false; // Clear the cell in the grid
}
// Log the cleared grid for debugging purposes
console.log('Grid after clearing row:', grid);
}
}
}
Asking ChatGPT to make Block Blast and then editing it myself.¶
This was what I got for asking for Block Blast in it’s entirety, and then fixing it myself. It’s not actually complete in the way I walked through the one above to be.
// Game settings
const gridSize = 10; // Grid is 10x10
const blockSize = 40; // Size of each block
let grid = []; // Game grid
let currentBlock; // Block currently being dragged
let dragging = false; // Flag for dragging state
let availableBlocks = []; // Initial blocks that can be dragged
function setup() {
createCanvas(gridSize * blockSize, gridSize * blockSize + 200);
// Initialize the grid with empty cells (false)
for (let i = 0; i < gridSize; i++) {
grid[i] = [];
for (let j = 0; j < gridSize; j++) {
grid[i][j] = false;
}
}
// Create random blocks for the player to drag
createAvailableBlocks();
}
function draw() {
background(240);
// Draw the grid
drawGrid();
// Draw the available blocks
for (let block of availableBlocks) {
block.display();
}
// Draw the current block while dragging
if (dragging && currentBlock) {
currentBlock.x = mouseX - blockSize / 2;
currentBlock.y = mouseY - blockSize / 2;
currentBlock.display();
}
// Check for completed rows or columns
checkForCompletedRows();
checkForCompletedColumns();
}
// Draw the game grid
function drawGrid() {
stroke(0);
for (let i = 0; i < gridSize; i++) {
for (let j = 0; j < gridSize; j++) {
if (grid[i][j]) {
fill(0, 0, 255); // Filled block color
} else {
noFill();
}
rect(i * blockSize, j * blockSize, blockSize, blockSize);
}
}
}
// Create a set of random blocks for the player to drag
function createAvailableBlocks() {
const shapes = [
[[1, 1], [1, 1]], // 2x2 block
[[1, 1, 1], [0, 1, 0]], // T shape
[[1, 1, 0], [0, 1, 1]], // S shape
[[0, 1, 1], [1, 1, 0]] // Z shape
];
for (let i = 0; i < 3; i++) { // Create 3 random blocks for the player to drag
const shape = random(shapes);
const block = new Block(shape, i * ((blockSize * 3) + 10), gridSize * blockSize +10); // Place blocks at different starting positions
availableBlocks.push(block);
}
}
// Block class
class Block {
constructor(shape, x, y) {
this.shape = shape;
this.x = x;
this.y = y;
}
// Display the block
display() {
for (let i = 0; i < this.shape.length; i++) {
for (let j = 0; j < this.shape[i].length; j++) {
if (this.shape[i][j] === 1) {
fill(255, 0, 0);
noStroke();
rect(this.x + j * blockSize, this.y + i * blockSize, blockSize, blockSize);
}
}
}
}
// Check if the block can be dropped at its current position
canPlace() {
for (let i = 0; i < this.shape.length; i++) {
for (let j = 0; j < this.shape[i].length; j++) {
if (this.shape[i][j] === 1) {
let gridX = Math.floor((this.x + j * blockSize) / blockSize);
let gridY = Math.floor((this.y + i * blockSize) / blockSize);
if (gridX < 0 || gridX >= gridSize || gridY < 0 || gridY >= gridSize || grid[gridX][gridY]) {
return false;
}
}
}
}
return true;
}
// Place the block on the grid
place() {
for (let i = 0; i < this.shape.length; i++) {
for (let j = 0; j < this.shape[i].length; j++) {
if (this.shape[i][j] === 1) {
let gridX = Math.floor((this.x + j * blockSize) / blockSize);
let gridY = Math.floor((this.y + i * blockSize) / blockSize);
grid[gridX][gridY] = true;
}
}
}
// Remove the block from the available blocks after placement
availableBlocks.splice(availableBlocks.indexOf(this), 1);
createRandomBlock(); // Create a new block after one is placed
}
}
// Create a new random block after one is placed
function createRandomBlock() {
const shapes = [
[[1, 1], [1, 1]], // 2x2 block
[[1, 1, 1], [0, 1, 0]], // T shape
[[1, 1, 0], [0, 1, 1]], // S shape
[[0, 1, 1], [1, 1, 0]] // Z shape
];
const shape = random(shapes);
const block = new Block(shape, random(width - 100), random(20, 100));
availableBlocks.push(block);
}
// Check for completed rows
function checkForCompletedRows() {
for (let row = 0; row < gridSize; row++) {
let fullRow = true;
for (let col = 0; col < gridSize; col++) {
if (!grid[row][col]) {
fullRow = false;
break;
}
}
if (fullRow) {
// Clear row and shift others down
for (let r = row; r > 0; r--) {
for (let c = 0; c < gridSize; c++) {
grid[r][c] = grid[r - 1][c];
}
}
// Empty the first row
for (let c = 0; c < gridSize; c++) {
grid[0][c] = false;
}
}
}
}
// Check for completed columns
function checkForCompletedColumns() {
for (let col = 0; col < gridSize; col++) {
let fullColumn = true;
for (let row = 0; row < gridSize; row++) {
if (!grid[row][col]) {
fullColumn = false;
break;
}
}
if (fullColumn) {
// Clear column and shift others left
for (let c = col; c < gridSize - 1; c++) {
for (let r = 0; r < gridSize; r++) {
grid[r][c] = grid[r][c + 1];
}
}
// Empty the last column
for (let r = 0; r < gridSize; r++) {
grid[r][gridSize - 1] = false;
}
}
}
}
// Start dragging the block
function mousePressed() {
for (let block of availableBlocks) {
if (mouseX > block.x && mouseX < block.x + block.shape[0].length * blockSize &&
mouseY > block.y && mouseY < block.y + block.shape.length * blockSize) {
currentBlock = block;
dragging = true;
break;
}
}
}
// Stop dragging the block
function mouseReleased() {
if (dragging && currentBlock) {
if (currentBlock.canPlace()) {
currentBlock.place();
}
dragging = false;
currentBlock = null;
}
}