ctf-server

MapUtil.scala

(6905B)

 package com.jcabrra
 package snippet
 
 import model._
 import net.liftweb._
 import http._
 import js._
 import JsCmds._
 import JE._
 import util._
 import util.Helpers._
 import xml.NodeSeq
 import net.liftmodules.extras._
 
 /**
  * TODO Future: Use MVVM and clean this up
  */
 object MapUtil {
   val (long,lat) = (
       Props.get("center.long") openOr "-73.989015", 
       Props.get("center.lat") openOr "40.752459")
   val zoomLevel = Props.get("center.zoomlevel") openOr "15"
   val container = "map"
   
   def genMap = {
     type GPS = (Double, Double)
     val challenges: Map[Challenge, GPS] = Challenge.findAll.map(c => (c, (c.long.get, c.lat.get))).toMap
     val capturedFlags = User.currentUser.map(_.capturedFlags.toList) openOr Nil
     
     val flags: Map[Flag, GPS] = Flag.findAll.map(f => (f, {
       if(capturedFlags.exists(_.id == f.id)) (f.long.get, f.lat.get)
       else f.genNearbyGPS
     })).toMap
     
     val unlockedFlags = 
       capturedFlags.flatMap(_.unlocks).flatMap(_.flags) ::: 
       flags.map(_._1).filter(_.prerequisite.isEmpty).toList
       
     val winningFlags = flags.map(_._1).filter(_.winner.get)
     		
     S.appendJs(JsRaw(s"""
         var po = org.polymaps;
         var map = po.map().container(
     		document.getElementById("$container").appendChild(po.svg("svg")))
 				.center({
 					lat : $lat,
 					lon : $long
 				}).zoom($zoomLevel).add(po.drag());
 		map.add(po.image().url(
 			po.url(
 				"http://{S}tile.cloudmade.com"
 					+ "/1a1b06b230af4efdbb989ea99e9841af"
 					+ "/999/256/{Z}/{X}/{Y}.png").hosts(
 					[ "a.", "b.", "c.", "" ])));
 		map.add(po.geoJson().features([${
     		// Generate Paths  		
     		val paths = flags.map { x => 
     		  val flag = x._1
     		  val (longA, latA) = x._2
     		  flag.prerequisite.map { preFlag => 
     		    
     		    val (longB, latB) = flags.get(preFlag).getOrElse((0,0))
     		    s"""{"geometry":{"coordinates":[[$longA,$latA],[$longB,$latB]],"type":"LineString"}}"""
     		  } mkString ","
     		}.foldLeft("")((a,b) => if(a.isEmpty || b.isEmpty) a+b else a+","+b)
     		    		
     		paths
     	}]).on("load", loadFlagPaths));
     
     	function loadFlagPaths(e) {
 			${
 			  val ids = flags.flatMap(_._1.prerequisite).map(_.id.get).toList
 			  var ret = ""
 			  for (i <- 0 until ids.size) {
 			    val captured = User.currentUser.exists(_.capturedFlags.exists(_.id.get == ids(i)))
 			    ret += s"""
             e.features[$i].element.id = "map-path${ids(i)}";
 			      e.features[$i].element.addClass("${if(captured) "captured" else ""}");
 			    """			  
 			  }
 			  ret
 			}
 		}
     
     	map.add(po.geoJson().features([${
     		// Generate flag points  		
     		val points = flags.map { x =>
     		    val (nearLong, nearLat) = x._2
     		    s"""{"geometry":{"coordinates":[$nearLong,$nearLat],"type":"Point"}}"""
     		} mkString ","
     		
     		points
     	}]).on("load", loadFlagPoints));
     	
     	function loadFlagPoints(e) {
 			${
 			  val ids = flags.map(_._1.id.get).toList
 			  var ret = ""
 			  for (i <- 0 until flags.size) {
 			    val captured = capturedFlags.exists(_.id.get == ids(i))
 			    val unlocked = unlockedFlags.exists(_.id.get == ids(i))
 			    val winner = winningFlags.exists(_.id.get == ids(i))
 			    
 			    ret += s"""
 			      e.features[$i].element.id = "map-flag${ids(i)}";
 			      e.features[$i].element.addClass("${if(captured) "captured" else ""}");
 			      e.features[$i].element.addClass("${if(!captured && unlocked) "unlocked" else ""}");
 			      e.features[$i].element.addClass("${if(winner) "winner" else ""}");
 			  	  e.features[$i].element.setAttribute("r", "${if(winner) "15" else "8"}");
 			    """			  
 			  }
 			  ret
 			}
 		}
 			
 		map.add(po.geoJson().features([${
     		// Generate challenge points  		
     		val points = challenges.map { x =>
     		    val (nearLong, nearLat) = x._2
     		    s"""{"geometry":{"coordinates":[$nearLong,$nearLat],"type":"Point"}}"""
     		} mkString ","
     		
     		points
     	}]).on("load", loadChallengePoints));
     	
     	function loadChallengePoints(e) {
 			${
 			  val ids = challenges.map(_._1.id.get).toList
 			  val radius = challenges.map(_._1.radius.get).toList
 			  var ret = ""
 			  for (i <- 0 until challenges.size) {
 			    ret += s"""
 			      e.features[$i].element.id = "map-challenge${ids(i)}";
 			  	  e.features[$i].element.setAttribute("r", "${radius(i)}");
 			    """			  
 			  }
 			  ret
 			}
 		}
 			
     	${
     	  // Generate Popovers
     	  challenges.map {
     	    c =>
     	      val challenge = c._1
     	      
     	      def capturedBy: NodeSeq = challenge.flags.flatMap(_.capturedBy).map {
     	        user => <img width='25' height='25' src={user.image.get}></img>
     	      }
     	      
     	      "$('#map-challenge"+challenge.id+"').popover({" + 
     	      s"""
     	      	"title" : "${challenge.name}",
     	      	"content" : "${
     	      	  
     	      	  def escDoubleQuote(str: String): String = {
     	      	    str.toList.map(_.toString).map(ch =>
     	      	    if (ch == "\"") "\\\"" else ch).mkString
     	      	  }
     	      	  
     	      	  val cont = User.currentUser.map {
     	      	    user =>
     	      	      
     	      	      def process(guess: String): JsCmd = {
     	      	        Challenges.processResponse(guess, user, challenge)
     	      	        SetValById(challenge.name+"-input", "")
     	      	      }
     	      	      
     	      	      def capturedFlags: NodeSeq = challenge.capturedFlags(user).map {
     	      	        flag => <p class='text-success'>{flag.answer}</p>
     	      	      }
 
     	      	      def input: NodeSeq = 
     	      	        if(challenge.fullySolvedBy(user)) NodeSeq.Empty 
     	      	        else SHtml.ajaxText("", false, process _, 
     	      	            "id" -> (challenge.name+"-input"), "placeholder" -> "guess")
     	      	        
     	      	      if(challenge.meetsPrerequisite(user)) {
     	      	        capturedFlags ++ <p>{challenge.hint}</p> ++ input ++ <p>{capturedBy}</p>
     	      	      } else {
     	      	        <p class='text-danger'>LOCKED!</p> ++ capturedBy
     	      	      }
     	      	  }.openOr(<p><a href='/login'>Join The Fun!</a></p> ++ capturedBy)  
     	      	  escDoubleQuote(cont.toString)
     	      	}",
     	      	"container" : "#$container",
     	      	"placement" : "bottom",
     	      	"html" : true
     	      	});
     	      	
     	      	window.onload = function() {
     	      		var unlockedOpacity;
     	      		setInterval(function() {
     	      			unlockedOpacity = unlockedOpacity === '1' ? '0.5' : '1';
           				jQuery(".unlocked").css("fill-opacity", unlockedOpacity);
     	      			po.geoJson().reload;
     	      		}, 500);
     	      	};
     	      	
     	      	map.on("move", function() {
     	      		jQuery(".popover").hide();
     	      	});
     	      """ 
     	  }.mkString
     	}
     """).cmd)
     "*" #> NodeSeq.Empty
   }
 }