Showing posts with label games. Show all posts
Showing posts with label games. Show all posts

Monday, November 24, 2014

Learning how to code: Gamecodization - first results

(Usa la lista desplegable de idiomas del menú de la derecha para traducir este artículo.
Artikulu hau euskaratzeko erabili eskumako menuan kokatuta dagoen hizkuntza-zerrenda) --->


This 2014/2015 school year’s first term is about to expire. After approximately 12 lessons of coding (less than 12 hours of work), and one week for project development (homework time) the final results are really awesome, taking into count that:


  1. Students didn’t have any previous knowledge about coding.
  2. They didn’t know anything about game strategies.


As a picture’s worth a thousand words, have a look at this video to see some examples:




Here you have some of my first conclusions about this exciting project called Gamecodization (more at gamecodization.com):

  1. Different levels of students: superb (20%), average (70%), poor (10%).
    1. I divided coding exercises in stages, so all students could catch up eventually.
    2. I had to consider repeating 1 session for the lost ones.

  1. Student types:
    1. Engaged: they know what they’re doing. They use pseudocode wisely. They understand and solve. They want to learn deeper.
    2. Robotic: they translate pseudocode without much understanding. They don’t really know where to place code (inside loops, conditions…).
    3. Lazy: they need to have most of the pieces in place to start understanding things.

  1. Pseudocode:
    1. It’s key to help students in the beginning.
    2. It can be a problem when students just do things robotically, translating from pseudocode to code without further understanding.

  1. Debugging.
    1. Students don’t read compiler’s messages, they prefer to ask the teacher.
    2. There are plenty of problems with variable names due to case sensitiveness.
    3. I instructed my students to use PRINT sparingly to know variables’ states.

  1. Exercise phases: a single exercise can have many stages (increasing complexity). Start really simple and build on them more layers. Examples:
    1. Guess the number. Stages:
      1. Calculate a random number and print it properly (no decimals).
      2. Read a number from the console and print it.
      3. Now compare both numbers, for higher than and lower than.
      4. Loop everything until the win state is reached.
      5. Include other elements: messages, points, leaderboards, preferences.
    2. Avoid long, tedious exercises to avoid students getting stuck.

  1. Homework:
    1. Aside of coding games, basic exercises are of help to clarify some concepts:
      1. Basic operations: use of the console, file I/O.
      2. Arranging of elements.
      3. Dynamic data structures.
      4. Etc.
    2. I gathered my students in groups and gave them flipped resources so they could group in teams at home.

  1. Assessment:
    1. Projects in pairs (in three people groups one of the participants tends not to work as hard as the rest).
      1. Ask for pseudocode and code: the last one could not execute in the last time. And as a teacher you can always check the pseudocode to tutor them better.
      2. Some interesting and easy games to develop.
        1. Escape the maze.
        2. Arkanoid.
        3. Asteroids.
        4. Snake.
        5. Frogger.
        6. Space invaders.
        7. Other of their choice.
    2. Test exam:
      1. This will make them memorize better basic instructions (LET, PRINT…). Otherwise they’ll feel they don’t have to bear anything in mind, and they’ll waste lots of time checking compiler’s help all the time.
      2. Anyway, I made it easy, in the end you want to keep fun in your classes.
    3. Grade: you have three elements for grading.
      1. Theory: test.
      2. Practice: pseudocode and code (if code works well pseudocode shouldn’t grade anymore).
      3. Attitude, interest, behaviour.

  1. Game structure for arcades: for this first stage all the game developed have been based in the following algorithm.
    1. Initialization.
    2. Main loop
      1. Movement.
      2. Laser
      3. Enemies.
      4. Collisions.
      5. Items (keys…).
      6. Win-state check.
    3. End of game
    4. Leaderboard.


The main strategy for teaching coding through games has been:

  1. The idea is not to teach the coding language used (in this case Basic256), but to teach coding basis (sequences, conditions and loops) and strategies to build games.

  1. As lessons went ahead, I maintained a document (a sort of a cheat sheet), so they could know what instructions and concepts had been worked with, so they didn’t need to check the official documentation over and over.

  1. It’s key to start teaching very basic things through a simple game, in this case “Guess the number”.
    1. Print on the text console.
    2. Read a number from the console.
    3. Calculate a random number.
    4. Compare both numbers.
    5. Repeat the operation until the number is guessed.

  1. With the previous game you’ve covered the three structures and some instructions, as PRINT, READ, RAND, LET; WHILE, IF THEN.

  1. The students shouldn’t be breaking their heads trying to figure out complex things. For example, I gave them enough information to calculate a random number, as INT(RAND*10). The same goes for spaceship movement, collisions, point scoring and so on. It’s like giving them basic pieces so they can combine them in different ways to create a wide range of outcomes.

  1. I passed rapidly to graphic based games. Visuals are key for students. For the second exercise we developed a rebounding point:
    1. Concepts of x,y positioning (plot).
    2. Variable for controlling the direction of the point (NE, NW, SE, SW).
    3. Out-of-bounds control, to make the point move properly.

  1. For the third exercise we started developing the Asteroids game (reduced version). In it I introduced the concepts of game structure (main loop), etc. Challenges took the form of:
    1. How to move several elements at the same time: they tried using FORs, popping up the concept of time slicing.
    2. How to set an element’s life-cycle in the main loop (as a laser), also popping the concept of flags.
    3. One of the topmost curious things was the fact that some students had the tendency to include code out of the main loop, revealing they hadn’t understood correctly previous concepts.

  1. Other aspects, as sprite collision, were easier to solve, as basic256 includes several ad-hoc functions. It is so easy to manage you don’t even need arrays to structure your sprites, as you can use expressions like SPRITEPLACE 1, SPRITEX(1)+5, SPRITEY(1) to move the sprite #1 to the right 5 positions.

  1. After finishing the basic version of asteroids we started including other elements: explosions, animations, points, leaderboards...

  1. As a final project my students had the opportunity to choose a game and develop it in groups (check the video).

Sunday, September 28, 2014

Gamification: a quick guide

Gamification. Let’s get down to work!


sponsor-badges.pngSimply said: the application of game elements in a system to better engage its participants. That is, you don’t transform your lessons into games, but you introduce game elements to ensure engagement.

ELEMENTS



The most commented elements to be used are the PBL triad: points, badges and leaderboards:
  1. Points: valuable units you earn when doing certain things. They have to be connected to rewards, like real points for your grade. Years ago I enrolled in a course inside a Moodle platform. Each action (as checking links, commenting in a forum, submitting documents, etc) was rewarded with points , and with them badges were earned.
    1. PRO: students can see their participation is rewarded.
    2. CON: doing actions just for earning points.
  2. Badges: representation of achievement. They give some social status.
    1. PRO: the proud and effort of achieving one.
    2. CON: discrimination and categorization inside classroom.
  3. Leaderboards: take the previous two and make an ordered list from top to down to know who’s winning.
    1. PRO: knowing where you are, competitivity, bragging rights.
    2. CON: creating a gap too big in classroom’s social structure; lazy students giving up.


xxx


There are more elements to be used:
  1. Progress bars, maps, and the like: to know where you are in the process.
  2. Easter eggs: strategically placed items to be found so you attract students to specific places.
  3. Random/sudden rewards: the more time you invest in the system, the bigger likelihood to obtain a random prize.
  4. Unlocking elements: keys opening treasure chests. Finish a task to unlock the next one.
  5. Webquests.
  6. Feedback: behaviour infused elements in your system.
  7. Storytelling: wrap up a boring lesson inside a story.
  8. Avatars:I believe these help in entering the magic circle, which is the locked environment where the game is played and its rules are naturally followed by students.
  9. Level-ups: similar to pokemon evolution. After assimilating some new abilities you get transformed into something more powerful.
  10. Certificates of achievement: similar to badges.
  11. Checklists of accomplishment: similar to progress bars.


GAMES


I’ve already said gamification doesn’t deal with game design, but that can be useful when designing our lessons. Three features are to be taken in count:
  1. Player’s journey:
    1. Onboarding: tinny tutorials to help students start. New knowledge is given as new rules are introduced, so first-time long explanations are avoided. Participants just know what they need.
    2. Scaffolding: progressive levels of difficulty.
    3. Paths to mastery: the road to students’ skill growth.
  2. Balance: equilibrating the rules so plummeting and rocketing are avoided.
  3. Experience creation: it has to be as real as it can. That way the magic circle gets stronger.





THE GAMIFIED LESSON


If we put everything in place our gamified lesson will have these features:
  1. Onboarding.
  2. Scaffolding.
  3. Social.
  4. Multifeedback.
  5. Map.
  6. Exchangeable rewards.


Gamification also deals with psychology: self determination, player models, engagement loops, progression loops, motivation, etc. Also with player types: killers, achievers, socializers and explorers. A lot to say about the previous, but it’s not this article’s point. You can find several MOOCs on gamification:

  1. I’ve personally done these two. There are good teachers, explain everything in a straightforward manner and the contents are really of great value. Check them!
  2. There’s another one I can’t comment about:




HOW TO’S: MOODLE


There’s an LMS which includes some features for gamification and that’s Moodle:


  1. Badges: PBL model, included in version 2.5.
  2. Points: try Level up!, a plugin design to score points as you get involved in different activities.
  3. Conditional elements:
    1. Progress bars: you have an ad-hoc plugin, or you can devise your own. Create several progress bar images (as photograms). Put each in a label, hide them and make them appear consecutively as tasks are being finished. Students will see just one bar changing its state (as in an animation film). Something similar is the lesson objectives module.
    2. Maps: it’s the same as in progress bars. You can open Photoshop or a layer based editing software, load a rectangular landscape (LOTR style) and a hero on another layer. Save the picture several times with the hero appearing in different spots of the landscape. Use those pictures as photograms.
    3. Random rewards: use the restrict access option. Quick example: create a hidden label with a treasure picture. Program it to appear at some time. Students will see the treasure as if it were random. With activity completion students can gather the treasure clicking on the check box.
    4. Easter eggs: tell your students some eggs have to be found. Place them in spots you want your students to go to. When clicking use a similar strategy as in random rewards.
    5. Element unlocking: use restrict access.
    6. Onboarding: place knowledge pills in hidden labels and make them appear as students go on accomplishing tasks.
  4. Activity completion: control how activities are accomplished (by seeing them, by obtaining a grade or by submitting them). It’s embedded in the system, so just activate it to get it in motion.
    1. Checklist: There’s an interesting plugin called Checklist to help students control their activities.
    2. Level-ups: make a level change label appear after finalizing some task.
  5. Games: even though gamification is not about games per se you can introduce some to reinforce the use of your glossaries (e.g through classic games as Hangman, Crosswords, etc.)
  6. Social: forums and chats.

AESTHETICS


This is a term I repeat over and over. A gamified lesson can lose power if it looks dull. To spice it up a little bit you can use these tricks:
  1. Use graphical labels instead of mere text.
  2. Decorate your course page with icons and images.
  3. Use dynamic and full of images resources as videos, presentations or animations: issuu, slideshare, pininterest, easel.ly, ted-ed, khan academy, phet, visual.ly, prezi. Check my Symbaloo boards (#1, #2) for more information.
  4. Consider embedding resources in labels on the course page instead of just placing the links. That gives it more color, but it also overloads it.