Spieler 1:
- Spieler 2:
+ Spieler 2:
+ Frage:
+ Alternative Antwort (0 Punkte):
diff --git a/web/js/main.js b/web/js/main.js
index 3f6b62b..c6f8812 100644
--- a/web/js/main.js
+++ b/web/js/main.js
@@ -132,12 +132,23 @@ $(document).ready(function() {
wsSend("setRightPoints", $("#mPunkteRight").val());
});
+ $("#alternateAnswerBtn").click(function(){
+ var is = $("#finalFragenSelect").val();
+ var answer = $("#alternateAnswer").val();
+ wsSend("setAnswer", is+"###"+answer);
+ });
+
+ $("#alternateAnswerPBtn").click(function(){
+ var is = $("#finalFragenSelect").val();
+ wsSend("setAnz", is+"###0");
+ });
});
function setFinalMode(status){
isFinalMode = status == "true" ? true : false;
$(".finalElement").attr("disabled", !isFinalMode);
var index = $("#questionsSelcet>option:selected").index();
+ index = index > 0 ? index : 0;
loadQuestionToGui(index);
}
@@ -319,12 +330,16 @@ function loadQuestionToGui(index) {
oneLine.find(".points").html(''+fragen[index]["antworten"][i]["anz"]+'');
(function() {
var is = i;
+ var is2 = i;
+ if (isFinalMode){
+ is = $("#finalFragenSelect").val();
+ }
var frage = fragen[index];
oneLine.find(".answer").click(function() {
- wsSend("setAnswer", is+"###"+frage["antworten"][is]["antwort"]);
+ wsSend("setAnswer", is+"###"+frage["antworten"][is2]["antwort"]);
});
oneLine.find(".points").click(function() {
- wsSend("setAnz", is+"###"+frage["antworten"][is]["anz"]);
+ wsSend("setAnz", is+"###"+frage["antworten"][is2]["anz"]);
});
})();
}
@@ -360,7 +375,11 @@ function setAnswer(index, answer) {
}
el.typed({
strings: [answer],
- typeSpeed: 20
+ typeSpeed: 50,
+ showCursor: false,
+ cursorChar: "",
+ fadeOut: true,
+ fadeOutDelay: 0,
});
}
diff --git a/web/js/typed.js b/web/js/typed.js
index 947dd00..8dd150f 100644
--- a/web/js/typed.js
+++ b/web/js/typed.js
@@ -1,6 +1,6 @@
// The MIT License (MIT)
-// Typed.js | Copyright (c) 2014 Matt Boldt | www.mattboldt.com
+// Typed.js | Copyright (c) 2016 Matt Boldt | www.mattboldt.com
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
@@ -23,19 +23,37 @@
-!function($){
+! function(window, document, $) {
"use strict";
- var Typed = function(el, options){
+ var Typed = function(el, options) {
+ var self = this;
// chosen element to manipulate text
- this.el = $(el);
+ this.el = el;
+
// options
- this.options = $.extend({}, $.fn.typed.defaults, options);
+ this.options = {};
+ Object.keys(defaults).forEach(function(key) {
+ self.options[key] = defaults[key];
+ });
+ Object.keys(options).forEach(function(key) {
+ self.options[key] = options[key];
+ });
+
+ // attribute to type into
+ this.isInput = this.el.tagName.toLowerCase() === 'input';
+ this.attr = this.options.attr;
+
+ // show cursor
+ this.showCursor = this.isInput ? false : this.options.showCursor;
// text content of element
- this.text = this.el.text();
+ this.elContent = this.attr ? this.el.getAttribute(this.attr) : this.el.textContent;
+
+ // html or plain text
+ this.contentType = this.options.contentType;
// typing speed
this.typeSpeed = this.options.typeSpeed;
@@ -49,6 +67,18 @@
// amount of time to wait before backspacing
this.backDelay = this.options.backDelay;
+ // Fade out instead of backspace
+ this.fadeOut = this.options.fadeOut;
+ this.fadeOutClass = this.options.fadeOutClass;
+ this.fadeOutDelay = this.options.fadeOutDelay;
+
+ // div containing strings
+ if($ && this.options.stringsElement instanceof $) {
+ this.stringsElement = this.options.stringsElement[0]
+ } else {
+ this.stringsElement = this.options.stringsElement;
+ }
+
// input strings of text
this.strings = this.options.strings;
@@ -58,9 +88,6 @@
// current array position
this.arrayPos = 0;
- // current string based on current values[] array position
- this.string = this.strings[this.arrayPos];
-
// number to stop backspacing on.
// default 0, can change depending on how many chars
// you want to remove at the time
@@ -69,209 +96,423 @@
// Looping logic
this.loop = this.options.loop;
this.loopCount = this.options.loopCount;
- this.curLoop = 1;
- if (this.loop === false){
- // number in which to stop going through array
- // set to strings[] array (length - 1) to stop deleting after last string is typed
- this.stopArray = this.strings.length-1;
- }
- else{
- this.stopArray = this.strings.length;
- }
+ this.curLoop = 0;
+
+ // for stopping
+ this.stop = false;
+
+ // custom cursor
+ this.cursorChar = this.options.cursorChar;
+
+ // shuffle the strings
+ this.shuffle = this.options.shuffle;
+ // the order of strings
+ this.sequence = [];
// All systems go!
this.build();
- }
+ };
- Typed.prototype = {
+ Typed.prototype = {
- constructor: Typed
+ constructor: Typed,
- , init: function(){
- // begin the loop w/ first current string (global self.string)
- // current string will be passed as an argument each time after this
- var self = this;
- setTimeout(function() {
- // Start typing
- self.typewrite(self.string, self.strPos)
- }, self.startDelay);
+ init: function() {
+ // begin the loop w/ first current string (global self.strings)
+ // current string will be passed as an argument each time after this
+ var self = this;
+ self.timeout = setTimeout(function() {
+ for (var i=0;i|");
- this.init();
+ if (this.fadeOut && this.el.classList.contains(this.fadeOutClass)) {
+ this.el.classList.remove(this.fadeOutClass);
+ this.cursor.classList.remove(this.fadeOutClass);
}
- // pass current string state to each function
- , typewrite: function(curString, curStrPos){
+ // varying values for setTimeout during typing
+ // can't be global since number changes each time loop is executed
+ var humanize = Math.round(Math.random() * (100 - 30)) + this.typeSpeed;
+ var self = this;
- // varying values for setTimeout during typing
- // can't be global since number changes each time loop is executed
- var humanize = Math.round(Math.random() * (30 - 30)) + this.typeSpeed;
- var self = this;
+ // ------------- optional ------------- //
+ // backpaces a certain string faster
+ // ------------------------------------ //
+ // if (self.arrayPos == 1){
+ // self.backDelay = 50;
+ // }
+ // else{ self.backDelay = 500; }
- // ------------- optional ------------- //
- // backpaces a certain string faster
- // ------------------------------------ //
- // if (self.arrayPos == 1){
- // self.backDelay = 50;
- // }
- // else{ self.backDelay = 500; }
+ // contain typing function in a timeout humanize'd delay
+ self.timeout = setTimeout(function() {
+ // check for an escape character before a pause value
+ // format: \^\d+ .. eg: ^1000 .. should be able to print the ^ too using ^^
+ // single ^ are removed from string
+ var charPause = 0;
+ var substr = curString.substr(curStrPos);
+ if (substr.charAt(0) === '^') {
+ var skip = 1; // skip atleast 1
+ if (/^\^\d+/.test(substr)) {
+ substr = /\d+/.exec(substr)[0];
+ skip += substr.length;
+ charPause = parseInt(substr);
+ }
- // contain typing function in a timeout
- setTimeout(function() {
+ // strip out the escape character and pause value so they're not printed
+ curString = curString.substring(0, curStrPos) + curString.substring(curStrPos + skip);
+ }
- // make sure array position is less than array length
- if (self.arrayPos < self.strings.length){
-
- // check for an escape character before a pause value
- if (curString.substr(curStrPos, 1) === "^") {
- var charPauseEnd = curString.substr(curStrPos + 1).indexOf(" ");
- var charPause = curString.substr(curStrPos + 1, charPauseEnd);
- // strip out the escape character and pause value so they're not printed
- curString = curString.replace("^" + charPause, "");
+ if (self.contentType === 'html') {
+ // skip over html tags while typing
+ var curChar = curString.substr(curStrPos).charAt(0);
+ if (curChar === '<' || curChar === '&') {
+ var tag = '';
+ var endTag = '';
+ if (curChar === '<') {
+ endTag = '>'
}
else {
- var charPause = 0;
+ endTag = ';'
+ }
+ while (curString.substr(curStrPos + 1).charAt(0) !== endTag) {
+ tag += curString.substr(curStrPos).charAt(0);
+ curStrPos++;
+ if (curStrPos + 1 > curString.length) { break; }
+ }
+ curStrPos++;
+ tag += endTag;
+ }
+ }
+
+ // timeout for any pause after a character
+ self.timeout = setTimeout(function() {
+ if (curStrPos === curString.length) {
+ // fires callback function
+ self.options.onStringTyped(self.arrayPos);
+
+ // is this the final string
+ if (self.arrayPos === self.strings.length - 1) {
+ // animation that occurs on the last typed string
+ self.options.callback();
+
+ self.curLoop++;
+
+ // quit if we wont loop back
+ if (self.loop === false || self.curLoop === self.loopCount)
+ return;
}
- // timeout for any pause after a character
- setTimeout(function() {
+ self.timeout = setTimeout(function() {
+ self.backspace(curString, curStrPos);
+ }, self.backDelay);
- // start typing each new char into existing string
- // curString is function arg
- self.el.text(self.text + curString.substr(0, curStrPos));
+ } else {
- // check if current character number is the string's length
- // and if the current array position is less than the stopping point
- // if so, backspace after backDelay setting
- if (curStrPos > curString.length && self.arrayPos < self.stopArray){
- clearTimeout(clear);
- self.options.onStringTyped();
- var clear = setTimeout(function(){
- self.backspace(curString, curStrPos);
- }, self.backDelay);
- }
-
- // else, keep typing
- else{
- // add characters one by one
- curStrPos++;
- // loop the function
- self.typewrite(curString, curStrPos);
- // if the array position is at the stopping position
- // finish code, on to next task
- if (self.loop === false){
- if (self.arrayPos === self.stopArray && curStrPos === curString.length){
- // animation that occurs on the last typed string
- // fires callback function
- var clear = self.options.callback();
- clearTimeout(clear);
- }
- }
- }
-
- // end of character pause
- }, charPause);
- }
- // if the array position is greater than array length
- // and looping is active, reset array pos and start over.
- else if (self.loop === true && self.loopCount === false){
- self.arrayPos = 0;
- self.init();
- }
- else if(self.loopCount !== false && self.curLoop < self.loopCount){
- self.arrayPos = 0;
- self.curLoop = self.curLoop+1;
- self.init();
+ /* call before functions if applicable */
+ if (curStrPos === 0) {
+ self.options.preStringTyped(self.arrayPos);
}
- // humanized value for typing
- }, humanize);
+ // start typing each new char into existing string
+ // curString: arg, self.el.html: original text inside element
+ var nextString = curString.substr(0, curStrPos + 1);
+ if (self.attr) {
+ self.el.setAttribute(self.attr, nextString);
+ } else {
+ if (self.isInput) {
+ self.el.value = nextString;
+ } else if (self.contentType === 'html') {
+ self.el.innerHTML = nextString;
+ } else {
+ self.el.textContent = nextString;
+ }
+ }
- }
-
- , backspace: function(curString, curStrPos){
-
- // varying values for setTimeout during typing
- // can't be global since number changes each time loop is executed
- var humanize = Math.round(Math.random() * (100 - 30)) + this.backSpeed;
- var self = this;
-
- setTimeout(function() {
-
- // ----- this part is optional ----- //
- // check string array position
- // on the first string, only delete one word
- // the stopNum actually represents the amount of chars to
- // keep in the current string. In my case it's 14.
- // if (self.arrayPos == 1){
- // self.stopNum = 14;
- // }
- //every other time, delete the whole typed string
- // else{
- // self.stopNum = 0;
- // }
-
- // ----- continue important stuff ----- //
- // replace text with current text + typed characters
- self.el.text(self.text + curString.substr(0, curStrPos));
-
- // if the number (id of character in current string) is
- // less than the stop number, keep going
- if (curStrPos > self.stopNum){
- // subtract characters one by one
- curStrPos--;
+ // add characters one by one
+ curStrPos++;
// loop the function
- self.backspace(curString, curStrPos);
- }
- // if the stop number has been reached, increase
- // array position to next string
- else if (curStrPos <= self.stopNum){
- clearTimeout(clear);
- var clear = self.arrayPos = self.arrayPos+1;
- // must pass new array position in this instance
- // instead of using global arrayPos
- self.typewrite(self.strings[self.arrayPos], curStrPos);
+ self.typewrite(curString, curStrPos);
}
+ // end of character pause
+ }, charPause);
// humanized value for typing
- }, humanize);
+ }, humanize);
+ },
+
+ backspace: function(curString, curStrPos) {
+ var self = this;
+ // exit when stopped
+ if (this.stop === true) {
+ return;
}
+ if (this.fadeOut){
+ this.initFadeOut();
+ return;
+ }
+
+ // varying values for setTimeout during typing
+ // can't be global since number changes each time loop is executed
+ var humanize = Math.round(Math.random() * (100 - 30)) + this.backSpeed;
+
+ self.timeout = setTimeout(function() {
+
+ // ----- this part is optional ----- //
+ // check string array position
+ // on the first string, only delete one word
+ // the stopNum actually represents the amount of chars to
+ // keep in the current string. In my case it's 14.
+ // if (self.arrayPos == 1){
+ // self.stopNum = 14;
+ // }
+ //every other time, delete the whole typed string
+ // else{
+ // self.stopNum = 0;
+ // }
+
+ if (self.contentType === 'html') {
+ // skip over html tags while backspacing
+ if (curString.substr(curStrPos).charAt(0) === '>') {
+ var tag = '';
+ while (curString.substr(curStrPos - 1).charAt(0) !== '<') {
+ tag -= curString.substr(curStrPos).charAt(0);
+ curStrPos--;
+ if (curStrPos < 0) { break; }
+ }
+ curStrPos--;
+ tag += '<';
+ }
+ }
+
+ // ----- continue important stuff ----- //
+ // replace text with base text + typed characters
+ var nextString = curString.substr(0, curStrPos);
+ self.replaceText(nextString);
+
+ // if the number (id of character in current string) is
+ // less than the stop number, keep going
+ if (curStrPos > self.stopNum) {
+ // subtract characters one by one
+ curStrPos--;
+ // loop the function
+ self.backspace(curString, curStrPos);
+ }
+ // if the stop number has been reached, increase
+ // array position to next string
+ else if (curStrPos <= self.stopNum) {
+ self.arrayPos++;
+
+ if (self.arrayPos === self.strings.length) {
+ self.arrayPos = 0;
+
+ // Shuffle sequence again
+ if(self.shuffle) self.sequence = self.shuffleArray(self.sequence);
+
+ self.init();
+ } else
+ self.typewrite(self.strings[self.sequence[self.arrayPos]], curStrPos);
+ }
+
+ // humanized value for typing
+ }, humanize);
+
+ },
+
+ // Adds a CSS class to fade out current string
+ initFadeOut: function(){
+ self = this;
+ this.el.className += ' ' + this.fadeOutClass;
+ this.cursor.className += ' ' + this.fadeOutClass;
+ return setTimeout(function() {
+ self.arrayPos++;
+ self.replaceText('');
+
+ // Resets current string if end of loop reached
+ if(self.strings.length > self.arrayPos) {
+ self.typewrite(self.strings[self.sequence[self.arrayPos]], 0);
+ } else {
+ self.typewrite(self.strings[0], 0);
+ self.arrayPos = 0;
+ }
+ }, self.fadeOutDelay);
+ },
+
+ // Replaces current text in the HTML element
+ replaceText: function(str) {
+ if (this.attr) {
+ this.el.setAttribute(this.attr, str);
+ } else {
+ if (this.isInput) {
+ this.el.value = str;
+ } else if (this.contentType === 'html') {
+ this.el.innerHTML = str;
+ } else {
+ this.el.textContent = str;
+ }
+ }
+ },
+
+ // Shuffles the numbers in the given array.
+ shuffleArray: function(array) {
+ var tmp, current, top = array.length;
+ if(top) while(--top) {
+ current = Math.floor(Math.random() * (top + 1));
+ tmp = array[current];
+ array[current] = array[top];
+ array[top] = tmp;
+ }
+ return array;
+ },
+
+ // Start & Stop currently not working
+
+ // , stop: function() {
+ // var self = this;
+
+ // self.stop = true;
+ // clearInterval(self.timeout);
+ // }
+
+ // , start: function() {
+ // var self = this;
+ // if(self.stop === false)
+ // return;
+
+ // this.stop = false;
+ // this.init();
+ // }
+
+ // Reset and rebuild the element
+ reset: function() {
+ var self = this;
+ clearInterval(self.timeout);
+ var id = this.el.getAttribute('id');
+ this.el.textContent = '';
+ if (typeof this.cursor !== 'undefined' && typeof this.cursor.parentNode !== 'undefined') {
+ this.cursor.parentNode.removeChild(this.cursor);
+ }
+ this.strPos = 0;
+ this.arrayPos = 0;
+ this.curLoop = 0;
+ // Send the callback
+ this.options.resetCallback();
}
- $.fn.typed = function (option) {
- return this.each(function () {
- var $this = $(this)
- , data = $this.data('typed')
- , options = typeof option == 'object' && option
- if (!data) $this.data('typed', (data = new Typed(this, options)))
- if (typeof option == 'string') data[option]()
+ };
+
+ Typed.new = function(selector, option) {
+ var elements = Array.prototype.slice.apply(document.querySelectorAll(selector));
+ elements.forEach(function(element) {
+ var instance = element._typed,
+ options = typeof option == 'object' && option;
+ if (instance) { instance.reset(); }
+ element._typed = instance = new Typed(element, options);
+ if (typeof option == 'string') instance[option]();
});
+ };
+
+ if ($) {
+ $.fn.typed = function(option) {
+ return this.each(function() {
+ var $this = $(this),
+ data = $this.data('typed'),
+ options = typeof option == 'object' && option;
+ if (data) { data.reset(); }
+ $this.data('typed', (data = new Typed(this, options)));
+ if (typeof option == 'string') data[option]();
+ });
+ };
}
- $.fn.typed.defaults = {
+ window.Typed = Typed;
+
+ var defaults = {
strings: ["These are the default values...", "You know what you should do?", "Use your own!", "Have a great day!"],
+ stringsElement: null,
// typing speed
typeSpeed: 0,
// time before typing starts
startDelay: 0,
// backspacing speed
backSpeed: 0,
+ // shuffle the strings
+ shuffle: false,
// time before backspacing
backDelay: 500,
+ // Fade out instead of backspace
+ fadeOut: false,
+ fadeOutClass: 'typed-fade-out',
+ fadeOutDelay: 500, // milliseconds
// loop
loop: false,
// false = infinite
loopCount: false,
- // ending callback function
- callback: function(){ null },
+ // show cursor
+ showCursor: true,
+ // character for cursor
+ cursorChar: "|",
+ // attribute to type (null == text)
+ attr: null,
+ // either html or text
+ contentType: 'html',
+ // call when done callback function
+ callback: function() {},
+ // starting callback function before each string
+ preStringTyped: function() {},
//callback for every typed string
- onStringTyped: function(){ null }
- }
+ onStringTyped: function() {},
+ // callback for reset
+ resetCallback: function() {}
+ };
-}(window.jQuery);
\ No newline at end of file
+}(window, document, window.jQuery);
