karma go troubleshooting

Karma go troubleshooting

Software Development Magazine - Project Management, Programming, Software Testing

Karma - a Javascript Test Runner

Karma is a test runner for JavaScript that runs on Node.js. It is very well suited to testing AngularJS or any other JavaScript projects. Using Karma to run tests using one of many popular JavaScript testing suites (Jasmine, Mocha, QUnit, etc.) and have those tests executed not only in the browsers of your choice, but also on the platform of your choice (desktop, phone, tablet.) Karma is highly configurable, integrates with popular continuous integration packages (Jenkins, Travis, and Semaphore) and has excellent plugin support.

Version Tested: v0.10 running on NodeJS 0.8.19 running on Windows 7 Professional 64-bit

License and Pricing: Open Source

The recommended installation location of Karma is in your global node_modules directory. Installing Karma is done via the Node Package Manager (NPM). From any command prompt, enter the command: npm install –g karma. Should you desire to install Karma to your local directory you can use: npm install karma –save-dev. This process will get you the default installation of Karma, which includes the karma-chrome-launcher, karma-coverage, and karma–jasmine plugins. There are also several plugins (a list can be found at https :// npmjs . org / browse / keyword / karma - plugin ) that you should consider installing to make your test management and output easier and more useful. I regularly use the karma–firefox-launcher and karma-ie-launcher plugins. All plugins should be installed before you try to configure or use Karma, but you can always add a new one later with no troubles at all. Installing plugins is just as easy as installing Karma. From any command prompt, enter the command: npm install -g-karma-<plugin name>.

Before you run Karma you must configure it. This is the most important step in setting up Karma. The easiest way to get started is to run the init command. In a command window, navigate to your project folder and enter karma init karma.conf.js (this is the default, but you can name the file whatever you want.) The questions are easy to answer and the net result is a properly structured Karma configuration file. You’ll need to answer the following questions:

  • What testing framework do you want to use?

Jasmine, Mocha, and QUnit are installed by default and can be referenced by name, but if you have installed another one you should name it here. Because each framework is a plugin, you will need to list the plugin file in the plugins section of the configuration file as well (see the sample configuration file below for an example.)

Require.js is a lazy-loading framework that many developers use to minimize the initial script load times in the browser. If your project uses is, you need to answer YES to this question.

  • Do you want to capture a browser automatically?

You should respond with the browser name(s) that you want to use, one per line. Remember that you must have the matching –launcher plugin installed for each browser, and that only the karma–chrome-launcher and karma–chromeCanary-launcher plugin are installed by default. Entering a blank line will move you to the next question.

  • What is the location of your source and test files?

This path is relative to the location of Karma. You can enter an absolute path and be assured of directing Karma to the right location, or enter a relative path if your files are located below the Karma folder.

  • Should any of the files included by the previous patterns be excluded?

If you use a very broad pattern, you may want to exclude the folder where you store your images, or where there are no .js files to test. Tighter patterns take up more lines in the configuration file, but also eliminate the need for an exclude block.

  • Do you want Karma to watch all the files and run tests on change?

Having Karma run continuously is very helpful as you can see your tests and code evolve in a TDD environment. If you don’t do TDD, you can opt to only run Karma when you are ready to execute your tests.

For the more adventurous or those that need more than just the basic configuration, you can edit the configuration file and tailor Karma to fit your needs. There are four main sections of the configuration file that you’ll want to pay particular attention to: preprocessors, plugins, browsers, and files.

Preprocessors enable you to do things to your code before it gets sent to the browser to have the tests run on it. Karma comes with the karma-coffee and karma-html2js preprocessors already installed. I regularly use the karma-coverage preprocessor to show me how much of my code I have covered with my tests. For a complete description of what any individual preprocessor does you should read the documentation on its website.

While Karma comes with several plugins pre-installed, you need to tell it which ones you want to use for running your tests. There are methods for dynamically determining which plugins get used, or you can just list them out. If your project doesn’t change much with respect to how you are testing your code, the static listing is the easiest way to go.

Browser support is critical for JavaScript. Karma comes with launchers pre-installed for Chrome, Chrome-Canary, and PhantomJS. Other launchers need to be installed if you want to test your JavaScript in other browsers. I regularly test in Chrome, IE, and Firefox. Karma takes care of capturing and killing the browser processes for you. This enables you to spend more time developing and less time doing the menial processes associated with testing. The default time allowed to capture any one browser is one minute, which should be more than enough time, but you can change that value via the captureTimeout option in the configuration file. You will also need to tell Karma where the executable files are for all browsers except IE. If you want to capture your browser manually (from a tablet, for example) you can point the browser to http://<hostname9gt;:9lt;port9gt; where <hostname9gt; is the hostname or IP address of the computer where Karma is running, and <port9gt; is the port you specified in the configuration file. By default this is port 9876, but if you have changed it in the port section of your configuration file then use that port.

You need to tell Karma which files are required to run your project, which files contain your tests, and which files need to be tested. For convenience, in my configuration file I have broken these files into their respective groups, with required files first, test files second, and files to be tested last. The order in which they appear is the order that they will be included in the browser, so depending upon your project you may need to pay attention to it. Each file or group of files can be flagged for being watched by Karma, included in the browser <script9gt; tag, and served by the Karma server. Files that are watched can trigger Karma to run all of the tests again, so pay particular attention to these. If you simply list all of your files, they will be watched, included, and served, which may result in performance loss during testing on older, slower computers.

Karma runs on NodeJS and the configuration is set up using module.exports so that it gets drawn into and consumed by NodeJS. Older versions of Karma did not have this feature, and they were slightly harder to configure correctly. A good sample of a Karma configuration file looks like this:

There are two main ways to run Karma: at the command line or via your IDE. I heavily favor running Karma from my IDE (WebStorm) because it keeps me on the same screen more. Regardless of which method you choose, running Karma does the following:

  1. Starts a web server in Node.
  2. Launches the specified browsers with a default URL that points to that web server.
  3. Attempts to capture the browser session in each browser.
  4. Upon capture of all browsers, the tests are run and the reports generated.
  5. If you have opted to have Karma stay running and monitor files, each time one of those files changes the tests will be re-run and the reports re-generated.
  6. If you have opted to only have Karma run once, each browser session is released and the browser is closed.

Testing is only useful if you can see the results, and Karma has several options available. The progress reporter is inserted into the configuration file that the init process creates by default. This reporter gives you a complete listing of each test that is run, in the order that they are executed, and whether they pass or fail. The dots reporter is included with Karma for those that run Travis. There are other reporters available as plugins (growl, Junit, Teamcity and Coverage) that can help make your testing process easier and more complete. Each reporter must be listed in the reporters section of the configuration file, and some reporters (such as the coverage reporter) require that they be referenced in the preprocessors section as well. The coverage reporter that is included with Karma is Istanbul and I have found it very well suited for my needs and for use with Karma.

Part of the beauty of Karma is how easily it can be integrated in to your IDE. Nearly all IDEs have a way to add an external tool that is launched on the command line. Configuring WebStorm 6 and older to run Karma as an external tool is covered in the introductory video that the creator (Vojta Jina) posted via YouTube (http://www.youtube.com/watch?v=MVw8N3hTfCI) and can be found at the 7:39 mark in the video. There is a handy link to this part just below the video. There is also integration built into the upcoming WebStorm 7 (currently accessible via the Early Access Program.) It has been my experience that integrating with WebStorm produces an excellent development environment. Support for configuring external tools isn’t limited to JetBrains products. Visual Studio 2008 or newer in any flavor except the Express versions will allow you to configure external tools to launch from the menu (you would need to create a batch file with the requisite Karma commands in it and tell VS to launch that file.) Sublime is also a heavily favored text editor for web development, and it also supports external tools. As long as your favored IDE supports external tools in some way, you should be able to launch Karma and have it run tests.

The vast majority of what you need to get up and running with Karma is contained in the Karma website. Most any other question can be answered by searching the Google Group or posting a question on Stack Overflow. Documentation for individual plugins will be found with those plugins. For anything that isn’t covered, the Google Group is the best resource to try first, and Stack Overflow is a very close second.

A large number of developers don’t test their JavaScript, and they really should. Too many of them think that testing is hard to set up and hard to do, and Karma is proof of the opposite. My team and I use Karma with Jasmine every day of the week. We found the installation and configuration to be fast and easy to follow. We went from downloading NodeJS to running tests via Karma in under an hour. When you consider that my team and I were totally new to testing, let alone testing JavaScript, this is pretty impressive. We chose Karma because it had support for AngularJS without any configuration changes, and because it would let us test our other scripts as well. In each of these areas it has excelled from day #1. We are now preparing to move our project to Yeoman and have no fear about how our tests will work because Yeoman fully supports Karma. We firmly believe that we could not have chosen a better tool to include in our daily routines.

Karma is the preferred test runner for projects written with AngularJS and is well on its way to larger acceptance within the greater JavaScript community. Its plugin architecture makes it easily adaptable to other test suites and reporters, all of which add value to the core of Karma. In agile or continuous integration environments, Karma shines as an indispensable tool to development teams, providing an easy and reliable way to modify existing code and craft new code as part of TDD. It is rare that a day goes by without this tool running on my computer.

Angular Unit Testing Quick Start

Why are you doing this?

Angular was written from the ground up to be testable and yet there are scores of Angular developers who are not writing enough (if any) tests for their application. Why is this? I believe that it is because that while testing Angular is easy, actually getting to that first step is hard. I remember the feeling of despair I felt the first time I was tasked with writing tests for a project I was on. Where do I start? How do I get this Karma thing to actually run? Find my files? How do I instantiate my controller? What if it has a service dependency? Aaaaaaaaargh!

I have since covered a lot of ground over the last couple years and I found that once you understand a few basic rules of engagement that testing in Angular is actually pretty straight forward and formulaic.

I wanted to try to illustrate some of these basic patterns in an easy to read, approachable way so that developers can get to that first test without losing their mind

Please use this material as a bridge to making tests a natural part of your development process; and if you find something amiss, do not hesitate to create a pull request on the repo. Nothing would make me happier! Enjoy!

Where can I see the actual tests?

The companion repository for this quick start guide can be found here https://github.com/simpulton/angular-testing-quick-start

How does Karma differ from Protractor?

I like to split my tests up into three different categories:

  1. End-to-End Tests - These are the tests where you want to mimic an actual user that visits your website. Each test contains a series of simulated user events (ex. go to http://mysite.com/home and then click on the button with ID 'my-button') and expected results (ex. after 200ms a new window should appear that says "Thank You").
  2. Integration Tests - These tests will call directly into your code. For example, you can use an integration test to call an Angular service. Typically each test will focus on one function. The test calls the target function with a set of parameters and then checks to make sure the results match expected values.
  3. Unit Tests - These are the same as integration tests except you take extra steps toensure that nothing is executed besides the one function you are testing. For example, when you test a service that uses $http to call a back end API, an integration test would include the API call. A unit test, however, would use a utility we will discuss later called $httpBackend to replace $http so that the code executed by the test is restricted to just the target function.

Protractor is the tool you will use for end-to-end tests while Karma handles integration and unit testing.

How do I install Karma?

How do does Karma know which files to include?

After installing Karma, we need to set up the karma.conf file. The files array in karma.conf contains all the files needed to run a test. This includes:

  • Any angular libraries used by your code
  • All your custom code
  • All your test specs

Below is an example of a full karma.conf file.

Note that most values in the karma.conf file can be overridden at the command line. For example, if you wanted to run Firefox instead of Chrome you could either change the value in karma.conf or keep the value the same and use this command:

I strongly suggest you take an existing karma.conf file like this one and adapt it to meet your needs. As long as you follow the conventions we outline in this guide, the only things you will likely want to change are:

  • files - to include all your custom code, dependencies and test code
  • reporters - if you want test coverage you will need to include the 'coverage' reporter
  • autoWatch and singleRun - most of the time you will want autoWatch=true and singleRun=false so that Karma will automatically re-run your tests as you make changes. However, if you are running Karma as part of a script like a git hook or continuous integration, then you will want to flip these two boolean values so that Karma only runs the tests once.

How is a basic spec organized?

In general, you want to have one test file for each and every non-test code file in your app. You should have a common naming scheme so that your build tools and test runners can pick out test files from non-test files. We are using one of the most common test file naming schemes: ".spec.js". So if you have a code file called "app.js", the file that contains all the tests for app.js would be called "app.spec.js". You will often see all test files in a separate directory from the rest of the code (usually called 'test'), but in the sample code we have put all specs right along side the code they are testing for your convenience.

Spec Code Structure

In general, your spec files should follow this structure:

Two things to note from this example.

First, you should make liberal use of before, beforeEach, after and afterEach to set up and tear down the appropriate context for tests. Ideally you only have a couple lines of code within each it() function.

The second thing to note is that the first parameter for the describe() and it() functions may be used by the test runner when tests are executed. For example, when this spec is run, some test runners may output:

So, make sure the string values are descriptive.

How do I inject a module in a spec?

The first thing your spec should do is define all the Angular modules that are needed for the tests in that spec. This is done using the module() function that comes from the angular-mocks library. For example:

This code will enable the spec to test the code from the myApp module. It is best practice to use beforeEach() instead of just before() so that each test is essentially running from a blank slate. If you don't do this, the state from a previous test may bleed into another test and affect the results.

How do I instantiate a controller in a spec?

Here is our controller that we want to test:

The angular-mocks library provides a service called $controller that we can use to help us test our controllers. In the beforeEach() below, we are injecting $controller along with any other dependencies we need to instantiate our controller.

Note that we are using the underscore syntax with _Messages_ to get a global reference to the Messages service. The underscores are ignored by the injector when the reference name is resolved.

How do I inject a service in a spec?

Testing an Angular service is a piece of cake. You can use the inject() function from angular-mocks to get a reference to either internal Angular core objects or any of your custom objects in the modules that are defined at the top of the spec. For example:

As a best practice, we suggest injecting objects in beforeEach() and saving the object to a local variable. Then in the test we just reference that local variable.

How do I test if an element is in the DOM?

The most tricky thing to test with Angular is code within templates. That is why you should try to reduce the amount of code in your templates as much as possible. Even if you are really good about this, though, you will always have some template code that you want to test.

You can split template testing into two categories. The first category includes templates that don't have any controllers, includes or custom directives. Essentially you are just testing logic that uses basic Angular expressions and core Angular directives. This use case is relatively easy to test. Take the following example:

We want to have access to this HTML file in our tests, but it is generally a bad idea to make an http call within your tests if you can avoid it. Fortunately, there is a nice feature in Karma that allows us to automatically package all of our HTML template files into an Angular module that we can access easily in our tests. Just add the following to your karma.conf.js file:

This will automatically package any file ending in .html within your src/ folder into an Angular module called myAppTemplates. Each template is accessible by using the $templateCache service. You can can test this template simply by injecting the $compile service with some test data and then checking the resulting HTML:

The second category of template testing is unfortunately more complex. We need to deal with dependencies within the template or surrounding the template such as a controller, the UI router, directives, etc. Let's look at one example of a more complex use case that includes a UI Router state and a controller:

In order to test the template and associated controller code, we need to instantiate the controller and surrounding context. To that end, we have created a helper function called compileRouteTemplateWithController that does everything we need.

We are using this helper function to get all the dependencies we need to run our tests. This includes creating scope, a controller and a render function. Feel free to use this and adapt it to your needs. Also, as an aside, whenever you see a lot of repetitive code within your tests, make sure you create your own helper functions.

OK, now we have everything in place to test our template.

The key part of this test was the use of the helper function to instantiate the template and all required dependencies:

How do I test route changes?

Testing a route essentially means testing that we configured the UI router $stateProvider correctly during the config phase. For example, given the following state configuration:

Our basic strategy for testing is to use the $state.go() and $state.href() methods to modify the current state and then check to make sure the route is changed appropriately.

How do I set up a spec for a directive?

Similar to how we test a template, we use the $compile service to help us test a directive. The key is to pass in a HTML snippet to $compile() that refers to the target directive. For example, if you had an element directive called 'experiment', you would simply call $compile("&#60;experiment&#62;&#60;/experiment&#62;"). You can see the full example here:

Note: depending on what your directive does, you may need to modify the HTML passed into $compile. For example, if the directive expects other attributes on the element or if you are testing a directive with transclusion (in which case you will want to put different snippets of HTML as children to the element that has the directive).

How/Why do I mock a service call in a controller spec?

We mentioned at the beginning that you can create both unit tests and integration tests with Karma. When you are writing a unit test, your goal is to test just one thing and either eliminate or mock out all other dependencies. In general, you can mock any object through the use of the $provide service. You use this service when you define the module you are using in your spec. For example:

In this case, we are overriding the SimpleService object. Once we do this, any code that injects SimpleService will get our mock object instead of the actual SimpleService.

There is one special case with mocking where Angular helps you out. Whenever you use $http to make a remote call, Angular has another service behind the scenes called $httpBackend that actually does all the hard work. The angular-mocks library has its own version of $httpBackend with a number of goodies to help us mock out calls to the back end. For example look at this code which makes an $http call:

If we call getExperiments() in our test, it will make an actual http request to data/experiments.json. We can intercept that call with $httpBackend, however, and define what should be returned instead of making a remote call.

Note that $httpBackend.flush() is needed because normally $http is asynchronous, but we want to execute our test in a synchronous fashion. The call to flush() will ensure that the .then() on the promise returned from $http will be executed immediately.

How do I determine if one method successfully calls another method?

How do I determine what arguments were included when I call a method?

Jasmine uses a spy to determine whether a method has been called and/or what arguments are set into a method call. So, for example:

A spy only exists within the describe() or it() function where it has been defined.

In addition to simply seeing if a spy has been called, we can also define what value the spy should return (using returnValue()) or what fake function the spy should run instead of the target function (using callFake()). For example:

How do I handle async operations in a spec?

By default, each test runs synchronously. So, if you have any asynchronous operation, the test will complete before the operation completes. There are ways of handling specific use cases (for example $httpBackend.flush() as mentioned earlier), but you can also use the Jasmine done() function. For example:

In this example, the test will not complete until done() is called. If done() contains a parameter, Jasmine treats that as an error and fails the test.

One last note on async operations. You may have noticed in our examples a call to $rootScope.$digest(). This will force the digest cycle to run which is needed whenever we are testing anything athat involves watchers (so, anything with templates).

How do I troubleshoot problems with my specs?

Spec code is run in the browser just like any other client side code. So, how do you debug your Angular app? That's right, the Chrome/FireFox dev tools. For example, after running Karma with Chrome there should be a Chrome window open on your machine that contains the output of the test. To debug, simply open up the Chrome dev tools and refresh the page.

How do I know I am formatting my specs in the most efficient manner?

Here is a quick list of best practices. Some of these we touched on earlier.

  • Use beforeEach() to set up the context for your tests.
  • Make sure the string descriptions you put in describe() and it() make sense as output
  • Use after() and afterEach() to cleanup your tests if there is any state that may bleed over.
  • If any one test is over 10 lines of code, you may need to refactor the test
  • If you find yourself repeating the same code for many tests, refactor the common code into a helper function

If you want to do some more digging, here are 6 resources that will get you started.

Installing Movie Battles II &#038; Troubleshooting Guide tutorial

This is an in depth guide to installing Movie Battles II. This guide will explain how to install Movie Battles II on Windows machines and Macintosh machines. Written by Supa.

Posted by MaceMadunusus on Jul 9th, 2010 - Basic Starting a mod

This is a step-by-step guide to installing Movie Battles 2, using either the archive file &#40;.zip&#41; downloaded from the website or moddb, or the launcher downloaded from the website. There should also be an included readme file with the official build that has similar information.

Movie Battles II Installation Instructions for CD/DVD version of Jedi Academy

Movie Battles II requires a physical copy of Star Wars Jedi Knight: Jedi Academy to run properly. If you do not own Jedi Academy you can buy it on Steam for $10 USD (found here, this includes both the PC and Mac versions of the game [if you choose to buy it on Steam you will need to scroll down to the installation instructions for Steam versions of the game). You must also be patched to the latest version of the game - Update 1.01 for Windows users, and 1.01e for Macintosh users. The Steam version of Jedi Academy will automatically be updated to 1.01 on installation.

  1. If you're reading this, that means you've already downloaded Movie Battles II.
  2. Navigate to your game's installation directory. This will be different depending on your operating system's architecture:
    • On 32-bit Operating Systems: C:\Program Files\LucasArts\Star Wars Jedi Knight Jedi Academy\GameData
    • On 64-bit Operating Systems: C:\Program Files (x86)\LucasArts\Star Wars Jedi Academy\GameData
    • Important: If you installed Jedi Academy in a different directory you will need to navigate to where you installed it to and find the GameData folder to continue.
  3. Select all of the files in the containing Movie Battles II archive (.zip) file, and drag them into your GameData folder, pressing OK whenever prompted. You may also simply drag the entire archive file to the GameData folder and use the extract to function.
  4. There are two noteworthy ways to run Movie Battles 2, without the Steam version which will be covered further on in the guide (search "Steam Version of Jedi Academy"). Running the Play_MBII.bat file included is the easiest way. You can also create a desktop shortcut of jamp.exe and add +set fs_game "MBII" into the target field at the end of the directory in the properties of the shortcut.

Karma go troubleshooting

  1. If you're reading this, that means you've already downloaded the MBII Launcher.
  2. Navigate to your game's installation directory. This will be different depending on your operating system's architecture
    • On 32-bit Operating Systems: C:\Program Files\LucasArts\Star Wars Jedi Knight Jedi Academy\GameData
    • On 64-bit Operating Systems: C:\Program Files (x86)\LucasArts\Star Wars Jedi Academy\GameData
    • Important: If you installed Jedi Academy in a different directory you will need to navigate to where you installed it to and find the GameData folder to continue.
  3. Select and move MBII Launcher to your GameData folder. It is required that the launcher be in your GameData folder for the game to run. Once you start the launcher press the Install button on the launcher and it will begin downloading automatically. If you installed Jedi Academy on a different drive than your operating system, you may need to make sure that it is the recognized path in the settings.
  4. Let the game download, and once finished press the Play button on the launcher.

For new installations of Movie Battles II on a computer running Microsoft Windows using the Steam version of Jedi Academy* These instructions require the Steam version of Jedi Academy.

  1. If you're reading this, that means you've already downloaded Movie Battles II.
  2. Navigate to your game's installation directory. This will be different depending on your operating system's architecture:
    • On 32-bit Operating Systems: C:\Program Files\Steam\steamapps\common\Jedi Academy\GameData
    • On 64-bit Operating Systems: C:\Program Files (x86)\Steam\steamapps\common\Jedi Academy\GameData
    • Important: If you installed Jedi Academy in a different directory you will need to navigate to where you installed it to and find the GameData folder to continue.
  3. Select all of the files in the containing Movie Battles II archive (.zip) file, and drag them into your GameData folder, pressing OK whenever prompted. You may also simply drag the entire archive file to the GameData folder and use the extract to function.
  4. To play Movie Battles II< you will need to set specific launch options. Right click on Jedi Academy in your Steam Library and select Properties. You should see a button labeled Set Launch Options. Select that, and in the text field copy and paste +set fs_game "MBII". Whenever you start Jedi Academy Multiplayer through Steam it will automatically load to Movie Battles II. If you want to run base, or another modification, you will need to remove or modify the launch options.

Karma go troubleshooting

  1. If you're reading this, that means you've already downloaded the MBII Launcher.
  2. Navigate to your game's installation directory. This will be different depending on your operating system's architecture:
    • On 32-bit Operating Systems: C:\Program Files\Steam\steamapps\common\Jedi Academy\GameData
    • On 64-bit Operating Systems: C:\Program Files (x86)\Steam\steamapps\common\Jedi Academy\GameData
    • Important: If you installed Jedi Academy in a different directory you will need to navigate to where you installed it to and find the GameData folder to continue.
  3. Select and move MBII Launcher to your GameData folder. It is required that the launcher be in your GameData folder for the game to run. Once you start the launcher press the Install button on the launcher and it will begin downloading automatically. If you installed Jedi Academy on a different drive than your operating system, you may need to make sure that it is the recognized path in the settings.
  4. Once the game is finished downloading and you have changed the above settings press the “Play9rdquo; button on the launcher.
    • If you run into an issue running MBII through the launcher, it is most likely because you didn't install Jedi Academy in the default directory. If this is the case, you will need to go into the settings of the launcher, and change the option Run game using: to MBII Client instead of JAMP, or run the game directly through Steam using launch parameters as described in the Archive Installation, if you want to have the Steam overlay.

Guide for new installations of Movie Battles II on a Macintosh.* Requires a physical copy of the Macintosh version of Jedi Academy, and can be purchased through the Mac store, as well as the Steam store.

  1. Navigate to your home library folder, by using the "Go" menu of the Finder while pressing the "alt" key.
  2. Go to "Application Support".
  3. Then depending on the version of jka you use open the folder :
    • "Jedi Academy" : for Steam Version
    • "Jedi Academy MP" : for CD Version
    • "OpenJK" : for OpenJK version
  4. Select the folder MBII contained in Movie Battles II .zip file, and drag it in to the folder previously identified (at point 3). There must be ONLY an MBII folder with all the files. If you have a zip containing a patch don't replace the entire folder, but replace the content inside that MBII folder.
  5. There are several ways to run MBII on a Mac :
    • On earlier patches (1.01c/d), you can hold shift while running Jedi Academy MP and type in “+set fs_game MBII”
    • Alternately for the newer patch (1.01e) and steam version, Redsaurus has provided us with an application for Mac that launches straight to MBII, JKJALauncher.app (you can download that here or here). You will need to launch it the first time holding the shift key to configure it by adding "+set fs_game MBII" in its setup.
  6. Enjoy!

Important note: JKJALauncher.app includes an auto-updater for the launcher.

Important information before you join a server As with any game, it is important that you run through the settings and controls before you join a game.

Settings: Video Settings (Widescreen Supported)Karma go troubleshooting

Settings: Widescreen Support OptionsKarma go troubleshooting

Settings: Important Network SettingsKarma go troubleshooting

Controls: Miscellaneous Weapon BindingsKarma go troubleshooting

Controls: Movie Battles Specific BindingsKarma go troubleshooting

Controls: Force Power BindingsKarma go troubleshooting

Controls: Turning off Auto-demo RecordingKarma go troubleshooting

Additional Troubleshooting Information

Steam Users: To run MBII, follow the instructions in the Installation Guide. Play_MBII.bat located in the GameData folder does not work with the Steam version of Jedi Academy.

Error: Error: MAX_QPATH Error

Solution: Remove mb2_rc_hangarc.pk3 from your MBII folder.

Error: Unexplained Mac client crashing

Solution: Disable EAX in your sound options, it may solve any unexplained crashing problems.

Error: Unexplained Crash to desktop on startup

Error: Models holding their arms out

Solution: If everything is installed properly, but you are still getting the "Jesus Stance" animation, copy the file z_MB_BaseAssets.pk3 from your MBII folder into the base folder.

Error: OpenGL Subsystem/VM_Create on UI failed Error

Solution: Update your DirectX drivers. (Download DirectX here: Support.microsoft.com)

Error: Application load error 5:0000065434

Solution: This happens if you are using the Steam version of Jedi Academy and it is not installed in the same directory as the Steam client. You will need to change the way the MBII Launcher runs the game. Go to the launcher settings and where it says Run game using: change that to MBII Client, and untick Steam Integration. Alternatively you can run the game through Steam by setting the Launch Parameters.

27 PDF Results and update :2017-08-23 10:59:12

hovers in place whenever you let go of the joysticks. WARNING: . The button light and the orientation lights on the arms turn off when Karma is powered off.

[PDF] Reincarnated Guide M3 - Karma-Lab

If you find that this is causing you to go off the beat too much, or you are having difficulty playing them this way, the fix is easy: . KARMA back on, .

[PDF] User Guide User - AT&T Wireless

karma ™QA1 User Some of . To learn even more, go to www.motorola.com/mykarma. . † Charging Lights † TTY Setup †Scroll † Slide Closed † Text Marquee .

[PDF] GRIP - GoPro Official Website - Capture

Battery Status Lights T&#233;moins d’&#233;tat de la batterie Luces de estado de la bater&#237;a Charging Port . sumerja el Karma Grip en agua ni lo exponga a l&#237;quidos, .

[PDF] THE LIGHT OF - selfdefinition.org

go ahead because you are not sure about the r ight . the light of lights beyond all darkness: . Karma Yoga, devotion: Bhakti Yoga,

[PDF] Frequently Asked Questions and Answers Ghia Specifics .

Frequently Asked Questions and Answers Q Do Karmann Ghias and Beetles share the same mechanicals? A Yes, this covers the beam, the transmission, and the engine.


‘FRIDAY NIGHT LIGHTS’ STAR ALICIA WITT STARS AS A BRIDE WHO . (“Friday Night Lights”) . (“Sweet Karma”), Scott Gibson .

[PDF] Mystic Lands: Varanasi: City of Light - Discovery Education

Mystic Lands: Varanasi: City of Light: Teacher’s Guide . • What is karma, . Hindus may go to ashrams any time of day for worship.

[PDF] Ways to Leave Your Karma - wisdomheart.com

50 Ways to Leave Your Karma. . forward together—it’s important to go beyond the surface and connect to what’s deeper. . your insula lights up.

[PDF] Zung of the Exalted Completely Pure Stainless Light

Zung of the Exalted Completely Pure Stainless Light . If you recite the mantra everyday and then go to the town or where there are . etc., their negative karma


Viridian purchases carbon offsets on behalf of our Travel Light members and their Karma . is the responsible way to go . the lights on for a day .

[PDF] Karma - ReplayTV: Customer Support Home

The link lights on docking station’s Ethernet port will light and blink . Karma anytime it is connected to a USB cable for an extended amount . 7 Go to Step 2.

[PDF] OASYS Keyboard KARMA Cubase Recording Notes 01sk

OASYS Keyboard KARMA Recording Notes . as you can restore the tracks at one go, . (even thought the KARMA On/Off and Latch lights remain On).

[PDF] The Karma and - SRI - Seven Ray Institute

The Karma and Dharma Of Individuals, Nations, . which go out into the endless space. . ignore traffic lights, overestimate


almost all the lights out, . you’ll put a lead weight on the tang and you’ll go into the . Karma & Emptiness in the Yoga Sutra: .

[PDF] Author Buzz Bissinger discusses LeBron, youth sports and .

Author Buzz Bissinger discusses LeBron, youth sports and Friday Night Lights . LeBron decided not to go to a predominantly black public high school

[PDF] Karma and Reincarnation - The Summit Lighthouse

Karma and Reincarnation . and what the great lights of East and West . emissaries who will represent th e Brotherhood and who will go forth

road trip with the Fisker Karma, . warning lights lit up on the dash—a . said the gas-cap light would go out when

[PDF] The Center for Enlightenment presents

Karma—The Law of Sowing and Reaping . New Lights Warner . The purpose of reincarnation is to provide opportunity for man to go on working out all his

[PDF] Rio Karma - ReplayTV: Customer Support Home

The Rio Karma may be left in the docking station for extended . The link lights on docking statio n’s Ethernet port will light and blink . 7 Go to Step 2.

[PDF] Healing Classes - Starr Fuentes

Geometry of Lights . . Karma Coupons . Letting Go . Lightening Strikes . Worn Sneakers: The Faster I Go, the Longer it Takes Healing Classes

[PDF] Karma-Is-Chemistry.pdf - durgayoga.com

karma is chemistry. may 2009 . . leveled a lot of people i knew. For me, go- . that god is a neuropeptide. by most people’s lights, .

[PDF] Troubleshooting a Charger Failure - eGO Vehicles

Troubleshooting a Charger Failure Revision: 2/04/04 Symptom: . If the indicator lights DO NOT illuminate the charger has failed and must be replaced.

[PDF] Turn Signal Switch/Hazard Switch Wiring - Old Volks Home

Turn Signal Switch/Hazard Switch Wiring . w/Sidemarker Parking Lights. Ignore these, terminate the ends with electrical tape and zip tie out of the way.

[PDF] Bomb squad trooper Umiddelbar Karma in Australia Belize .

Australia Umiddelbar Karma Radiant trigonometry in Australia Fantasia of lights hartford ct . apps android Umiddelbar Karma Go sms pro android Match bubble from .

[PDF] Books To Share Fun With Fingerplays and Songs

by Karma Wilson Oh, yes, I see him! Splendiferous Christmas by Jane O’Connor . Additional verses: lights/go on and off; popcorn/good to eat; star/up on top.

[PDF] Pb 500h Service Manual - freepdfbookz.com

lights download pdf for free . app cvs employee benefits diy coffee diy coffee craigslist harrisburg earthly needs a novel credit karma problems dizzycats go to .