some updates

source/Caching.hx

@@ -0,0 +1,128 @@
+package;
+
+import haxe.Exception;
+import flixel.tweens.FlxEase;
+import flixel.tweens.FlxTween;
+import sys.FileSystem;
+import sys.io.File;
+import flixel.FlxG;
+import flixel.FlxSprite;
+import flixel.addons.transition.FlxTransitionSprite.GraphicTransTileDiamond;
+import flixel.addons.transition.FlxTransitionableState;
+import flixel.addons.transition.TransitionData;
+import flixel.graphics.FlxGraphic;
+import flixel.graphics.frames.FlxAtlasFrames;
+import flixel.math.FlxPoint;
+import flixel.math.FlxRect;
+import flixel.util.FlxColor;
+import flixel.util.FlxTimer;
+import flixel.text.FlxText;
+
+using StringTools;
+
+class Caching extends MusicBeatState
+{
+    var toBeDone = 0;
+    var done = 0;
+
+    var text:FlxText;
+    var kadeLogo:FlxSprite;
+
+	override function create()
+	{
+        FlxG.mouse.visible = false;
+
+        FlxG.worldBounds.set(0,0);
+
+        text = new FlxText(FlxG.width / 2, FlxG.height / 2 + 300,0,"Loading...");
+        text.size = 34;
+        text.alignment = FlxTextAlign.CENTER;
+        text.alpha = 0;
+
+        kadeLogo = new FlxSprite(FlxG.width / 2, FlxG.height / 2).loadGraphic(Paths.image('KadeEngineLogo'));
+        kadeLogo.x -= kadeLogo.width / 2;
+        kadeLogo.y -= kadeLogo.height / 2 + 100;
+        text.y -= kadeLogo.height / 2 - 125;
+        text.x -= 170;
+        kadeLogo.setGraphicSize(Std.int(kadeLogo.width * 0.6));
+
+        kadeLogo.alpha = 0;
+
+        add(kadeLogo);
+        add(text);
+
+        trace('starting caching..');
+        
+        sys.thread.Thread.create(() -> {
+            cache();
+        });
+
+
+        super.create();
+    }
+
+    var calledDone = false;
+
+    override function update(elapsed) 
+    {
+
+        if (toBeDone != 0 && done != toBeDone)
+        {
+            var alpha = HelperFunctions.truncateFloat(done / toBeDone * 100,2) / 100;
+            kadeLogo.alpha = alpha;
+            text.alpha = alpha;
+            text.text = "Loading... (" + done + "/" + toBeDone + ")";
+        }
+
+        super.update(elapsed);
+    }
+
+
+    function cache()
+    {
+
+        var images = [];
+        var music = [];
+
+        trace("caching images...");
+
+        for (i in FileSystem.readDirectory(FileSystem.absolutePath("assets/shared/images/characters")))
+        {
+            if (!i.endsWith(".png"))
+                continue;
+            images.push(i);
+        }
+
+        trace("caching music...");
+
+        for (i in FileSystem.readDirectory(FileSystem.absolutePath("assets/songs")))
+        {
+            music.push(i);
+        }
+
+        toBeDone = Lambda.count(images) + Lambda.count(music);
+
+        trace("LOADING: " + toBeDone + " OBJECTS.");
+
+        for (i in images)
+        {
+            var replaced = i.replace(".png","");
+            FlxG.bitmap.add(Paths.image("characters/" + replaced,"shared"));
+            trace("cached " + replaced);
+            done++;
+        }
+
+        for (i in music)
+        {
+            FlxG.sound.cache(Paths.inst(i));
+            FlxG.sound.cache(Paths.voices(i));
+            trace("cached " + i);
+            done++;
+        }
+
+        trace("Finished caching...");
+
+        FlxG.switchState(new TitleState());
+    }
+
+}

source/GameDimensions.hx

@@ -0,0 +1,7 @@
+package;
+
+class GameDimensions
+{
+	public static var width:Int = 1280;
+	public static var height:Int = 720;
+}

source/GlobalVideo.hx

@@ -0,0 +1,95 @@
+package;
+
+import openfl.Lib;
+
+class GlobalVideo
+{
+	private static var video:VideoHandler;
+	private static var webm:WebmHandler;
+	public static var isWebm:Bool = false;
+	public static var isAndroid:Bool = false;
+	public static var daAlpha1:Float = 0.2;
+	public static var daAlpha2:Float = 1;
+
+	public static function setVid(vid:VideoHandler):Void
+	{
+		video = vid;
+	}
+	
+	public static function getVid():VideoHandler
+	{
+		return video;
+	}
+	
+	public static function setWebm(vid:WebmHandler):Void
+	{
+		webm = vid;
+		isWebm = true;
+	}
+	
+	public static function getWebm():WebmHandler
+	{
+		return webm;
+	}
+	
+	public static function get():Dynamic
+	{
+		if (isWebm)
+		{
+			return getWebm();
+		} else {
+			return getVid();
+		}
+	}
+	
+	public static function calc(ind:Int):Dynamic
+	{
+		var stageWidth:Int = Lib.current.stage.stageWidth;
+		var stageHeight:Int = Lib.current.stage.stageHeight;
+
+		var width:Float = GameDimensions.width;
+		var height:Float = GameDimensions.height;
+		
+		//trace("AH: " + stageWidth);
+		//trace(width);
+		
+		var ratioX:Float = height / width;
+		var ratioY:Float = width / height;
+		var appliedWidth:Float = stageHeight * ratioY;
+		var appliedHeight:Float = stageWidth * ratioX;
+		//trace(appliedWidth);
+		var remainingX:Float = stageWidth - appliedWidth;
+		var remainingY:Float = stageHeight - appliedHeight;
+		remainingX = remainingX / 2;
+		remainingY = remainingY / 2;
+		
+		appliedWidth = Std.int(appliedWidth);
+		appliedHeight = Std.int(appliedHeight);
+		
+		if (appliedHeight > stageHeight)
+		{
+			remainingY = 0;
+			appliedHeight = stageHeight;
+		}
+		
+		if (appliedWidth > stageWidth)
+		{
+			remainingX = 0;
+			appliedWidth = stageWidth;
+		}
+		
+		switch(ind)
+		{
+			case 0:
+				return remainingX;
+			case 1:
+				return remainingY;
+			case 2:
+				return appliedWidth;
+			case 3:
+				return appliedHeight;
+		}
+		
+		return null;
+	}
+}

source/Main.hx

@@ -1,5 +1,7 @@
 package;
 
+
+import webm.WebmPlayer;
 import openfl.display.BlendMode;
 import openfl.text.TextFormat;
 import openfl.display.Application;
@@ -49,6 +51,8 @@ class Main extends Sprite
 		}
 	}
 
+	public static var webmHandler:WebmHandler;
+
 	private function init(?E:Event):Void
 	{
 		if (hasEventListener(Event.ADDED_TO_STAGE))
@@ -73,10 +77,8 @@ class Main extends Sprite
 			gameHeight = Math.ceil(stageHeight / zoom);
 		}
 
-		#if !debug
-		initialState = TitleState;
-		#end
-
+		initialState = Caching;
+		
 		game = new FlxGame(gameWidth, gameHeight, initialState, zoom, framerate, framerate, skipSplash, startFullscreen);
 
 		addChild(game);

source/ModchartState.hx

@@ -1,6 +1,7 @@
 // this file is for modchart things, this is to declutter playstate.hx
 
 // Lua
+import openfl.display3D.textures.VideoTexture;
 import flixel.graphics.FlxGraphic;
 import flixel.graphics.frames.FlxAtlasFrames;
 #if windows
@@ -417,6 +418,33 @@ class ModchartState
 				
 	
 				// hud/camera
+
+				Lua_helper.add_callback(lua,"initBackgroundVideo", function(videoName:String) {
+					trace('playing assets/videos/' + videoName + '.webm');
+					PlayState.instance.backgroundVideo("assets/videos/" + videoName + ".webm");
+				});
+
+				Lua_helper.add_callback(lua,"pauseVideo", function() {
+					if (!GlobalVideo.get().paused)
+						GlobalVideo.get().pause();
+				});
+
+				Lua_helper.add_callback(lua,"resumeVideo", function() {
+					if (GlobalVideo.get().paused)
+						GlobalVideo.get().pause();
+				});
+				
+				Lua_helper.add_callback(lua,"restartVideo", function() {
+					GlobalVideo.get().restart();
+				});
+
+				Lua_helper.add_callback(lua,"setVideoSpritePos", function(x:Int,y:Int) {
+					PlayState.instance.videoSprite.setPosition(x,y);
+				});
+				
+				Lua_helper.add_callback(lua,"setVideoSpriteScale", function(scale:Float) {
+					PlayState.instance.videoSprite.setGraphicSize(Std.int(PlayState.instance.videoSprite.width * scale));
+				});
 	
 				Lua_helper.add_callback(lua,"setHudAngle", function (x:Float) {
 					PlayState.instance.camHUD.angle = x;

source/PlayState.hx

@@ -1,5 +1,6 @@
 package;
 
+import webm.WebmPlayer;
 import flixel.input.keyboard.FlxKey;
 import haxe.Exception;
 import openfl.geom.Matrix;
@@ -1344,6 +1345,9 @@ class PlayState extends MusicBeatState
 			case 'Bopeebo' | 'Philly Nice' | 'Blammed' | 'Cocoa' | 'Eggnog': allowedToHeadbang = true;
 			default: allowedToHeadbang = false;
 		}
+
+		if (useVideo)
+			GlobalVideo.get().resume();
 		
 		#if windows
 		// Updating Discord Rich Presence (with Time Left)
@@ -1506,16 +1510,6 @@ class PlayState extends MusicBeatState
 
 					switch (Math.abs(i))
 					{
-						case 0:
-							babyArrow.x += Note.swagWidth * 0;
-							babyArrow.animation.add('static', [0]);
-							babyArrow.animation.add('pressed', [4, 8], 12, false);
-							babyArrow.animation.add('confirm', [12, 16], 24, false);
-						case 1:
-							babyArrow.x += Note.swagWidth * 1;
-							babyArrow.animation.add('static', [1]);
-							babyArrow.animation.add('pressed', [5, 9], 12, false);
-							babyArrow.animation.add('confirm', [13, 17], 24, false);
 						case 2:
 							babyArrow.x += Note.swagWidth * 2;
 							babyArrow.animation.add('static', [2]);
@@ -1526,75 +1520,85 @@ class PlayState extends MusicBeatState
 							babyArrow.animation.add('static', [3]);
 							babyArrow.animation.add('pressed', [7, 11], 12, false);
 							babyArrow.animation.add('confirm', [15, 19], 24, false);
+						case 1:
+							babyArrow.x += Note.swagWidth * 1;
+							babyArrow.animation.add('static', [1]);
+							babyArrow.animation.add('pressed', [5, 9], 12, false);
+							babyArrow.animation.add('confirm', [13, 17], 24, false);
+						case 0:
+							babyArrow.x += Note.swagWidth * 0;
+							babyArrow.animation.add('static', [0]);
+							babyArrow.animation.add('pressed', [4, 8], 12, false);
+							babyArrow.animation.add('confirm', [12, 16], 24, false);
 					}
 				
-				case 'normal':
-					babyArrow.frames = Paths.getSparrowAtlas('NOTE_assets');
-					babyArrow.animation.addByPrefix('green', 'arrowUP');
-					babyArrow.animation.addByPrefix('blue', 'arrowDOWN');
-					babyArrow.animation.addByPrefix('purple', 'arrowLEFT');
-					babyArrow.animation.addByPrefix('red', 'arrowRIGHT');
+					case 'normal':
+						babyArrow.frames = Paths.getSparrowAtlas('NOTE_assets');
+						babyArrow.animation.addByPrefix('green', 'arrowUP');
+						babyArrow.animation.addByPrefix('blue', 'arrowDOWN');
+						babyArrow.animation.addByPrefix('purple', 'arrowLEFT');
+						babyArrow.animation.addByPrefix('red', 'arrowRIGHT');
+		
+						babyArrow.antialiasing = true;
+						babyArrow.setGraphicSize(Std.int(babyArrow.width * 0.7));
+		
+						switch (Math.abs(i))
+						{
+							case 0:
+								babyArrow.x += Note.swagWidth * 0;
+								babyArrow.animation.addByPrefix('static', 'arrowLEFT');
+								babyArrow.animation.addByPrefix('pressed', 'left press', 24, false);
+								babyArrow.animation.addByPrefix('confirm', 'left confirm', 24, false);
+							case 1:
+								babyArrow.x += Note.swagWidth * 1;
+								babyArrow.animation.addByPrefix('static', 'arrowDOWN');
+								babyArrow.animation.addByPrefix('pressed', 'down press', 24, false);
+								babyArrow.animation.addByPrefix('confirm', 'down confirm', 24, false);
+							case 2:
+								babyArrow.x += Note.swagWidth * 2;
+								babyArrow.animation.addByPrefix('static', 'arrowUP');
+								babyArrow.animation.addByPrefix('pressed', 'up press', 24, false);
+								babyArrow.animation.addByPrefix('confirm', 'up confirm', 24, false);
+							case 3:
+								babyArrow.x += Note.swagWidth * 3;
+								babyArrow.animation.addByPrefix('static', 'arrowRIGHT');
+								babyArrow.animation.addByPrefix('pressed', 'right press', 24, false);
+								babyArrow.animation.addByPrefix('confirm', 'right confirm', 24, false);
+							}
 	
-					babyArrow.antialiasing = true;
-					babyArrow.setGraphicSize(Std.int(babyArrow.width * 0.7));
+					default:
+						babyArrow.frames = Paths.getSparrowAtlas('NOTE_assets');
+						babyArrow.animation.addByPrefix('green', 'arrowUP');
+						babyArrow.animation.addByPrefix('blue', 'arrowDOWN');
+						babyArrow.animation.addByPrefix('purple', 'arrowLEFT');
+						babyArrow.animation.addByPrefix('red', 'arrowRIGHT');
 	
-					switch (Math.abs(i))
-					{
-						case 0:
-							babyArrow.x += Note.swagWidth * 0;
-							babyArrow.animation.addByPrefix('static', 'arrowLEFT');
-							babyArrow.animation.addByPrefix('pressed', 'left press', 24, false);
-							babyArrow.animation.addByPrefix('confirm', 'left confirm', 24, false);
-						case 1:
-							babyArrow.x += Note.swagWidth * 1;
-							babyArrow.animation.addByPrefix('static', 'arrowDOWN');
-							babyArrow.animation.addByPrefix('pressed', 'down press', 24, false);
-							babyArrow.animation.addByPrefix('confirm', 'down confirm', 24, false);
-						case 2:
-							babyArrow.x += Note.swagWidth * 2;
-							babyArrow.animation.addByPrefix('static', 'arrowUP');
-							babyArrow.animation.addByPrefix('pressed', 'up press', 24, false);
-							babyArrow.animation.addByPrefix('confirm', 'up confirm', 24, false);
-						case 3:
-							babyArrow.x += Note.swagWidth * 3;
-							babyArrow.animation.addByPrefix('static', 'arrowRIGHT');
-							babyArrow.animation.addByPrefix('pressed', 'right press', 24, false);
-							babyArrow.animation.addByPrefix('confirm', 'right confirm', 24, false);
+						babyArrow.antialiasing = true;
+						babyArrow.setGraphicSize(Std.int(babyArrow.width * 0.7));
+	
+						switch (Math.abs(i))
+						{
+							case 0:
+								babyArrow.x += Note.swagWidth * 0;
+								babyArrow.animation.addByPrefix('static', 'arrowLEFT');
+								babyArrow.animation.addByPrefix('pressed', 'left press', 24, false);
+								babyArrow.animation.addByPrefix('confirm', 'left confirm', 24, false);
+							case 1:
+								babyArrow.x += Note.swagWidth * 1;
+								babyArrow.animation.addByPrefix('static', 'arrowDOWN');
+								babyArrow.animation.addByPrefix('pressed', 'down press', 24, false);
+								babyArrow.animation.addByPrefix('confirm', 'down confirm', 24, false);
+							case 2:
+								babyArrow.x += Note.swagWidth * 2;
+								babyArrow.animation.addByPrefix('static', 'arrowUP');
+								babyArrow.animation.addByPrefix('pressed', 'up press', 24, false);
+								babyArrow.animation.addByPrefix('confirm', 'up confirm', 24, false);
+							case 3:
+								babyArrow.x += Note.swagWidth * 3;
+								babyArrow.animation.addByPrefix('static', 'arrowRIGHT');
+								babyArrow.animation.addByPrefix('pressed', 'right press', 24, false);
+								babyArrow.animation.addByPrefix('confirm', 'right confirm', 24, false);
 						}
-
-				default:
-					babyArrow.frames = Paths.getSparrowAtlas('NOTE_assets');
-					babyArrow.animation.addByPrefix('green', 'arrowUP');
-					babyArrow.animation.addByPrefix('blue', 'arrowDOWN');
-					babyArrow.animation.addByPrefix('purple', 'arrowLEFT');
-					babyArrow.animation.addByPrefix('red', 'arrowRIGHT');
-
-					babyArrow.antialiasing = true;
-					babyArrow.setGraphicSize(Std.int(babyArrow.width * 0.7));
-
-					switch (Math.abs(i))
-					{
-						case 0:
-							babyArrow.x += Note.swagWidth * 0;
-							babyArrow.animation.addByPrefix('static', 'arrowLEFT');
-							babyArrow.animation.addByPrefix('pressed', 'left press', 24, false);
-							babyArrow.animation.addByPrefix('confirm', 'left confirm', 24, false);
-						case 1:
-							babyArrow.x += Note.swagWidth * 1;
-							babyArrow.animation.addByPrefix('static', 'arrowDOWN');
-							babyArrow.animation.addByPrefix('pressed', 'down press', 24, false);
-							babyArrow.animation.addByPrefix('confirm', 'down confirm', 24, false);
-						case 2:
-							babyArrow.x += Note.swagWidth * 2;
-							babyArrow.animation.addByPrefix('static', 'arrowUP');
-							babyArrow.animation.addByPrefix('pressed', 'up press', 24, false);
-							babyArrow.animation.addByPrefix('confirm', 'up confirm', 24, false);
-						case 3:
-							babyArrow.x += Note.swagWidth * 3;
-							babyArrow.animation.addByPrefix('static', 'arrowRIGHT');
-							babyArrow.animation.addByPrefix('pressed', 'right press', 24, false);
-							babyArrow.animation.addByPrefix('confirm', 'right confirm', 24, false);
-					}
 			}
 
 			babyArrow.updateHitbox();
@@ -1706,6 +1710,9 @@ class PlayState extends MusicBeatState
 
 	public static var songRate = 1.5;
 
+	public var stopUpdate = false;
+	public var removedVideo = false;
+
 	override public function update(elapsed:Float)
 	{
 		#if !debug
@@ -1715,6 +1722,18 @@ class PlayState extends MusicBeatState
 		if (FlxG.save.data.botplay && FlxG.keys.justPressed.ONE)
 			camHUD.visible = !camHUD.visible;
 
+
+		if (useVideo && GlobalVideo.get() != null && !stopUpdate)
+			{		
+				if (GlobalVideo.get().ended && !removedVideo)
+				{
+					remove(videoSprite);
+					removedVideo = true;
+				}
+			}
+
+
+		
 		#if windows
 		if (executeModchart && luaModchart != null && songStarted)
 		{
@@ -1838,6 +1857,12 @@ class PlayState extends MusicBeatState
 
 		if (FlxG.keys.justPressed.SEVEN)
 		{
+			if (useVideo)
+				{
+					GlobalVideo.get().stop();
+					remove(videoSprite);
+					removedVideo = true;
+				}
 			#if windows
 			DiscordClient.changePresence("Chart Editor", null, null, true);
 			#end
@@ -1883,6 +1908,13 @@ class PlayState extends MusicBeatState
 		#if debug
 		if (FlxG.keys.justPressed.EIGHT)
 		{
+			if (useVideo)
+				{
+					GlobalVideo.get().stop();
+					remove(videoSprite);
+					removedVideo = true;
+				}
+
 			FlxG.switchState(new AnimationDebug(SONG.player2));
 			#if windows
 			if (luaModchart != null)
@@ -2433,6 +2465,12 @@ class PlayState extends MusicBeatState
 
 	function endSong():Void
 	{
+		if (useVideo)
+			{
+				GlobalVideo.get().stop();
+				PlayState.instance.remove(PlayState.instance.videoSprite);
+			}
+
 		if (!loadRep)
 			rep.SaveReplay(saveNotes);
 		else
@@ -3066,6 +3104,66 @@ class PlayState extends MusicBeatState
 				});
 			}
 
+			public var fuckingVolume:Float = 1;
+			public var useVideo = false;
+
+			public static var webmHandler:WebmHandler;
+
+			public var playingDathing = false;
+
+			public var videoSprite:FlxSprite;
+
+			public function backgroundVideo(source:String) // for background videos
+				{
+					useVideo = true;
+			
+					var ourSource:String = "assets/videos/daWeirdVid/dontDelete.webm";
+					WebmPlayer.SKIP_STEP_LIMIT = 90;
+					var str1:String = "WEBM SHIT"; 
+					webmHandler = new WebmHandler();
+					webmHandler.source(ourSource);
+					webmHandler.makePlayer();
+					webmHandler.webm.name = str1;
+			
+					GlobalVideo.setWebm(webmHandler);
+
+					GlobalVideo.get().source(source);
+					GlobalVideo.get().clearPause();
+					if (GlobalVideo.isWebm)
+					{
+						GlobalVideo.get().updatePlayer();
+					}
+					GlobalVideo.get().show();
+			
+					if (GlobalVideo.isWebm)
+					{
+						GlobalVideo.get().restart();
+					} else {
+						GlobalVideo.get().play();
+					}
+					
+					var data = webmHandler.webm.bitmapData;
+			
+					videoSprite = new FlxSprite(-470,-30).loadGraphic(data);
+			
+					videoSprite.setGraphicSize(Std.int(videoSprite.width * 1.2));
+			
+					remove(gf);
+					remove(boyfriend);
+					remove(dad);
+					add(videoSprite);
+					 add(gf);
+					add(boyfriend);
+					add(dad);
+			
+					trace('poggers');
+			
+					if (!songStarted)
+						webmHandler.pause();
+					else
+						webmHandler.resume();
+				}
+
 	function noteMiss(direction:Int = 1, daNote:Note):Void
 	{
 		if (!boyfriend.stunned)

source/VideoHandler.hx

@@ -0,0 +1,195 @@
+//This was made by GWebDev lol btw this uses actuate
+package;
+
+import motion.Actuate;
+import openfl.display.Sprite;
+import openfl.events.AsyncErrorEvent;
+import openfl.events.MouseEvent;
+import openfl.events.NetStatusEvent;
+import openfl.media.Video;
+import openfl.net.NetConnection;
+import openfl.net.NetStream;
+import flixel.FlxG;
+
+using StringTools;
+
+class VideoHandler
+{
+	public var netStream:NetStream;
+	public var video:Video;
+	public var isReady:Bool = false;
+	public var addOverlay:Bool = false;
+	public var vidPath:String = "";
+	public var ignoreShit:Bool = false;
+	
+	public function new()
+	{
+		isReady = false;
+	}
+	
+	public function source(?vPath:String):Void
+	{
+		if (vPath != null && vPath.length > 0)
+		{
+		vidPath = vPath;
+		}
+	}
+	
+	public function init1():Void
+	{
+		isReady = false;
+		video = new Video();
+		video.visible = false;
+	}
+	
+	public function init2():Void
+	{
+		#if web
+		var netConnection = new NetConnection ();
+		netConnection.connect (null);
+		
+		netStream = new NetStream (netConnection);
+		netStream.client = { onMetaData: client_onMetaData };
+		netStream.addEventListener (AsyncErrorEvent.ASYNC_ERROR, netStream_onAsyncError);
+
+		netConnection.addEventListener (NetStatusEvent.NET_STATUS, netConnection_onNetStatus);
+		netConnection.addEventListener (NetStatusEvent.NET_STATUS, onPlay);
+		netConnection.addEventListener (NetStatusEvent.NET_STATUS, onEnd);
+		#end
+	}
+	
+	public function client_onMetaData (metaData:Dynamic) {
+		
+		video.attachNetStream (netStream);
+		
+		video.width = FlxG.width;
+		video.height = FlxG.height;
+		
+	}
+	
+	
+	public function netStream_onAsyncError (event:AsyncErrorEvent):Void {
+		
+		trace ("Error loading video");
+		
+	}
+	
+	
+	public function netConnection_onNetStatus (event:NetStatusEvent):Void {
+		trace (event.info.code);
+	}
+	
+	public function play():Void
+	{
+		#if web
+		ignoreShit = true;
+		netStream.close();
+		init2();
+		netStream.play(vidPath);
+		ignoreShit = false;
+		#end
+		trace(vidPath);
+	}
+	
+	public function stop():Void
+	{
+		netStream.close();
+		onStop();
+	}
+	
+	public function restart():Void
+	{
+		play();
+		onRestart();
+	}
+	
+	public function update(elapsed:Float):Void
+	{
+		video.x = GlobalVideo.calc(0);
+		video.y = GlobalVideo.calc(1);
+		video.width = GlobalVideo.calc(2);
+		video.height = GlobalVideo.calc(3);
+	}
+	
+	public var stopped:Bool = false;
+	public var restarted:Bool = false;
+	public var played:Bool = false;
+	public var ended:Bool = false;
+	public var paused:Bool = false;
+	
+	public function pause():Void
+	{
+		netStream.pause();
+		paused = true;
+	}
+	
+	public function resume():Void
+	{
+		netStream.resume();
+		paused = false;
+	}
+	
+	public function togglePause():Void
+	{
+		if (paused)
+		{
+			resume();
+		} else {
+			pause();
+		}
+	}
+	
+	public function clearPause():Void
+	{
+		paused = false;
+	}
+	
+	public function onStop():Void
+	{
+		if (!ignoreShit)
+		{
+			stopped = true;
+		}
+	}
+	
+	public function onRestart():Void
+	{
+		restarted = true;
+	}
+	
+	public function onPlay(event:NetStatusEvent):Void
+	{
+		if (event.info.code == "NetStream.Play.Start")
+		{
+			played = true;
+		}
+	}
+	
+	public function onEnd(event:NetStatusEvent):Void
+	{
+		if (event.info.code == "NetStream.Play.Complete")
+		{
+			ended = true;
+		}
+	}
+	
+	public function alpha():Void
+	{
+		video.alpha = GlobalVideo.daAlpha1;
+	}
+	
+	public function unalpha():Void
+	{
+		video.alpha = GlobalVideo.daAlpha2;
+	}
+	
+	public function hide():Void
+	{
+		video.visible = false;
+	}
+	
+	public function show():Void
+	{
+		video.visible = true;
+	}
+}

source/WebmHandler.hx

@@ -0,0 +1,169 @@
+package;
+
+import flixel.FlxG;
+import openfl.display.Sprite;
+#if desktop
+import webm.*;
+#end
+
+class WebmHandler
+{
+	#if desktop
+	public var webm:WebmPlayer;
+	public var vidPath:String = "";
+	public var io:WebmIo;
+	public var initialized:Bool = false;
+	
+	public function new()
+	{
+	}
+	
+	public function source(?vPath:String):Void
+	{
+		if (vPath != null && vPath.length > 0)
+		{
+		vidPath = vPath;
+		}
+	}
+	
+	public function makePlayer():Void
+	{
+		io = new WebmIoFile(vidPath);
+		webm = new WebmPlayer();
+		webm.fuck(io, false);
+		webm.addEventListener(WebmEvent.PLAY, function(e) {
+			onPlay();
+		});
+		webm.addEventListener(WebmEvent.COMPLETE, function(e) {
+			onEnd();
+		});
+		webm.addEventListener(WebmEvent.STOP, function(e) {
+			onStop();
+		});
+		webm.addEventListener(WebmEvent.RESTART, function(e) {
+			onRestart();
+		});
+		webm.visible = false;
+		initialized = true;
+	}
+	
+	public function updatePlayer():Void
+	{
+		io = new WebmIoFile(vidPath);
+		webm.fuck(io, false);
+	}
+	
+	public function play():Void
+	{
+		if (initialized)
+		{
+			webm.play();
+		}
+	}
+	
+	public function stop():Void
+	{
+		if (initialized)
+		{
+			webm.stop();
+		}
+	}
+	
+	public function restart():Void
+	{
+		if (initialized)
+		{
+			webm.restart();
+		}
+	}
+	
+	public function update(elapsed:Float)
+	{
+		webm.x = GlobalVideo.calc(0);
+		webm.y = GlobalVideo.calc(1);
+		webm.width = GlobalVideo.calc(2);
+		webm.height = GlobalVideo.calc(3);
+	}
+	
+	public var stopped:Bool = false;
+	public var restarted:Bool = false;
+	public var played:Bool = false;
+	public var ended:Bool = false;
+	public var paused:Bool = false;
+	
+	public function pause():Void
+	{
+		webm.changePlaying(false);
+		paused = true;
+	}
+	
+	public function resume():Void
+	{
+		webm.changePlaying(true);
+		paused = false;
+	}
+	
+	public function togglePause():Void
+	{
+		if (paused)
+		{
+			resume();
+		} else {
+			pause();
+		}
+	}
+	
+	public function clearPause():Void
+	{
+		paused = false;
+		webm.removePause();
+	}
+	
+	public function onStop():Void
+	{
+		stopped = true;
+	}
+	
+	public function onRestart():Void
+	{
+		restarted = true;
+	}
+	
+	public function onPlay():Void
+	{
+		played = true;
+	}
+	
+	public function onEnd():Void
+	{
+		trace("IT ENDED!");
+		ended = true;
+	}
+	
+	public function alpha():Void
+	{
+		webm.alpha = GlobalVideo.daAlpha1;
+	}
+	
+	public function unalpha():Void
+	{
+		webm.alpha = GlobalVideo.daAlpha2;
+	}
+	
+	public function hide():Void
+	{
+		webm.visible = false;
+	}
+	
+	public function show():Void
+	{
+		webm.visible = true;
+	}
+	#else
+	public var webm:Sprite;
+	public function new()
+	{
+	trace("THIS IS ANDROID! or some shit...");
+	}
+	#end
+}